Changeset 03cd7a9e in mainline


Ignore:
Timestamp:
2024-12-13T08:44:05Z (10 months ago)
Author:
Nataliia Korop <n.corop08@…>
Children:
f08447b
Parents:
59fe16d
git-author:
Nataliia Korop <n.corop08@…> (2024-10-28 09:57:08)
git-committer:
Nataliia Korop <n.corop08@…> (2024-12-13 08:44:05)
Message:

refactoring after 23.10

Location:
uspace
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/pcapctl/main.c

    r59fe16d r03cd7a9e  
    107107        bool stop = false;
    108108        int dev_number = -1;
    109         const char *output_file_name;
     109        const char *output_file_name = "";
    110110        int idx = 0;
    111111        int ret = 0;
    … …  
    117117                ret = getopt_long(argc, argv, "d:lhf:rt", opts, &idx);
    118118                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;
     119                        case 'd':
     120                        {
     121                                char *rest;
     122                                long result = strtol(optarg, &rest, 10);
     123                                dev_number = (int)result;
     124                                errno_t rc = pcapctl_is_valid_device(&dev_number);
     125                                if (rc != EOK) {
     126                                        printf("Device with index %d not found\n", dev_number);
     127                                        return 1;
     128                                }
     129                                break;
    127130                        }
    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;
     131                        case 'l':
     132                        {
     133                                list_devs();
     134                                return 0;
     135                        }
     136                        case 'h':
     137                        {
     138                                usage();
     139                                return 0;
     140                        }
     141                        case 'f':
     142                        {
     143                                output_file_name = optarg;
     144                                break;
     145                        }
     146                        case 'r':
     147                        {
     148                                start = true;
     149                                break;
     150                        }
     151                        case 't':
     152                        {       stop = true;
     153                                break;
     154                        }
    144155                }
    145156        }
    146157
    147         printf("%s: HelenOS Packet Dumping utility: device - %d\n", NAME, dev_number);
     158        printf("%s: HelenOS Packet Dumping utility: device - %d.\n", NAME, dev_number);
    148159
    149160        if (start) {
    150                 // start with dev number and optional..name
     161                /* start with dev number and name*/
    151162                start_dumping(&dev_number, output_file_name);
    152163        } else if (stop) {
    153                 //stop with dev number
     164                /* stop with dev number*/
    154165                stop_dumping(&dev_number);
    155166        }

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

    r59fe16d r03cd7a9e  
    22092209        return EOK;
    22102210
    2211         // err_add_to_cat:
    2212         // ddf_fun_unbind(fun);
    22132211err_fun_bind:
    22142212err_rx_structure:

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

    r59fe16d r03cd7a9e  
    280280
    281281/* pcapdump interface */
    282 extern pcap_iface_t *nic_get_pcap_iface(nic_t *);
     282extern pcap_dumper_t *nic_get_pcap_iface(nic_t *);
    283283
    284284extern errno_t nic_fun_add_to_cats(ddf_fun_t *fun);

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

    r59fe16d r03cd7a9e  
    198198
    199199        /** Interface for dumping packets */
    200         pcap_iface_t pcapdump;
     200        pcap_dumper_t pcapdump;
    201201
    202202        /** Data specific for particular driver */

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

    r59fe16d r03cd7a9e  
    11411141}
    11421142
    1143 pcap_iface_t *nic_get_pcap_iface(nic_t *nic_data)
     1143pcap_dumper_t *nic_get_pcap_iface(nic_t *nic_data)
    11441144{
    11451145        return &nic_data->pcapdump;

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

    r59fe16d r03cd7a9e  
    850850        if (rc != EOK)
    851851                return rc;
    852                 return rc;
    853852
    854853        rc = ddf_fun_add_to_category(fun, "pcap");

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

    r59fe16d r03cd7a9e  
    5454#define PCAP_LINKTYPE_ETHERNET 1    /* IEEE 802.3 Ethernet */
    5555#define PCAP_LINKTYPE_IP_RAW 101        /* Raw IP packet */
     56#define PCAP_LINKTYPE_IEEE802_11_RADIO 127
    5657#define WIRESHARK_EX 0xc
    5758#define WIRESHARK_SNAPLEN 0xffff
    … …  
    99100    pcap_writer_t *writer, const void *captured_packet, size_t size);
    100101
    101 extern void pcap_set_time(pcap_packet_header_t *header, bool nano);
     102extern void pcap_set_time(pcap_packet_header_t *header);
    102103
    103104#endif

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

    r59fe16d r03cd7a9e  
    3737
    3838#include <errno.h>
     39#include <fibril_synch.h>
    3940#include "pcap.h"
    4041
    41 typedef struct pcap_iface {
     42typedef struct pcap_dumper {
     43        fibril_mutex_t mutex;
    4244        bool to_dump;
    43         errno_t (*init)(const char *);
    44         void (*add_packet)(const void *data, size_t size);
    45         void (*fini)(void);
    46 } pcap_iface_t;
     45        pcap_writer_t writer;
     46} pcap_dumper_t;
    4747
    48 extern void pcap_close_file(void);
    49 extern errno_t pcap_iface_init(pcap_iface_t *);
    50 //init to file
    51 //init to serial
    52 //add packet, dostane strukturu, data, velikost ... to to this pcap_iface_t
     48
     49extern void pcap_dumper_stop(struct pcap_dumper *);
     50
     51extern errno_t pcap_dumper_init(pcap_dumper_t *);
     52
    5353// v ramci init jeste linktype prg
    5454//set snaplen taky lze pridavat prg
    55 //create kam posila
    56 // init
    57 extern errno_t pcap_init(const char *);
    58 extern void pcap_add_packet(const void *data, size_t size);
     55
     56extern errno_t pcap_dumper_start(struct pcap_dumper *, const char *);
     57extern void pcap_dumper_add_packet(struct pcap_dumper *, const void *data, size_t size);
    5958
    6059#endif

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

    r59fe16d r03cd7a9e  
    4848} pcap_request_t;
    4949
    50 extern errno_t pcapdump_init(pcap_iface_t *);
    51 extern void pcapdump_packet(pcap_iface_t *, const void *, size_t);
    52 
     50extern errno_t pcapdump_init(pcap_dumper_t *);
     51extern void pcapdump_packet(pcap_dumper_t *, const void *, size_t);
    5352extern void pcapdump_conn(ipc_call_t *, void *);
    5453#endif

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

    r59fe16d r03cd7a9e  
    4343 *
    4444 */
    45 void pcap_set_time(pcap_packet_header_t *header, bool nano) // maybe without bool nano as nano is in pcapng
     45void pcap_set_time(pcap_packet_header_t *header)
    4646{
    4747        struct timespec ts;
    4848        getrealtime(&ts);
    4949        header->seconds_stamp = (uint32_t)ts.tv_sec;
    50         header->magic_stamp = (uint32_t)ts.tv_nsec / 1000;
     50        header->magic_stamp = (uint32_t)ts.tv_nsec;
    5151}
    5252
    … …  
    5858void pcap_writer_add_header(pcap_writer_t *writer)
    5959{
    60         pcap_file_header_t file_header = { PCAP_MAGIC_MICRO, PCAP_MAJOR_VERSION, PCAP_MINOR_VERSION,
     60        pcap_file_header_t file_header = { PCAP_MAGIC_NANO, PCAP_MAJOR_VERSION, PCAP_MINOR_VERSION,
    6161                0x00000000, 0x00000000, (uint32_t)PCAP_SNAP_LEN, (uint32_t)PCAP_LINKTYPE_ETHERNET };
    6262        writer->ops->write_buffer(writer, &file_header, sizeof(file_header));
    … …  
    7575                return;
    7676        pcap_packet_header_t pcap_packet;
    77         pcap_set_time(&pcap_packet, false);
    78         pcap_packet.original_length = (uint32_t)size;
     77        pcap_set_time(&pcap_packet);
     78        pcap_packet.original_length = size;
    7979
    8080        if (PCAP_SNAP_LEN < size) {
    … …  
    9898{
    9999        errno_t rc;
    100         printf("File: %s\n", filename);
    101100        writer->data = fopen(filename, "a");
    102101        if (writer->data == NULL) {

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

    r59fe16d r03cd7a9e  
    6565};
    6666
    67 static pcap_writer_t pcap_writer = {
    68         .ops = &file_ops,
    69 };
     67// static size_t pcap_short_file_w32(pcap_writer_t *writer, uint32_t data)
     68// {
     69//      return fwrite(&data, 1, 4, (FILE *)writer->data);
     70// }
    7071
    71 errno_t pcap_init(const char *name)
     72// static size_t pcap_short_file_w16(pcap_writer_t *writer, uint16_t data)
     73// {
     74//      return fwrite(&data, 1, 2, (FILE *)writer->data);
     75// }
     76
     77// static size_t pcap_short_file_wbuffer(pcap_writer_t *writer, const void *data, size_t size)
     78// {
     79//      return fwrite(data, 1, size<60?size:60, (FILE *)writer->data);
     80// }
     81
     82// static void pcap_short_file_close(pcap_writer_t *writer)
     83// {
     84//      fclose((FILE *)writer->data);
     85// }
     86
     87
     88// static pcap_writer_ops_t short_file_ops = {
     89//      .write_u32 = &pcap_short_file_w32,
     90//      .write_u16 = &pcap_short_file_w16,
     91//      .write_buffer = &pcap_short_file_wbuffer,
     92//      .close = &pcap_short_file_close
     93
     94// };
     95
     96errno_t pcap_dumper_start(struct pcap_dumper *dumper, const char *name)
    7297{
    73         errno_t rc = pcap_writer_to_file_init(&pcap_writer, name);
     98        fibril_mutex_lock(&dumper->mutex);
     99
     100        /** When try to start when already started, close current and starts new */
     101        if (dumper->to_dump == true)
     102        {
     103                pcap_dumper_stop(dumper);
     104        }
     105        errno_t rc = pcap_writer_to_file_init(&dumper->writer, name);
     106        if (rc == EOK)
     107        {
     108                dumper->to_dump = true;
     109        }
     110        else
     111        {
     112                printf("Failed creating pcap dumper: %s", str_error(rc));
     113        }
     114        fibril_mutex_unlock(&dumper->mutex);
    74115        return rc;
    75116}
    76117
    77 void pcap_add_packet(const void *data, size_t size)
     118//udelat globalni
     119void pcap_dumper_add_packet(struct pcap_dumper *dumper, const void *data, size_t size)
    78120{
    79         if (pcap_writer.data == NULL)
     121        fibril_mutex_lock(&dumper->mutex);
     122
     123        if (dumper->writer.data == NULL || !dumper->to_dump)
     124        {
     125                fibril_mutex_unlock(&dumper->mutex);
    80126                return;
    81         pcap_writer_add_packet(&pcap_writer, data, size);
     127        }
     128        pcap_writer_add_packet(&dumper->writer, data, size);
     129        fibril_mutex_unlock(&dumper->mutex);
    82130}
    83131
    84 void pcap_close_file(void)
     132//udelt globalni
     133void pcap_dumper_stop(struct pcap_dumper *dumper)
    85134{
    86         pcap_writer.ops->close(&pcap_writer);
    87         pcap_writer.data = NULL;
     135        fibril_mutex_lock(&dumper->mutex);
     136
     137        /** If want to stop, when already stopped, do nothing */
     138        if (dumper->to_dump == false) {
     139                fibril_mutex_unlock(&dumper->mutex);
     140                return;
     141        }
     142        dumper->to_dump = false;
     143        dumper->writer.ops->close(&dumper->writer);
     144        dumper->writer.data = NULL;
     145        fibril_mutex_unlock(&dumper->mutex);
    88146}
    89147
    90148/** Initialize interface for dumping packets
    91149 *
    92  * @param iface Device dumping interface
     150 * @param dumper Device dumping interface
    93151 *
    94152 */
    95 errno_t pcap_iface_init(pcap_iface_t *iface)
     153errno_t pcap_dumper_init(pcap_dumper_t *dumper)
    96154{
    97         iface->to_dump = false;
    98         iface->add_packet = pcap_add_packet;
    99         iface->init = pcap_init;
    100         iface->fini = pcap_close_file;
    101 
     155        fibril_mutex_initialize(&dumper->mutex);
     156        dumper->to_dump = false;
     157        dumper->writer.ops = &file_ops;
    102158        return EOK;
    103159}

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

    r59fe16d r03cd7a9e  
    151151        printf("number: %d\n", *index);
    152152        if (*index == -1) {
    153 
    154                 rc = loc_service_get_id("net/eth1", &svc, 0);
    155                 if (rc != EOK)
    156                 {
    157                         fprintf(stderr, "Error getting service id.\n");
    158                         return ENOENT;
    159                 }
    160         }
    161         else {
    162                 rc  = pcapctl_cat_get_svc(index, &svc);
    163                 if (rc != EOK) {
    164                         printf("Error finding the device with index: %d\n", *index);
    165                         goto error;
    166                 }
     153                *index = 0;
     154        }
     155
     156        rc  = pcapctl_cat_get_svc(index, &svc);
     157        if (rc != EOK) {
     158                printf("Error finding the device with index: %d\n", *index);
     159                goto error;
    167160        }
    168161
    … …  
    206199        aid_t req = async_send_0(exch, PCAP_CONTROL_SET_START, NULL);
    207200
    208         rc = async_data_write_start(exch, (const void *) name, size);
     201        rc = async_data_write_start(exch, (const void *)name, size);
    209202
    210203        pcapctl_dump_exchange_end(exch);

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

    r59fe16d r03cd7a9e  
    3838#include <async.h>
    3939#include <errno.h>
     40#include <stdlib.h>
    4041#include <fibril_synch.h>
     42#include <str.h>
    4143
    4244#include "pcapdump_iface.h"
    4345
    44 FIBRIL_MUTEX_INITIALIZE(to_dump_mutex);
    45 
    46 static void pcapdump_start_srv(ipc_call_t *icall, pcap_iface_t *iface)
     46static void pcapdump_start_srv(ipc_call_t *icall, pcap_dumper_t *dumper)
    4747{
    4848        char *data;
    4949        size_t size;
    50         errno_t rc = async_data_write_accept((void **) &data, false, 0, 0, 0, &size);
     50        errno_t rc = async_data_write_accept((void **) &data, true, 0, 0, 0, &size);
    5151        if (rc != EOK) {
    5252                async_answer_0(icall, rc);
    … …  
    5454        }
    5555
    56         /** When try to start when already started, close current and starts new */
    57         if (iface->to_dump == true) {
    58                 iface->fini();
     56        assert(str_length(data) == size && "Data were damaged during transmission.\n");
     57
     58        rc = pcap_dumper_start(dumper, (const char *)data);
     59        free(data);
     60        if (rc != EOK)
     61        {
     62                //TODO what?
    5963        }
    60         iface->init((const char *)data);
    61 
    62         fibril_mutex_lock(&to_dump_mutex);
    63         iface->to_dump = true;
    64         fibril_mutex_unlock(&to_dump_mutex);
    65 
    66         async_answer_0(icall, rc);
     64        async_answer_0(icall, EOK);
    6765}
    6866
    69 static void pcapdump_stop_srv(ipc_call_t *icall, pcap_iface_t *iface)
     67static void pcapdump_stop_srv(ipc_call_t *icall, pcap_dumper_t *dumper)
    7068{
    71         /** If want to stop, when already stopped, do nothing */
    72         if (iface->to_dump == false) {
    73                 async_answer_0(icall, EOK);
    74                 return;
    75         }
    76 
    77         fibril_mutex_lock(&to_dump_mutex);
    78         iface->to_dump = false;
    79         fibril_mutex_unlock(&to_dump_mutex);
    80 
    81         iface->fini();
     69        pcap_dumper_stop(dumper);
    8270        async_answer_0(icall, EOK);
    8371}
    … …  
    8573void pcapdump_conn(ipc_call_t *icall, void *arg)
    8674{
    87         pcap_iface_t *iface = (pcap_iface_t *)arg;
    88         printf("pcapdump_conn\n");
    89         assert((iface != NULL) && "pcapdump requires pcap interface\n");
     75        pcap_dumper_t *dumper = (pcap_dumper_t *)arg;
     76
     77        assert((dumper != NULL) && "pcapdump requires pcap dumper\n");
    9078
    9179        /* Accept connection */
    … …  
    10391                switch (method) {
    10492                case PCAP_CONTROL_SET_START:
    105                         pcapdump_start_srv(&call, iface);
     93                        pcapdump_start_srv(&call, dumper);
    10694                        break;
    10795                case PCAP_CONTROL_SET_STOP:
    108                         pcapdump_stop_srv(&call, iface);
     96                        pcapdump_stop_srv(&call, dumper);
    10997                        break;
    11098                default:
    … …  
    115103}
    116104
    117 errno_t pcapdump_init(pcap_iface_t *iface)
     105errno_t pcapdump_init(pcap_dumper_t *dumper)
    118106{
    119107        port_id_t port;
    120108        errno_t rc;
    121109
    122         rc = pcap_iface_init(iface);
     110        rc = pcap_dumper_init(dumper);
    123111
    124112        if (rc != EOK) {
    … …  
    128116
    129117        rc = async_create_port(INTERFACE_PCAP_CONTROL,
    130             pcapdump_conn, iface, &port);
     118            pcapdump_conn, dumper, &port);
    131119        if (rc != EOK) {
    132120                return rc;
    … …  
    139127 * Called every time, the packet is sent/recieved by the device
    140128 *
    141  * @param iface Dumping interface
     129 * @param dumper Dumping interface
    142130 * @param data The packet
    143131 * @param size Size of the packet
    144132 *
    145133 */
    146 void pcapdump_packet(pcap_iface_t *iface, const void *data, size_t size)
     134void pcapdump_packet(pcap_dumper_t *dumper, const void *data, size_t size)
    147135{
    148136
    149         if (iface == NULL) {
     137        if (dumper == NULL) {
    150138                return;
    151139        }
    152140
    153         if (!iface->to_dump) {
    154                 return;
    155         }
    156 
    157         iface->add_packet(data, size);
     141        pcap_dumper_add_packet(dumper, data, size);
    158142}
    159143

  • uspace/srv/net/ethip/ethip.c

    r59fe16d r03cd7a9e  
    5555#define NAME "ethip"
    5656/** Interface for dumping packets */
    57 pcap_iface_t pcapdump;
    5857
    5958static errno_t ethip_open(iplink_srv_t *srv);
    … …  
    9392        }
    9493
    95         rc = pcapdump_init(&pcapdump);
    96         if (rc != EOK) {
    97                 log_msg(LOG_DEFAULT, LVL_ERROR, "Failed initializing dumping interface.");
    98                 return rc;
    99         }
    10094
    10195        rc = ethip_nic_discovery_start();
    … …  
    206200        if (rc != EOK)
    207201                return rc;
    208         pcapdump_packet(&pcapdump, data, size);
    209202        rc = ethip_nic_send(nic, data, size);
    210203        free(data);
    … …  
    251244                return rc;
    252245        }
    253         pcapdump_packet(&pcapdump, data, size);
    254246
    255247        iplink_recv_sdu_t sdu;
Note: See TracChangeset for help on using the changeset viewer.