Changeset 325ea9c in mainline

Timestamp:

2024-03-04T08:47:50Z (2 months ago)

Author:

Nataliia Korop <n.corop08@…>

Children:

e846bec

Parents:

192019f

Message:

long name without mapping ok

Location:

uspace

Files:

• app/pcapctl/main.c (modified) (3 diffs)
• lib/pcap/include/pcapctl_dump.h (modified) (1 diff)
• lib/pcap/include/pcapdump_iface.h (modified) (1 diff)
• lib/pcap/src/pcapctl_dump.c (modified) (3 diffs)

uspace/app/pcapctl/main.c

@@ -50 +50 @@
 pcapctl_sess_t sess;
 
-static void start_dumping(const char *name)
+static errno_t start_dumping(const char *drv_name, const char *name)
 {
+        errno_t rc = pcapctl_dump_init(&sess, drv_name);
+        if (rc != EOK) {
+                //fprintf(stderr, "Error initializing ...\n");
+                return 1;
+        }
         pcapctl_dump_start(name, &sess);
+        return EOK;
 }
 
-static void stop_dumping(void)
+/** Session might */
+static errno_t stop_dumping(const char *drv_name)
 {
+        errno_t rc = pcapctl_dump_init(&sess, drv_name);
+        if (rc != EOK) {
+                fprintf(stderr, "Error initializing ...\n");
+                return 1;
+        }
         pcapctl_dump_stop(&sess);
+        return EOK;
+}
+
+static void list_devs(void) {
+        pcapctl_list();
 }
 
@@ -63 +80 @@
 {
         fprintf(stderr, "Usage:\n");
-        fprintf(stderr, "  %s start <outfile>: Packets will be written to <outfile>\n", progname);
-        fprintf(stderr, "  %s stop: Dumping stops\n", progname);
+        fprintf(stderr, "  %s start <device> <outfile>: Packets dumped from <device> will be written to <outfile>\n", progname);
+        fprintf(stderr, "  %s stop <device>: Dumping from <device> stops\n", progname);
 
 }
@@ -74 +91 @@
                 return 1;
         } else {
-                errno_t rc = pcapctl_dump_init(&sess);
-                if (rc != EOK) {
-                        fprintf(stderr, "Error initializing ...\n");
-                        return 1;
-                }
-                if (str_cmp(argv[1], "start") == 0) {
+                if (str_cmp(argv[1], "--help") == 0 || str_cmp(argv[1], "-h") == 0) {
+                        usage(argv[0]);
+                        return 0;
+                } else if (str_cmp(argv[1], "list") == 0) {
+                        list_devs();
+                        return 0;
+                } else if (str_cmp(argv[1], "start") == 0) {
+                        if (argc != 4) {
+                                usage(argv[0]);
+                                return 1;
+                        }
+                        start_dumping(argv[2], argv[3]);
+                } else if (str_cmp(argv[1], "stop") == 0) {
                         if (argc != 3) {
                                 usage(argv[0]);
                                 return 1;
                         }
-                        start_dumping(argv[2]);
-                } else if (str_cmp(argv[1], "stop") == 0) {
-                        stop_dumping();
+                        stop_dumping(argv[2]);
                         fprintf(stdout, "Dumping was stopped\n");
                         return EOK;

uspace/lib/pcap/include/pcapctl_dump.h

@@ -49 +49 @@
 } pcapctl_sess_t;
 
-extern errno_t pcapctl_dump_init(pcapctl_sess_t *);
+extern errno_t pcapctl_dump_init(pcapctl_sess_t *, const char *);
 extern errno_t pcapctl_dump_start(const char *, pcapctl_sess_t *);
 extern errno_t pcapctl_dump_stop(pcapctl_sess_t *);
+extern errno_t pcapctl_list(void);
 
 #endif

uspace/lib/pcap/include/pcapdump_iface.h

@@ -44 +44 @@
 typedef enum {
         PCAP_CONTROL_SET_START = IPC_FIRST_USER_METHOD,
-        PCAP_CONTROL_SET_STOP
+        PCAP_CONTROL_SET_STOP,
+        PCAP_CONTROL_GET_NAME
 } pcap_request_t;
 

uspace/lib/pcap/src/pcapctl_dump.c

@@ -51 +51 @@
 }
 
-errno_t pcapctl_dump_init(pcapctl_sess_t *sess)
-{
+static errno_t pcapctl_cat_has_drv(const char *drv_name, service_id_t* svc) {
         errno_t rc;
-        char *svc_name;
         category_id_t pcap_cat;
         size_t count;
@@ -70 +68 @@
                 return rc;
         }
+
+        for (unsigned i = 0; i < count; ++i) {
+                char *name = NULL;
+                loc_service_get_name(pcap_svcs[i], &name);
+                if (!str_cmp(drv_name, name)) {
+                        *svc =  pcap_svcs[i];
+                        return EOK;
+                }
+        }
+        free(pcap_svcs);
+        return 1;
+}
+
+extern errno_t pcapctl_list(void) {
+
+        errno_t rc;
+        category_id_t pcap_cat;
+        size_t count;
+        service_id_t *pcap_svcs = NULL;
+
+        rc = loc_category_get_id("pcap", &pcap_cat, 0);
+        if (rc != EOK) {
+                printf("Error resolving category 'pcap'.\n");
+                return rc;
+        }
+
+        rc = loc_category_get_svcs(pcap_cat, &pcap_svcs, &count);
+        if (rc != EOK) {
+                printf("Error resolving list of pcap services.\n");
+                return rc;
+        }
+
         assert((count > 0) && "TODO: not implemented when no services are available\n");
 
-        rc = loc_service_get_name(pcap_svcs[0], &svc_name); // Note: for now [0], because only one driver is in pcap_svcs and there is no need to find particular
+        fprintf(stdout, "Drivers:\n");
+        for (unsigned i = 0; i < count; ++i) {
+                char *name = NULL;
+                loc_service_get_name(pcap_svcs[i], &name);
+
+                fprintf(stdout, "driver: %s\n", name);
+        }
+        return EOK;
+}
+
+errno_t pcapctl_dump_init(pcapctl_sess_t *sess, const char *drv_name)
+{
+        errno_t rc;
+        service_id_t svc;
+        rc  = pcapctl_cat_has_drv(drv_name, &svc);
         if (rc != EOK) {
-                printf("Error getting service name.\n");
-                goto error;
+                fprintf(stderr, "No such driver was found.\n");
+                return 1;
         }
-        printf("Using device: %s\n", svc_name);
-
-        async_sess_t *new_session = loc_service_connect(pcap_svcs[0], INTERFACE_PCAP_CONTROL, 0);
+        async_sess_t *new_session = loc_service_connect(svc, INTERFACE_PCAP_CONTROL, 0);
         if (new_session == NULL) {
-                printf("Error connecting to service.\n");
+                fprintf(stderr, "Error connecting to service.\n");
                 rc =  EREFUSED;
                 goto error;
@@ -88 +130 @@
         rc = EOK;
 error:
-        free(pcap_svcs);
         return rc;
 }