/*!
* init sl internal structures
*/
int sl_startup()
{
init_tags( sl_tag.s, &tag_suffix,
"SER-stateless",
SL_TOTAG_SEPARATOR );
/*timeout*/
sl_timeout = (unsigned int*)shm_malloc(sizeof(unsigned int));
if (!sl_timeout)
{
LOG(L_ERR,"ERROR:sl_startup: no more free memory!\n");
return -1;
}
*(sl_timeout)=get_ticks();
return 1;
}
int sl_startup(void)
{
init_tags( sl_tag.s, &tag_suffix,
"OpenSIPS-stateless",
SL_TOTAG_SEPARATOR );
/*timeout*/
sl_timeout = (unsigned int*)shm_malloc(sizeof(unsigned int));
if (!sl_timeout)
{
LM_ERR("no more shm memory!\n");
return -1;
}
*(sl_timeout)=get_ticks();
return 0;
}
void tm_init_tags(void)
{
init_tags(tm_tags, &tm_tag_suffix,
"OpenSIPS-TM/tags", TM_TAG_SEPARATOR );
}
/**Initializes SEAS to-tags
*/
static void seas_init_tags(void)
{
init_tags(seas_tags, &seas_tag_suffix,"VozTele-Seas/tags",'-');
LM_DBG("seas_init_tags, seas_tags=%s\n",seas_tags);
}
/*
Main code and general functions
*/
int main(int argc, char *argv[])
{
char *dev = NULL;
char errbuf[PCAP_ERRBUF_SIZE] = {0};
bpf_u_int32 mask;
bpf_u_int32 net;
if (argc > 1) {
proc_ops(argc, argv);
dev = argv[optind];
if(!dev) {
printf("No network interface name given\n\n");
show_help();
}
if(!op.port) {
strcpy(filter_exp + 5, "3306");
op.port_n = 3306;
}
}
else
show_help();
if(pcap_lookupnet(dev, &net, &mask, errbuf) == -1) {
printf("Couldn't get netmask for device %s: %s\n", dev, errbuf);
net = mask = 0;
}
handle = pcap_open_live(dev, SNAP_LEN, 1, 1000, errbuf);
if(handle == NULL) {
printf("Couldn't open device %s: %s\n", dev, errbuf);
exit(-1);
}
if (strlen(errbuf) > 0) {
printf("Warning from pcap_open_live: %s\n", errbuf);
}
if(pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {
printf("Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));
exit(-1);
}
if (pcap_setfilter(handle, &fp) == -1) {
printf("Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));
exit(-1);
}
printf("mysqlsniffer listening for MySQL on interface %s %s\n", dev, filter_exp);
signal(SIGINT, handle_ctrl_c);
signal(SIGHUP, handle_sighup);
init_tags();
init_state_map();
pcap_loop(handle, -1, proc_packet, NULL);
printf("ERROR: pcap_loop returned from an infinite loop\n");
cleanup();
print_stats();
exit(-1);
}
static void init_dialog_tags()
{
/* taken from tm, might be useful */
init_tags(dialog_tags, &dialog_tag_suffix, "SER-DIALOG/tags", '-');
}
int
cmdline_main (int argc, char *argv[])
{
guchar *output;
int num_frames = 1;
#ifdef MOVIES
int generate_movie = 0;
quicktime_t *output_movie;
guchar **rows;
#endif
int antialiasing = 0, supersampling = 0;
int img_width, img_height;
char *generator = 0;
userval_info_t *userval_info;
int num_input_drawables = 0;
gboolean size_is_set = FALSE;
char *script = NULL;
char *output_filename;
gboolean htmldoc = FALSE;
define_t *defines = NULL;
int bench_render_count = 1;
int render_num;
gboolean bench_no_output = FALSE;
gboolean bench_no_backend = FALSE;
int compile_time_limit = DEFAULT_OPTIMIZATION_TIMEOUT;
for (;;)
{
static struct option long_options[] =
{
{ "version", no_argument, 0, OPTION_VERSION },
{ "help", no_argument, 0, OPTION_HELP },
{ "intersampling", no_argument, 0, 'i' },
{ "oversampling", no_argument, 0, 'o' },
{ "cache", required_argument, 0, 'c' },
{ "generator", required_argument, 0, 'g' },
{ "size", required_argument, 0, 's' },
{ "script-file", required_argument, 0, 'f' },
{ "htmldoc", no_argument, 0, OPTION_HTMLDOC },
{ "bench-no-output", no_argument, 0, OPTION_BENCH_NO_OUTPUT },
{ "bench-only-compile", no_argument, 0, OPTION_BENCH_ONLY_COMPILE },
{ "bench-no-compile-time-limit", no_argument, 0, OPTION_BENCH_NO_COMPILE_TIME_LIMIT },
{ "bench-no-backend", no_argument, 0, OPTION_BENCH_NO_BACKEND },
{ "bench-render-count", required_argument, 0, OPTION_BENCH_RENDER_COUNT },
#ifdef MOVIES
{ "frames", required_argument, 0, 'F' },
{ "movie", required_argument, 0, 'M' },
#endif
{ 0, 0, 0, 0 }
};
int option, option_index;
option = getopt_long(argc, argv,
#ifdef MOVIES
"f:ioF:D:M:c:g:s:",
#else
"f:ioD:c:g:s:",
#endif
long_options, &option_index);
if (option == -1)
break;
switch (option)
{
case OPTION_VERSION :
printf("MathMap " MATHMAP_VERSION "\n"
"\n"
"Copyright (C) 1997-2009 Mark Probst\n"
"\n"
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Foundation; either version 2 of the License, or\n"
"(at your option) any later version.\n"
"\n"
"This program is distributed in the hope that it will be useful,\n"
"but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
"GNU General Public License for more details.\n"
"\n"
"You should have received a copy of the GNU General Public License\n"
"along with this program; if not, write to the Free Software\n"
"Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.\n");
return 0;
case OPTION_HELP :
usage();
return 0;
case OPTION_HTMLDOC :
htmldoc = TRUE;
break;
case 'f' :
if (!g_file_get_contents(optarg, &script, NULL, NULL))
{
fprintf(stderr, _("Error: The script file `%s' could not be read.\n"), optarg);
return 1;
}
break;
case 'i' :
antialiasing = 1;
break;
case 'o' :
supersampling = 1;
break;
case 'c' :
cache_size = atoi(optarg);
assert(cache_size > 0);
break;
case 'D' :
append_define(optarg, &defines);
break;
case 'I' :
alloc_cmdline_image_input_drawable(optarg);
break;
case 'g' :
generator = optarg;
break;
case 's' :
if (!parse_image_size(optarg, &img_width, &img_height))
{
fprintf(stderr, _("Error: Invalid image size. Syntax is <width>x<height>. Example: 1024x768.\n"));
exit(1);
}
size_is_set = 1;
break;
case OPTION_BENCH_RENDER_COUNT :
bench_render_count = atoi(optarg);
break;
case OPTION_BENCH_ONLY_COMPILE :
bench_render_count = 0;
break;
case OPTION_BENCH_NO_OUTPUT :
bench_no_output = TRUE;
break;
case OPTION_BENCH_NO_COMPILE_TIME_LIMIT :
compile_time_limit = -1;
break;
case OPTION_BENCH_NO_BACKEND :
bench_no_backend = TRUE;
break;
#ifdef MOVIES
case 'F' :
generate_movie = 1;
num_frames = atoi(optarg);
assert(num_frames > 0);
break;
case 'M' :
alloc_cmdline_movie_input_drawable(optarg);
break;
#endif
}
}
if (script != NULL)
{
if (argc - optind != 1)
{
usage();
return 1;
}
output_filename = argv[optind];
}
else
{
if (argc - optind != 2)
{
usage();
return 1;
}
script = argv[optind];
output_filename = argv[optind + 1];
}
init_tags();
init_builtins();
init_macros();
init_compiler();
if (htmldoc)
{
mathmap_t *mathmap = parse_mathmap(script);
filter_t *filter;
FILE *out;
if (mathmap == NULL)
{
fprintf(stderr, _("Error: Could not read MathMap script: %s\n"), error_string);
return 1;
}
out = fopen(output_filename, "w");
if (out == NULL)
{
fprintf(stderr, _("Error: Cannot open file `%s' for writing: %s\n"),
output_filename, strerror(errno));
return 1;
}
for (filter = mathmap->filters; filter != NULL; filter = filter->next)
{
if (filter->kind != FILTER_MATHMAP)
continue;
if (!write_filter_html_doc(out, filter->v.mathmap.decl))
return 1;
}
fclose(out);
}
else if (generator == 0)
{
char *support_paths[4];
mathmap_t *mathmap;
mathmap_invocation_t *invocation;
int current_frame;
support_paths[0] = g_strdup_printf("%s/mathmap", GIMPDATADIR);
support_paths[1] = g_strdup_printf("%s/.gimp-2.6/mathmap", getenv("HOME"));
support_paths[2] = g_strdup_printf("%s/.gimp-2.4/mathmap", getenv("HOME"));
support_paths[3] = NULL;
mathmap = compile_mathmap(script, support_paths, compile_time_limit, bench_no_backend);
if (bench_no_backend)
return 0;
if (mathmap == 0)
{
fprintf(stderr, _("Error: %s\n"), error_string);
exit(1);
}
if (bench_render_count == 0)
return 0;
if (!size_is_set)
for (userval_info = mathmap->main_filter->userval_infos;
userval_info != NULL;
userval_info = userval_info->next)
{
define_t *define;
unsigned char *image;
if (userval_info->type != USERVAL_IMAGE)
continue;
define = lookup_define(defines, userval_info->name);
if (define == NULL)
{
fprintf(stderr, _("Error: No value defined for input image `%s'.\n"), userval_info->name);
return 1;
}
image = read_image(define->value, &img_width, &img_height);
if (image == NULL)
{
fprintf(stderr, _("Error: Could not read input image `%s'.\n"), define->value);
return 1;
}
free(image);
size_is_set = TRUE;
break;
}
if (!size_is_set)
{
fprintf(stderr, _("Error: Image size not set and no input images given.\n"));
exit(1);
}
invocation = invoke_mathmap(mathmap, NULL, img_width, img_height, TRUE);
for (userval_info = mathmap->main_filter->userval_infos;
userval_info != NULL;
userval_info = userval_info->next)
{
userval_t *userval = &invocation->uservals[userval_info->index];
define_t *define = lookup_define(defines, userval_info->name);
if (define == NULL)
{
if (userval_info->type == USERVAL_IMAGE)
{
fprintf(stderr, _("Error: No value defined for input image `%s'.\n"), userval_info->name);
return 1;
}
}
else
switch (userval_info->type)
{
case USERVAL_INT_CONST :
userval->v.int_const = atoi(define->value);
break;
case USERVAL_FLOAT_CONST :
userval->v.float_const = g_ascii_strtod(define->value, NULL);
break;
case USERVAL_BOOL_CONST :
userval->v.bool_const = (float)atoi(define->value);
break;
case USERVAL_IMAGE :
assign_image_userval_drawable(userval_info, userval,
alloc_cmdline_image_input_drawable(define->value));
++num_input_drawables;
break;
default :
fprintf(stderr, _("Error: Can only define user values for types int, float, bool and image.\n"));
return 1;
}
}
for (render_num = 0; render_num < bench_render_count; ++render_num)
{
#ifdef MOVIES
for (i = 0; i < num_input_drawables; ++i)
if (input_drawables[i].type == DRAWABLE_MOVIE)
{
assert(quicktime_video_width(input_drawables[i].v.movie, 0) == img_width);
assert(quicktime_video_height(input_drawables[i].v.movie, 0) == img_height);
}
#endif
invocation_set_antialiasing(invocation, antialiasing);
invocation->supersampling = supersampling;
invocation->output_bpp = 4;
output = (guchar*)malloc((long)invocation->output_bpp * (long)img_width * (long)img_height);
assert(output != 0);
#ifdef MOVIES
if (generate_movie)
{
output_movie = quicktime_open(output_filename, 0, 1);
assert(output_movie != 0);
quicktime_set_video(output_movie, 1, img_width, img_height, 25, QUICKTIME_JPEG);
assert(quicktime_supported_video(output_movie, 0));
quicktime_seek_start(output_movie);
rows = (guchar**)malloc(sizeof(guchar*) * img_height);
for (i = 0; i < img_height; ++i)
rows[i] = output + img_width * invocation->output_bpp * i;
}
#endif
for (current_frame = 0; current_frame < num_frames; ++current_frame)
{
float current_t = (float)current_frame / (float)num_frames;
image_t *closure = closure_image_alloc(&invocation->mathfuncs,
NULL,
invocation->mathmap->main_filter->num_uservals,
invocation->uservals,
img_width, img_height);
mathmap_frame_t *frame = invocation_new_frame(invocation, closure,
current_frame, current_t);
call_invocation_parallel_and_join(frame, closure, 0, 0, img_width, img_height, output, 1);
invocation_free_frame(frame);
#ifdef MOVIES
if (generate_movie && !bench_no_output)
{
fprintf(stderr, _("writing frame %d\n"), current_frame);
assert(quicktime_encode_video(output_movie, rows, 0) == 0);
}
#endif
closure_image_free(closure);
}
if (!bench_no_output)
{
#ifdef MOVIES
if (generate_movie)
quicktime_close(output_movie);
else
#endif
write_image(output_filename, img_width, img_height, output,
invocation->output_bpp, img_width * invocation->output_bpp, IMAGE_FORMAT_PNG);
}
free(output);
}
}
else
{
if (strcmp(generator, "blender") == 0)
{
if (!blender_generate_plug_in(script, output_filename))
return 1;
}
/*
else if (strcmp(generator, "pixeltree") == 0)
{
if (!pixeltree_generate_plug_in(argv[optind], argv[optind + 1]))
return 1;
}
*/
else
{
fprintf(stderr, _("Unknown generator `%s'\n"), generator);
return 1;
}
}
return 0;
}
