Changeset e5b2777 in mainline

Timestamp:

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

Author:

Nataliia Korop <n.corop08@…>

Children:

31d2aee

Parents:

e1e8f7a

git-author:

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

git-committer:

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

Message:

create drv iface for drivers

Location:

uspace/lib

Files:

• nic/include/nic.h (modified) (1 diff)
• nic/src/nic_driver.c (modified) (5 diffs)
• nic/src/nic_impl.c (modified) (2 diffs)
• pcap/include/pcap.h (modified) (2 diffs)
• pcap/include/pcap_dumper.h (modified) (1 diff)
• pcap/include/pcapdump_client.h (modified) (2 diffs)
• pcap/include/pcapdump_drv_iface.h (added)
• pcap/include/pcapdump_srv.h (modified) (1 diff)
• pcap/meson.build (modified) (1 diff)
• pcap/src/pcap.c (modified) (1 diff)
• pcap/src/pcap_dumper.c (modified) (9 diffs)
• pcap/src/pcapdump_client.c (modified) (7 diffs)
• pcap/src/pcapdump_drv_iface.c (added)
• pcap/src/pcapdump_srv.c (modified) (2 diffs)

uspace/lib/nic/include/nic.h

@@ -280 +280 @@
 
 /* pcapdump interface */
-extern pcap_dumper_t *nic_get_pcap_iface(nic_t *);
+extern pcap_dumper_t *nic_get_pcap_dumper(nic_t *);
 
 extern errno_t nic_fun_add_to_cats(ddf_fun_t *fun);

uspace/lib/nic/src/nic_driver.c

@@ -47 +47 @@
 #include <ops/nic.h>
 #include <errno.h>
-#include <pcapdump_srv.h>
+#include <pcapdump_drv_iface.h>
 
 #include "nic_driver.h"
@@ -523 +523 @@
          *               calls it inside send_frame handler (with locked main lock)
          */
-        pcapdump_packet(nic_get_pcap_iface(nic_data), frame->data, frame->size);
+        pcapdump_packet(nic_get_pcap_dumper(nic_data), frame->data, frame->size);
         fibril_rwlock_read_lock(&nic_data->rxc_lock);
         nic_frame_type_t frame_type;
@@ -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_dumper(nic_data), frame->data, frame->size);
         nic_release_frame(nic_data, frame);
 }
@@ -651 +651 @@
         nic_data->dev = device;
 
-        errno_t pcap_rc  = pcapdump_init(nic_get_pcap_iface(nic_data));
+        errno_t pcap_rc  = pcapdump_init(nic_get_pcap_dumper(nic_data));
         if (pcap_rc != EOK) {
                 printf("Failed creating pcapdump port\n");
@@ -1141 +1141 @@
 }
 
-pcap_dumper_t *nic_get_pcap_iface(nic_t *nic_data)
+pcap_dumper_t *nic_get_pcap_dumper(nic_t *nic_data)
 {
         return &nic_data->pcapdump;

uspace/lib/nic/src/nic_impl.c

@@ -40 +40 @@
 #include <ipc/services.h>
 #include <ns.h>
-#include <pcapdump_srv.h>
+#include <pcapdump_drv_iface.h>
 #include "nic_driver.h"
 #include "nic_ev.h"
@@ -180 +180 @@
                 return EBUSY;
         }
-        pcapdump_packet(nic_get_pcap_iface(nic_data), data, size);
+        pcapdump_packet(nic_get_pcap_dumper(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.h

@@ -55 +55 @@
 #define PCAP_LINKTYPE_IP_RAW 101        /* Raw IP packet */
 #define PCAP_LINKTYPE_IEEE802_11_RADIO 127
+#define PCAP_LINKTYPE_USB_LINUX_MMAPPED 220
 #define WIRESHARK_EX 0xc
 #define WIRESHARK_SNAPLEN 0xffff
@@ -94 +95 @@
 };
 
-extern void pcap_writer_add_header(pcap_writer_t *writer);
+extern void pcap_writer_add_header(pcap_writer_t *writer, uint32_t linktype, bool nano);
 extern void pcap_writer_add_packet(pcap_writer_t *writer, const void *captured_packet, size_t size);
 extern void pcap_set_time(pcap_packet_header_t *header);

uspace/lib/pcap/include/pcap_dumper.h

@@ -46 +46 @@
 } pcap_dumper_t;
 
-extern void pcap_dumper_stop(struct pcap_dumper *);
-extern errno_t pcap_dumper_init(pcap_dumper_t *); ///tahle
+extern void pcap_dumper_stop(pcap_dumper_t *);
 extern int pcap_dumper_get_ops_number(void);
