Changeset 1d14090 in mainline

Timestamp:

2024-12-13T08:44:05Z (10 months ago)

Author:

Nataliia Korop <n.corop08@…>

Children:

64ea525

Parents:

f08447b

git-author:

Nataliia Korop <n.corop08@…> (2024-11-10 09:08:41)

git-committer:

Nataliia Korop <n.corop08@…> (2024-12-13 08:44:05)

Message:

dumper ops can be set by user

Location:

uspace

Files:

• app/pcapctl/main.c (modified) (6 diffs)
• lib/nic/include/nic.h (modified) (1 diff)
• lib/nic/src/nic_driver.c (modified) (1 diff)
• lib/nic/src/nic_impl.c (modified) (1 diff)
• lib/pcap/include/pcap_dumper.h (moved) (moved from uspace/lib/pcap/include/pcap_iface.h ) (1 diff)
• lib/pcap/include/pcapctl_dump.h (modified) (1 diff)
• lib/pcap/include/pcapdump_iface.h (modified) (1 diff)
• lib/pcap/meson.build (modified) (1 diff)
• lib/pcap/src/pcap.c (modified) (1 diff)
• lib/pcap/src/pcap_dumper.c (moved) (moved from uspace/lib/pcap/src/pcap_iface.c ) (9 diffs)
• lib/pcap/src/pcapctl_dump.c (modified) (2 diffs)
• lib/pcap/src/pcapdump_iface.c (modified) (2 diffs)

uspace/app/pcapctl/main.c

@@ -52 +52 @@
         }
 
-        pcapctl_dump_start(name, sess);
+        rc = pcapctl_dump_start(name, sess);
+        if (rc != EOK)
+        {
+                printf("Starting the dumping was not successful.\n");
+        }
         pcapctl_dump_close(sess);
         return EOK;
@@ -64 +68 @@
                 return 1;
         }
-        pcapctl_dump_stop(sess);
+        rc = pcapctl_dump_stop(sess);
+        if (rc != EOK)
+        {
+                printf("Stoping the dumping was not successful.\n");
+        }
+        pcapctl_dump_close(sess);
+        return EOK;
+}
+
+static errno_t set_dumper_ops(int *dev_number, const char *name)
+{
+        pcapctl_sess_t *sess = NULL;
+        errno_t rc = pcapctl_dump_open(dev_number, &sess);
+        if (rc != EOK)
+        {
+                return rc;
+        }
+
+        rc = pcapctl_dump_set_ops(name, sess);
+        if (rc != EOK)
+        {
+                printf("Setting dumper ops was not successful.\n");
+        }
         pcapctl_dump_close(sess);
         return EOK;
@@ -84 +110 @@
         { "start", no_argument, 0, 'r' },
         { "stop", no_argument, 0, 't' },
+        { "ops", required_argument, 0, 'o' },
         { 0, 0, 0, 0 }
 };
@@ -106 +133 @@
         bool start = false;
         bool stop = false;
+        bool set_ops = false;
         int dev_number = -1;
         const char *output_file_name = "";
+        const char *ops_name = "";
         int idx = 0;
         int ret = 0;
@@ -142 +171 @@
                         stop = true;
                         break;
+                case 'o':
+                        set_ops = true;
+                        ops_name = optarg;
+                        break;
                 }
         }
@@ -154 +187 @@
                 stop_dumping(&dev_number);
         }
+        else if (set_ops)
+        {
+                set_dumper_ops(&dev_number, ops_name);
+        }
         return 0;
 }

uspace/lib/nic/include/nic.h

@@ -44 +44 @@
 #include <device/hw_res_parsed.h>
 #include <ops/nic.h>
-#include <pcap_iface.h>
+#include <pcap_dumper.h>
 
 #define DEVICE_CATEGORY_NIC "nic"

uspace/lib/nic/src/nic_driver.c

@@ -562 +562 @@
                 fibril_rwlock_write_unlock(&nic_data->stats_lock);
         }
-        pcapdump_packet(nic_get_pcap_iface(nic_data), frame->data, frame->size);
+        //pcapdump_packet(nic_get_pcap_iface(nic_data), frame->data, frame->size);
         nic_release_frame(nic_data, frame);
 }

uspace/lib/nic/src/nic_impl.c

@@ -180 +180 @@
                 return EBUSY;
         }
-        //pcapdump_packet(nic_get_pcap_iface(nic_data), data, size);
+        pcapdump_packet(nic_get_pcap_iface(nic_data), data, size);
         nic_data->send_frame(nic_data, data, size);
         fibril_rwlock_read_unlock(&nic_data->main_lock);

uspace/lib/pcap/include/pcap_dumper.h

@@ -48 +48 @@
 extern void pcap_dumper_stop(struct pcap_dumper *);
 extern errno_t pcap_dumper_init(pcap_dumper_t *);
