dabba/capture.c

   1 /* __LICENSE_HEADER_BEGIN__ */
   2
   3 /*
   4  * Copyright (C) 2009-2012      Emmanuel Roullit <emmanuel.roullit@gmail.com>
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or (at
   9  * your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13  * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
  14  * for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along
  17  * with this program; if not, write to the Free Software Foundation, Inc.,
  18  * 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
  19  *
  20  */
  21
  22 /* __LICENSE_HEADER_END__ */
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <assert.h>
  28 #include <getopt.h>
  29 #include <inttypes.h>
  30 #include <errno.h>
  31
  32 #include <dabbacore/macros.h>
  33 #include <dabbacore/strlcpy.h>
  34 #include <dabbacore/packet_mmap.h>
  35 #include <dabba/dabba.h>
  36 #include <dabba/help.h>
  37 #include <dabba/ipc.h>
  38 #include <dabbad/dabbad.h>
  39
  40 enum capture_start_option {
  41         OPT_CAPTURE_DEVICE,
  42         OPT_CAPTURE_PCAP,
  43         OPT_CAPTURE_SIZE
  44 };
  45
  46 static struct option *capture_start_options_get(void)
  47 {
  48         static struct option capture_start_option[] = {
  49                 {"device", required_argument, NULL, OPT_CAPTURE_DEVICE},
  50                 {"pcap", required_argument, NULL, OPT_CAPTURE_PCAP},
  51                 {"size", required_argument, NULL, OPT_CAPTURE_SIZE},
  52                 {NULL, 0, NULL, 0},
  53         };
  54
  55         return capture_start_option;
  56 }
  57
  58 static int prepare_capture_start_query(int argc, char **argv,
  59                                        struct dabba_ipc_msg *msg)
  60 {
  61         struct dabba_capture *capture_start_msg = msg->msg_body.msg.capture;
  62         int ret = 0;
  63         int rc = 0;
  64
  65         assert(msg);
  66         msg->mtype = 1;
  67         msg->msg_body.type = DABBA_CAPTURE_START;
  68
  69         while ((ret =
  70                 getopt_long_only(argc, argv, "", capture_start_options_get(),
  71                                  NULL)) != EOF) {
  72                 switch (ret) {
  73                 case OPT_CAPTURE_DEVICE:
  74                         strlcpy(capture_start_msg->dev_name, optarg,
  75                                 sizeof(capture_start_msg->dev_name));
  76                         break;
  77
  78                 case OPT_CAPTURE_PCAP:
  79                         strlcpy(capture_start_msg->pcap_name, optarg,
  80                                 sizeof(capture_start_msg->pcap_name));
  81                         break;
  82                 case OPT_CAPTURE_SIZE:
  83                         capture_start_msg->size = strtoull(optarg, NULL, 10);
  84                         break;
  85                 default:
  86                         show_usage(capture_start_options_get());
  87                         rc = -1;
  88                         break;
  89                 }
  90         }
  91
  92         /* Assume conservative values for now */
  93         capture_start_msg->page_order = 10;
  94         capture_start_msg->frame_size = PACKET_MMAP_ETH_FRAME_LEN;
  95
  96         return rc;
  97 }
  98
  99 static void prepare_capture_list_query(struct dabba_ipc_msg *msg)
 100 {
 101         assert(msg);
 102         msg->mtype = 1;
 103         msg->msg_body.type = DABBA_CAPTURE_LIST;
 104 }
 105
 106 static void display_capture_list_msg_header(void)
 107 {
 108         printf("---\n");
 109         printf("  captures:\n");
 110 }
 111
 112 static void display_capture_list(const struct dabba_ipc_msg const *msg)
 113 {
 114         size_t a;
 115
 116         assert(msg);
 117         assert(msg->msg_body.elem_nr <= ARRAY_SIZE(msg->msg_body.msg.capture));
 118
 119         for (a = 0; a < msg->msg_body.elem_nr; a++) {
 120                 printf("    - id: %u\n",
 121                        (uint32_t) msg->msg_body.msg.capture[a].thread_id);
 122                 printf("      packet mmap size: %" PRIu64 "\n",
 123                        msg->msg_body.msg.capture[a].size);
 124         }
 125 }
 126
 127 int cmd_capture_start(int argc, const char **argv)
 128 {
 129         struct dabba_ipc_msg msg;
 130         int rc;
 131
 132         assert(argc >= 0);
 133         assert(argv);
 134
 135         memset(&msg, 0, sizeof(msg));
 136
 137         rc = prepare_capture_start_query(argc, (char **)argv, &msg);
 138
 139         if (rc)
 140                 return rc;
 141
 142         /* For now, just one capture request at a time */
 143         msg.msg_body.elem_nr = 1;
 144
 145         return dabba_ipc_msg(&msg);
 146 }
 147
 148 int cmd_capture_list(int argc, const char **argv)
 149 {
 150         int rc;
 151         struct dabba_ipc_msg msg;
 152
 153         assert(argc >= 0);
 154         assert(argv);
 155
 156         memset(&msg, 0, sizeof(msg));
 157         prepare_capture_list_query(&msg);
 158         display_capture_list_msg_header();
 159
 160         do {
 161                 msg.msg_body.offset += msg.msg_body.elem_nr;
 162                 msg.msg_body.elem_nr = 0;
 163
 164                 rc = dabba_ipc_msg(&msg);
 165
 166                 if (rc)
 167                         break;
 168
 169                 display_capture_list(&msg);
 170         } while (msg.msg_body.elem_nr);
 171
 172         return rc;
 173 }
 174
 175 int cmd_capture(int argc, const char **argv)
 176 {
 177         const char *cmd = argv[0];
 178         size_t i;
 179         static struct cmd_struct capture_commands[] = {
 180                 {"list", cmd_capture_list, 0},
 181                 {"start", cmd_capture_start, 0}
 182         };
 183
 184         /* TODO --help handling here */
 185
 186         for (i = 0; ARRAY_SIZE(capture_commands); i++) {
 187                 struct cmd_struct *p = capture_commands + i;
 188                 if (strcmp(p->cmd, cmd))
 189                         continue;
 190                 return (run_builtin(p, argc, argv));
 191         }
 192
 193         return ENOSYS;
 194 }