-extern errno_t pcap_dumper_set_ops(struct pcap_dumper *, int);
-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);
+extern errno_t pcap_dumper_set_ops(pcap_dumper_t *, int);
+extern errno_t pcap_dumper_start(pcap_dumper_t *, const char *);
+extern void pcap_dumper_add_packet(pcap_dumper_t *, const void *data, size_t size);
 
 #endif

uspace/lib/pcap/include/pcapdump_client.h

@@ -36 +36 @@
  */
 
-#ifndef _PCAPCTL_DUMP_H_
-#define _PCAPCTL_DUMP_H_
+#ifndef _PCAPDUMP_CLIENT_H_
+#define _PCAPDUMP_CLIENT_H_
 
 #include <stdbool.h>
@@ -51 +51 @@
 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 *, int *, 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_srv.h

@@ -40 +40 @@
 
 #include <errno.h>
-#include "pcap_dumper.h"
 
-extern errno_t pcapdump_init(pcap_dumper_t *);
-extern void pcapdump_packet(pcap_dumper_t *, const void *, size_t);
 extern void pcapdump_conn(ipc_call_t *, void *);
 #endif

uspace/lib/pcap/meson.build

@@ -32 +32 @@
     'src/pcapdump_srv.c',
     'src/pcapdump_client.c',
+    'src/pcapdump_drv_iface.c',
 )

uspace/lib/pcap/src/pcap.c

@@ -56 +56 @@
  *
  */
-void pcap_writer_add_header(pcap_writer_t *writer)
+void pcap_writer_add_header(pcap_writer_t *writer, uint32_t linktype, bool nano)
 {
-        pcap_file_header_t file_header = { PCAP_MAGIC_NANO, PCAP_MAJOR_VERSION, PCAP_MINOR_VERSION,
-                0x00000000, 0x00000000, (uint32_t)PCAP_SNAP_LEN, (uint32_t)PCAP_LINKTYPE_ETHERNET };
+        uint32_t magic_version = PCAP_MAGIC_MICRO;
+        if (nano)
+        {
+                magic_version = PCAP_MAGIC_NANO;
+        }
+        pcap_file_header_t file_header = { magic_version, PCAP_MAJOR_VERSION, PCAP_MINOR_VERSION,
+                0x00000000, 0x00000000, (uint32_t)PCAP_SNAP_LEN, linktype };
         writer->ops->write_buffer(writer, &file_header, sizeof(file_header));
 }

uspace/lib/pcap/src/pcap_dumper.c

@@ -40 +40 @@
 
 #define SHORT_OPS_BYTE_COUNT 60
