List the disappearance of the ADDRESS macros as an API change.
[metze/wireshark/wip.git] / echld_test.c
1 /* echld-test.c
2  *  basic test framework for echld
3  *
4  * Wireshark - Network traffic analyzer
5  * By Gerald Combs <gerald@wireshark.org>
6  * Copyright 1998 Gerald Combs
7  *
8  * Copyright (c) 2013 by Luis Ontanon <luis@ontanon.org>
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
23  */
24
25 #include <config.h>
26
27 #ifdef HAVE_FCNTL_H
28 #include <fcntl.h>
29 #endif
30
31 #ifdef HAVE_SYS_TYPES_H
32 # include <sys/types.h>
33 #endif
34
35 #include <sys/uio.h>
36
37 #ifdef HAVE_UNISTD_H
38 #include <unistd.h>
39 #endif
40
41 #include <signal.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45
46 #include <glib.h>
47 #include <glib/gprintf.h>
48
49 #include "echld/echld.h"
50 #include "echld/echld-util.h"
51
52 #include "epan/epan.h"
53 #include "wsutil/str_util.h"
54
55 typedef char* (*cmd_cb_t)(char** params, char** err);
56
57 typedef struct _cmd_t {
58         const char* txt;
59         cmd_cb_t cb;
60         int args_taken;
61         const char* help;
62 } cmd_t;
63
64
65 #define MAX_PARAMSETS 16
66
67 static enc_msg_t* paramsets[MAX_PARAMSETS] = {
68         NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL,
69         NULL,NULL,NULL,NULL, NULL,NULL,NULL,NULL
70 };
71
72 static int nps = 0;
73
74 static char* ps_cmd(char** pars _U_, char** err _U_) {
75         int n_id = nps++;
76
77         if (n_id >= MAX_PARAMSETS) {
78                 *err = g_strdup("Max Num of Paramsets reached");
79                 return NULL;
80         }
81
82         paramsets[n_id] = echld_new_child_params();
83
84         return g_strdup_printf("New Paramset ps_id=%d",n_id);
85 }
86
87 static char* psadd_cmd(char** params _U_, char** err) {
88         int ps_id = (int) strtol(params[1], NULL, 10);
89
90         if (ps_id >= nps) {
91                 *err = g_strdup_printf("No paramset pd_is=%d",ps_id);
92                 return NULL;
93         }
94
95         echld_new_child_params_add_params(paramsets[ps_id], params[2], params[3], NULL);
96
97         return g_strdup_printf("PSAdd ps_id=%d %s='%s'", ps_id, params[2], params[3]);
98 }
99
100 static char* psmerge_cmd(char** params, char** err) {
101         int ps1_id = (int) strtol(params[1], NULL, 10);
102         int ps2_id = (int) strtol(params[2], NULL, 10);
103         int n_id;
104
105         if (ps1_id >= nps) {
106                 *err = g_strdup_printf("No paramset pd_is=%d",ps1_id);
107                 return NULL;
108         }
109
110         if (ps2_id >= nps) {
111                 *err = g_strdup_printf("No paramset pd_is=%d",ps2_id);
112                 return NULL;
113         }
114
115         n_id = nps++;
116
117         if (n_id >= MAX_PARAMSETS) {
118                 *err = g_strdup_printf("Max Num of Paramsets reached");
119                 return NULL;
120         }
121
122         paramsets[n_id] = echld_new_child_params_merge(paramsets[ps1_id],paramsets[ps2_id]);
123
124         return g_strdup_printf("Merged Paramset ps1_id=%d ps2_id=%d ps_id=%d",ps1_id, ps2_id, n_id);
125 }
126
127 static char* new_child_cmd(char** params, char** err) {
128         int ps_id = (int) strtol(params[1], NULL, 10);
129         int child;
130
131         if (ps_id >= nps) {
132                 *err = g_strdup_printf("No paramset pd_is=%d",ps_id);
133                 return NULL;
134         }
135
136         child = echld_new(paramsets[ps_id],NULL,NULL);
137
138         if (child <= 0) {
139                 *err = g_strdup("No child\n");
140                 return NULL;
141         }
142
143         return g_strdup_printf("New chld_id=%d\n",child);
144 }
145
146
147 void ping_cb(long usec, void* data) {
148         int ping_id = *((int*)data);
149
150         if (usec >= 0) {
151                 fprintf(stdout, "Ping ping_id=%d returned in %dus\n",ping_id,(int)usec);
152         } else {
153                 fprintf(stdout, "Ping ping_id=%d erored\n",ping_id);
154         }
155
156         g_free(data);
157 }
158
159
160 static char* ping_cmd(char** params, char** err) {
161         int child = (int) strtol(params[1], NULL, 10);
162         static int ping_id = 0;
163         int* ping_data = g_new(int,1);
164
165         *ping_data = ping_id++;
166
167         if (!echld_ping(child,ping_cb,ping_data)) {
168                 *err = g_strdup_printf("Could not send ping child=%d",child);
169                 return NULL;
170         } else {
171                 return g_strdup_printf("Ping sent child=%d",child);
172         }
173 }
174
175 void param_cb(const char* param, const char* value, const char* error, void* data _U_) {
176         if (error) {
177                 fprintf(stdout, "Param Set Error msg=%s\n", error );
178         } else {
179                 fprintf(stdout, "Param: param='%s' val='%s'\n", param, value );
180         }
181 }
182
183 static char* set_cmd(char** params, char** err) {
184         int child = (int) strtol(params[1], NULL, 10);
185         char* param = params[2];
186         char* value = params[3];
187
188         if ( ! echld_set_param(child,param,value,param_cb,NULL) ) {
189                 *err = g_strdup_printf("Failed to SET child=%d param='%s' value='%s'",child,param,value);
190                 return NULL;
191         } else {
192                 return g_strdup_printf("Set command sent child=%d param='%s' value='%s'",child,param,value);
193         }
194 }
195
196 static char* get_cmd(char** params, char** err) {
197         int child = (int) strtol(params[1], NULL, 10);
198         char* param = params[2];
199
200         if ( ! echld_get_param(child,param,param_cb,NULL) ) {
201                 *err = g_strdup_printf("Failed to GET child=%d param='%s'",child,param);
202                 return NULL;
203         } else {
204                 return g_strdup_printf("Get command sent child=%d param='%s'",child,param);
205         }
206 }
207
208 static void close_cb(const char* error, void* data) {
209         if (error) {
210                 fprintf(stdout, "Close Error msg=%s\n", error );
211         } else {
212                 fprintf(stdout, "Closed: child=%d\n", *((int*)data) );
213         }
214 }
215
216 static char* close_cmd(char** params, char** err) {
217         int child = (int) strtol(params[1], NULL, 10);
218         int* cmdp = g_new(int,1);
219         *cmdp = child;
220         if ( ! echld_close(child,close_cb,cmdp) ) {
221                 *err = g_strdup_printf("Could not close child=%d",child);
222                 return NULL;
223         } else {
224                 return g_strdup_printf("CLose command sent child=%d",child);
225         }
226 }
227 int keep_going = 1;
228
229 static char* quit_cmd(char** params _U_, char** err _U_) {
230         keep_going = 0;
231         return g_strdup("Quitting");
232 }
233
234 static char* help_cmd(char**, char**);
235
236 static char* open_file_cmd(char** pars _U_, char** err _U_) {
237         *err = g_strdup("Not Implemented");
238         return NULL;
239 }
240
241 static char* prepare_capture_cmd(char** pars _U_, char** err _U_) {
242         *err = g_strdup("Not Implemented");
243         return NULL;
244 }
245
246 static char* start_capture_cmd(char** pars _U_, char** err _U_) {
247         *err = g_strdup("Not Implemented");
248         return NULL;
249 }
250
251 static char* get_sum_cmd(char** pars _U_, char** err _U_) {
252         *err = g_strdup("Not Implemented");
253         return NULL;
254 }
255
256 static char* get_tree_cmd(char** pars _U_, char** err _U_) {
257         *err = g_strdup("Not Implemented");
258         return NULL;
259 }
260
261 static char* get_buf_cmd(char** pars _U_, char** err _U_) {
262         *err = g_strdup("Not Implemented");
263         return NULL;
264 }
265
266 static char* stop_cmd(char** pars _U_, char** err _U_) {
267         *err = g_strdup("Not Implemented");
268         return NULL;
269 }
270
271 static char* note_cmd(char** pars _U_, char** err _U_) {
272         *err = g_strdup("Not Implemented");
273         return NULL;
274 }
275
276 static char* apply_cmd(char** pars _U_, char** err _U_) {
277         *err = g_strdup("Not Implemented");
278         return NULL;
279 }
280
281 static char* save_cmd(char** pars _U_, char** err _U_) {
282         *err = g_strdup("Not Implemented");
283         return NULL;
284 }
285
286 static char* run_cmd(char** pars, char** err _U_);
287
288
289
290
291 cmd_t commands[] = {
292         { "QUIT", quit_cmd, 0, "QUIT"},
293         { "HELP", help_cmd, 0, "HELP"},
294         { "RUN", run_cmd, 1, "RUN filename"},
295         { "PS", ps_cmd, 1, "PS [dummy]"},
296         { "PSADD", psadd_cmd, 4, "PSADD ps_id param value"},
297         { "PSMERGE", psmerge_cmd, 4, "PSMERGE ps_id ps_id"},
298         { "NEW", new_child_cmd, 1, "NEW ps_id"},
299         { "PING", ping_cmd, 1, "PING child_id"},
300         { "SET", set_cmd, 3, "SET child_id param_name param_val"},
301         { "GET", get_cmd, 2, "GET child_id param_name"},
302         { "CLOSE", close_cmd, 1, "CLOSE child_id"},
303         { "FILE", open_file_cmd, 2, "FILE child_id filename"},
304         { "PREP", prepare_capture_cmd, 2, "PREP child_id intfname params"},
305         { "START",start_capture_cmd,1,"START child_id"},
306         { "SUM", get_sum_cmd,2,"SUM child_id packet_range"},
307         { "TREE", get_tree_cmd,2,"TREE child_id packet_range"},
308         { "BUFF", get_buf_cmd,2,"BUFF child_id buffer_name"},
309         { "STOP", stop_cmd,1,"STOP child_id"},
310         { "NOTE", note_cmd,1,"NOTE child_id framenum note..."},
311         { "APPLY", apply_cmd,1,"APPLY child_id dfilter"},
312         { "SAVE", save_cmd,1,"SAVE child_id filename params"},
313         { NULL, NULL, 0, NULL }
314 };
315
316 static char* help_cmd(char** params _U_, char** err _U_) {
317         GString* out = g_string_new("Commands:\n");
318         cmd_t* c = commands;
319
320         for (;c->txt;c++) {
321                 g_string_append_printf(out,"%s\n",c->help);
322         }
323         return g_string_free(out,FALSE);
324 }
325
326
327 static int invoke_cmd(FILE* in_fp) {
328         size_t len;
329         char* cmd_line;
330
331         if(( cmd_line = fgetln(in_fp,&len) )) {
332                 cmd_t* c = commands;
333                 cmd_line[len] = 0;
334                 g_strchomp(cmd_line);
335
336                 for (;c->txt;c++) {
337                         if ( strcasestr(cmd_line, c->txt) == cmd_line ) {
338                                 char** params = g_strsplit(cmd_line, " ", c->args_taken+1);
339                                 char* err = NULL;
340                                 char* str = c->cb(params,&err);
341
342                                 if (err) {
343                                         fprintf(stdout, "Error: %s\n", err);
344                                         g_free(err);
345                                 } else {
346                                         fprintf(stdout, "%s\n", str);
347                                         g_free(str);
348                                 }
349
350                                 g_strfreev(params);
351                                 return TRUE;
352                         }
353                 }
354
355                 fprintf(stdout, "Error: no such command %s\n", cmd_line);
356                 return TRUE;
357         } else {
358                 return FALSE;
359         }
360 }
361
362 static char* run_cmd(char** pars, char** err _U_) {
363         FILE* fp = ws_stdio_fopen(pars[1],"r");
364         while(invoke_cmd(fp)) { ; }
365         fclose(fp);
366         return NULL;
367 }
368
369
370 int got_param = 0;
371
372
373 int main(int argc _U_, char** argv _U_) {
374         struct timeval tv;
375         int tot_cycles = 0;
376         echld_init_t init = {ECHLD_ENCODING_JSON,argv[0],main,NULL,NULL,NULL,NULL,NULL,NULL};
377
378
379         tv.tv_sec = 5;
380         tv.tv_usec = 0;
381
382         echld_set_parent_dbg_level(5);
383
384         echld_initialize(&init);
385
386         do {
387                 fd_set rfds;
388                 fd_set efds;
389                 int nfds;
390
391                 FD_ZERO(&rfds);
392                 FD_ZERO(&efds);
393                 FD_SET(0,&rfds);
394                 FD_SET(0,&efds);
395
396                 nfds = echld_select(FD_SETSIZE, &rfds, NULL, &efds, &tv);
397
398                 if (FD_ISSET(0,&rfds)) {
399                         invoke_cmd(stdin);
400                 }
401
402                 tot_cycles++;
403         } while( keep_going );
404
405         fprintf(stderr, "Done: tot_cycles=%d\n", tot_cycles );
406
407         echld_terminate();
408         return 0;
409 }
410
411 /*
412  * Editor modelines  -  http://www.wireshark.org/tools/modelines.html
413  *
414  * Local variables:
415  * c-basic-offset: 8
416  * tab-width: 8
417  * indent-tabs-mode: t
418  * End:
419  *
420  * vi: set shiftwidth=8 tabstop=8 noexpandtab:
421  * :indentSize=8:tabSize=8:noTabs=false:
422  */