osmith
/
wireshark
forked from osmocom/wireshark
1
0
Fork 0
Code Pull Requests Releases Wiki Activity

another iteration, prepared for automake. 

svn path=/trunk/; revision=50136
This commit is contained in:
Luis Ontanon 2013-06-25 03:33:02 +00:00
parent e591c9f21e
commit db09d8d0f0
10 changed files with 124 additions and 138 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
echld/Makefile.am
View File

@ -20,15 +20,22 @@
# along with this program; if not, write to the Free Software # along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
include ../Makefile.am.inc
ACLOCAL_AMFLAGS = `../aclocal-flags` ACLOCAL_AMFLAGS = `../aclocal-flags`
include Makefile.common
# Optional objects that I know how to build. These will be # Optional objects that I know how to build. These will be
# linked into libechld. # linked into libechld.
echld_optional_objects = echld_optional_objects = $(LIBECHLD_SRC)
lib_LTLIBRARIES = libechld.la
libechld_la_LDFLAGS = -version-info 0:0:0 @LDFLAGS_SHAREDLIB@
include ../Makefile.am.inc
include Makefile.common
AM_CFLAGS =-DWS_BUILD_DLL AM_CFLAGS =-DWS_BUILD_DLL
@ -36,22 +43,17 @@ if HAVE_WARNINGS_AS_ERRORS
AM_CFLAGS += -Werror AM_CFLAGS += -Werror
endif endif
lib_LTLIBRARIES = libechld.la
# http://www.gnu.org/software/libtool/manual/html_node/Updating-version-info.html
libechld_la_LDFLAGS = -version-info 0:0:0 @LDFLAGS_SHAREDLIB@
AM_CPPFLAGS = -I$(srcdir)/.. AM_CPPFLAGS = -I$(srcdir)/..
libechld_la_SOURCES = \ libechld_la_SOURCES = \
$(LIBECHLD_SRC) \ $(LIBECHLD_SRC) \
$(LIBECHLD_INCLUDES) $(LIBECHLD_INCLUDES)
EXTRA_libechld_la_SOURCES= libechld_la_DEPENDENCIES=
libechld_la_DEPENDENCIES=
libechld_la_LIBADD = \ libechld_la_LIBADD = \
../epan/libwireshark.la \
../wsutil/libwsutil.la \
@GLIB_LIBS@ @GLIB_LIBS@
EXTRA_DIST = \ EXTRA_DIST = \
@ -67,32 +69,3 @@ CLEANFILES = \
MAINTAINERCLEANFILES = \ MAINTAINERCLEANFILES = \
Makefile.in Makefile.in
bin_PROGRAMS =
@echld_test_bin@
EXTRA_PROGRAMS = echld_test
echld_test_LDADD = \
echld/libechld.la \
@GLIB_LIBS@
echld_test_CFLAGS = $(AM_CLEAN_CFLAGS)
# ABI compliance checker can be obtained from
# http://ispras.linux-foundation.org/index.php/ABI_compliance_checker
# Checked using version 1.21.12
#dumpabi-libechld: all abi-descriptor.xml
# rm -rf abi-check-headers abi_dumps .libs/*.abi.tar.gz
# mkdir abi-check-headers
# cp ../config.h ../ws_symbol_export.h *.h abi-check-headers/
# abi-compliance-checker -l libechld -v1 `readlink .libs/libechld.so | sed 's/.*\.so\.//'` \
# -relpath $(abs_srcdir) -dump-abi abi-descriptor.xml || \
# cat logs/libechld/[0-9]*/log.txt
# cp -f abi_dumps/libechld/libechld_* .libs/
# cd .libs && ln -sf libechld_*.abi.tar.gz libechld.abi.tar.gz
#
#checkapi:
# $(PERL) ../tools/checkAPIs.pl -g abort -g termoutput \
# $(PERL) ../tools/checkAPIs.pl -g termoutput -build \
# $(LIBWSUTIL_SRC)
# file_util.c unicode-utils.c

4
echld/Makefile.common
View File

@ -40,7 +40,3 @@ LIBECHLD_INCLUDES = \
echld-int.h \ echld-int.h \
echld-util.h \ echld-util.h \
echld.h echld.h
# echld_test specifics
echld_test_SOURCES = \
echld_test.c

22
echld/echld-int.h
View File

