int main(int argc, char **argv)
{
Octstr *os1;
Octstr *os2;
time_t start, diff;
gwlib_init();
os1 = octstr_create(argv[1]);
os2 = octstr_create(argv[2]);
counter = counter_create();
start = time(NULL);
for_each_file(os1, 1, count_file);
diff = (time(NULL) - start);
debug("",0,"file count: %ld in %lds", (long) counter_value(counter), (long) diff);
#ifdef HAVE_NFTW
counter_set(counter, 0);
start = time(NULL);
for_each_file2(os2, 1, count_file2);
diff = (time(NULL) - start);
debug("",0,"file count: %ld in %lds", (long) counter_value(counter), (long) diff);
#endif
counter_destroy(counter);
octstr_destroy(os1);
octstr_destroy(os2);
gwlib_shutdown();
return 0;
}
static void disconnect(GtkWidget *widget, gpointer data)
{
gdk_input_remove(fd_tag);
counter_destroy(counter);
counter = NULL;
gtk_label_set_text(GTK_LABEL(freq_label), "--- Mhz");
}
int smscconn_destroy(SMSCConn *conn)
{
if (conn == NULL)
return 0;
if (conn->status != SMSCCONN_DEAD)
return -1;
mutex_lock(conn->flow_mutex);
counter_destroy(conn->received);
counter_destroy(conn->received_dlr);
counter_destroy(conn->sent);
counter_destroy(conn->sent_dlr);
counter_destroy(conn->failed);
load_destroy(conn->incoming_sms_load);
load_destroy(conn->incoming_dlr_load);
load_destroy(conn->outgoing_sms_load);
load_destroy(conn->outgoing_dlr_load);
octstr_destroy(conn->name);
octstr_destroy(conn->id);
octstr_destroy(conn->admin_id);
gwlist_destroy(conn->allowed_smsc_id, octstr_destroy_item);
gwlist_destroy(conn->denied_smsc_id, octstr_destroy_item);
gwlist_destroy(conn->preferred_smsc_id, octstr_destroy_item);
octstr_destroy(conn->denied_prefix);
octstr_destroy(conn->allowed_prefix);
octstr_destroy(conn->preferred_prefix);
octstr_destroy(conn->unified_prefix);
octstr_destroy(conn->our_host);
octstr_destroy(conn->log_file);
if (conn->denied_smsc_id_regex != NULL) gw_regex_destroy(conn->denied_smsc_id_regex);
if (conn->allowed_smsc_id_regex != NULL) gw_regex_destroy(conn->allowed_smsc_id_regex);
if (conn->preferred_prefix_regex != NULL) gw_regex_destroy(conn->preferred_prefix_regex);
if (conn->denied_prefix_regex != NULL) gw_regex_destroy(conn->denied_prefix_regex);
if (conn->allowed_prefix_regex != NULL) gw_regex_destroy(conn->allowed_prefix_regex);
octstr_destroy(conn->reroute_to_smsc);
dict_destroy(conn->reroute_by_receiver);
mutex_unlock(conn->flow_mutex);
mutex_destroy(conn->flow_mutex);
gw_free(conn);
return 0;
}
static void empty_msg_lists(void)
{
Msg *msg;
#ifndef NO_WAP
if (list_len(incoming_wdp) > 0 || list_len(outgoing_wdp) > 0)
warning(0, "Remaining WDP: %ld incoming, %ld outgoing",
list_len(incoming_wdp), list_len(outgoing_wdp));
info(0, "Total WDP messages: received %ld, sent %ld",
counter_value(incoming_wdp_counter),
counter_value(outgoing_wdp_counter));
#endif
while((msg = list_extract_first(incoming_wdp))!=NULL)
msg_destroy(msg);
while((msg = list_extract_first(outgoing_wdp))!=NULL)
msg_destroy(msg);
list_destroy(incoming_wdp, NULL);
list_destroy(outgoing_wdp, NULL);
counter_destroy(incoming_wdp_counter);
counter_destroy(outgoing_wdp_counter);
#ifndef NO_SMS
/* XXX we should record these so that they are not forever lost...
*/
if (list_len(incoming_sms) > 0 || list_len(outgoing_sms) > 0)
debug("bb", 0, "Remaining SMS: %ld incoming, %ld outgoing",
list_len(incoming_sms), list_len(outgoing_sms));
info(0, "Total SMS messages: received %ld, sent %ld",
counter_value(incoming_sms_counter),
counter_value(outgoing_sms_counter));
#endif
list_destroy(incoming_sms, msg_destroy_item);
list_destroy(outgoing_sms, msg_destroy_item);
counter_destroy(incoming_sms_counter);
counter_destroy(outgoing_sms_counter);
}
#include "work.h"
#include <stdio.h>
void get_time(imagedata_t *img, const char *fn, logger_t *l) { /*{{{*/
// this is a hack that is targeted to a
// specific small set of jpeg images,
// not expected, or more so, expected to
// not work with arbitrary files
log(l, "trying to open \"%s\"\n", fn);
FILE *fd = fopen(fn, "rb");
assert(fd);
char dstr[20];
fseek(fd, 188, SEEK_SET);
fread(dstr, sizeof(char), 19, fd);
fclose(fd);
dstr[19] = '\0';
// 2013:12:27 18:20:32
// 0123456789012345678
img->time.tm_year = atoi(dstr)-1900;
img->time.tm_mon = atoi(dstr+5);
img->time.tm_mday = atoi(dstr+8);
img->time.tm_hour = atoi(dstr+11);
img->time.tm_min = atoi(dstr+14);
img->time.tm_sec = atoi(dstr+17);
img->stamp = mktime(&img->time);
log(l, "%s -> %s -> %04d-%02d-%02d %02d:%02d:%02d -> %Ld\n", fn, dstr,
img->time.tm_year, img->time.tm_mon, img->time.tm_mday,
img->time.tm_hour, img->time.tm_min, img->time.tm_sec,
img->stamp
);
} /*}}}*/
void scalepow2(bitmap_t *out, bitmap_t *in, unsigned int spow) { /*{{{*/
unsigned int limit = 1<<spow;
for (size_t ty=0; ty<out->height; ++ty) {
for (size_t tx=0; tx<out->width; ++tx) {
size_t tp = tx + ty*out->width;
unsigned int ys = 0;
unsigned int cbs = 0;
unsigned int crs = 0;
size_t ctr = 0;
for (size_t y=0; y<limit; ++y) {
size_t sy = ty*limit + y;
if (sy >= in->height) { break; }
for (size_t x=0; x<limit; ++x) {
size_t sx = tx*limit + x;
if (sx >= in->width) { break; }
size_t sp = sx + sy*in->width;
ys += in->data[sp].x[0];
cbs += in->data[sp].x[1];
crs += in->data[sp].x[2];
++ctr;
}
}
ctr = ctr==0?1:ctr;
out->data[tp].x[0] = ys/ctr;
out->data[tp].x[1] = cbs/ctr;
out->data[tp].x[2] = crs/ctr;
}
}
} /*}}}*/
void init_threaddata(threaddata_t *td, const char *ofmt, const char *ifmt, int start, int stop) { /*{{{*/
log_init(&td->common.l, stdout);
log(&td->common.l, "- logger created\n");
td->common.writerstr = calloc(strlen(ofmt)+32, sizeof(char));
assert(td->common.writerstr != NULL);
sprintf(td->common.writerstr, "pnmtojpeg -quality=100 > %s", ofmt);
log(&td->common.l, "- output shape is '%s'\n", td->common.writerstr);
td->common.readerfmt = ifmt;
td->common.readerstr = calloc(strlen(ifmt)+16, sizeof(char));
assert(td->common.readerstr != NULL);
sprintf(td->common.readerstr, "jpegtopnm < %s", ifmt);
log(&td->common.l, "- input shape is '%s'\n", td->common.readerstr);
log(&td->common.l, "- initializing counter\n");
counter_init(&td->counter, start, stop);
log(&td->common.l, "- initializing buffer\n");
buffer_init(&td->buffer, BUFFERSIZE, loader, unloader);
//font_load_gz(&td->font, "data/sun12x22.psfu");
font_load_gz(&td->font, "/usr/share/kbd/consolefonts/sun12x22.psfu.gz");
} /*}}}*/
void destroy_threaddata(threaddata_t *td) { /*{{{*/
buffer_destroy(&td->buffer, &td->common);
log(&td->common.l, "- destroying counter\n");
counter_destroy(&td->counter);
log(&td->common.l, "- destroying logger\n");
log_destroy(&td->common.l);
free(td->common.writerstr);
free(td->common.readerstr);
} /*}}}*/
void boxc_cleanup(void)
{
octstr_destroy(box_allow_ip);
octstr_destroy(box_deny_ip);
box_allow_ip = NULL;
box_deny_ip = NULL;
counter_destroy(boxid);
boxid = NULL;
}
static void store_spool_shutdown()
{
if (spool == NULL)
return;
counter_destroy(counter);
octstr_destroy(spool);
gwlist_destroy(loaded, NULL);
}
static void smasi_destroy(SMASI *smasi)
{
if (smasi == NULL) return;
gwlist_destroy(smasi->msgs_to_send, msg_destroy_item);
dict_destroy(smasi->sent_msgs);
gwlist_destroy(smasi->received_msgs, msg_destroy_item);
counter_destroy(smasi->message_id_counter);
octstr_destroy(smasi->host);
octstr_destroy(smasi->username);
octstr_destroy(smasi->password);
gw_free(smasi);
}
static void client_thread(void *arg)
{
List *reqh;
unsigned long i;
long succeeded, failed;
HTTPCaller *caller;
char buf[1024];
long in_queue;
Counter *counter = NULL;
caller = arg;
succeeded = 0;
failed = 0;
reqh = gwlist_create();
sprintf(buf, "%ld", (long) gwthread_self());
http_header_add(reqh, "X-Thread", buf);
if (auth_username != NULL && auth_password != NULL)
http_add_basic_auth(reqh, auth_username, auth_password);
in_queue = 0;
counter = counter_create();
for (;;) {
i = counter_increase(counter);
if (i >= max_requests)
goto receive_rest;
start_request(caller, reqh, i);
if (interval > 0)
gwthread_sleep(interval);
++in_queue;
if (receive_reply(caller) == -1)
++failed;
else
++succeeded;
--in_queue;
}
receive_rest:
while (in_queue > 0) {
if (receive_reply(caller) == -1)
++failed;
else
++succeeded;
--in_queue;
}
counter_destroy(counter);
http_destroy_headers(reqh);
http_caller_destroy(caller);
info(0, "This thread: %ld succeeded, %ld failed.", succeeded, failed);
}
void wsp_push_client_shutdown(void)
{
gw_assert(push_client_run_status == running);
push_client_run_status = terminating;
gwlist_remove_producer(push_client_queue);
gwthread_join_every(main_thread);
debug("wap.wsp", 0, "wsp_push_client_shutdown: %ld push client machines"
"left", gwlist_len(push_client_machines));
gwlist_destroy(push_client_machines, push_client_machine_destroy);
gwlist_destroy(push_client_queue, wap_event_destroy_item);
counter_destroy(push_client_machine_id_counter);
}
void wtp_initiator_shutdown(void)
{
gw_assert(initiator_run_status == running);
initiator_run_status = terminating;
gwlist_remove_producer(queue);
gwthread_join_every(main_thread);
debug("wap.wtp", 0, "wtp_initiator_shutdown: %ld init_machines left",
gwlist_len(init_machines));
gwlist_destroy(init_machines, init_machine_destroy);
gwlist_destroy(queue, wap_event_destroy_item);
counter_destroy(init_machine_id_counter);
timers_shutdown();
}
void wsp_session_shutdown(void) {
gw_assert(run_status == running);
run_status = terminating;
gwlist_remove_producer(queue);
gwthread_join_every(main_thread);
gwlist_destroy(queue, wap_event_destroy_item);
debug("wap.wsp", 0, "WSP: %ld session machines left.",
gwlist_len(session_machines));
gwlist_destroy(session_machines, machine_destroy);
counter_destroy(session_id_counter);
wsp_strings_shutdown();
}
void wtls_shutdown(void)
{
/* Make sure that we're actually running; if so, then
prepare for termination */
gw_assert(wtls_run_status == running);
wtls_run_status = terminating;
gwlist_remove_producer(wtls_queue);
gwthread_join_every(main_thread);
/* Print out a friendly message stating that we're going to die */
debug("wap.wtls", 0, "wtls_shutdown: %ld wtls machines left",
gwlist_len(wtls_machines));
/* And clean up nicely after ourselves */
gwlist_destroy(wtls_machines, wtls_machine_destroy);
gwlist_destroy(wtls_queue, wap_event_destroy_item);
counter_destroy(wtls_machine_id_counter);
}
static void conndata_destroy(ConnData *conndata)
{
if (conndata == NULL)
return;
if (conndata->http_ref)
http_caller_destroy(conndata->http_ref);
octstr_destroy(conndata->allow_ip);
octstr_destroy(conndata->send_url);
octstr_destroy(conndata->dlr_url);
octstr_destroy(conndata->username);
octstr_destroy(conndata->password);
octstr_destroy(conndata->proxy);
octstr_destroy(conndata->system_id);
octstr_destroy(conndata->alt_charset);
counter_destroy(conndata->open_sends);
gwlist_destroy(conndata->msg_to_send, NULL);
if (conndata->max_pending_sends)
semaphore_destroy(conndata->max_pending_sends);
gw_free(conndata);
}
int main(int argc, char **argv)
{
int cf_index;
int restart = 0;
Msg *msg;
Cfg *cfg;
double heartbeat_freq = DEFAULT_HEARTBEAT;
gwlib_init();
cf_index = get_and_set_debugs(argc, argv, NULL);
setup_signal_handlers();
if (argv[cf_index] == NULL)
config_filename = octstr_create("kannel.conf");
else
config_filename = octstr_create(argv[cf_index]);
cfg = cfg_create(config_filename);
if (cfg_read(cfg) == -1)
panic(0, "Couldn't read configuration from `%s'.", octstr_get_cstr(config_filename));
report_versions("wapbox");
cfg = init_wapbox(cfg);
info(0, "------------------------------------------------------------");
info(0, GW_NAME " wapbox version %s starting up.", GW_VERSION);
sequence_counter = counter_create();
wsp_session_init(&wtp_resp_dispatch_event,
&wtp_initiator_dispatch_event,
&wap_appl_dispatch,
&wap_push_ppg_dispatch_event);
wsp_unit_init(&dispatch_datagram, &wap_appl_dispatch);
wsp_push_client_init(&wsp_push_client_dispatch_event,
&wtp_resp_dispatch_event);
if (cfg)
wtp_initiator_init(&dispatch_datagram, &wsp_session_dispatch_event,
timer_freq);
wtp_resp_init(&dispatch_datagram, &wsp_session_dispatch_event,
&wsp_push_client_dispatch_event, timer_freq);
wap_appl_init(cfg);
#if (HAVE_WTLS_OPENSSL)
wtls_secmgr_init();
wtls_init(&write_to_bearerbox);
#endif
if (cfg) {
wap_push_ota_init(&wsp_session_dispatch_event,
&wsp_unit_dispatch_event);
wap_push_ppg_init(&wap_push_ota_dispatch_event, &wap_appl_dispatch,
cfg);
}
wml_init(wml_xml_strict);
if (bearerbox_host == NULL)
bearerbox_host = octstr_create(BB_DEFAULT_HOST);
connect_to_bearerbox(bearerbox_host, bearerbox_port, bearerbox_ssl, NULL
/* bearerbox_our_port */);
if (cfg)
wap_push_ota_bb_address_set(bearerbox_host);
program_status = running;
if (0 > heartbeat_start(write_to_bearerbox, heartbeat_freq,
wap_appl_get_load)) {
info(0, GW_NAME "Could not start heartbeat.");
}
while (program_status != shutting_down) {
WAPEvent *dgram;
int ret;
/* block infinite for reading messages */
ret = read_from_bearerbox(&msg, INFINITE_TIME);
if (ret == -1) {
error(0, "Bearerbox is gone, restarting");
program_status = shutting_down;
restart = 1;
break;
} else if (ret == 1) /* timeout */
continue;
else if (msg == NULL) /* just to be sure, may not happens */
break;
if (msg_type(msg) == admin) {
if (msg->admin.command == cmd_shutdown) {
info(0, "Bearerbox told us to die");
program_status = shutting_down;
} else if (msg->admin.command == cmd_restart) {
info(0, "Bearerbox told us to restart");
restart = 1;
program_status = shutting_down;
}
/*
* XXXX here should be suspend/resume, add RSN
*/
} else if (msg_type(msg) == wdp_datagram) {
switch (msg->wdp_datagram.destination_port) {
case CONNECTIONLESS_PORT:
case CONNECTION_ORIENTED_PORT:
dgram = wap_event_create(T_DUnitdata_Ind);
dgram->u.T_DUnitdata_Ind.addr_tuple = wap_addr_tuple_create(
msg->wdp_datagram.source_address,
msg->wdp_datagram.source_port,
msg->wdp_datagram.destination_address,
msg->wdp_datagram.destination_port);
dgram->u.T_DUnitdata_Ind.user_data = msg->wdp_datagram.user_data;
msg->wdp_datagram.user_data = NULL;
wap_dispatch_datagram(dgram);
break;
case WTLS_CONNECTIONLESS_PORT:
case WTLS_CONNECTION_ORIENTED_PORT:
#if (HAVE_WTLS_OPENSSL)
dgram = wtls_unpack_wdp_datagram(msg);
if (dgram != NULL)
wtls_dispatch_event(dgram);
#endif
break;
default:
panic(0,"Bad packet received! This shouldn't happen!");
break;
}
} else {
warning(0, "Received other message than wdp/admin, ignoring!");
}
msg_destroy(msg);
}
info(0, GW_NAME " wapbox terminating.");
program_status = shutting_down;
heartbeat_stop(ALL_HEARTBEATS);
counter_destroy(sequence_counter);
if (cfg)
wtp_initiator_shutdown();
wtp_resp_shutdown();
wsp_push_client_shutdown();
wsp_unit_shutdown();
wsp_session_shutdown();
wap_appl_shutdown();
radius_acct_shutdown();
if (cfg) {
wap_push_ota_shutdown();
wap_push_ppg_shutdown();
}
wml_shutdown();
close_connection_to_bearerbox();
alog_close();
wap_map_destroy();
wap_map_user_destroy();
octstr_destroy(device_home);
octstr_destroy(bearerbox_host);
octstr_destroy(config_filename);
/*
* Just sleep for a while to get bearerbox chance to restart.
* Otherwise we will fail while trying to connect to bearerbox!
*/
if (restart) {
gwthread_sleep(10.0);
/* now really restart */
restart_box(argv);
}
log_close_all();
gwlib_shutdown();
return 0;
}
/*
* Destroy data structures of the module.
*/
static void dlr_spool_shutdown()
{
counter_destroy(counter);
octstr_destroy(spool_dir);
}
int main(int argc, char **argv)
{
int opt;
unsigned long sended = 0;
Octstr *cf, *rf;
gwlib_init();
bb_host = octstr_create("localhost");
bb_port = 13001;
bb_ssl = 0;
while ((opt = getopt(argc, argv, "hv:b:p:si:n:a:f:D:u:d:r:")) != EOF) {
switch (opt) {
case 'v':
log_set_output_level(atoi(optarg));
break;
case 'b':
octstr_destroy(bb_host);
bb_host = octstr_create(optarg);
break;
case 'p':
bb_port = atoi(optarg);
break;
case 's':
bb_ssl = 1;
break;
case 'i':
smsbox_id = octstr_create(optarg);
break;
case 'n':
service = octstr_create(optarg);
break;
case 'a':
account = octstr_create(optarg);
break;
case 'f':
from = octstr_create(optarg);
break;
case 'D':
dlr_mask = atoi(optarg);
break;
case 'u':
dlr_url = octstr_create(optarg);
break;
case 'd':
delay = atof(optarg);
break;
case 'r':
smsc_id = octstr_create(optarg);
break;
case '?':
default:
error(0, "Invalid option %c", opt);
help();
panic(0, "Stopping.");
}
}
if (optind == argc || argc-optind < 2) {
help();
exit(1);
}
/* check some mandatory elements */
if (from == NULL)
panic(0,"Sender address not specified. Use option -f to specify sender address.");
if ((DLR_IS_ENABLED(dlr_mask) && dlr_url == NULL) || (!DLR_IS_ENABLED(dlr_mask) && dlr_url != NULL))
panic(0,"dlr-url address OR dlr-mask not specified. Use option -D or -u to specify dlr values");
rf = octstr_create(argv[argc-1]);
cf = octstr_create(argv[argc-2]);
report_versions("mtbatch");
write_pid_file();
init_batch(cf, rf);
connect_to_bearerbox(bb_host, bb_port, bb_ssl, NULL /* bb_our_host */);
identify_to_bearerbox();
gwthread_create(read_messages_from_bearerbox, NULL);
sended = run_batch();
/* avoid exiting before sending all msgs */
while(sended > counter_value(counter)) {
gwthread_sleep(0.1);
}
program_status = shutting_down;
gwthread_join_all();
octstr_destroy(bb_host);
octstr_destroy(smsbox_id);
octstr_destroy(content);
octstr_destroy(service);
octstr_destroy(account);
octstr_destroy(dlr_url);
octstr_destroy(smsc_id);
counter_destroy(counter);
gwlist_destroy(lines, octstr_destroy_item);
gwlib_shutdown();
return 0;
}
int smscconn_send(SMSCConn *conn, Msg *msg)
{
int ret = -1;
List *parts = NULL;
gw_assert(conn != NULL);
mutex_lock(conn->flow_mutex);
if (conn->status == SMSCCONN_DEAD || conn->why_killed != SMSCCONN_ALIVE) {
mutex_unlock(conn->flow_mutex);
return -1;
}
/* if this a retry of splitted message, don't unify prefix and don't try to split */
if (msg->sms.split_parts == NULL) {
/* normalize the destination number for this smsc */
char *uf = conn->unified_prefix ? octstr_get_cstr(conn->unified_prefix) : NULL;
normalize_number(uf, &(msg->sms.receiver));
/* split msg */
parts = sms_split(msg, NULL, NULL, NULL, NULL, 1,
counter_increase(split_msg_counter) & 0xff, 0xff, conn->max_sms_octets);
if (gwlist_len(parts) == 1) {
/* don't create split_parts of sms fit into one */
gwlist_destroy(parts, msg_destroy_item);
parts = NULL;
}
}
if (parts == NULL)
ret = conn->send_msg(conn, msg);
else {
long i, parts_len = gwlist_len(parts);
struct split_parts *split = gw_malloc(sizeof(*split));
/* must duplicate, because smsc2_route will destroy this msg */
split->orig = msg_duplicate(msg);
split->parts_left = counter_create();
split->status = SMSCCONN_SUCCESS;
counter_set(split->parts_left, parts_len);
split->smsc_conn = conn;
debug("bb.sms.splits", 0, "new split_parts created %p", split);
for (i = 0; i < parts_len; i++) {
msg = gwlist_get(parts, i);
msg->sms.split_parts = split;
ret = conn->send_msg(conn, msg);
if (ret < 0) {
if (i == 0) {
counter_destroy(split->parts_left);
gwlist_destroy(parts, msg_destroy_item);
gw_free(split);
mutex_unlock(conn->flow_mutex);
return ret;
}
/*
* Some parts were sent. So handle this within
* bb_smscconn_XXX().
*/
split->status = SMSCCONN_FAILED_REJECTED;
counter_increase_with(split->parts_left, -(parts_len - i));
warning(0, "Could not send all parts of a split message");
break;
}
}
gwlist_destroy(parts, msg_destroy_item);
}
mutex_unlock(conn->flow_mutex);
return ret;
}
static void destroy(GtkWidget *widget, gpointer data)
{
counter_destroy(counter);
gtk_exit(0);
}
int main(int argc, char **argv)
{
struct sigaction act;
int port;
int opt;
double run_time;
char *log_file;
char *config_file;
gwlib_init();
act.sa_handler = handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
sigaction(SIGTERM, &act, NULL);
sigaction(SIGINT, &act, NULL);
port = 2345;
smsc_system_id = octstr_create("kannel_smpp");
smsc_source_addr = octstr_create("123456");
message_id_counter = counter_create();
bearerbox_host = octstr_create("127.0.0.1");
port_for_smsbox = 13001;
max_to_esme = 1;
num_to_esme = counter_create();
num_from_esme = counter_create();
num_to_bearerbox = counter_create();
num_from_bearerbox = counter_create();
log_file = config_file = NULL;
while ((opt = getopt(argc, argv, "hv:p:m:l:c:")) != EOF) {
switch (opt) {
case 'v':
log_set_output_level(atoi(optarg));
break;
case 'h':
help();
exit(0);
case 'm':
max_to_esme = atoi(optarg);
break;
case 'p':
port = atoi(optarg);
break;
case 'l':
log_file = optarg;
break;
case 'c':
config_file = optarg;
break;
case '?':
default:
error(0, "Invalid option %c", opt);
help();
panic(0, "Stopping.");
}
}
if (log_file != NULL)
log_open(log_file, GW_DEBUG, GW_NON_EXCL);
if (config_file != NULL) {
Cfg *cfg;
Octstr *tmp = octstr_create(config_file);
cfg = cfg_create(tmp);
octstr_destroy(tmp);
if (cfg_read(cfg) == -1)
panic(0, "Errors in config file.");
smpp_pdu_init(cfg);
cfg_destroy(cfg);
}
info(0, "Starting drive_smpp test.");
gwthread_create(accept_thread, &port);
gwthread_join_all();
debug("test.smpp", 0, "Program exiting normally.");
run_time = difftime(last_from_esme, first_to_esme);
info(0, "Number of messages sent to ESME: %ld",
counter_value(num_to_esme));
info(0, "Number of messages sent to smsbox: %ld",
counter_value(num_from_bearerbox));
info(0, "Number of messages sent to bearerbox: %ld",
counter_value(num_to_bearerbox));
info(0, "Number of messages sent to SMSC: %ld",
counter_value(num_from_esme));
info(0, "Time: %.0f secs", run_time);
info(0, "Time until all sent to ESME: %.0f secs",
difftime(last_to_esme, start_time));
info(0, "Time from first from bb to last to bb: %.0f secs",
difftime(last_to_bb, first_from_bb));
info(0, "Time until all sent to SMSC: %.0f secs",
difftime(last_from_esme, start_time));
info(0, "SMPP messages SMSC to ESME: %.1f msgs/sec",
counter_value(num_to_esme) / run_time);
info(0, "SMPP messages ESME to SMSC: %.1f msgs/sec",
counter_value(num_from_esme) / run_time);
octstr_destroy(smsc_system_id);
octstr_destroy(smsc_source_addr);
octstr_destroy(bearerbox_host);
counter_destroy(num_to_esme);
counter_destroy(num_from_esme);
counter_destroy(num_to_bearerbox);
counter_destroy(num_from_bearerbox);
counter_destroy(message_id_counter);
gwlib_shutdown();
return 0;
}
int main(int argc, char **argv)
{
int opt;
Cfg *cfg = NULL;
gwlib_init();
server_port = CONNECTION_ORIENTED_PORT;
while ((opt = getopt(argc, argv, "v:meti:p:")) != EOF) {
switch (opt) {
case 'v':
log_set_output_level(atoi(optarg));
break;
case 'm':
verbose += 1;
break;
case 'e':
verbose += 2;
break;
case 't':
verbose += 4;
break;
case 'h':
help();
exit(0);
case 'i':
interface_name = octstr_create(optarg);
break;
case 'p':
server_port = atoi(optarg);
break;
case '?':
default:
error(0, "Invalid option %c", opt);
help();
panic(0, "Stopping.");
}
}
if (optind == argc) {
help();
exit(0);
}
/* get the host or IP of the real wap gw to forward the WDP packets */
wapgw = octstr_create(argv[optind]);
/* if no interface was given use 0.0.0.0 */
if (!interface_name)
interface_name = octstr_create("*");
report_versions("wapproxy");
/* initialize main inbound and outbound queues */
outgoing_wdp = gwlist_create();
incoming_wdp = gwlist_create();
flow_threads = gwlist_create();
outgoing_wdp_counter = counter_create();
incoming_wdp_counter = counter_create();
/* start the main UDP listening threads */
udp_start(cfg);
gwlist_add_producer(outgoing_wdp);
debug("bb", 0, "starting WDP routers");
if (gwthread_create(service_router, NULL) == -1)
panic(0, "Failed to start a new thread for inbound WDP routing");
if (gwthread_create(wdp_router, NULL) == -1)
panic(0, "Failed to start a new thread for outbound WDP routing");
gwthread_sleep(5.0); /* give time to threads to register themselves */
while (gwlist_consume(flow_threads) != NULL)
;
udp_shutdown();
gwlist_remove_producer(outgoing_wdp);
gwlist_destroy(flow_threads, NULL);
gwlist_destroy(incoming_wdp, NULL);
gwlist_destroy(outgoing_wdp, NULL);
counter_destroy(incoming_wdp_counter);
counter_destroy(outgoing_wdp_counter);
octstr_destroy(interface_name);
octstr_destroy(wapgw);
gwlib_shutdown();
return 0;
}
int main(int argc, char **argv)
{
int opt,
num_threads;
time_t start,
end;
double run_time;
long threads[MAX_THREADS];
long i;
Octstr *fos;
gwlib_init();
num_threads = 1;
while ((opt = getopt(argc, argv, "HhBbnEpv:qr:t:c:a:i:e:k:d:s:S:I:m:u:")) != EOF) {
switch(opt) {
case 'v':
log_set_output_level(atoi(optarg));
break;
case 'q':
verbose = 0;
break;
case 'r':
max_pushes = atoi(optarg);
break;
case 'i':
wait_seconds = atof(optarg);
break;
case 't':
num_threads = atoi(optarg);
if (num_threads > MAX_THREADS)
num_threads = MAX_THREADS;
break;
case 'H':
use_hardcoded = 1;
break;
case 'c':
content_flag = octstr_create(optarg);
if (octstr_compare(content_flag, octstr_imm("wml")) != 0 &&
octstr_compare(content_flag, octstr_imm("si")) != 0 &&
octstr_compare(content_flag, octstr_imm("sl")) != 0 &&
octstr_compare(content_flag, octstr_imm("nil")) != 0 &&
octstr_compare(content_flag, octstr_imm("mms")) != 0 &&
octstr_compare(content_flag, octstr_imm("scrap")) != 0 &&
octstr_compare(content_flag, octstr_imm("multipart")) != 0) {
octstr_destroy(content_flag);
error(0, "TEST_PPG: Content type not known");
help();
exit(1);
}
break;
case 'a':
appid_flag = octstr_create(optarg);
if (octstr_compare(appid_flag, octstr_imm("any")) != 0 &&
octstr_compare(appid_flag, octstr_imm("ua")) != 0 &&
octstr_compare(appid_flag, octstr_imm("mms")) != 0 &&
octstr_compare(appid_flag, octstr_imm("nil")) != 0 &&
octstr_compare(appid_flag, octstr_imm("scrap")) != 0) {
octstr_destroy(appid_flag);
error(0, "TEST_PPG: Push application id not known");
help();
exit(1);
}
break;
case 'n':
use_numeric = 1;
break;
case 's':
appid_string = octstr_create(optarg);
use_string = 1;
break;
case 'S':
content_header = octstr_create(optarg);
use_content_header = 1;
break;
case 'e':
content_transfer_encoding = octstr_create(optarg);
if (octstr_compare(content_transfer_encoding, octstr_imm("base64")) != 0) {
octstr_destroy(content_transfer_encoding);
error(0, "TEST_PPG: unknown content transfer"
" encoding \"%s\"", octstr_get_cstr(content_transfer_encoding));
help();
exit(1);
}
break;
case 'k':
connection = octstr_create(optarg);
if (octstr_compare(connection, octstr_imm("close")) != 0 &&
octstr_compare(connection, octstr_imm("keep-alive")) != 0) {
octstr_destroy(connection);
error(0, "TEST_PPG: Connection-header unacceptable");
help();
exit(1);
}
break;
case 'h':
help();
exit(1);
case 'b':
use_headers = 1;
break;
case 'B':
accept_binary = 1;
break;
case 'd':
delimiter = octstr_create(optarg);
if (octstr_compare(delimiter, octstr_imm("crlf")) != 0 &&
octstr_compare(delimiter, octstr_imm("lf")) != 0) {
octstr_destroy(delimiter);
error(0, "illegal d value");
help();
exit(1);
}
break;
case 'E':
add_epilogue = 1;
break;
case 'p':
add_preamble = 1;
break;
case 'I':
initiator_uri = octstr_create(optarg);
break;
case 'm':
use_dlr_mask = 1;
dlr_mask = octstr_create(optarg);
break;
case 'u':
use_dlr_url = 1;
dlr_url = octstr_create(optarg);
break;
case '?':
default:
error(0, "TEST_PPG: Invalid option %c", opt);
help();
error(0, "Stopping");
exit(1);
}
}
if (optind == argc) {
help();
exit(1);
}
push_data = argv + optind;
num_urls = argc - optind;
if (content_flag == NULL)
content_flag = octstr_imm("si");
if (appid_flag == NULL)
appid_flag = octstr_imm("ua");
if (appid_string == NULL)
appid_string = octstr_imm("x-wap-application-id: wml.ua");
if (content_header == NULL)
use_content_header = 0;
if (dlr_mask == NULL)
use_dlr_mask = 0;
if (dlr_url == NULL)
use_dlr_url = 0;
if (delimiter == NULL)
delimiter = octstr_imm("crlf");
if (use_hardcoded) {
username = octstr_imm("troo");
password = octstr_imm("far");
}
if (push_data[0] == NULL) {
error(0, "No ppg address or config file, stopping");
exit(1);
}
use_config = 0;
if (!use_hardcoded) {
if (push_data[1] == NULL) {
info(0, "a configuration file input assumed");
read_test_ppg_config(fos = octstr_format("%s", push_data[0]));
octstr_destroy(fos);
use_config = 1;
}
}
if (!use_config)
push_url = octstr_format("%s", push_data[0]);
if (!use_hardcoded && !use_config && push_data[1] != NULL) {
if (push_data[2] == NULL) {
error(0, "no pap control document, stopping");
exit(1);
} else {
info(0, "an input without a configuration file assumed");
content_file = octstr_create(push_data[1]);
pap_file = octstr_create(push_data[2]);
debug("test.ppg", 0, "using %s as a content file", push_data[1]);
debug("test.ppg", 0, "using %s as a control file", push_data[2]);
}
}
boundary = "asdlfkjiurwghasf";
counter = counter_create();
time(&start);
if (num_threads == 0)
push_thread(http_caller_create());
else {
for (i = 0; i < num_threads; ++i)
threads[i] = gwthread_create(push_thread, http_caller_create());
for (i = 0; i < num_threads; ++i)
gwthread_join(threads[i]);
}
time(&end);
run_time = difftime(end, start);
info(0, "TEST_PPG: %ld requests in %f seconds, %f requests per second",
max_pushes, run_time, max_pushes / run_time);
octstr_destroy(content_flag);
octstr_destroy(appid_flag);
octstr_destroy(content_header);
octstr_destroy(content_file);
octstr_destroy(pap_file);
octstr_destroy(ssl_client_certkey_file);
octstr_destroy(username);
octstr_destroy(password);
octstr_destroy(push_url);
octstr_destroy(connection);
octstr_destroy(delimiter);
octstr_destroy(dlr_mask);
octstr_destroy(dlr_url);
counter_destroy(counter);
gwlib_shutdown();
exit(0);
}