-#define NAME "pcap"
 
 /** Initialize writing to .pcap file.
@@ -55 +54 @@
                 return EINVAL;
         }
-        pcap_writer_add_header(writer);
+        pcap_writer_add_header(writer, (uint32_t)PCAP_LINKTYPE_ETHERNET, false);
 
         return EOK;
@@ -70 +69 @@
 }
 
+static errno_t pcap_writer_to_file_usb_init(pcap_writer_t *writer, const char *filename)
+{
+        writer->data = fopen(filename, "a");
+        if (writer->data == NULL) {
+                return EINVAL;
+        }
+        pcap_writer_add_header(writer, (uint32_t)PCAP_LINKTYPE_USB_LINUX_MMAPPED, false);
+
+        return EOK;
+}
+
 static size_t pcap_file_w32(pcap_writer_t *writer, uint32_t data)
 {
@@ -122 +132 @@
 };
 
-static pcap_writer_ops_t ops[3] = {file_ops, short_file_ops, append_file_ops};
+static const pcap_writer_ops_t usb_file_ops = {
+        .open = &pcap_writer_to_file_usb_init,
+        .write_u32 = &pcap_file_w32,
+        .write_u16 = &pcap_file_w16,
+        .write_buffer = &pcap_file_wbuffer,
+        .close = &pcap_file_close
+};
+
+static pcap_writer_ops_t ops[4] = {file_ops, short_file_ops, append_file_ops, usb_file_ops};
 
 int pcap_dumper_get_ops_number(void)
@@ -129 +147 @@
 }
 
-errno_t pcap_dumper_start(struct pcap_dumper *dumper, const char *name)
+errno_t pcap_dumper_start(pcap_dumper_t *dumper, const char *name)
 {
         fibril_mutex_lock(&dumper->mutex);
@@ -147 +165 @@
 }
 
-errno_t pcap_dumper_set_ops(struct pcap_dumper *dumper, int index)
+errno_t pcap_dumper_set_ops(pcap_dumper_t *dumper, int index)
 {
         fibril_mutex_lock(&dumper->mutex);
@@ -156 +174 @@
 }
 
-void pcap_dumper_add_packet(struct pcap_dumper *dumper, const void *data, size_t size)
+void pcap_dumper_add_packet(pcap_dumper_t *dumper, const void *data, size_t size)
 {
         fibril_mutex_lock(&dumper->mutex);
@@ -169 +187 @@
 }
 
-void pcap_dumper_stop(struct pcap_dumper *dumper)
+void pcap_dumper_stop(pcap_dumper_t *dumper)
 {
         fibril_mutex_lock(&dumper->mutex);
@@ -183 +201 @@
 }
 
-/** Initialize interface for dumping packets
- *
- * @param dumper Device dumping interface
- *
- */
-errno_t pcap_dumper_init(pcap_dumper_t *dumper)
-{
-        fibril_mutex_initialize(&dumper->mutex);
-        dumper->to_dump = false;
-        dumper->writer.ops = NULL;
-
-        errno_t rc = log_init(NAME);
-        if (rc != EOK) {
-                printf("%s : Failed to initialize log.\n", NAME);
-                return 1;
-        }
-        return EOK;
-}
+
 
 /** @}

uspace/lib/pcap/src/pcapdump_client.c

@@ -61 +61 @@
         rc = loc_category_get_id("pcap", &pcap_cat, 0);
         if (rc != EOK) {
-                printf("Error resolving category 'pcap'.\n");
+                fprintf(stderr, "Error resolving category 'pcap'.\n");
                 return rc;
         }
@@ -67 +67 @@
         rc = loc_category_get_svcs(pcap_cat, &pcap_svcs, &count);
         if (rc != EOK) {
-                printf("Error resolving list of pcap services.\n");
+                fprintf(stderr, "Error resolving list of pcap services.\n");
                 free(pcap_svcs);
                 return rc;
@@ -89 +89 @@
         rc = loc_category_get_id("pcap", &pcap_cat, 0);
         if (rc != EOK) {
-                printf("Error resolving category pcap.\n");
+                fprintf(stderr, "Error resolving category pcap.\n");
                 return rc;
         }
@@ -95 +95 @@
         rc = loc_category_get_svcs(pcap_cat, &pcap_svcs, &count);
         if (rc != EOK) {
-                printf("Error resolving list of pcap services.\n");
+                fprintf(stderr, "Error resolving list of pcap services.\n");
                 free(pcap_svcs);
                 return rc;
@@ -141 +141 @@
         rc = loc_category_get_id("pcap", &pcap_cat, 0);
         if (rc != EOK) {
-                printf("Error resolving category pcap.\n");
+                fprintf(stderr, "Error resolving category pcap.\n");
                 return rc;
         }
@@ -147 +147 @@
         rc = loc_category_get_svcs(pcap_cat, &pcap_svcs, &count);
         if (rc != EOK) {
-                printf("Error resolving list of pcap services.\n");
+                fprintf(stderr, "Error resolving list of pcap services.\n");
                 free(pcap_svcs);
                 return rc;
@@ -179 +179 @@
         rc  = pcapctl_cat_get_svc(index, &svc);
         if (rc != EOK) {
-                printf("Error finding the device with index: %d\n", *index);
+                fprintf(stderr, "Error finding the device with index: %d\n", *index);
                 goto error;
         }

uspace/lib/pcap/src/pcapdump_srv.c

@@ -43 +43 @@
 #include <io/log.h>
 
+#include "pcap_dumper.h"
 #include "pcapdump_srv.h"
 #include "pcapdump_ipc.h"
@@ -127 +128 @@
 }
 
-errno_t pcapdump_init(pcap_dumper_t *dumper)
-{
-        port_id_t port;
-        errno_t rc;
 
-        rc = pcap_dumper_init(dumper);
-
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_DEBUG, "Failed creating pcap interface: %s", str_error(rc));
-                return rc;
-        }
-
-        rc = async_create_port(INTERFACE_PCAP_CONTROL, pcapdump_conn, dumper, &port);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_DEBUG, "Failed creating port: %s", str_error(rc));
-                return rc;
-        }
-        return EOK;
-}
-
-/** Dumping function for driver
- *
- * Called every time, the packet is sent/recieved by the device
- *
- * @param dumper Dumping interface
- * @param data The packet
- * @param size Size of the packet
- *
- */
-void pcapdump_packet(pcap_dumper_t *dumper, const void *data, size_t size)
-{
-        if (dumper == NULL) {
-                return;
-        }
-        pcap_dumper_add_packet(dumper, data, size);
-}
 
 /** @}