Changeset e1e8f7a in mainline


Ignore:
Timestamp:
2024-12-13T08:44:05Z (11 months ago)
Author:
Nataliia Korop <n.corop08@…>
Children:
e5b2777
Parents:
467d2b9
git-author:
Nataliia Korop <n.corop08@…> (2024-11-16 11:14:06)
git-committer:
Nataliia Korop <n.corop08@…> (2024-12-13 08:44:05)
Message:

set ops as number and with start req

Location:
uspace
Files:
1 added
8 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/pcapctl/main.c

    r467d2b9 re1e8f7a  
    4343#define NAME "pcapctl"
    4444#define DEFAULT_DEV_NUM 0
     45#define DECIMAL_SYSTEM 10
    4546
    46 static errno_t start_dumping(int *dev_number, const char *name)
     47static errno_t start_dumping(int *dev_number, const char *name, int *ops_index)
    4748{
    4849        pcapctl_sess_t *sess = NULL;
    … …  
    5253        }
    5354
    54         rc = pcapctl_dump_start(name, sess);
     55        rc = pcapctl_is_valid_ops_number(ops_index, sess);
     56        if (rc != EOK)
     57        {
     58                printf("Wrong number of ops: %d.\n", *ops_index);
     59                pcapctl_dump_close(sess);
     60                return rc;
     61        }
     62
     63        rc = pcapctl_dump_start(name, ops_index, sess);
    5564        if (rc != EOK) {
    5665                printf("Starting the dumping was not successful.\n");
    … …  
    7079        if (rc != EOK) {
    7180                printf("Stoping the dumping was not successful.\n");
    72         }
    73         pcapctl_dump_close(sess);
    74         return EOK;
    75 }
    76 
    77 static errno_t set_dumper_ops(int *dev_number, const char *name)
    78 {
    79         pcapctl_sess_t *sess = NULL;
    80         errno_t rc = pcapctl_dump_open(dev_number, &sess);
    81         if (rc != EOK) {
    82                 return rc;
    83         }
    84 
    85         rc = pcapctl_dump_set_ops(name, sess);
    86         if (rc != EOK) {
    87                 printf("Setting dumper ops was not successful.\n");
    8881        }
    8982        pcapctl_dump_close(sess);
    … …  
    129122        bool start = false;
    130123        bool stop = false;
    131         bool set_ops = false;
    132124        int dev_number = -1;
     125        int ops_number = -1;
    133126        const char *output_file_name = "";
    134         const char *ops_name = "";
    135127        int idx = 0;
    136128        int ret = 0;
    … …  
    144136                case 'd':
    145137                        char *rest;
    146                         long result = strtol(optarg, &rest, 10);
    147                         dev_number = (int)result;
     138                        long dev_result = strtol(optarg, &rest, DECIMAL_SYSTEM);
     139                        dev_number = (int)dev_result;
    148140                        errno_t rc = pcapctl_is_valid_device(&dev_number);
    149141                        if (rc != EOK) {
    … …  
    168160                        break;
    169161                case 'o':
    170                         set_ops = true;
    171                         ops_name = optarg;
     162                        char* ops_inval;
     163                        long ops_result = strtol(optarg, &ops_inval, DECIMAL_SYSTEM);
     164                        ops_number = (int)ops_result;
    172165                        break;
    173166                }
    … …  
    178171        if (start) {
    179172                /* start with dev number and name */
    180                 start_dumping(&dev_number, output_file_name);
     173                start_dumping(&dev_number, output_file_name, &ops_number);
    181174        } else if (stop) {
    182175                /* stop with dev number */
    183176                stop_dumping(&dev_number);
    184         } else if (set_ops) {
    185                 set_dumper_ops(&dev_number, ops_name);
    186177        }
    187178        return 0;

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

    r467d2b9 re1e8f7a  
    8181/** Operations for dumper. */
    8282typedef struct {
    83         errno_t (*open)(struct pcap_writer *, const char *);
     83        errno_t (*open)(pcap_writer_t *, const char *);
    8484        size_t (*write_u32)(struct pcap_writer *, uint32_t);
    8585        size_t (*write_u16)(struct pcap_writer *, uint16_t);
    … …  
    8989
    9090/** Interface for working with .pcap file. */
    91 typedef struct pcap_writer {
     91struct pcap_writer {
    9292        void *data;
    9393        pcap_writer_ops_t *ops;
    94 } pcap_writer_t;
     94};
    9595
    9696extern void pcap_writer_add_header(pcap_writer_t *writer);

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

    r467d2b9 re1e8f7a  
    4747
    4848extern void pcap_dumper_stop(struct pcap_dumper *);
    49 extern errno_t pcap_dumper_init(pcap_dumper_t *);
    50 extern errno_t pcap_dumper_set_ops(struct pcap_dumper *, const char *);
     49extern errno_t pcap_dumper_init(pcap_dumper_t *); ///tahle
     50extern int pcap_dumper_get_ops_number(void);
     51extern errno_t pcap_dumper_set_ops(struct pcap_dumper *, int);
    5152extern errno_t pcap_dumper_start(struct pcap_dumper *, const char *);
    5253extern void pcap_dumper_add_packet(struct pcap_dumper *, const void *data, size_t size);

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

    r467d2b9 re1e8f7a  
    5151extern errno_t pcapctl_dump_open(int *, pcapctl_sess_t **);
    5252extern errno_t pcapctl_dump_close(pcapctl_sess_t *);
    53 extern errno_t pcapctl_dump_start(const char *, pcapctl_sess_t *);
    54 extern errno_t pcapctl_dump_set_ops(const char *, pcapctl_sess_t *);
     53extern errno_t pcapctl_dump_start(const char *, int *, pcapctl_sess_t *);
     54// extern errno_t pcapctl_dump_set_ops(const char *, pcapctl_sess_t *);
    5555extern errno_t pcapctl_dump_stop(pcapctl_sess_t *);
    5656extern errno_t pcapctl_list(void);
    5757extern errno_t pcapctl_is_valid_device(int *);
     58extern errno_t pcapctl_is_valid_ops_number(int *index, pcapctl_sess_t* sess);
     59
    5860
    5961#endif

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

    r467d2b9 re1e8f7a  
    4242#include "pcap_dumper.h"
    4343
    44 typedef enum {
    45         PCAP_CONTROL_SET_START = IPC_FIRST_USER_METHOD,
    46         PCAP_CONTROL_SET_STOP,
    47         PCAP_CONTROL_GET_NAME,
    48         PCAP_CONTROL_SET_OPS,
    49 } pcap_request_t;
    50 
    5144extern errno_t pcapdump_init(pcap_dumper_t *);
    5245extern void pcapdump_packet(pcap_dumper_t *, const void *, size_t);

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

    r467d2b9 re1e8f7a  
    3939#include "pcap_dumper.h"
    4040
     41#define SHORT_OPS_BYTE_COUNT 60
     42#define NAME "pcap"
     43
    4144/** Initialize writing to .pcap file.
    4245 *
    … …  
    4851static errno_t pcap_writer_to_file_init(pcap_writer_t *writer, const char *filename)
    4952{
    50         errno_t rc;
    5153        writer->data = fopen(filename, "a");
    5254        if (writer->data == NULL) {
    53                 rc = EINVAL;
    54                 return rc;
     55                return EINVAL;
    5556        }
    5657        pcap_writer_add_header(writer);
    5758
    58         rc = EOK;
    59         return rc;
     59        return EOK;
     60}
     61
     62static errno_t pcap_writer_to_file_init_append(pcap_writer_t *writer, const char *filename)
     63{
     64        writer->data = fopen(filename, "a");
     65        if (writer->data == NULL) {
     66                return EINVAL;
     67        }
     68
     69        return EOK;
    6070}
    6171
    … …  
    8292}
    8393
    84 static pcap_writer_ops_t file_ops = {
     94static const pcap_writer_ops_t file_ops = {
    8595        .open = &pcap_writer_to_file_init,
    8696        .write_u32 = &pcap_file_w32,
    … …  
    90100};
    91101
    92 static size_t pcap_short_file_w32(pcap_writer_t *writer, uint32_t data)
    93 {
    94         return fwrite(&data, 1, 4, (FILE *)writer->data);
    95 }
    96 
    97 static size_t pcap_short_file_w16(pcap_writer_t *writer, uint16_t data)
    98 {
    99         return fwrite(&data, 1, 2, (FILE *)writer->data);
    100 }
    101 
    102102static size_t pcap_short_file_wbuffer(pcap_writer_t *writer, const void *data, size_t size)
    103103{
    104         return fwrite(data, 1, size < 60 ? size : 60, (FILE *)writer->data);
    105 }
    106 
    107 static void pcap_short_file_close(pcap_writer_t *writer)
    108 {
    109         fclose((FILE *)writer->data);
    110 }
    111 
    112 static pcap_writer_ops_t short_file_ops = {
     104        return fwrite(data, 1, size < 60 ? size : 60, (FILE *)writer->data); //define
     105}
     106
     107static const pcap_writer_ops_t short_file_ops = {
    113108        .open = &pcap_writer_to_file_init,
    114         .write_u32 = &pcap_short_file_w32,
    115         .write_u16 = &pcap_short_file_w16,
     109        .write_u32 = &pcap_file_w32,
     110        .write_u16 = &pcap_file_w16,
    116111        .write_buffer = &pcap_short_file_wbuffer,
    117         .close = &pcap_short_file_close
     112        .close = &pcap_file_close
    118113
    119114};
     115
     116static const pcap_writer_ops_t append_file_ops = {
     117        .open = &pcap_writer_to_file_init_append,
     118        .write_u32 = &pcap_file_w32,
     119        .write_u16 = &pcap_file_w16,
     120        .write_buffer = &pcap_file_wbuffer,
     121        .close = &pcap_file_close
     122};
     123
     124static pcap_writer_ops_t ops[3] = {file_ops, short_file_ops, append_file_ops};
     125
     126int pcap_dumper_get_ops_number(void)
     127{
     128        return (int)(sizeof(ops) / sizeof(pcap_writer_ops_t));
     129}
    120130
    121131errno_t pcap_dumper_start(struct pcap_dumper *dumper, const char *name)
    … …  
    137147}
    138148
    139 errno_t pcap_dumper_set_ops(struct pcap_dumper *dumper, const char *name)
     149errno_t pcap_dumper_set_ops(struct pcap_dumper *dumper, int index)
    140150{
    141151        fibril_mutex_lock(&dumper->mutex);
    142152        errno_t rc = EOK;
    143         if (!str_cmp(name, "short_file")) {
    144                 dumper->writer.ops = &short_file_ops;
    145         } else if (!str_cmp(name, "full_file")) {
    146                 dumper->writer.ops = &file_ops;
    147         } else {
    148                 rc = EINVAL;
    149         }
     153        dumper->writer.ops = &ops[index];
    150154        fibril_mutex_unlock(&dumper->mutex);
    151155        return rc;
    … …  
    190194        dumper->writer.ops = NULL;
    191195
    192         errno_t rc = log_init("pcap");
     196        errno_t rc = log_init(NAME);
    193197        if (rc != EOK) {
    194                 printf("pcap : Failed to initialize log.\n");
     198                printf("%s : Failed to initialize log.\n", NAME);
    195199                return 1;
    196200        }

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

    r467d2b9 re1e8f7a  
    4141#include <ctype.h>
    4242#include "pcapdump_client.h"
    43 #include "pcapdump_srv.h"
     43#include "pcapdump_ipc.h"
    4444
    4545/** Finish an async exchange on the pcapctl session
    … …  
    100100        }
    101101        if (*index + 1 > (int)count || *index < 0) {
     102                return EINVAL;
     103        }
     104        return EOK;
     105}
     106
     107
     108errno_t pcapctl_is_valid_ops_number(int *index, pcapctl_sess_t* sess)
     109{
     110        async_exch_t *exch = async_exchange_begin(sess->sess);
     111        ipc_call_t answer;
     112        aid_t req = async_send_0(exch, PCAP_CONTROL_GET_OPS_NUM, &answer);
     113
     114        async_exchange_end(exch);
     115
     116        errno_t retval;
     117        async_wait_for(req, &retval);
     118
     119        if (retval != EOK) {
     120                return retval;
     121        }
     122
     123        int ops_count = (int)ipc_get_arg1(&answer);
     124        if (*index + 1 > ops_count || *index < 0)
     125        {
    102126                return EINVAL;
    103127        }
    … …  
    149173                return ENOMEM;
    150174
    151         printf("number: %d\n", *index);
    152175        if (*index == -1) {
    153176                *index = 0;
    … …  
    190213 * @return EOK on success or an error code
    191214 */
    192 errno_t pcapctl_dump_start(const char *name, pcapctl_sess_t *sess)
     215errno_t pcapctl_dump_start(const char *name, int *ops_index, pcapctl_sess_t *sess)
    193216{
    194217        errno_t rc;
    … …  
    196219
    197220        size_t size = str_size(name);
    198         aid_t req = async_send_0(exch, PCAP_CONTROL_SET_START, NULL);
     221        aid_t req = async_send_1(exch, PCAP_CONTROL_SET_START, *ops_index, NULL);
    199222
    200223        rc = async_data_write_start(exch, name, size);
    … …  
    227250}
    228251
    229 errno_t pcapctl_dump_set_ops(const char *ops_name, pcapctl_sess_t *sess)
    230 {
    231         errno_t rc;
    232         async_exch_t *exch = async_exchange_begin(sess->sess);
    233 
    234         size_t size = str_size(ops_name);
    235         aid_t req = async_send_0(exch, PCAP_CONTROL_SET_OPS, NULL);
    236 
    237         rc = async_data_write_start(exch, ops_name, size);
    238 
    239         pcapctl_dump_exchange_end(exch);
    240 
    241         if (rc != EOK) {
    242                 async_forget(req);
    243                 return rc;
    244         }
    245 
    246         errno_t retval;
    247         async_wait_for(req, &retval);
    248         return retval;
    249 }
    250252
    251253/** @}

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

    r467d2b9 re1e8f7a  
    4444
    4545#include "pcapdump_srv.h"
     46#include "pcapdump_ipc.h"
    4647
    4748static void pcapdump_start_srv(ipc_call_t *icall, pcap_dumper_t *dumper)
    … …  
    4950        char *data;
    5051        size_t size;
     52        int ops_index = (int)ipc_get_arg1(icall);
    5153        errno_t rc = async_data_write_accept((void **) &data, true, 0, 0, 0, &size);
    5254        if (rc != EOK) {
    … …  
    5658
    5759        assert(str_length(data) == size && "Data were damaged during transmission.\n");
     60
     61        rc = pcap_dumper_set_ops(dumper, ops_index);
     62        if (rc != EOK)
     63        {
     64                log_msg(LOG_DEFAULT, LVL_DEBUG, "Setting ops for dumper was not successful.\n");
     65                free(data);
     66                async_answer_0(icall, EOK);
     67                return;
     68        }
    5869
    5970        rc = pcap_dumper_start(dumper, (const char *)data);
    … …  
    7182}
    7283
    73 static void pcapdump_set_ops_srv(ipc_call_t *icall, pcap_dumper_t *dumper)
     84
     85static void pcapdump_get_ops_num_srv(ipc_call_t *icall)
    7486{
    75         char *data;
    76         size_t size;
    77         errno_t rc = async_data_write_accept((void **) &data, true, 0, 0, 0, &size);
    78         if (rc != EOK) {
    79                 async_answer_0(icall, rc);
    80                 return;
    81         }
     87        size_t count = pcap_dumper_get_ops_number();
    8288
    83         assert(str_length(data) == size && "Data were damaged during transmission.\n");
     89        log_msg(LOG_DEFAULT, LVL_NOTE, "Getting number of ops.\n");
    8490
    85         rc = pcap_dumper_set_ops(dumper, (const char *)data);
    86         free(data);
    87         if (rc != EOK) {
    88                 log_msg(LOG_DEFAULT, LVL_DEBUG, "Setting ops for dumper was not successful.\n");
    89         }
    90 
    91         log_msg(LOG_DEFAULT, LVL_NOTE, "Setting ops for dumper was successful.\n");
    92 
    93         async_answer_0(icall, EOK);
     91        async_answer_1(icall, EOK, count);
    9492}
    9593
    … …  
    119117                        pcapdump_stop_srv(&call, dumper);
    120118                        break;
    121                 case PCAP_CONTROL_SET_OPS:
    122                         pcapdump_set_ops_srv(&call, dumper);
     119                case PCAP_CONTROL_GET_OPS_NUM:
     120                        pcapdump_get_ops_num_srv(&call);
    123121                        break;
    124122                default:
Note: See TracChangeset for help on using the changeset viewer.