@ -122,8 +122,8 @@ typedef struct _echld_reader {
#define READER_FD_ISSET(R,fdset_p) READER_FD_ISSET(R.fd,&(fdset_p)) #define READER_FD_ISSET(R,fdset_p) READER_FD_ISSET(R.fd,&(fdset_p))
#define READER_FD_CLEAR(R,fdset_p) READER_FD_CLEAR(R.fd,&(fdset_p)) #define READER_FD_CLEAR(R,fdset_p) READER_FD_CLEAR(R.fd,&(fdset_p))
void echld_init_reader(echld_reader_t* r, int fd, size_t initial); extern void echld_init_reader(echld_reader_t* r, int fd, size_t initial);
void echld_reset_reader(echld_reader_t* r, int fd, size_t initial); extern void echld_reset_reader(echld_reader_t* r, int fd, size_t initial);
typedef struct _param { typedef struct _param {
const char* name; const char* name;
@ -174,23 +174,25 @@ typedef struct _parent_in {
echld_bool_t (*packet_list) (enc_msg_t*, char**, char**, char**); // name, filter, range echld_bool_t (*packet_list) (enc_msg_t*, char**, char**, char**); // name, filter, range
} parent_decoder_t; } parent_decoder_t;
void echld_get_all_codecs(child_encoder_t**, child_decoder_t**, echld_parent_encoder_t**, parent_decoder_t**); extern void echld_get_all_codecs(child_encoder_t**, child_decoder_t**, echld_parent_encoder_t**, parent_decoder_t**);
void echld_init_reader(echld_reader_t* r, int fd, size_t initial); extern void echld_init_reader(echld_reader_t* r, int fd, size_t initial);
void free_reader(echld_reader_t* r); extern void free_reader(echld_reader_t* r);
long echld_read_frame(echld_reader_t* r, read_cb_t cb, void* cb_data); extern long echld_read_frame(echld_reader_t* r, read_cb_t cb, void* cb_data);
long echld_write_frame(int fd, GByteArray* ba, guint16 chld_id, echld_msg_type_t type, guint16 reqh_id, void* data); extern long echld_write_frame(int fd, GByteArray* ba, guint16 chld_id, echld_msg_type_t type, guint16 reqh_id, void* data);
void echld_child_initialize(int pipe_from_parent, int pipe_to_parent, int reqh_id); extern void echld_child_initialize(int pipe_from_parent, int pipe_to_parent, int reqh_id);
int echld_child_loop(void); extern int echld_child_loop(void);
/* never returns*/ /* never returns*/
void echld_dispatcher_start(int* in_pipe_fds, int* out_pipe_fds); extern void echld_dispatcher_start(int* in_pipe_fds, int* out_pipe_fds);
extern void dummy_switch(echld_msg_type_t type); extern void dummy_switch(echld_msg_type_t type);
extern void echld_unused(void);
#define DEBUG_CHILD 5 #define DEBUG_CHILD 5
#define DEBUG_DISPATCHER 5 #define DEBUG_DISPATCHER 5

2
echld/echld-util.c
View File

@ -61,7 +61,7 @@ static gboolean pong(echld_msg_type_t type, GByteArray* ba _U_, void* data) {
} }
echld_state_t echld_ping(int chld_id, echld_ping_cb_t pcb, void* cb_data) { extern echld_state_t echld_ping(int chld_id, echld_ping_cb_t pcb, void* cb_data) {
struct _ping* p = g_new0(struct _ping,1); struct _ping* p = g_new0(struct _ping,1);
p->cb = pcb; p->cb = pcb;

18
echld/echld-util.h
View File

@ -23,22 +23,26 @@
* along with this program; if not, write to the Free Software * along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/ */
#ifndef __ECHLD_UTIL
#define __ECHLD_UTIL
typedef void (*echld_ping_cb_t)(long usec, void* data); typedef void (*echld_ping_cb_t)(long usec, void* data);
echld_state_t echld_ping(int child_id, echld_ping_cb_t pcb, void* cb_data); WS_DLL_PUBLIC echld_state_t echld_ping(int child_id, echld_ping_cb_t pcb, void* cb_data);
typedef void (*echld_list_interface_cb_t)(char* intf_name, char* params, void* cb_data); typedef void (*echld_list_interface_cb_t)(char* intf_name, char* params, void* cb_data);
echld_state_t echld_list_interfaces(int child_id, echld_list_interface_cb_t, void* cb_data); WS_DLL_PUBLIC echld_state_t echld_list_interfaces(int child_id, echld_list_interface_cb_t, void* cb_data);
typedef void (*echild_get_packet_summary_cb_t)(char* summary, void* data); typedef void (*echild_get_packet_summary_cb_t)(char* summary, void* data);
echld_state_t echld_open_file(int child_id, const char* filename,echild_get_packet_summary_cb_t,void*); WS_DLL_PUBLIC echld_state_t echld_open_file(int child_id, const char* filename,echild_get_packet_summary_cb_t,void*);
echld_state_t echld_open_interface(int child_id, const char* intf_name, const char* params); WS_DLL_PUBLIC echld_state_t echld_open_interface(int child_id, const char* intf_name, const char* params);
echld_state_t echld_start_capture(int child_id, echild_get_packet_summary_cb_t); WS_DLL_PUBLIC echld_state_t echld_start_capture(int child_id, echild_get_packet_summary_cb_t);
echld_state_t echld_stop_capture(int child_id); WS_DLL_PUBLIC echld_state_t echld_stop_capture(int child_id);
typedef void (*echild_get_packets_cb)(char* tree_text,void* data); typedef void (*echild_get_packets_cb)(char* tree_text,void* data);
typedef void (*echild_get_buffer_cb)(char* buffer_text, void* data); typedef void (*echild_get_buffer_cb)(char* buffer_text, void* data);
echld_state_t echld_get_packets_range(int child_id, const char* range, echild_get_packets_cb, echild_get_buffer_cb, void* data); WS_DLL_PUBLIC echld_state_t echld_get_packets_range(int child_id, const char* range, echild_get_packets_cb, echild_get_buffer_cb, void* data);
#endif

66
echld/echld.h
View File

@ -27,6 +27,8 @@
#ifndef __ECHLD_H #ifndef __ECHLD_H
#define __ECHLD_H #define __ECHLD_H
#include "ws_symbol_export.h"
#define ECHLD_VERSION "0.0" #define ECHLD_VERSION "0.0"
#define ECHLD_MAJOR_VERSION 0 /* increases when existing things change */ #define ECHLD_MAJOR_VERSION 0 /* increases when existing things change */
/* if this changes an old client may or may not work */ /* if this changes an old client may or may not work */
@ -72,10 +74,10 @@ typedef int echld_bool_t;
typedef struct timeval tv_t; typedef struct timeval tv_t;
/* will initialize epan registering protocols and taps */ /* will initialize epan registering protocols and taps */
void echld_initialize(echld_encoding_t); WS_DLL_PUBLIC void echld_initialize(echld_encoding_t);
/* cleans up (?) echld and kills the server process(es) */ /* cleans up (?) echld and kills the server process(es) */
echld_state_t echld_terminate(void); WS_DLL_PUBLIC echld_state_t echld_terminate(void);
/* /*
* returning ECHLD_NO_ERROR means there has being no error * returning ECHLD_NO_ERROR means there has being no error
@ -86,23 +88,23 @@ echld_state_t echld_terminate(void);
* for managing asyncronous errors use a msgh for ECHLD_ERROR * for managing asyncronous errors use a msgh for ECHLD_ERROR
* the response cb of reqh might be a ECHLD_ERROR message * the response cb of reqh might be a ECHLD_ERROR message
*/ */
echld_error_t echld_get_error(const char** errstr_ptr); WS_DLL_PUBLIC echld_error_t echld_get_error(const char** errstr_ptr);
/* /*
* Children Management Operations * Children Management Operations
*/ */
/* create a new worker process */ /* create a new worker process */
echld_chld_id_t echld_new(void* child_data); 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() */ /* will return NULL on error, if NULL is also ok for you use echld_get_error() */
void* echld_get_data(echld_chld_id_t); WS_DLL_PUBLIC void* echld_get_data(echld_chld_id_t);
echld_state_t echld_set_data(echld_chld_id_t id, void* child_data); 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) */ /* 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); typedef echld_bool_t (*echld_iter_cb_t)(echld_chld_id_t, void* child_data, void* cb_data);
void echld_foreach_child(echld_iter_cb_t cb, 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 */ /* enc_msg_t is an obscure object for an encoded message */
typedef struct _GByteArray enc_msg_t; typedef struct _GByteArray enc_msg_t;
@ -145,14 +147,14 @@ typedef struct _parent_out {
enc_msg_t* (*save_file)(const char* filename, const char* params); enc_msg_t* (*save_file)(const char* filename, const char* params);
} echld_parent_encoder_t; } echld_parent_encoder_t;
echld_parent_encoder_t* echld_get_encoder(void); WS_DLL_PUBLIC echld_parent_encoder_t* echld_get_encoder(void);
/* /*
* decoder * decoder
* it returns an allocated string with the decoded response of the message, you free it. * it returns an allocated string with the decoded response of the message, you free it.
* it destroys the enc_msg_t as well. * it destroys the enc_msg_t as well.
*/ */
char* echld_decode(echld_msg_type_t, enc_msg_t*); WS_DLL_PUBLIC char* echld_decode(echld_msg_type_t, enc_msg_t*);
/* /*
* Request Handlers * Request Handlers
@ -165,28 +167,28 @@ char* echld_decode(echld_msg_type_t, enc_msg_t*);
* resp_cb is the callback and cb_data the data it is going to be passed if executed * resp_cb is the callback and cb_data the data it is going to be passed if executed
* *
* returns the reqh id */ * returns the reqh id */
echld_reqh_id_t echld_reqh(echld_chld_id_t, echld_msg_type_t, int usecs_timeout, enc_msg_t*, echld_msg_cb_t, void*); WS_DLL_PUBLIC echld_reqh_id_t echld_reqh(echld_chld_id_t, echld_msg_type_t, int usecs_timeout, enc_msg_t*, echld_msg_cb_t, void*);
/* get callback data for a live request */ /* get callback data for a live request */
void* echld_reqh_get_data(echld_chld_id_t, echld_reqh_id_t); WS_DLL_PUBLIC void* echld_reqh_get_data(echld_chld_id_t, echld_reqh_id_t);
/* get the total timeout time for a live request, -1 is err */ /* get the total timeout time for a live request, -1 is err */
int echld_reqh_get_to(echld_chld_id_t, echld_reqh_id_t); WS_DLL_PUBLIC int echld_reqh_get_to(echld_chld_id_t, echld_reqh_id_t);
/* get the remaining timeout time for a live request, -1 is err */ /* get the remaining timeout time for a live request, -1 is err */
int echld_reqh_get_remaining_to(echld_chld_id_t, echld_reqh_id_t); WS_DLL_PUBLIC int echld_reqh_get_remaining_to(echld_chld_id_t, echld_reqh_id_t);
/* get the callback for a live request */ /* get the callback for a live request */
echld_msg_cb_t echld_reqh_get_cb(echld_chld_id_t, echld_reqh_id_t); WS_DLL_PUBLIC echld_msg_cb_t echld_reqh_get_cb(echld_chld_id_t, echld_reqh_id_t);
/* set callback data for a live request */ /* set callback data for a live request */
echld_state_t echld_reqh_set_data(echld_chld_id_t, echld_reqh_id_t, void* ); WS_DLL_PUBLIC echld_state_t echld_reqh_set_data(echld_chld_id_t, echld_reqh_id_t, void* );
/* get the callback for a live request */ /* get the callback for a live request */
echld_state_t echld_reqh_set_cb(echld_chld_id_t, echld_reqh_id_t, echld_msg_cb_t); WS_DLL_PUBLIC echld_state_t echld_reqh_set_cb(echld_chld_id_t, echld_reqh_id_t, echld_msg_cb_t);
/* stop receiving a live request */ /* stop receiving a live request */
echld_state_t echld_reqh_detach(echld_chld_id_t, echld_reqh_id_t); WS_DLL_PUBLIC echld_state_t echld_reqh_detach(echld_chld_id_t, echld_reqh_id_t);
/* /*
@ -195,34 +197,34 @@ echld_state_t echld_reqh_detach(echld_chld_id_t, echld_reqh_id_t);
*/ */
/* start a message handler */ /* start a message handler */
echld_msgh_id_t echld_msgh(echld_chld_id_t, echld_msg_type_t, echld_msg_cb_t resp_cb, void* msg_data); WS_DLL_PUBLIC echld_msgh_id_t echld_msgh(echld_chld_id_t, echld_msg_type_t, echld_msg_cb_t resp_cb, void* msg_data);
/* stop it */ /* stop it */
echld_state_t echld_msgh_detach(echld_chld_id_t, echld_msgh_id_t); WS_DLL_PUBLIC echld_state_t echld_msgh_detach(echld_chld_id_t, echld_msgh_id_t);
/* get a msgh's data */ /* get a msgh's data */
void* echld_msgh_get_data(echld_chld_id_t, echld_msgh_id_t); WS_DLL_PUBLIC void* echld_msgh_get_data(echld_chld_id_t, echld_msgh_id_t);
/* get a msgh's cb */ /* get a msgh's cb */
echld_msg_cb_t echld_msgh_get_cb(echld_chld_id_t, echld_msgh_id_t); WS_DLL_PUBLIC echld_msg_cb_t echld_msgh_get_cb(echld_chld_id_t, echld_msgh_id_t);
/* get a msgh's type */ /* get a msgh's type */
echld_msg_type_t echld_msgh_get_type(echld_chld_id_t, echld_msgh_id_t); WS_DLL_PUBLIC echld_msg_type_t echld_msgh_get_type(echld_chld_id_t, echld_msgh_id_t);
/* get it all from a msgh */ /* get it all from a msgh */
echld_state_t echld_msgh_get_all(echld_chld_id_t, int msgh_id, echld_msg_type_t*, echld_msg_cb_t*, void**); WS_DLL_PUBLIC echld_state_t echld_msgh_get_all(echld_chld_id_t, int msgh_id, echld_msg_type_t*, echld_msg_cb_t*, void**);
/* set a msgh's data */ /* set a msgh's data */
echld_state_t echld_msgh_set_data(echld_chld_id_t, int msgh_id, void* ); WS_DLL_PUBLIC echld_state_t echld_msgh_set_data(echld_chld_id_t, int msgh_id, void* );
/* set a msgh's cb */ /* set a msgh's cb */
echld_state_t echld_msgh_set_cb(echld_chld_id_t, int msgh_id, echld_msg_cb_t); WS_DLL_PUBLIC echld_state_t echld_msgh_set_cb(echld_chld_id_t, int msgh_id, echld_msg_cb_t);
/* set a msgh's type */ /* set a msgh's type */
echld_state_t echld_msgh_set_type(echld_chld_id_t, int msgh_id, echld_msg_type_t); WS_DLL_PUBLIC echld_state_t echld_msgh_set_type(echld_chld_id_t, int msgh_id, echld_msg_type_t);
/* set all elements of a msgh */ /* set all elements of a msgh */
echld_state_t echld_msgh_set_all(echld_chld_id_t, int msgh_id, echld_msg_type_t, echld_msg_cb_t, void*); WS_DLL_PUBLIC echld_state_t echld_msgh_set_all(echld_chld_id_t, int msgh_id, echld_msg_type_t, echld_msg_cb_t, void*);
@ -236,7 +238,7 @@ echld_state_t echld_msgh_set_all(echld_chld_id_t, int msgh_id, echld_msg_type_t,
* *
* returns ECHLD_TIMEOUT or ECHLD_OK if something was done * returns ECHLD_TIMEOUT or ECHLD_OK if something was done
*/ */
echld_state_t echld_wait(tv_t* timeout); WS_DLL_PUBLIC echld_state_t echld_wait(tv_t* timeout);
#define ECHLD_WAIT() do { struct timeval tv; int rfds, efds; \ #define ECHLD_WAIT() do { struct timeval tv; int rfds, efds; \
echld_select(echld_fdset(&rfds, &efds),&rfds, NULL, &efds, NULL) \ echld_select(echld_fdset(&rfds, &efds),&rfds, NULL, &efds, NULL) \
@ -246,16 +248,16 @@ echld_state_t echld_wait(tv_t* timeout);
to be used in place of select() in the main loop of the parent code to be used in place of select() in the main loop of the parent code
it will serve the children pipes and return as if select() was called. it will serve the children pipes and return as if select() was called.
*/ */
int echld_select(int nfds, fd_set* rfds, fd_set* wfds, fd_set* efds, tv_t* timeout); WS_DLL_PUBLIC int echld_select(int nfds, fd_set* rfds, fd_set* wfds, fd_set* efds, tv_t* timeout);
/* or fit these two in your select loop */ /* or fit these two in your select loop */
/* returns nfds set */ /* returns nfds set */
int echld_fdset(fd_set* rfds, fd_set* efds); WS_DLL_PUBLIC int echld_fdset(fd_set* rfds, fd_set* efds);
int echld_fd_read(fd_set* rfds, fd_set* efds); WS_DLL_PUBLIC int echld_fd_read(fd_set* rfds, fd_set* efds);
void echld_set_parent_dbg_level(int lvl); WS_DLL_PUBLIC void echld_set_parent_dbg_level(int lvl);
#define ECHLD_MAX_CHILDREN 32 #define ECHLD_MAX_CHILDREN 32

7
echld/echld_child.c
View File

@ -534,3 +534,10 @@ int echld_child_loop(void) {
} }
extern void echld_unused(void) {
intflist2json(NULL);
child_start_interface_listing();
child_open_file(0, 0, NULL, NULL, 0);
child_open_interface(0, 0, NULL, NULL, NULL, 0);
}

6
echld/echld_common.c
View File

@ -722,3 +722,9 @@ extern void dummy_switch(echld_msg_type_t type) {
case EC_ACTUAL_ERROR: break; case EC_ACTUAL_ERROR: break;
} }
} }
static void* unused = int_deca;
extern void unused_things(void) {
unused = NULL;
}

