Changes in / [34aad53d:c37c24c] in mainline


Ignore:
Location:
uspace
Files:
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/pcapctl/main.c

    r34aad53d rc37c24c  
    3636#include <str.h>
    3737#include <errno.h>
     38#include <arg_parse.h>
     39#include <getopt.h>
    3840
    3941#include "pcapctl_dump.h"
    4042
    4143#define NAME "pcapctl"
     44#define DEFAULT_DEV_NUM 0
    4245
    43 pcapctl_sess_t* sess;
    44 
    45 static errno_t start_dumping(const char *svc_name, const char *name)
     46static errno_t start_dumping(int *dev_number, const char *name)
    4647{
    47         errno_t rc = pcapctl_dump_open(svc_name, &sess);
     48        pcapctl_sess_t *sess = NULL;
     49        errno_t rc = pcapctl_dump_open(dev_number, &sess);
    4850        if (rc != EOK) {
    4951                return 1;
    5052        }
     53
    5154        pcapctl_dump_start(name, sess);
    5255        pcapctl_dump_close(sess);
    … …  
    5457}
    5558
    56 /** Session might */
    57 static errno_t stop_dumping(const char *svc_name)
     59static errno_t stop_dumping(int *dev_number)
    5860{
    59         errno_t rc = pcapctl_dump_open(svc_name, &sess);
     61        pcapctl_sess_t *sess = NULL;
     62        errno_t rc = pcapctl_dump_open(dev_number, &sess);
    6063        if (rc != EOK) {
    6164                return 1;
    6265        }
    63 
    6466        pcapctl_dump_stop(sess);
    6567        pcapctl_dump_close(sess);
    … …  
    6769}
    6870
    69 static void list_devs(void) {
     71static void list_devs(void)
     72{
    7073        pcapctl_list();
    7174}
    7275
    73 static void usage(const char *progname)
     76/**
     77 * Array of supported commandline options
     78 */
     79static 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
     89static void usage(void)
    7490{
    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);
     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");
    79102}
    80103
    81104int main(int argc, char *argv[])
    82105{
    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) {
     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);
     126                                return 1;
     127                        }
     128                        break;
     129                case 'l':
    91130                        list_devs();
    92131                        return 0;
    93                 } else if (str_cmp(argv[1], "start") == 0) {
    94                         if (argc != 4) {
    95                                 usage(argv[0]);
    96                                 return 1;
    97                         }
    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;
     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;
    110144                }
     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);
    111155        }
    112156        return 0;

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

    r34aad53d rc37c24c  
    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");
     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);
    22092214        if (rc != EOK) {
    2210                 ddf_msg(LVL_ERROR, "Failed adding function to category pcap");
    2211                 goto err_add_to_cat;
    2212         }
    2213 
     2215                ddf_msg(LVL_ERROR, "Failed adding function to categories");
     2216                return rc;
     2217        }
    22142218        return EOK;
    22152219
    2216 err_add_to_cat:
    2217         ddf_fun_unbind(fun);
     2220        // err_add_to_cat:
     2221        // ddf_fun_unbind(fun);
    22182222err_fun_bind:
    22192223err_rx_structure:

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

    r34aad53d rc37c24c  
    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        }
    451458
    452459        return EOK;

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

    r34aad53d rc37c24c  
    4242#include <stdio.h>
    4343#include <str.h>
     44#include <pcapdump_iface.h>
    4445
    4546#include "defs.h"
    … …  
    13131314        }
    13141315
     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
    13151322        ddf_msg(LVL_NOTE, "The %s device has been successfully initialized.",
    13161323            ddf_dev_get_name(dev));

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

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

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

    r34aad53d rc37c24c  
    844844}
    845845
     846errno_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
     860err_add_to_cat:
     861        ddf_fun_unbind(fun);
     862        return rc;
     863}
     864
    846865/** @}
    847866 */

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

    r34aad53d rc37c24c  
    4949} pcapctl_sess_t;
    5050
    51 extern errno_t pcapctl_dump_open(const char *svcname, pcapctl_sess_t **rsess);
     51extern errno_t pcapctl_dump_open(int *, 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 
     56extern errno_t pcapctl_is_valid_device(int *);
    5757
    5858#endif

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

    r34aad53d rc37c24c  
    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.