-
-// v ramci init jeste linktype prg
-//set snaplen taky lze pridavat prg
-
+extern errno_t pcap_dumper_set_ops(struct pcap_dumper *, const char *);
 extern errno_t pcap_dumper_start(struct pcap_dumper *, const char *);
 extern void pcap_dumper_add_packet(struct pcap_dumper *, const void *data, size_t size);

uspace/lib/pcap/include/pcapctl_dump.h

@@ -49 +49 @@
 } pcapctl_sess_t;
 
-extern errno_t pcapctl_dump_open(int *, pcapctl_sess_t **rsess);
-extern errno_t pcapctl_dump_close(pcapctl_sess_t *sess);
+extern errno_t pcapctl_dump_open(int *, pcapctl_sess_t **);
+extern errno_t pcapctl_dump_close(pcapctl_sess_t *);
 extern errno_t pcapctl_dump_start(const char *, pcapctl_sess_t *);
+extern errno_t pcapctl_dump_set_ops(const char *, pcapctl_sess_t *);
 extern errno_t pcapctl_dump_stop(pcapctl_sess_t *);
 extern errno_t pcapctl_list(void);

uspace/lib/pcap/include/pcapdump_iface.h

@@ -40 +40 @@
 
 #include <errno.h>
-#include "pcap_iface.h"
+#include "pcap_dumper.h"
 
 typedef enum {
         PCAP_CONTROL_SET_START = IPC_FIRST_USER_METHOD,
         PCAP_CONTROL_SET_STOP,
-        PCAP_CONTROL_GET_NAME
+        PCAP_CONTROL_GET_NAME,
+        PCAP_CONTROL_SET_OPS,
 } pcap_request_t;
 

uspace/lib/pcap/meson.build