66
echld/echld_parent.c
View File

@ -95,7 +95,7 @@ static void parent_dbg(int level, const char* fmt, ...) {
#define PARENT_DBG(attrs) #define PARENT_DBG(attrs)
#endif #endif
void echld_set_parent_dbg_level(int lvl) { extern void echld_set_parent_dbg_level(int lvl) {
PARENT_DBG((0,"Debug Level Set: %d",(dbg_level = lvl))); PARENT_DBG((0,"Debug Level Set: %d",(dbg_level = lvl)));
} }
@ -238,7 +238,7 @@ void echld_initialize(echld_encoding_t enc) {
} }
echld_state_t echld_terminate(void) { extern echld_state_t echld_terminate(void) {
echld_cleanup(); echld_cleanup();
return TRUE; return TRUE;
} }
@ -295,7 +295,7 @@ static echld_state_t reqh_snd(echld_t* c, echld_msg_type_t t, GByteArray* ba, ec
} }
echld_reqh_id_t echld_reqh( extern echld_reqh_id_t echld_reqh(
echld_chld_id_t child_id, echld_chld_id_t child_id,
echld_msg_type_t t, echld_msg_type_t t,
int usecs_timeout, int usecs_timeout,
@ -307,7 +307,7 @@ echld_reqh_id_t echld_reqh(
} }
/* get callback data for a live request */ /* get callback data for a live request */
void* echld_reqh_get_data(int child_id, int reqh_id) { extern void* echld_reqh_get_data(int child_id, int reqh_id) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
int idx; int idx;
@ -322,7 +322,7 @@ void* echld_reqh_get_data(int child_id, int reqh_id) {
} }
/* get the callback for a live request */ /* get the callback for a live request */
echld_msg_cb_t echld_reqh_get_cb(int child_id, int reqh_id) { extern echld_msg_cb_t echld_reqh_get_cb(int child_id, int reqh_id) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
int idx; int idx;
@ -337,7 +337,7 @@ echld_msg_cb_t echld_reqh_get_cb(int child_id, int reqh_id) {
} }
/* set callback data for a live request */ /* set callback data for a live request */
gboolean echld_reqh_set_data(int child_id, int reqh_id, void* cb_data) { extern gboolean echld_reqh_set_data(int child_id, int reqh_id, void* cb_data) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
int idx; int idx;
@ -353,7 +353,7 @@ gboolean echld_reqh_set_data(int child_id, int reqh_id, void* cb_data) {
} }
/* get the callback for a live request */ /* get the callback for a live request */
gboolean echld_reqh_set_cb(int child_id, int reqh_id, echld_msg_cb_t cb){ extern gboolean echld_reqh_set_cb(int child_id, int reqh_id, echld_msg_cb_t cb){
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
int idx; int idx;
@ -369,7 +369,7 @@ gboolean echld_reqh_set_cb(int child_id, int reqh_id, echld_msg_cb_t cb){
/* stop receiving a live request */ /* stop receiving a live request */
gboolean echld_reqh_detach(int child_id, int reqh_id) { extern gboolean echld_reqh_detach(int child_id, int reqh_id) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
int idx; int idx;
@ -428,7 +428,7 @@ int chld_cmp(const void *a, const void *b) {
static int msgh_attach(echld_t* c, echld_msg_type_t t, echld_msg_cb_t resp_cb, void* cb_data); static int msgh_attach(echld_t* c, echld_msg_type_t t, echld_msg_cb_t resp_cb, void* cb_data);
int echld_new(void* child_data) { extern int echld_new(void* child_data) {
int next_chld_id = 1; int next_chld_id = 1;
echld_t* c = get_child(-1); echld_t* c = get_child(-1);
@ -454,12 +454,12 @@ int echld_new(void* child_data) {
/* XXX these fail silently */ /* XXX these fail silently */
void* echld_get_data(int child_id) { extern void* echld_get_data(int child_id) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return c ? c->data : NULL; return c ? c->data : NULL;
} }
echld_state_t echld_set_data(echld_chld_id_t chld_id, void* data) { extern echld_state_t echld_set_data(echld_chld_id_t chld_id, void* data) {
echld_t* c = get_child(chld_id); echld_t* c = get_child(chld_id);
if (c) { if (c) {
c->data = data; c->data = data;
@ -494,7 +494,7 @@ static int msgh_attach(echld_t* c, echld_msg_type_t t, echld_msg_cb_t resp_cb, v
return 0; return 0;
} }
int echld_msgh(int child_id, echld_msg_type_t t, echld_msg_cb_t resp_cb, void* cb_data) { extern int echld_msgh(int child_id, echld_msg_type_t t, echld_msg_cb_t resp_cb, void* cb_data) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
if (c) return msgh_attach(c,t,resp_cb,cb_data); if (c) return msgh_attach(c,t,resp_cb,cb_data);
@ -513,7 +513,7 @@ static echld_state_t msgh_detach(echld_t* c, int msgh_id) {
return 1; return 1;
} }
echld_state_t echld_msgh_detach(int child_id, int msgh_id) { extern echld_state_t echld_msgh_detach(int child_id, int msgh_id) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return msgh_detach(c,msgh_id); return msgh_detach(c,msgh_id);
} }
@ -528,7 +528,7 @@ static void* msgh_get_data(echld_t* c, int msgh_id) {
return ((hdlr_t*)(c->handlers->data))[idx].cb_data; return ((hdlr_t*)(c->handlers->data))[idx].cb_data;
} }
void* echld_msgh_get_data(int child_id, int msgh_id) { extern void* echld_msgh_get_data(int child_id, int msgh_id) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return msgh_get_data(c,msgh_id); return msgh_get_data(c,msgh_id);
} }
@ -542,7 +542,7 @@ static echld_msg_cb_t msgh_get_cb(echld_t* c, int msgh_id) {
return ((hdlr_t*)(c->handlers->data))[idx].cb; return ((hdlr_t*)(c->handlers->data))[idx].cb;
} }
echld_msg_cb_t echld_msgh_get_cb(int child_id, int msgh_id) { extern echld_msg_cb_t echld_msgh_get_cb(int child_id, int msgh_id) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return msgh_get_cb(c,msgh_id); return msgh_get_cb(c,msgh_id);
} }
@ -556,7 +556,7 @@ static echld_msg_type_t msgh_get_type(echld_t* c, int msgh_id) {
return ((hdlr_t*)(c->handlers->data))[idx].type; return ((hdlr_t*)(c->handlers->data))[idx].type;
} }
echld_msg_type_t echld_msgh_get_type(int child_id, int msgh_id) { extern echld_msg_type_t echld_msgh_get_type(int child_id, int msgh_id) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return c ? msgh_get_type(c,msgh_id) : EC_ACTUAL_ERROR; return c ? msgh_get_type(c,msgh_id) : EC_ACTUAL_ERROR;
} }
@ -577,7 +577,7 @@ static echld_state_t msgh_get_all(echld_t* c, int msgh_id, echld_msg_type_t* t,
return 0; return 0;
} }
gboolean echld_msgh_get_all(int child_id, int msgh_id, echld_msg_type_t* t, echld_msg_cb_t* cb, void** data) { extern gboolean echld_msgh_get_all(int child_id, int msgh_id, echld_msg_type_t* t, echld_msg_cb_t* cb, void** data) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return c && msgh_get_all(c,msgh_id,t,cb,data); return c && msgh_get_all(c,msgh_id,t,cb,data);
} }
@ -597,7 +597,7 @@ static echld_state_t msgh_set_all(echld_t* c, int msgh_id, echld_msg_type_t t, e
return 0; return 0;
} }
gboolean echld_msgh_set_all(int child_id, int msgh_id, echld_msg_type_t t, echld_msg_cb_t cb, void* data) { extern gboolean echld_msgh_set_all(int child_id, int msgh_id, echld_msg_type_t t, echld_msg_cb_t cb, void* data) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return c ? msgh_set_all(c,msgh_id,t,cb,data) : FALSE; return c ? msgh_set_all(c,msgh_id,t,cb,data) : FALSE;
} }
@ -614,13 +614,13 @@ static gboolean msgh_set_data(echld_t* c, int msgh_id, void* data) {
} }
gboolean echld_msgh_set_data(int child_id, int msgh_id, void* data){ extern gboolean echld_msgh_set_data(int child_id, int msgh_id, void* data){
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return c ? msgh_set_data(c,msgh_id,data) : FALSE; return c ? msgh_set_data(c,msgh_id,data) : FALSE;
} }
/* set a msgh's cb */ /* set a msgh's cb */
gboolean msgh_set_cb(echld_t* c, int msgh_id, echld_msg_cb_t cb) { extern gboolean msgh_set_cb(echld_t* c, int msgh_id, echld_msg_cb_t cb) {
int idx = msgh_idx(c,msgh_id); int idx = msgh_idx(c,msgh_id);
if (idx < 0) return FALSE; if (idx < 0) return FALSE;
@ -630,7 +630,7 @@ gboolean msgh_set_cb(echld_t* c, int msgh_id, echld_msg_cb_t cb) {
return TRUE; return TRUE;
} }
gboolean echld_msgh_set_cb(int child_id, int msgh_id, echld_msg_cb_t cb) { extern gboolean echld_msgh_set_cb(int child_id, int msgh_id, echld_msg_cb_t cb) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return c ? msgh_set_cb(c,msgh_id,cb) : FALSE; return c ? msgh_set_cb(c,msgh_id,cb) : FALSE;
} }
@ -647,14 +647,14 @@ static gboolean msgh_set_type(echld_t* c, int msgh_id, echld_msg_type_t t) {
return TRUE; return TRUE;
} }
gboolean echld_msgh_set_type(int child_id, int msgh_id, echld_msg_type_t t) { extern gboolean echld_msgh_set_type(int child_id, int msgh_id, echld_msg_type_t t) {
echld_t* c = get_child(child_id); echld_t* c = get_child(child_id);
return c ? msgh_set_type(c,msgh_id,t) : FALSE; return c ? msgh_set_type(c,msgh_id,t) : FALSE;
} }
/* call cb(id,child_data,cb_data) for each child*/ /* call cb(id,child_data,cb_data) for each child*/
void echld_foreach_child(echld_iter_cb_t cb, void* cb_data) { extern void echld_foreach_child(echld_iter_cb_t cb, void* cb_data) {
int i; int i;
for(i=0;i<ECHLD_MAX_CHILDREN;i++) { for(i=0;i<ECHLD_MAX_CHILDREN;i++) {
echld_t* c = &(parent.children[i]); echld_t* c = &(parent.children[i]);
@ -707,14 +707,14 @@ static long parent_read_frame(guint8* b, size_t len, echld_chld_id_t chld_id, ec
return 1; return 1;
} }
int echld_fdset(fd_set* rfds, fd_set* efds) { extern int echld_fdset(fd_set* rfds, fd_set* efds) {
FD_SET(parent.reader.fd, rfds); FD_SET(parent.reader.fd, rfds);
FD_SET(parent.reader.fd, efds); FD_SET(parent.reader.fd, efds);
FD_SET(parent.dispatcher_fd, efds); FD_SET(parent.dispatcher_fd, efds);
return 2; return 2;
} }
int echld_fd_read(fd_set* rfds, fd_set* efds) { extern int echld_fd_read(fd_set* rfds, fd_set* efds) {
int r_nfds=0; int r_nfds=0;
if (FD_ISSET(parent.reader.fd,efds) || FD_ISSET(parent.dispatcher_fd,efds) ) { if (FD_ISSET(parent.reader.fd,efds) || FD_ISSET(parent.dispatcher_fd,efds) ) {
/* Handle errored dispatcher */ /* Handle errored dispatcher */
@ -730,7 +730,7 @@ int echld_fd_read(fd_set* rfds, fd_set* efds) {
return r_nfds; return r_nfds;
} }
int echld_select(int nfds, fd_set* rfds, fd_set* wfds, fd_set* efds, struct timeval* timeout) { extern int echld_select(int nfds, fd_set* rfds, fd_set* wfds, fd_set* efds, struct timeval* timeout) {
fd_set my_rfds, my_wfds, my_efds; fd_set my_rfds, my_wfds, my_efds;
int r_nfds; int r_nfds;
@ -747,22 +747,10 @@ int echld_select(int nfds, fd_set* rfds, fd_set* wfds, fd_set* efds, struct time
return r_nfds ; return r_nfds ;
} }
echld_state_t echld_wait(struct timeval* timeout) { extern echld_state_t echld_wait(struct timeval* timeout) {
if ( echld_select(0, NULL, NULL, NULL, timeout) < 0) { if ( echld_select(0, NULL, NULL, NULL, timeout) < 0) {
return -1; return -1;
} else { } else {
return ECHLD_OK; return ECHLD_OK;
} }
} }
/* Ping the child */

16
echld/echld_test.c → echld_test.c
View File

@ -41,13 +41,18 @@
#include <unistd.h> #include <unistd.h>
#endif #endif
#include "echld.h"
#include "echld-util.h"
#include <signal.h> #include <signal.h>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <glib.h>
#include <glib/gprintf.h>
#include "echld/echld.h"
#include "echld/echld-util.h"
#include "epan/epan.h"
#include "wsutil/str_util.h"
int pings = 0; int pings = 0;
int errors = 0; int errors = 0;
@ -66,11 +71,14 @@ int main(int argc, char** argv) {
struct timeval tv; struct timeval tv;
int tot_cycles = 0; int tot_cycles = 0;
int npings; int npings;
GString* str = g_string_new("");
tv.tv_sec = 0; tv.tv_sec = 0;
tv.tv_usec = 250000; tv.tv_usec = 250000;
echld_set_parent_dbg_level(4);
switch(argc) { switch(argc) {
case 1: case 1:
npings = 10; npings = 10;