echld/echld-int.h

   1 /* echld_child-int.h
   2  *  epan working child API internals
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * Copyright (c) 2013 by Luis Ontanon <luis@ontanon.org>
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  25  */
  26 #ifndef __ECHLD_HDR_INT_
  27 #define __ECHLD_HDR_INT_
  28
  29 #include "config.h"
  30
  31 #ifdef HAVE_FCNTL_H
  32 #include <fcntl.h>
  33 #endif
  34
  35 #ifdef HAVE_SYS_TYPES_H
  36 # include <sys/types.h>
  37 #endif
  38
  39 #ifdef HAVE_SYS_WAIT_H
  40 # include <sys/wait.h>
  41 #endif
  42
  43 #include <sys/time.h>
  44 #include <sys/uio.h>
  45
  46 #ifdef HAVE_UNISTD_H
  47 #include <unistd.h>
  48 #endif
  49
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <stdarg.h>
  53 #include <errno.h>
  54 #include <signal.h>
  55 #include <locale.h>
  56
  57 #include <arpa/inet.h>
  58
  59
  60 #include <glib.h>
  61 #include <glib/gprintf.h>
  62
  63
  64
  65 #include "capture_opts.h"
  66 #include "capture_session.h"
  67 #include "capture_ifinfo.h"
  68 #include "capture_sync.h"
  69 #include "version_info.h"
  70 #include "cfile.h"
  71 #include "wsutil/crash_info.h"
  72 #include "wsutil/privileges.h"
  73 #include "epan/filesystem.h"
  74 #include "epan/epan.h"
  75 #include "epan/prefs.h"
  76 #include "epan/ex-opt.h"
  77 #include "epan/funnel.h"
  78 #include "epan/prefs.h"
  79 #include "epan/timestamp.h"
  80 #include "epan/disabled_protos.h"
  81 #include "echld.h"
  82
  83 #ifdef __cplusplus
  84 extern "C" {
  85 #endif
  86
  87 /* XXX these shouldn't be needed */
  88 typedef struct tvbuff tvb_t;
  89
  90 struct _hdr {
  91         guint32 type_len;
  92         guint16 chld_id;
  93         guint16 reqh_id;
  94 };
  95
  96
  97 #define ECHLD_HDR_LEN (sizeof(struct _hdr))
  98
  99 typedef union _hdr_t {
 100         struct _hdr h;
 101         guint8 b[ECHLD_HDR_LEN];
 102 } hdr_t;
 103
 104 #define HDR_TYPE(H) ((((H)->h.type_len)&0xff000000)>>24)
 105 #define HDR_LEN(H) ((((H)->h.type_len)&0x00ffffff))
 106
 107 #define GET_HDR_ELEMS(H,T,L,C,R) do { guint32 tl = H->h.type_len; \
 108         T=HDR_TYPE(H); L=HDR_LEN(H); C=H->h.chld_id; R=H->h.req_id; } while(0)
 109
 110
 111 typedef enum _cst {
 112         FREE=0,
 113         CREATING,
 114         IDLE,
 115         READY,
 116         READING,
 117         CAPTURING,
 118         DONE,
 119         CLOSING,
 120         CLOSED=-1,
 121         ERRORED=-2
 122 } child_state_t;
 123
 124 extern const char* echld_state_str(child_state_t);
 125 extern const char* echld_msg_type_str(echld_msg_type_t id);
 126 #define ST(st) echld_state_str(st)
 127 #define TY(ty) echld_msg_type_str(ty)
 128
 129 /* these manage the de-framing machine in the receiver side */
 130 typedef struct _echld_reader {
 131         guint8* rp; /* the read pointer*/
 132         size_t  len;  /* the used size = (.wp - .rp) */
 133
 134         guint8* wp; /* the write pointer */
 135         int fd; /* the filedesc is serving */
 136
 137         guint8* data; /* the allocated read buffer */
 138         size_t  actual_len; /* the actual len of the allocated buffer */
 139 } echld_reader_t;
 140
 141
 142 #define reader_is_empty(R) ( (R)->len == 0 )
 143 #define reader_has_header(R) ((R)->len >= ECHLD_HDR_LEN)
 144 #define reader_has_frame(R) ( reader_has_header(R) && ( (HDR_LEN( (hdr_t*)((R)->rp) ) + ECHLD_HDR_LEN) >= ((R)->len )))
 145
 146 #define READER_FD_SET(R,fdset_p) FD_SET(R.fd,&(fdset_p))
 147 #define READER_FD_ISSET(R,fdset_p) READER_FD_ISSET(R.fd,&(fdset_p))
 148 #define READER_FD_CLEAR(R,fdset_p) READER_FD_CLEAR(R.fd,&(fdset_p))
 149
 150 extern void echld_common_set_dbg(int level, FILE* fp, const char* prefix);
 151
 152 extern void echld_init_reader(echld_reader_t* r, int fd, size_t initial);
 153 extern void echld_reset_reader(echld_reader_t* r, int fd, size_t initial);
 154
 155 typedef struct _param {
 156         const char* name;
 157         char* (*get)(char** err );
 158         echld_bool_t (*set)(char* val , char** err);
 159         const char* desc;
 160 } param_t;
 161
 162 extern param_t* paramset_find (param_t* paramsets, char* name, char** err);
 163
 164 extern char* paramset_apply_get (param_t* paramsets, char* name, char** err);
 165 extern echld_bool_t paramset_apply_set (param_t* paramsets, char* name, char* val, char** err);
 166 extern echld_bool_t paramset_apply_em(param_t* paramset, enc_msg_t* em, char** err);
 167
 168 #define PARAM_LIST_FMT "%s(%s): %s\n" /* name, rw|ro|wo, desc */
 169 char* paramset_get_params_list(param_t* paramsets,const char* fmt);
 170
 171 #define PARAM_STR(Name, Default) static char* param_ ## Name = Default;  \
 172  static char* param_get_ ## Name (char** err _U_ ) { return  (param_ ## Name) ? g_strdup(param_ ## Name) : (*err = g_strdup( #Name " not set"), NULL); } \
 173  static echld_bool_t param_set_ ## Name (char* val , char** err _U_) { if (param_ ## Name) g_free(param_ ## Name); param_ ## Name = g_strdup(val); return TRUE; } \
 174
 175 #define PARAM_INT(Name, Default) static int param_ ## Name = Default;  \
 176  static char* param_get_ ## Name (char** err _U_ ) { return  g_strdup_printf("%d",param_ ## Name); } \
 177  static echld_bool_t param_set_ ## Name (char* val , char** err _U_) {  char* p; int temp = (int)strtol(val, &p, 10); if (p<=val) { *err = g_strdup("not an integer"); return FALSE; } else {   param_ ## Name = temp; return TRUE; } }
 178
 179 #define PARAM_BOOL(Name, Default) static gboolean param_ ## Name = Default;  \
 180  static char* param_get_ ## Name (char** err _U_ ) { return  g_strdup_printf("%s",param_ ## Name ? "TRUE" : "FALSE"); } \
 181  static echld_bool_t param_set_ ## Name (char* val , char** err _U_) { param_ ## Name = (*val == 'T' || *val == 't') ? TRUE : FALSE; return TRUE;}
 182
 183 #define PARAM(Name,Desc) {#Name, param_get_ ## Name, param_set_ ## Name, Desc}
 184 #define RO_PARAM(Name,Desc) {#Name, param_get_ ## Name, NULL, Desc}
 185 #define WO_PARAM(Name,Desc) {#Name, NULL, param_set_ ## Name, Desc}
 186
 187 typedef struct _echld_epan_stuff_t {
 188 #ifdef HAVE_LIBPCAP
 189         capture_session cap_sess;
 190         capture_options cap_opts;
 191         capture_file cfile;
 192 #endif
 193         e_prefs* prefs;
 194 } echld_epan_stuff_t;
 195
 196 /* the call_back used by read_frame() */
 197 typedef long (*read_cb_t)(guint8*, size_t, echld_chld_id_t, echld_msg_type_t, echld_reqh_id_t, void*);
 198
 199
 200 typedef struct _child_in {
 201         echld_bool_t (*error)                   (guint8*, size_t, int* , char**);
 202         echld_bool_t (*set_param)               (guint8*, size_t, char** param,  char** value);
 203         echld_bool_t (*get_param)               (guint8*, size_t, char** param);
 204         echld_bool_t (*close_child)             (guint8*, size_t, int* mode);
 205         echld_bool_t (*open_file)               (guint8*, size_t, char** filename);
 206         echld_bool_t (*open_interface)  (guint8*, size_t, char** intf_name, char** params);
 207         echld_bool_t (*get_sum)                 (guint8*, size_t, char** range);
 208         echld_bool_t (*get_tree)                (guint8*, size_t, char** range);
 209         echld_bool_t (*get_buffer)              (guint8*, size_t, char** name);
 210         echld_bool_t (*add_note)                (guint8*, size_t, int* packet_number, char** note);
 211         echld_bool_t (*apply_filter)    (guint8*, size_t, char** filter);
 212         echld_bool_t (*save_file)               (guint8*, size_t, char** filename, char** params);
 213 } child_decoder_t;
 214
 215 typedef struct _child_out {
 216         enc_msg_t* (*error)             (int , const char*);
 217         enc_msg_t* (*child_dead)        (const char*);
 218         enc_msg_t* (*param)             (const char*, const char*);
 219         enc_msg_t* (*notify)            (const char*); // pre-encoded
 220         enc_msg_t* (*packet_sum)        (int, const char*); // framenum, sum(pre-encoded)
 221         enc_msg_t* (*tree)              (int, const char*); // framenum, tree(pre-encoded)
 222         enc_msg_t* (*buffer)            (int , const char*, const char*, const char*); // totlen,name,range,data
 223         enc_msg_t* (*packet_list)       (const char*, const char*, const char*); // name, filter, range
 224 } child_encoder_t;
 225
 226
 227 typedef struct _parent_in {
 228         echld_bool_t (*error)           (enc_msg_t*, int* , char**);
 229         echld_bool_t (*child_dead)      (enc_msg_t*, char**);
 230         echld_bool_t (*param)           (enc_msg_t*, char**, char**);
 231         echld_bool_t (*notify)          (enc_msg_t*, char**); // pre-encoded
 232         echld_bool_t (*packet_sum)      (enc_msg_t*, int*, char**); // framenum, sum(pre-encoded)
 233         echld_bool_t (*packet)          (enc_msg_t*, int*, char**); // framenum, tree(pre-encoded)
 234         echld_bool_t (*buffer)          (enc_msg_t*, int*, char**, char**, char**); // totlen,name,range,data
 235         echld_bool_t (*packet_list) (enc_msg_t*, char**, char**, char**); // name, filter, range
 236 } parent_decoder_t;
 237
 238 extern void echld_get_all_codecs(child_encoder_t**, child_decoder_t**, echld_parent_encoder_t**, parent_decoder_t**);
 239
 240 extern void echld_init_reader(echld_reader_t* r, int fd, size_t initial);
 241 extern void free_reader(echld_reader_t* r);
 242
 243 extern long echld_read_frame(echld_reader_t* r, read_cb_t cb, void* cb_data);
 244 extern long echld_write_frame(int fd, GByteArray* ba, guint16 chld_id, echld_msg_type_t type, guint16 reqh_id, void* data);
 245
 246
 247 extern void echld_child_initialize(echld_chld_id_t chld_id, int pipe_from_parent, int pipe_to_parent, int reqh_id, echld_epan_stuff_t* es);
 248 extern int echld_child_loop(void);
 249
 250 /* never returns*/
 251 extern void echld_dispatcher_start(int* in_pipe_fds, int* out_pipe_fds, char* argv0, int (*main)(int, char **));
 252
 253
 254 extern void dummy_switch(echld_msg_type_t type);
 255 extern void echld_unused(void);
 256
 257 /* config stuff */
 258
 259 /* initial debug levels */
 260 /* undefine to avoid debugging */
 261 #define DEBUG_BASE 5
 262 #define DEBUG_CHILD 5
 263 #define DEBUG_DISPATCHER 5
 264 #define DEBUG_PARENT 5
 265
 266 /* timers */
 267 #define DISPATCHER_WAIT_INITIAL 5000000 /* 5s */
 268 #define CHILD_CLOSE_SLEEP_TIME 2000000 /* 2s */
 269 #define CHILD_START_WAIT_TIME 100000 /* 0.1s */
 270 #define DISP_KILLED_CHILD_WAIT 100000 /* 0.1s */
 271
 272 /* fatalities */
 273 #define BROKEN_PARENT_PIPE 9
 274 #define BROKEN_DUMPCAP_PIPE 10
 275 #define BROKEN_READFILE 11
 276 #define DISPATCHER_DEAD 12
 277 #define UNIMPLEMENTED 13
 278 #define CANNOT_FORK 14
 279 #define SHOULD_HAVE_EXITED_BEFORE 15
 280 #define DISPATCHER_PIPE_FAILED 16
 281 #define TERMINATED 17
 282 #define CANNOT_PREINIT_EPAN 18
 283 #define NO_INITIALIZER 19
 284
 285 #ifndef DEBUG_BASE
 286 #define echld_common_set_dbg(a,b,c)
 287 #endif
 288
 289
 290
 291
 292 #ifdef __cplusplus
 293 extern "C" {
 294 #endif
 295
 296 #endif