} echld_child_t;
+static echld_epan_stuff_t* stuff = NULL;
static echld_child_t child;
exit(0);
}
-
-void echld_child_initialize(echld_chld_id_t chld_id, int pipe_from_parent, int pipe_to_parent, int reqh_id) {
+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) {
+ stuff = es;
close_sleep_time.tv_sec = CHILD_CLOSE_SLEEP_TIME / 1000000;
close_sleep_time.tv_usec = CHILD_CLOSE_SLEEP_TIME % 1000000;
return s;
}
+#ifdef PCAP_NG_DEFAULT
+static int out_file_type = WTAP_FILE_PCAPNG;
+#else
+static int out_file_type = WTAP_FILE_PCAP;
+#endif
+
+static echld_bool_t param_set_out_file_type(char* val, char** err) {
+ int oft = wtap_short_string_to_file_type(val);
+
+ if (oft < 0) {
+ *err = g_strdup_printf("\"%s\" isn't a valid capture file type", val);
+ return FALSE;
+ } else {
+ out_file_type = oft;
+ return TRUE;
+ }
+}
+
+static char* param_get_out_file_type(char** err _U_) {
+ return g_strdup_printf("%s(%d): %s",
+ wtap_file_type_short_string(out_file_type),
+ out_file_type, wtap_file_type_string(out_file_type));
+}
+
+
+static echld_bool_t param_set_add_hosts_file(char* val, char** err) {
+ if (add_hosts_file(val)) {
+ return TRUE;
+ } else {
+ *err = g_strdup_printf("Can't read host entries from \"%s\"",val);
+ return FALSE;
+ }
+}
+
PARAM_BOOL(quiet,FALSE);
+PARAM_BOOL(start_capture,FALSE);
+PARAM_BOOL(push_details,FALSE);
+PARAM_BOOL(print_hex,FALSE);
static char* param_get_params(char** err _U_);
-static param_t params[] = {
+static param_t child_params[] = {
#ifdef DEBUG_CHILD
PARAM(dbg_level,"Debug Level (0<int<5)"),
# endif
PARAM(dfilter,"Dispay Filter (str)"),
RO_PARAM(packet_count,"Packets Read/Captured So Far (str)"),
RO_PARAM(file_list,"List of Files in the Current Dir"),
+ PARAM(start_capture,"Automatically start capture"),
PARAM(quiet,"Quiet Mode"),
+ PARAM(push_details,"Whether details of dissection should be passed"),
+ PARAM(print_hex,"Output in hex"),
+ PARAM(out_file_type,"Output File Type"),
+ WO_PARAM(add_hosts_file,"Add a Hosts File"),
RO_PARAM(params,"This List"),
{NULL,NULL,NULL,NULL}
};
static char* param_get_params(char** err _U_) {
- param_t* p = params;
- GString* str = g_string_new("");
- char* s;
-
- for (;p->name;p++) {
- g_string_append_printf(str,"%s(%s): %s\n",
- p->name,((p->get && p->set)?"rw":(p->get?"ro":"wo")),p->desc);
- }
-
- s = str->str;
- g_string_free(str,FALSE);
- return s;
+ return paramset_get_params_list(child_params,PARAM_LIST_FMT);
}
-static param_t* get_paramset(char* name) {
- int i;
- for (i = 0; params[i].name != NULL;i++) {
- if (strcmp(name,params[i].name) == 0 ) return &(params[i]);
- }
- return NULL;
-}
-
-
-
-
-
-
static void child_open_file(char* filename) {
CHILD_DBG((2,"CMD open file filename='%s'",filename));
child_err(ECHLD_ERR_UNIMPLEMENTED,child.reqh_id,"open file not implemented yet!");
static long child_receive(guint8* b, size_t len, echld_chld_id_t chld_id, echld_msg_type_t type, echld_reqh_id_t reqh_id, void* data _U_) {
GByteArray ba;
GByteArray* gba;
+ char* err = NULL;
child.reqh_id = reqh_id;
return 0;
}
+ ba.data = b;
+ ba.len = (guint)len;
+
switch(type) {
case ECHLD_NEW_CHILD: {
- child.state = IDLE;
- CHILD_RESP(NULL,ECHLD_HELLO);
+ child.state = CREATING;
+ if ( !paramset_apply_em(child_params,(enc_msg_t*)&ba, &err) ) {
+ child_err(ECHLD_ERR_CRASHED_CHILD,reqh_id,
+ "Initial Paramset Error '%s'",err);
+ } else {
+ child.state = IDLE;
+ CHILD_RESP(NULL,ECHLD_HELLO);
+ }
break;
}
case ECHLD_PING:
- ba.data = b;
- ba.len = (guint)len;
CHILD_DBG((1,"PONG"));
CHILD_RESP(&ba,ECHLD_PONG);
break;
char* value;
if ( child.dec->set_param && child.dec->set_param(b,len,¶m,&value) ) {
- param_t* p = get_paramset(param);
- char* err;
-
- if (!p) {
- child_err(ECHLD_CANNOT_SET_PARAM,reqh_id,"no such param='%s'",param);
- break;
- }
-
- if (!p->set) {
- child_err(ECHLD_CANNOT_GET_PARAM,reqh_id,"reason='read only'");
- break;
- }
-
- if (! p->set(value,&err) ) {
- child_err(ECHLD_CANNOT_SET_PARAM,reqh_id,"reason='%s'",err);
+ if (! paramset_apply_set (child_params, param, value, &err) ) {
+ child_err(ECHLD_CANNOT_SET_PARAM,reqh_id,"%s",err);
g_free(err);
- break;
+ return 0;
}
gba = child.enc->param(param,value);
case ECHLD_GET_PARAM: {
char* param;
if ( child.dec->get_param && child.dec->get_param(b,len,¶m) ) {
- char* err;
char* val;
- param_t* p = get_paramset(param);
-
- if (!p) {
- child_err(ECHLD_CANNOT_GET_PARAM,reqh_id,"no such param='%s'",param);
- break;
- }
-
- if (!p->get) {
- child_err(ECHLD_CANNOT_GET_PARAM,reqh_id,"reason='write only'");
- break;
- }
-
- if (!(val = p->get(&err))) {
- child_err(ECHLD_CANNOT_GET_PARAM,reqh_id,"reason='%s'",err);
+ if (! (val = paramset_apply_get (child_params, param, &err)) ) {
+ child_err(ECHLD_CANNOT_GET_PARAM,reqh_id,"%s",err);
g_free(err);
- break;
+ return 0;
}
-
+
gba = child.enc->param(param,val);
CHILD_RESP(gba,ECHLD_PARAM);
g_byte_array_free(gba,TRUE);
}
-static void child_dumpcap_read(void) {
+static int child_dumpcap_read(void) {
// this folk manages the reading of dumpcap's pipe
// it has to read interface descriptions when doing so
// and managing capture during capture
- CHILD_DBG((2,"child_dumpcap_read"));
+ CHILD_DBG((2,"child_dumpcap_read"));
+ return FALSE;
+}
+
+static void child_file_read(void) {
+
}
int echld_child_loop(void) {
fd_set efds;
struct timeval timeout;
int nfds;
+ gboolean captured = FALSE;
FD_ZERO(&rfds);
FD_ZERO(&wfds);
FD_SET(child.fds.pipe_from_dumpcap,&rfds);
}
- if (child.fds.file_being_read > 0) {
- FD_SET(child.fds.file_being_read,&rfds);
- }
-
#ifdef DEBUG_CHILD
- if (step >= 100) CHILD_DBG((4,"child_loop: select()ing step=%d",step++));
+ if (step <= 20) CHILD_DBG((4,"child_loop: select()ing step=%d",step++));
#endif
+ timeout.tv_sec = 0;
+ timeout.tv_usec = 999999;
+
nfds = select(FD_SETSIZE, &rfds, &wfds, &efds, &timeout);
#ifdef DEBUG_CHILD
- if (step >= 100) CHILD_DBG((4,"child_loop: select()ed nfds=%d",nfds));
+ if (step <= 20) CHILD_DBG((4,"child_loop: select()ed nfds=%d",nfds));
#endif
if ( FD_ISSET(disp_from,&efds) ) {
break;
}
- if (child.fds.file_being_read > 0 && FD_ISSET(child.fds.file_being_read,&efds) ) {
- CHILD_DBG((0,"Broken Readfile Pipe step=%d",step));
- break;
- }
-
if (FD_ISSET(disp_from, &rfds)) {
long st = echld_read_frame(&(child.parent), child_receive, &child);
#ifdef DEBUG_CHILD
step = 0;
#endif
- child_dumpcap_read();
+ captured = child_dumpcap_read();
+ }
+
+ if ( child.state == READING || captured ) {
+ child_file_read();
}
} while(1);
return (long) writev(fd, iov, iov_cnt);
}
+/* paramset management */
+param_t* paramset_find (param_t* paramsets, char* name, char** err) {
+ int i;
+ for (i = 0; paramsets[i].name != NULL;i++) {
+ if (strcmp(name,paramsets[i].name) == 0 ) return &(paramsets[i]);
+ }
+
+ *err = g_strdup_printf("Could not find param='%s'",name);
+ return NULL;
+}
+
+echld_bool_t paramset_apply_set (param_t* paramsets, char* name, char* val, char** err) {
+ param_t* p = paramset_find(paramsets,name,err);
+
+ if ( !p ) return FALSE;
+ if ( ! p->set ) {
+ *err = g_strdup_printf("Cannot set RO param='%s'",name);
+ return FALSE;
+ }
+
+ return p->set(val,err);
+}
+
+char* paramset_apply_get (param_t* paramsets, char* name, char** err) {
+ param_t* p = paramset_find(paramsets,name,err);
+
+ if ( !p ) return NULL;
+
+ if ( ! p->get ) {
+ *err = g_strdup_printf("Cannot get WO param='%s'",name);
+ return NULL;
+ }
+
+ return p->get(err);
+}
+
+echld_bool_t paramset_apply_em(param_t* paramset, enc_msg_t* em, char** err) {
+ GByteArray* ba = (GByteArray*)em;
+ char* p = (char*) ba->data;
+ int tot_len = ba->len;
+ long rem = tot_len;
+ p[rem-1] = '\0'; /* make sure last char is null */
+
+ while(rem > 2) {
+ char* param = p;
+ long param_len = strlen(param)+1;
+ char* value = p + param_len;
+ long value_len;
+
+ rem -= param_len;
+
+ if (rem < 0) {
+ *err = g_strdup_printf("Malformed msg param len invalid");
+ return FALSE;
+ }
+
+ value_len = strlen(value)+1;
+
+ rem -= value_len;
+ p = value + value_len;
+
+ if (rem < 0) {
+ *err = g_strdup_printf("Malformed msg value len invalid");
+ return FALSE;
+ }
+
+ if (! paramset_apply_set(paramset,param,value,err))
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+char* paramset_get_params_list(param_t* paramsets,const char* fmt) {
+ param_t* p = paramsets;
+ GString* str = g_string_new("");
+ char* s;
+
+ for (;p->name;p++) {
+ g_string_append_printf(str,fmt,
+ p->name,
+ ((p->get && p->set)?"rw":(p->get?"ro":"wo")),
+ p->desc);
+ }
+
+ s = str->str;
+ g_string_free(str,FALSE);
+ return s;
+}
/* encoders and decoders */
struct dispatcher* dispatcher;
-
#ifdef DEBUG_DISPATCHER
static int debug_lvl = DEBUG_DISPATCHER;
static FILE* debug_fp = NULL;
#define DISP_RESP(B,T) (DISP_WRITE( dispatcher->parent_out, (B), 0, (T), dispatcher->reqh_id))
+
+static echld_epan_stuff_t stuff;
+
+static void init_stuff(void) {
+#ifdef HAVE_LIBPCAP
+ capture_opts_init(&stuff.cap_opts);
+ capture_session_init(&stuff.cap_sess, (void *)&stuff.cfile);
+#endif
+
+}
+
static void children_massacre(void) {
int i;
struct dispatcher_child* cc = dispatcher->children;
return s;
}
-static char* intf_list;
+static char* intf_list = NULL;
static void get_interfaces(char** err) {
int err_no = 0;
static long disp_loop_timeout_usec = DISPATCHER_WAIT_INITIAL;
-static char* param_get_loop_to(char** err _U_) {
+static char* param_get_loop_timeout(char** err _U_) {
return g_strdup_printf("%fs", (((float)disp_loop_timeout_usec)/1000000.0) );
}
-static echld_bool_t param_set_loop_to(char* val , char** err ) {
+static echld_bool_t param_set_loop_timeout(char* val , char** err ) {
char* p;
int usec = (int)strtol(val, &p, 10); /*XXX: "10ms" or "500us" or "1s" */
return TRUE;
}
-GString *comp_info_str;
-GString *runtime_info_str;
+static GString *comp_info_str;
+static GString *runtime_info_str;
+static const char* version_str = "Echld " VERSION;
+static char* version_long_str = NULL;
+
+
+static char* param_get_long_version(char** err _U_) {
+ return g_strdup(version_long_str);
+}
static char* param_get_version(char** err _U_) {
- char* str;
+ return g_strdup(version_str);
+}
+
+static char* param_get_capture_types(char** err _U_) {
+ GString* str = g_string_new("");
+ char* s;
+ int i;
+
+ for (i = 0; i < WTAP_NUM_FILE_TYPES; i++) {
+ if (wtap_dump_can_open(i)) {
+ g_string_append_printf(str,"%s: %s\n",
+ wtap_file_type_short_string(i), wtap_file_type_string(i));
+ }
+ }
- str = g_strdup_printf("Echld " VERSION "%s\n"
- "\n"
- "%s"
- "\n"
- "%s"
- "\n"
- "%s",
- wireshark_svnversion, get_copyright_info(), comp_info_str->str,
- runtime_info_str->str);
+ s = str->str;
+ g_string_free(str,FALSE);
+ return s;
+}
- g_string_free(runtime_info_str,TRUE);
- g_string_free(comp_info_str,TRUE);
+static echld_bool_t param_set_add_hosts_file(char* val, char** err) {
+ if (add_hosts_file(val)) {
+ return TRUE;
+ } else {
+ *err = g_strdup_printf("Can't read host entries from \"%s\"",val);
+ return FALSE;
+ }
+}
- return str;
+static echld_bool_t param_set_x_opt(char* val, char** err) {
+ if (ex_opt_add(val)) {
+ return TRUE;
+ } else {
+ *err = g_strdup_printf("Cannot set X opt '%s'",val);
+ return FALSE;
+ }
}
+
+
+
static char* param_get_params(char** err _U_);
static param_t disp_params[] = {
#ifdef DEBUG_DISPATCHER
- {"dbg_level", param_get_dbg_level, param_set_dbg_level,"0>int>5"},
+ PARAM(dbg_level,"0>int>5"),
# endif
- {"version",param_get_version,NULL,"version string"},
- {"loop_timeout",param_get_loop_to,param_set_loop_to,"main loop step timeout"},
- {"interfaces",param_get_interfaces,NULL,"interface information"},
- {"params",param_get_params,NULL,"this list"},
+ RO_PARAM(long_version,"long version string"),
+ RO_PARAM(version,"version string"),
+ PARAM(loop_timeout,"main loop step timeout"),
+ RO_PARAM(interfaces,"interface information"),
+ RO_PARAM(capture_types,"the available capture types"),
+ WO_PARAM(add_hosts_file,"Add a hosts file"),
+ WO_PARAM(x_opt,"Set a -X option"),
+ RO_PARAM(params,"This List"),
{NULL,NULL,NULL,NULL}
};
static char* param_get_params(char** err _U_) {
- param_t* p = disp_params;
- GString* str = g_string_new("");
- char* s;
-
- for (;p->name;p++) {
- g_string_append_printf(str,"%s(%s): %s\n",
- p->name,((p->get && p->set)?"rw":(p->get?"ro":"wo")),p->desc);
- }
-
- s = str->str;
- g_string_free(str,FALSE);
- return s;
-}
-
-
-static param_t* get_paramset(char* name) {
- int i;
- for (i = 0; disp_params[i].name != NULL;i++) {
- if (strcmp(name,disp_params[i].name) == 0 ) return &(disp_params[i]);
- }
- return NULL;
+ return paramset_get_params_list(disp_params,PARAM_LIST_FMT);
}
-
-
static struct dispatcher_child* dispatcher_get_child(struct dispatcher* d, int chld_id) {
int i;
struct dispatcher_child* cc = d->children;
}
static void preinit_epan(char* argv0, int (*main)(int, char **)) {
+ char *gpf_path, *pf_path;
+ char *gdp_path, *dp_path;
+ int gpf_open_errno, gpf_read_errno;
+ int pf_open_errno, pf_read_errno;
+ int gdp_open_errno, gdp_read_errno;
+ int dp_open_errno, dp_read_errno;
char* error;
error = init_progfile_dir(argv0, main);
runtime_info_str = g_string_new("Running ");
get_runtime_version_info(runtime_info_str, NULL);
- capture_opts_init(&dispatcher->capture_opts);
+ version_long_str = g_strdup_printf("%s%s\n%s\n%s\n%s",
+ version_str, wireshark_svnversion, get_copyright_info(),
+ comp_info_str->str, runtime_info_str->str);
if (error) {
DISP_FATAL((CANNOT_PREINIT_EPAN,"Failed epan_preinit: msg='%s'",error));
/* Add it to the information to be reported on a crash. */
ws_add_crash_info("Echld " VERSION "%s\n%s\n%s",
wireshark_svnversion, comp_info_str->str, runtime_info_str->str);
+
+ init_stuff();
capture_sync_set_fetch_dumpcap_pid_cb(set_dumpcap_pid);
DISP_FATAL((CANNOT_PREINIT_EPAN,"Error getting interfaces: %s", error));
}
-
prefs_apply_all();
/* disabled protocols as per configuration file */
set_disabled_protos_list();
- /* Here we do initialization of parts of epan that will be the same for every child we fork */
+ initialize_funnel_ops();
- DISP_DBG((2,"epan preinit done"));
+ setlocale(LC_ALL, "");
+
+ stuff.prefs = read_prefs(&gpf_open_errno, &gpf_read_errno, &gpf_path, &pf_open_errno, &pf_read_errno, &pf_path);
+ // check 4 errors
+
+ read_disabled_protos_list(&gdp_path, &gdp_open_errno, &gdp_read_errno, &dp_path, &dp_open_errno, &dp_read_errno);
+ // check 4 errors
+ cap_file_init(&stuff.cfile);
+
+ timestamp_set_precision(TS_PREC_AUTO_USEC);
+
+ DISP_DBG((2,"epan preinit done"));
}
static void dispatcher_clear(void) {
DISP_DBG((2,"dispatcher_clear"));
/* remove unnecessary stuff for the working child */
+ /* remove signal handlers */
}
void dispatcher_sig(int sig) {
DISP_FATAL((TERMINATED,"SIG sig=%d",sig));
exit(1);
-
}
void dispatcher_reaper(int sig) {
close(pipe_to_child);
close(pipe_from_child);
- echld_child_initialize(chld_id, pipe_from_disp,pipe_to_disp,reqh_id);
+ echld_child_initialize(chld_id, pipe_from_disp,pipe_to_disp,reqh_id,&stuff);
exit( echld_child_loop() );
char* value;
if ( dispatcher->dec.from_parent->set_param(b,len,¶m,&value) ) {
GByteArray* ba;
- param_t* p = get_paramset(param);
char* err;
- if (!p) {
- dispatcher_err(ECHLD_CANNOT_SET_PARAM,"no such param='%s'",param);
- return 0;
- }
-
- if (! p->set ) {
- dispatcher_err(ECHLD_CANNOT_SET_PARAM,"reason='read only'");
- return 0;
- }
-
- if (! p->set(value,&err) ) {
- dispatcher_err(ECHLD_CANNOT_SET_PARAM,"reason='%s'",err);
+ if (! paramset_apply_set (disp_params, param, value, &err) ) {
+ dispatcher_err(ECHLD_CANNOT_SET_PARAM,"%s",err);
g_free(err);
return 0;
}
char* err;
char* val;
- param_t* p = get_paramset(param);
-
- if (!p) {
- dispatcher_err(ECHLD_CANNOT_GET_PARAM,"no such param='%s'",param);
- return 0;
- }
-
- if (! p->get ) {
- dispatcher_err(ECHLD_CANNOT_SET_PARAM,"reason='write only'");
- return 0;
- }
-
- if (!(val = p->get(&err))) {
- dispatcher_err(ECHLD_CANNOT_GET_PARAM,"reason='%s'",err);
+ if (! (val = paramset_apply_get (disp_params, param, &err)) ) {
+ dispatcher_err(ECHLD_CANNOT_GET_PARAM,"%s",err);
g_free(err);
return 0;
}
dispatcher = &d;
-
echld_init_reader(&(d.parent_in),in_pipe_fds[0],4096);
d.parent_out = out_pipe_fds[1];
d.children = g_new0(struct dispatcher_child,ECHLD_MAX_CHILDREN);
#include <stdarg.h>
#include <errno.h>
#include <signal.h>
+#include <locale.h>
#include <arpa/inet.h>
#include "capture_ifinfo.h"
#include "capture_sync.h"
#include "version_info.h"
+#include "cfile.h"
#include "wsutil/crash_info.h"
#include "wsutil/privileges.h"
#include "epan/filesystem.h"
#include "epan/epan.h"
#include "epan/prefs.h"
+#include "epan/ex-opt.h"
+#include "epan/funnel.h"
+#include "epan/prefs.h"
+#include "epan/timestamp.h"
#include "disabled_protos.h"
#include "echld.h"
const char* desc;
} param_t;
+extern param_t* paramset_find (param_t* paramsets, char* name, char** err);
+
+extern char* paramset_apply_get (param_t* paramsets, char* name, char** err);
+extern echld_bool_t paramset_apply_set (param_t* paramsets, char* name, char* val, char** err);
+extern echld_bool_t paramset_apply_em(param_t* paramset, enc_msg_t* em, char** err);
+
+#define PARAM_LIST_FMT "%s(%s): %s\n" /* name, rw|ro|wo, desc */
+char* paramset_get_params_list(param_t* paramsets,const char* fmt);
+
#define PARAM_STR(Name, Default) static char* param_ ## Name = Default; \
static char* param_get_ ## Name (char** err _U_ ) { return (param_ ## Name) ? g_strdup(param_ ## Name) : (*err = g_strdup( #Name " not set"), NULL); } \
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; } \
#define RO_PARAM(Name,Desc) {#Name, param_get_ ## Name, NULL, Desc}
#define WO_PARAM(Name,Desc) {#Name, NULL, param_set_ ## Name, Desc}
+typedef struct _echld_epan_stuff_t {
+#ifdef HAVE_LIBPCAP
+ capture_session cap_sess;
+ capture_options cap_opts;
+ capture_file cfile;
+#endif
+ e_prefs* prefs;
+} echld_epan_stuff_t;
+
/* the call_back used by read_frame() */
typedef long (*read_cb_t)(guint8*, size_t, echld_chld_id_t, echld_msg_type_t, echld_reqh_id_t, void*);
extern long echld_write_frame(int fd, GByteArray* ba, guint16 chld_id, echld_msg_type_t type, guint16 reqh_id, void* data);
-extern void echld_child_initialize(echld_chld_id_t chld_id, int pipe_from_parent, int pipe_to_parent, int reqh_id);
+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);
extern int echld_child_loop(void);
/* never returns*/
#define DISP_KILLED_CHILD_WAIT 100000 /* 0.1s */
/* fatalities */
-#define BROKEN_PARENT_PIPE 123
-#define BROKEN_DUMPCAP_PIPE 124
-#define BROKEN_READFILE 125
-#define DISPATCHER_DEAD 126
-#define UNIMPLEMENTED 127
-#define CANNOT_FORK 128
-#define SHOULD_HAVE_EXITED_BEFORE 129
-#define DISPATCHER_PIPE_FAILED 130
-#define TERMINATED 140
-#define CANNOT_PREINIT_EPAN 141
+#define BROKEN_PARENT_PIPE 9
+#define BROKEN_DUMPCAP_PIPE 10
+#define BROKEN_READFILE 11
+#define DISPATCHER_DEAD 12
+#define UNIMPLEMENTED 13
+#define CANNOT_FORK 14
+#define SHOULD_HAVE_EXITED_BEFORE 15
+#define DISPATCHER_PIPE_FAILED 16
+#define TERMINATED 17
+#define CANNOT_PREINIT_EPAN 18
+#define NO_INITIALIZER 19
#ifndef DEBUG_BASE
#define echld_common_set_dbg(a,b,c)
#endif
+
+
+
#ifdef __cplusplus
extern "C" {
#endif
-/* echld_child.h
+/* echld.h
* epan working child API
*
* $Id$
/* id of message handlers, a negative value is an error */
typedef int echld_msgh_id_t;
+/* enc_msg_t is an obscure object for an encoded message (a GbyteArray for now)*/
+typedef struct _GByteArray enc_msg_t;
+
/* sets the codec set by name */
typedef enum _echld_encoding {
ECHLD_ENCODING_TEXT = 'T',
/* typedef for a timeval so that sys/time.h is not required in the client */
typedef struct timeval tv_t;
-/* will initialize epan registering protocols and taps */
-WS_DLL_PUBLIC void echld_initialize(echld_encoding_t, char* argv0, int (*main)(int, char **));
+typedef void (*cleanup_cb_t)(void*);
+typedef int (*main_t)(int, char**); /* a pointer to main() */
+
+/* I will be passed to echld_initialize() */
+typedef struct _echld_init {
+ echld_encoding_t encoding; /* only JSON for now */
+ char* argv0; /* the value of argv[0] */
+ main_t main;
+ cleanup_cb_t after_fork_cb; /* to be called after fork to free the
+ child processes from entities of the parent */
+ void* after_fork_cb_data;
-/* cleans up (?) echld and kills the server process(es) */
+ cleanup_cb_t at_term_cb; /* to be called after echld_terminate() is done */
+ void* at_term_cb_data;
+} echld_init_t;
+
+/* will initialize echld forking the dispatcher and registering protocols and taps */
+WS_DLL_PUBLIC void echld_initialize(echld_init_t*);
+
+/* cleans up echld and kills the server process(es) */
WS_DLL_PUBLIC echld_state_t echld_terminate(void);
+
/*
* returning ECHLD_NO_ERROR means there has being no error
*
*/
WS_DLL_PUBLIC echld_error_t echld_get_error(const char** errstr_ptr);
-/*
- * Children Management Operations
- */
-
-/* create a new worker process */
-WS_DLL_PUBLIC echld_chld_id_t echld_new(void* child_data);
-
-/* will return NULL on error, if NULL is also ok for you use echld_get_error() */
-WS_DLL_PUBLIC void* echld_get_data(echld_chld_id_t);
-
-WS_DLL_PUBLIC echld_state_t echld_set_data(echld_chld_id_t id, void* child_data);
-
-/* for each child call cb(id,child_data,cb_data) */
-typedef echld_bool_t (*echld_iter_cb_t)(echld_chld_id_t, void* child_data, void* cb_data);
-WS_DLL_PUBLIC void echld_foreach_child(echld_iter_cb_t cb, void* cb_data);
-
-/* enc_msg_t is an obscure object for an encoded message */
-typedef struct _GByteArray enc_msg_t;
-
/*
* prototype of message callbacks passed to echld_reqh() and echld_msgh()
typedef echld_bool_t (*echld_msg_cb_t)(echld_msg_type_t type, enc_msg_t* msg_buff, void* cb_data);
-
/* encoding and decoding */
enc_msg_t* (*save_file)(const char* filename, const char* params);
} echld_parent_encoder_t;
+
WS_DLL_PUBLIC echld_parent_encoder_t* echld_get_encoder(void);
+
/*
* decoder
* it returns an allocated string with the decoded response of the message, you free it.
*/
WS_DLL_PUBLIC char* echld_decode(echld_msg_type_t, enc_msg_t*);
+/*
+ * Children Management Operations
+ */
+
+WS_DLL_PUBLIC enc_msg_t* echld_new_child_params(void);
+
+/* takes the em, and param=value pairs of strings, NULL to end.
+ echld_new_child_params_add_params(em,param1_str,val1_str,param2_str,val2_str,NULL); */
+WS_DLL_PUBLIC void echld_new_child_params_add_params(enc_msg_t*, ...);
+
+WS_DLL_PUBLIC enc_msg_t* echld_new_child_params_merge(enc_msg_t*, enc_msg_t*);
+
+
+/* create a new worker process */
+WS_DLL_PUBLIC echld_chld_id_t echld_new(enc_msg_t* new_child_parameters, void* child_data);
+
+/* will return NULL on error, if NULL is also ok for you use echld_get_error() */
+WS_DLL_PUBLIC void* echld_get_data(echld_chld_id_t);
+
+WS_DLL_PUBLIC echld_state_t echld_set_data(echld_chld_id_t id, void* child_data);
+
+/* for each child call cb(id,child_data,cb_data) */
+typedef echld_bool_t (*echld_iter_cb_t)(echld_chld_id_t, void* child_data, void* cb_data);
+WS_DLL_PUBLIC void echld_foreach_child(echld_iter_cb_t cb, void* cb_data);
+
/*
* Request Handlers
*
}
/* will initialize epan registering protocols and taps */
-void echld_initialize(echld_encoding_t enc, char* argv0, int (*main)(int, char **)) {
+void echld_initialize(echld_init_t* init) {
int from_disp[2];
int to_disp[2];
-
PARENT_DBG((1,"Echld Starting"));
- if (enc != ECHLD_ENCODING_JSON) {
+ if (!init) {
+ PARENT_FATAL((NO_INITIALIZER,"Missing Initializer"));
+ }
+
+ if (init->encoding != ECHLD_ENCODING_JSON) {
PARENT_FATAL((UNIMPLEMENTED,"Only JSON implemented"));
}
#endif
/* child code */
echld_cleanup();
- echld_dispatcher_start(to_disp,from_disp,argv0,main);
+
+ if (init->after_fork_cb)
+ init->after_fork_cb(init->after_fork_cb_data);
+
+ echld_dispatcher_start(to_disp,from_disp,init->argv0,init->main);
+
PARENT_FATAL((SHOULD_HAVE_EXITED_BEFORE,"This shoudln't happen"));
} else {
/* parent code */
static int next_chld_id = 1;
-extern int echld_new(void* child_data) {
+extern int echld_new(enc_msg_t* new_child_em, void* child_data) {
echld_t* c = get_child(-1);
if (!c) return -1;
c->data = child_data;
c->state = CREATING;
- g_byte_array_set_size(parent.snd,0);
-
PARENT_DBG((1,"Child[%d]: =>CREATING",c->chld_id));
msgh_attach(c,ECHLD_CHILD_DEAD, parent_dead_child , c);
- reqh_snd(c, ECHLD_NEW_CHILD, parent.snd, parent_get_hello, c);
+ reqh_snd(c, ECHLD_NEW_CHILD, (GByteArray*)new_child_em, parent_get_hello, c);
return c->chld_id;
}
return ECHLD_OK;
}
}
+
+enc_msg_t* echld_new_child_params(void) {
+ return (enc_msg_t*)g_byte_array_new();
+}
+
+enc_msg_t* echld_new_child_params_merge(enc_msg_t* em1, enc_msg_t* em2) {
+ GByteArray* ba = g_byte_array_new();
+ GByteArray* b1 = (GByteArray*)em1;
+ GByteArray* b2 = (GByteArray*)em2;
+
+ g_byte_array_append(ba,b1->data,b1->len);
+ g_byte_array_append(ba,b2->data,b2->len);
+
+ return (enc_msg_t*)ba;
+}
+
+WS_DLL_PUBLIC void echld_new_child_params_add_params(enc_msg_t* em, ...) {
+ GByteArray* ba = (GByteArray*) em;
+ va_list ap;
+
+ va_start(ap,em);
+ do {
+ char* param_str = va_arg(ap, char*);
+
+ if (param_str) {
+ char* val_str = va_arg(ap, char*);
+
+ g_byte_array_append(ba, (guint8*) param_str, (guint)strlen(param_str)+1);
+ g_byte_array_append(ba, (guint8*) val_str, (guint)strlen(val_str)+1);
+ continue;
+ }
+
+ break;
+ } while(1);
+ va_end(ap);
+
+}
const char* help;
} cmd_t;
-static char* new_child_cmd(char** params _U_, char** err) {
- int child = echld_new(NULL);
+
+#define MAX_PARAMSETS 16
+
+static enc_msg_t* paramsets[MAX_PARAMSETS] = {
+ NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL,
+ NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL
+};
+
+static int nps = 0;
+
+static char* ps_cmd(char** pars _U_, char** err _U_) {
+ int n_id = nps++;
+
+ if (n_id >= MAX_PARAMSETS) {
+ *err = g_strdup("Max Num of Paramsets reached");
+ return NULL;
+ }
+
+ paramsets[n_id] = echld_new_child_params();
+
+ return g_strdup_printf("New Paramset ps_id=%d",n_id);
+}
+
+static char* psadd_cmd(char** params _U_, char** err) {
+ int ps_id = (int) strtol(params[1], NULL, 10);
+
+ if (ps_id >= nps) {
+ *err = g_strdup_printf("No paramset pd_is=%d",ps_id);
+ return NULL;
+ }
+
+ echld_new_child_params_add_params(paramsets[ps_id], params[2], params[3], NULL);
+
+ return g_strdup_printf("PSAdd ps_id=%d %s='%s'", ps_id, params[2], params[3]);
+}
+
+static char* psmerge_cmd(char** params, char** err) {
+ int ps1_id = (int) strtol(params[1], NULL, 10);
+ int ps2_id = (int) strtol(params[2], NULL, 10);
+ int n_id;
+
+ if (ps1_id >= nps) {
+ *err = g_strdup_printf("No paramset pd_is=%d",ps1_id);
+ return NULL;
+ }
+
+ if (ps2_id >= nps) {
+ *err = g_strdup_printf("No paramset pd_is=%d",ps2_id);
+ return NULL;
+ }
+
+ n_id = nps++;
+
+ if (n_id >= MAX_PARAMSETS) {
+ *err = g_strdup_printf("Max Num of Paramsets reached");
+ return NULL;
+ }
+
+ paramsets[n_id] = echld_new_child_params_merge(paramsets[ps1_id],paramsets[ps2_id]);
+
+ return g_strdup_printf("Merged Paramset ps1_id=%d ps2_id=%d ps_id=%d",ps1_id, ps2_id, n_id);
+}
+
+static char* new_child_cmd(char** params, char** err) {
+ int ps_id = (int) strtol(params[1], NULL, 10);
+ int child;
+
+ if (ps_id >= nps) {
+ *err = g_strdup_printf("No paramset pd_is=%d",ps_id);
+ return NULL;
+ }
+
+ child = echld_new(paramsets[ps_id],NULL);
if (child <= 0) {
*err = g_strdup("No child\n");
return NULL;
}
+static char* run_cmd(char** pars, char** err _U_);
+
+
+
cmd_t commands[] = {
{ "QUIT", quit_cmd, 0, "QUIT"},
{ "HELP", help_cmd, 0, "HELP"},
- { "NEW", new_child_cmd, 0, "NEW"},
+ { "RUN", run_cmd, 1, "RUN filename"},
+ { "PS", ps_cmd, 1, "PS [dummy]"},
+ { "PSADD", psadd_cmd, 4, "PSADD ps_id param value"},
+ { "PSMERGE", psmerge_cmd, 4, "PSMERGE ps_id ps_id"},
+ { "NEW", new_child_cmd, 1, "NEW ps_id"},
{ "PING", ping_cmd, 1, "PING child_id"},
{ "SET", set_cmd, 3, "SET child_id param_name param_val"},
{ "GET", get_cmd, 2, "GET child_id param_name"},
}
+static int invoke_cmd(FILE* in_fp) {
+ size_t len;
+ char* cmd_line;
+ if(( cmd_line = fgetln(in_fp,&len) )) {
+ cmd_t* c = commands;
+ cmd_line[len] = 0;
+ g_strchomp(cmd_line);
+
+ for (;c->txt;c++) {
+ if ( strcasestr(cmd_line, c->txt) == cmd_line ) {
+ char** params = g_strsplit(cmd_line, " ", c->args_taken+1);
+ char* err = NULL;
+ char* str = c->cb(params,&err);
+
+ if (err) {
+ fprintf(stdout, "Error: %s\n", err);
+ g_free(err);
+ } else {
+ fprintf(stdout, "%s\n", str);
+ g_free(str);
+ }
+
+ g_strfreev(params);
+ return TRUE;
+ }
+ }
+
+ fprintf(stdout, "Error: no such command %s\n", cmd_line);
+ return TRUE;
+ } else {
+ return FALSE;
+ }
+}
+
+static char* run_cmd(char** pars, char** err _U_) {
+ FILE* fp = fopen(pars[1],"r");
+ while(invoke_cmd(fp)) { ; }
+ fclose(fp);
+ return NULL;
+}
int got_param = 0;
int main(int argc _U_, char** argv _U_) {
struct timeval tv;
int tot_cycles = 0;
+ echld_init_t init = {ECHLD_ENCODING_JSON,argv[0],main,NULL,NULL,NULL,NULL};
+
tv.tv_sec = 5;
tv.tv_usec = 0;
echld_set_parent_dbg_level(5);
- echld_initialize(ECHLD_ENCODING_JSON,argv[0],main);
+ echld_initialize(&init);
do {
fd_set rfds;
nfds = echld_select(FD_SETSIZE, &rfds, NULL, &efds, &tv);
if (FD_ISSET(0,&rfds)) {
- size_t len;
- char* cmd_line;
-
- if(( cmd_line = fgetln(stdin,&len) )) {
- cmd_t* c = commands;
- cmd_line[len] = 0;
- g_strchomp(cmd_line);
-
- for (;c->txt;c++) {
- if ( strcasestr(cmd_line, c->txt) == cmd_line ) {
- char** params = g_strsplit(cmd_line, " ", c->args_taken+1);
- char* err = NULL;
- char* str = c->cb(params,&err);
-
- if (err) {
- fprintf(stdout, "Error: %s\n", err);
- g_free(err);
- } else {
- fprintf(stdout, "%s\n", str);
- g_free(str);
- }
-
- g_strfreev(params);
- goto cmd_executed;
- }
- }
-
- fprintf(stdout, "Error: no such command %s\n", cmd_line);
- }
+ invoke_cmd(stdin);
}
- cmd_executed:
tot_cycles++;
} while( keep_going );
git.samba.org / metze / wireshark / wip.git / commitdiff