Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/pcap/src/pcapctl_dump.c

    re4cc266 r384f081  
    3838#include <str.h>
    3939#include <stdlib.h>
    40 
     40#include <stdio.h>
     41#include <ctype.h>
    4142#include "pcapctl_dump.h"
    4243#include "pcapdump_iface.h"
    … …  
    5152}
    5253
    53 static errno_t pcapctl_cat_get_svc(const char *drv_name, service_id_t* svc) {
     54static errno_t pcapctl_cat_get_svc(int *index, service_id_t *svc)
     55{
    5456        errno_t rc;
    5557        category_id_t pcap_cat;
    … …  
    6668        if (rc != EOK) {
    6769                printf("Error resolving list of pcap services.\n");
    68                 return rc;
    69         }
    70 
     70                free(pcap_svcs);
     71                return rc;
     72        }
     73        if (*index < (int)count) {
     74                *svc =  pcap_svcs[*index];
     75                free(pcap_svcs);
     76                return EOK;
     77        }
     78
     79        return ENOENT;
     80}
     81
     82errno_t pcapctl_is_valid_device(int *index)
     83{
     84        errno_t rc;
     85        category_id_t pcap_cat;
     86        size_t count;
     87        service_id_t *pcap_svcs = NULL;
     88
     89        rc = loc_category_get_id("pcap", &pcap_cat, 0);
     90        if (rc != EOK) {
     91                printf("Error resolving category pcap.\n");
     92                return rc;
     93        }
     94
     95        rc = loc_category_get_svcs(pcap_cat, &pcap_svcs, &count);
     96        if (rc != EOK) {
     97                printf("Error resolving list of pcap services.\n");
     98                free(pcap_svcs);
     99                return rc;
     100        }
     101        if (*index + 1 > (int)count || *index < 0) {
     102                return EINVAL;
     103        }
     104        return EOK;
     105}
     106
     107/**
     108 *
     109 */
     110errno_t pcapctl_list(void)
     111{
     112        errno_t rc;
     113        category_id_t pcap_cat;
     114        size_t count;
     115        service_id_t *pcap_svcs = NULL;
     116
     117        rc = loc_category_get_id("pcap", &pcap_cat, 0);
     118        if (rc != EOK) {
     119                printf("Error resolving category pcap.\n");
     120                return rc;
     121        }
     122
     123        rc = loc_category_get_svcs(pcap_cat, &pcap_svcs, &count);
     124        if (rc != EOK) {
     125                printf("Error resolving list of pcap services.\n");
     126                free(pcap_svcs);
     127                return rc;
     128        }
     129
     130        fprintf(stdout, "Devices:\n");
    71131        for (unsigned i = 0; i < count; ++i) {
    72132                char *name = NULL;
    73133                loc_service_get_name(pcap_svcs[i], &name);
    74                 if (!str_cmp(drv_name, name)) {
    75                         *svc =  pcap_svcs[i];
    76                         return EOK;
    77                 }
     134                fprintf(stdout, "%d. %s\n", i, name);
    78135        }
    79136        free(pcap_svcs);
    80         return 1;
    81 }
    82 
    83 extern errno_t pcapctl_list(void) {
    84 
    85         errno_t rc;
    86         category_id_t pcap_cat;
    87         size_t count;
    88         service_id_t *pcap_svcs = NULL;
    89 
    90         rc = loc_category_get_id("pcap", &pcap_cat, 0);
    91         if (rc != EOK) {
    92                 printf("Error resolving category pcap.\n");
    93                 return rc;
    94         }
    95 
    96         rc = loc_category_get_svcs(pcap_cat, &pcap_svcs, &count);
    97         if (rc != EOK) {
    98                 printf("Error resolving list of pcap services.\n");
    99                 free(pcap_svcs);
    100                 return rc;
    101         }
    102 
    103         fprintf(stdout, "Services:\n");
    104         for (unsigned i = 0; i < count; ++i) {
    105                 char *name = NULL;
    106                 loc_service_get_name(pcap_svcs[i], &name);
    107                 fprintf(stdout, "service: %s\n", name);
    108         }
    109         free(pcap_svcs);
    110         return EOK;
    111 }
    112 
    113 
    114 errno_t pcapctl_dump_open(const char *svcname, pcapctl_sess_t **rsess)
     137        return EOK;
     138}
     139
     140/**
     141 *
     142 */
     143errno_t pcapctl_dump_open(int *index, pcapctl_sess_t **rsess)
    115144{
    116145        errno_t rc;
    … …  
    120149                return ENOMEM;
    121150
    122         rc  = pcapctl_cat_get_svc(svcname, &svc);
    123         if (rc != EOK) {
     151        rc  = pcapctl_cat_get_svc(index, &svc);
     152        if (rc != EOK) {
     153                printf("Error finding the device with index: %d\n", *index);
    124154                goto error;
    125155        }
     156
    126157        async_sess_t *new_session = loc_service_connect(svc, INTERFACE_PCAP_CONTROL, 0);
    127158        if (new_session == NULL) {
    … …  
    130161                goto error;
    131162        }
    132 
    133163        sess->sess = new_session;
    134164        *rsess = sess;
    … …  
    139169}
    140170
     171/**
     172 *
     173 */
    141174errno_t pcapctl_dump_close(pcapctl_sess_t *sess)
    142175{
Note: See TracChangeset for help on using the changeset viewer.