@@ -29 +29 @@
 src = files(
     'src/pcap.c',
-    'src/pcap_iface.c',
+    'src/pcap_dumper.c',
     'src/pcapdump_iface.c',
     'src/pcapctl_dump.c',

uspace/lib/pcap/src/pcap.c

@@ -72 +72 @@
 void pcap_writer_add_packet(pcap_writer_t *writer, const void *captured_packet, size_t size)
 {
-        if (!writer->data)
-                return;
+
         pcap_packet_header_t pcap_packet;
         pcap_set_time(&pcap_packet);

uspace/lib/pcap/src/pcap_dumper.c

@@ -35 +35 @@
 
 #include <errno.h>
-#include "pcap_iface.h"
+#include <str.h>
+#include "pcap_dumper.h"
 
 static size_t pcap_file_w32(pcap_writer_t *writer, uint32_t data)
@@ -49 +50 @@
 static size_t pcap_file_wbuffer(pcap_writer_t *writer, const void *data, size_t size)
 {
+        assert(writer->data);
         return fwrite(data, 1, size, (FILE *)writer->data);
 }
@@ -55 +57 @@
 {
         fclose((FILE *)writer->data);
+        writer->data = NULL;
 }
 
@@ -65 +68 @@
 };
 
-// static size_t pcap_short_file_w32(pcap_writer_t *writer, uint32_t data)
-// {
-//      return fwrite(&data, 1, 4, (FILE *)writer->data);
-// }
+static size_t pcap_short_file_w32(pcap_writer_t *writer, uint32_t data)
+{
+        return fwrite(&data, 1, 4, (FILE *)writer->data);
+}
 
-// static size_t pcap_short_file_w16(pcap_writer_t *writer, uint16_t data)
-// {
-//      return fwrite(&data, 1, 2, (FILE *)writer->data);
-// }
+static size_t pcap_short_file_w16(pcap_writer_t *writer, uint16_t data)
+{
+        return fwrite(&data, 1, 2, (FILE *)writer->data);
+}
 
-// static size_t pcap_short_file_wbuffer(pcap_writer_t *writer, const void *data, size_t size)
-// {
-//      return fwrite(data, 1, size<60?size:60, (FILE *)writer->data);
-// }
+static size_t pcap_short_file_wbuffer(pcap_writer_t *writer, const void *data, size_t size)
+{
+        return fwrite(data, 1, size<60?size:60, (FILE *)writer->data);
+}
 
-// static void pcap_short_file_close(pcap_writer_t *writer)
-// {
-//      fclose((FILE *)writer->data);
-// }
+static void pcap_short_file_close(pcap_writer_t *writer)
+{
+        fclose((FILE *)writer->data);
+}
 
-// static pcap_writer_ops_t short_file_ops = {
-//      .write_u32 = &pcap_short_file_w32,
-//      .write_u16 = &pcap_short_file_w16,
-//      .write_buffer = &pcap_short_file_wbuffer,
-//      .close = &pcap_short_file_close
+static pcap_writer_ops_t short_file_ops = {
+        .write_u32 = &pcap_short_file_w32,
+        .write_u16 = &pcap_short_file_w16,
+        .write_buffer = &pcap_short_file_wbuffer,
+        .close = &pcap_short_file_close
 
-// };
+};
 
 errno_t pcap_dumper_start(struct pcap_dumper *dumper, const char *name)
@@ -98 +101 @@
 
         /** When try to start when already started, close current and starts new */
-        if (dumper->to_dump == true) {
+        if (dumper->to_dump) {
                 pcap_dumper_stop(dumper);
         }
@@ -111 +114 @@
 }
 
-//udelat globalni
+errno_t pcap_dumper_set_ops(struct pcap_dumper *dumper, const char *name)
+{
+        fibril_mutex_lock(&dumper->mutex);
+        errno_t rc = EOK;
+        if (!str_cmp(name, "short_file"))
+        {
+                dumper->writer.ops = &short_file_ops;
+        }
+        else if (!str_cmp(name, "full_file"))
+        {
+                dumper->writer.ops = &file_ops;
+        }
+        else
+        {
+                rc = EINVAL;
+        }
+        fibril_mutex_unlock(&dumper->mutex);
+        return rc;
+}
+
+
 void pcap_dumper_add_packet(struct pcap_dumper *dumper, const void *data, size_t size)
 {
         fibril_mutex_lock(&dumper->mutex);
 
-        if (dumper->writer.data == NULL || !dumper->to_dump) {
+        if (!dumper->to_dump) {
                 fibril_mutex_unlock(&dumper->mutex);
                 return;
         }
+
         pcap_writer_add_packet(&dumper->writer, data, size);
         fibril_mutex_unlock(&dumper->mutex);
 }
 
-//udelt globalni
 void pcap_dumper_stop(struct pcap_dumper *dumper)
 {
@@ -130 +153 @@
 
         /** If want to stop, when already stopped, do nothing */
-        if (dumper->to_dump == false) {
+        if (!dumper->to_dump) {
                 fibril_mutex_unlock(&dumper->mutex);
                 return;
@@ -136 +159 @@
         dumper->to_dump = false;
         dumper->writer.ops->close(&dumper->writer);
-        dumper->writer.data = NULL;
         fibril_mutex_unlock(&dumper->mutex);
 }
@@ -149 +171 @@
         fibril_mutex_initialize(&dumper->mutex);
         dumper->to_dump = false;
-        dumper->writer.ops = &file_ops;
+        dumper->writer.ops = NULL;
         return EOK;
 }

uspace/lib/pcap/src/pcapctl_dump.c

@@ -198 +198 @@
         aid_t req = async_send_0(exch, PCAP_CONTROL_SET_START, NULL);
 
-        rc = async_data_write_start(exch, (const void *)name, size);
+        rc = async_data_write_start(exch, name, size);
 
         pcapctl_dump_exchange_end(exch);
@@ -227 +227 @@
 }
 
+errno_t pcapctl_dump_set_ops(const char *ops_name, pcapctl_sess_t *sess)
+{
+        errno_t rc;
+        async_exch_t *exch = async_exchange_begin(sess->sess);
+
+        size_t size = str_size(ops_name);
+        aid_t req = async_send_0(exch, PCAP_CONTROL_SET_OPS, NULL);
+
+        rc = async_data_write_start(exch, ops_name, size);
+
+        pcapctl_dump_exchange_end(exch);
+
+        if (rc != EOK) {
+                async_forget(req);
+                return rc;
+        }
+
+        errno_t retval;
+        async_wait_for(req, &retval);
+        return retval;
+}
+
 /** @}
  */

uspace/lib/pcap/src/pcapdump_iface.c

@@ -70 +70 @@
 }
 
+static void pcapdump_set_ops_srv(ipc_call_t *icall, pcap_dumper_t *dumper)
+{
+        char *data;
+        size_t size;
+        errno_t rc = async_data_write_accept((void **) &data, true, 0, 0, 0, &size);
+        if (rc != EOK) {
+                async_answer_0(icall, rc);
+                return;
+        }
+
+        assert(str_length(data) == size && "Data were damaged during transmission.\n");
+
+        rc = pcap_dumper_set_ops(dumper, (const char *)data);
+        free(data);
+        if (rc != EOK) {
+                //TODO what?
+        }
+        async_answer_0(icall, EOK);
+
+}
+
 void pcapdump_conn(ipc_call_t *icall, void *arg)
 {
@@ -94 +115 @@
                 case PCAP_CONTROL_SET_STOP:
                         pcapdump_stop_srv(&call, dumper);
+                        break;
+                case PCAP_CONTROL_SET_OPS:
+                        pcapdump_set_ops_srv(&call, dumper);
                         break;
                 default: