Changes in / [c37c24c:34aad53d] in mainline


Ignore:
Location:
uspace
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/pcapctl/main.c

    rc37c24c r34aad53d  
    3636#include <str.h>
    3737#include <errno.h>
    38 #include <arg_parse.h>
    39 #include <getopt.h>
    4038
    4139#include "pcapctl_dump.h"
    4240
    4341#define NAME "pcapctl"
    44 #define DEFAULT_DEV_NUM 0
    4542
    46 static errno_t start_dumping(int *dev_number, const char *name)
     43pcapctl_sess_t* sess;
     44
     45static errno_t start_dumping(const char *svc_name, const char *name)
    4746{
    48         pcapctl_sess_t *sess = NULL;
    49         errno_t rc = pcapctl_dump_open(dev_number, &sess);
     47        errno_t rc = pcapctl_dump_open(svc_name, &sess);
    5048        if (rc != EOK) {
    5149                return 1;
    5250        }
    53 
    5451        pcapctl_dump_start(name, sess);
    5552        pcapctl_dump_close(sess);
    … …  
    5754}
    5855
    59 static errno_t stop_dumping(int *dev_number)
     56/** Session might */
     57static errno_t stop_dumping(const char *svc_name)
    6058{
    61         pcapctl_sess_t *sess = NULL;
    62         errno_t rc = pcapctl_dump_open(dev_number, &sess);
     59        errno_t rc = pcapctl_dump_open(svc_name, &sess);
    6360        if (rc != EOK) {
    6461                return 1;
    6562        }
     63
    6664        pcapctl_dump_stop(sess);
    6765        pcapctl_dump_close(sess);
    … …  
    6967}
    7068
    71 static void list_devs(void)
    72 {
     69static void list_devs(void) {
    7370        pcapctl_list();
    7471}
    7572
    76 /**
    77  * Array of supported commandline options
    78  */
    79 static const struct option opts[] = {
    80         { "device", required_argument, 0, 'd' },
    81         { "list", no_argument, 0, 'l' },
    82         { "help", no_argument, 0, 'h' },
    83         { "outfile", required_argument, 0, 'f' },
    84         { "start", no_argument, 0, 'r' },
    85         { "stop", no_argument, 0, 't' },
    86         { 0, 0, 0, 0 }
    87 };
    88 
    89 static void usage(void)
     73static void usage(const char *progname)
    9074{
    91         printf("Usage:\n"
    92             NAME " --list | -l \n"
    93             "\tList of devices\n"
    94             NAME " --start | -r --device= | -d <device number from list> --outfile= | -f <outfile>\n"
    95             "\tPackets dumped from device will be written to <outfile>\n"
    96             NAME " --stop | -t --device= | -d <device>\n"
    97             "\tDumping from <device> stops\n"
    98             NAME " --start | -s --outfile= | -f <outfile>\n"
    99             "\tPackets dumped from the 0. device from the list will be written to <outfile>\n"
    100             NAME " --help | -h\n"
    101             "\tShow this application help.\n");
     75        fprintf(stderr, "Usage:\n");
     76        fprintf(stderr, "  %s list: List of devices\n", progname);
     77        fprintf(stderr, "  %s start <device> <outfile>: Packets dumped from <device> will be written to <outfile>\n", progname);
     78        fprintf(stderr, "  %s stop <device>: Dumping from <device> stops\n", progname);
    10279}
    10380
    10481int main(int argc, char *argv[])
    10582{
    106         bool start = false;
    107         bool stop = false;
    108         int dev_number = DEFAULT_DEV_NUM;
    109         const char *output_file_name;
    110         int idx = 0;
    111         int ret = 0;
    112         if (argc == 1) {
    113                 usage();
    114                 return 0;
    115         }
    116         while (ret != -1) {
    117                 ret = getopt_long(argc, argv, "d:lhf:rt", opts, &idx);
    118                 switch (ret) {
    119                 case 'd':
    120                         char *rest;
    121                         long result = strtol(optarg, &rest, 10);
    122                         dev_number = (int)result;
    123                         errno_t rc = pcapctl_is_valid_device(&dev_number);
    124                         if (rc != EOK) {
    125                                 printf("Device with index %d not found\n", dev_number);
     83        if (argc < 2) {
     84                usage(argv[0]);
     85                return 1;
     86        } else {
     87                if (str_cmp(argv[1], "--help") == 0 || str_cmp(argv[1], "-h") == 0) {
     88                        usage(argv[0]);
     89                        return 0;
     90                } else if (str_cmp(argv[1], "list") == 0) {
     91                        list_devs();
     92                        return 0;
     93                } else if (str_cmp(argv[1], "start") == 0) {
     94                        if (argc != 4) {
     95                                usage(argv[0]);
    12696                                return 1;
    12797                        }
    128                         break;
    129                 case 'l':
    130                         list_devs();
    131                         return 0;
    132                 case 'h':
    133                         usage();
    134                         return 0;
    135                 case 'f':
    136                         output_file_name = optarg;
    137                         break;
    138                 case 'r':
    139                         start = true;
    140                         break;
    141                 case 't':
    142                         stop = true;
    143                         break;
     98                        start_dumping(argv[2], argv[3]);
     99                } else if (str_cmp(argv[1], "stop") == 0) {
     100                        if (argc != 3) {
     101                                usage(argv[0]);
     102                                return 1;
     103                        }
     104                        stop_dumping(argv[2]);
     105                        fprintf(stdout, "Dumping was stopped\n");
     106                        return EOK;
     107                } else {
     108                        usage(argv[0]);
     109                        return 1;
    144110                }
    145         }
    146 
    147         printf("%s: HelenOS Packet Dumping utility: device - %d\n", NAME, dev_number);
    148 
    149         if (start) {
    150                 // start with dev number and optional..name
    151                 start_dumping(&dev_number, output_file_name);
    152         } else if (stop) {
    153                 //stop with dev number
    154                 stop_dumping(&dev_number);
    155111        }
    156112        return 0;

  • uspace/drv/nic/e1k/e1k.c

    rc37c24c r34aad53d  
    22022202                goto err_fun_bind;
    22032203
    2204         // rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
    2205         // if (rc != EOK)
    2206         //      goto err_add_to_cat;
    2207 
    2208         // rc = ddf_fun_add_to_category(fun, "pcap");
    2209         // if (rc != EOK) {
    2210         //      ddf_msg(LVL_ERROR, "Failed adding function to category pcap");
    2211         //      goto err_add_to_cat;
    2212         // }
    2213         rc = nic_fun_add_to_cats(fun);
     2204        rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
     2205        if (rc != EOK)
     2206                goto err_add_to_cat;
     2207
     2208        rc = ddf_fun_add_to_category(fun, "pcap");
    22142209        if (rc != EOK) {
    2215                 ddf_msg(LVL_ERROR, "Failed adding function to categories");
    2216                 return rc;
    2217         }
     2210                ddf_msg(LVL_ERROR, "Failed adding function to category pcap");
     2211                goto err_add_to_cat;
     2212        }
     2213
    22182214        return EOK;
    22192215
    2220         // err_add_to_cat:
    2221         // ddf_fun_unbind(fun);
     2216err_add_to_cat:
     2217        ddf_fun_unbind(fun);
    22222218err_fun_bind:
    22232219err_rx_structure:

  • uspace/drv/nic/ne2k/ne2k.c

    rc37c24c r34aad53d  
    449449                return rc;
    450450        }
    451         rc = ddf_fun_add_to_category(fun, "pcap");
    452         if (rc != EOK) {
    453                 //ddf_msg(LVL_ERROR, "Failed adding function to category pcap");
    454                 ddf_fun_unbind(fun);
    455                 ddf_fun_destroy(fun);
    456                 return rc;
    457         }
    458451
    459452        return EOK;

  • uspace/drv/nic/rtl8139/driver.c

    rc37c24c r34aad53d  
    4242#include <stdio.h>
    4343#include <str.h>
    44 #include <pcapdump_iface.h>
    4544
    4645#include "defs.h"
    … …  
    13141313        }
    13151314
    1316         rc = ddf_fun_add_to_category(fun, "pcap");
    1317         if (rc != EOK) {
    1318                 ddf_msg(LVL_ERROR, "Failed adding function to category pcap");
    1319                 goto err_fun_bind;
    1320         }
    1321 
    13221315        ddf_msg(LVL_NOTE, "The %s device has been successfully initialized.",
    13231316            ddf_dev_get_name(dev));

  • uspace/lib/nic/include/nic.h

    rc37c24c r34aad53d  
    282282extern pcap_iface_t *nic_get_pcap_iface(nic_t *);
    283283
    284 extern errno_t nic_fun_add_to_cats(ddf_fun_t *fun);
    285 
    286284#endif // __NIC_H__
    287285

  • uspace/lib/nic/src/nic_impl.c

    rc37c24c r34aad53d  
    844844}
    845845
    846 errno_t nic_fun_add_to_cats(ddf_fun_t *fun)
    847 {
    848         errno_t rc;
    849         rc = ddf_fun_add_to_category(fun, DEVICE_CATEGORY_NIC);
    850         if (rc != EOK)
    851                 goto err_add_to_cat;
    852 
    853         rc = ddf_fun_add_to_category(fun, "pcap");
    854         if (rc != EOK) {
    855                 //ddf_msg(LVL_ERROR, "Failed adding function to category pcap");
    856                 goto err_add_to_cat;
    857         }
    858         return EOK;
    859 
    860 err_add_to_cat:
    861         ddf_fun_unbind(fun);
    862         return rc;
    863 }
    864 
    865846/** @}
    866847 */

  • uspace/lib/pcap/include/pcapctl_dump.h

    rc37c24c r34aad53d  
    4949} pcapctl_sess_t;
    5050
    51 extern errno_t pcapctl_dump_open(int *, pcapctl_sess_t **rsess);
     51extern errno_t pcapctl_dump_open(const char *svcname, pcapctl_sess_t **rsess);
    5252extern errno_t pcapctl_dump_close(pcapctl_sess_t *sess);
    5353extern errno_t pcapctl_dump_start(const char *, pcapctl_sess_t *);
    5454extern errno_t pcapctl_dump_stop(pcapctl_sess_t *);
    5555extern errno_t pcapctl_list(void);
    56 extern errno_t pcapctl_is_valid_device(int *);
     56
    5757
    5858#endif

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

    rc37c24c r34aad53d  
    3838#include <str.h>
    3939#include <stdlib.h>
    40 #include <stdio.h>
    41 #include <ctype.h>
     40
    4241#include "pcapctl_dump.h"
    4342#include "pcapdump_iface.h"
    … …  
    5251}
    5352
    54 static errno_t pcapctl_cat_get_svc(int *index, service_id_t *svc)
    55 {
     53static errno_t pcapctl_cat_get_svc(const char *drv_name, service_id_t* svc) {
    5654        errno_t rc;
    5755        category_id_t pcap_cat;
    … …  
    6866        if (rc != EOK) {
    6967                printf("Error resolving list of pcap services.\n");
    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 
    82 errno_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");
    9268                return rc;
    9369        }
    9470
    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;
     71        for (unsigned i = 0; i < count; ++i) {
     72                char *name = NULL;
     73                loc_service_get_name(pcap_svcs[i], &name);
     74                if (!str_cmp(drv_name, name)) {
     75                        *svc =  pcap_svcs[i];
     76                        return EOK;
     77                }
    10078        }
    101         if (*index + 1 > (int)count || *index < 0) {
    102                 return EINVAL;
    103         }
    104         return EOK;
     79        free(pcap_svcs);
     80        return 1;
    10581}
    10682
    107 /**
    108  *
    109  */
    110 errno_t pcapctl_list(void)
    111 {
     83extern errno_t pcapctl_list(void) {
     84
    11285        errno_t rc;
    11386        category_id_t pcap_cat;
    … …  
    128101        }
    129102
    130         fprintf(stdout, "Devices:\n");
     103        fprintf(stdout, "Services:\n");
    131104        for (unsigned i = 0; i < count; ++i) {
    132105                char *name = NULL;
    133106                loc_service_get_name(pcap_svcs[i], &name);
    134                 fprintf(stdout, "%d. %s\n", i, name);
     107                fprintf(stdout, "service: %s\n", name);
    135108        }
    136109        free(pcap_svcs);
    … …  
    138111}
    139112
    140 /**
    141  *
    142  */
    143 errno_t pcapctl_dump_open(int *index, pcapctl_sess_t **rsess)
     113
     114errno_t pcapctl_dump_open(const char *svcname, pcapctl_sess_t **rsess)
    144115{
    145116        errno_t rc;
    … …  
    149120                return ENOMEM;
    150121
    151         rc  = pcapctl_cat_get_svc(index, &svc);
     122        rc  = pcapctl_cat_get_svc(svcname, &svc);
    152123        if (rc != EOK) {
    153                 printf("Error finding the device with index: %d\n", *index);
    154124                goto error;
    155125        }
    156 
    157126        async_sess_t *new_session = loc_service_connect(svc, INTERFACE_PCAP_CONTROL, 0);
    158127        if (new_session == NULL) {
    … …  
    161130                goto error;
    162131        }
     132
    163133        sess->sess = new_session;
    164134        *rsess = sess;
    … …  
    169139}
    170140
    171 /**
    172  *
    173  */
    174141errno_t pcapctl_dump_close(pcapctl_sess_t *sess)
    175142{
Note: See TracChangeset for help on using the changeset viewer.