int store_spool_init(const Octstr *store_dir)
{
DIR *dir;
store_messages = store_spool_messages;
store_save = store_spool_save;
store_save_ack = store_spool_save_ack;
store_load = store_spool_load;
store_dump = store_spool_dump;
store_shutdown = store_spool_shutdown;
store_status = store_spool_status;
if (store_dir == NULL)
return 0;
/* check if we can open directory */
if ((dir = opendir(octstr_get_cstr(store_dir))) == NULL) {
error(errno, "Could not open directory `%s'", octstr_get_cstr(store_dir));
return -1;
}
closedir(dir);
loaded = gwlist_create();
gwlist_add_producer(loaded);
spool = octstr_duplicate(store_dir);
counter = counter_create();
return 0;
}
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 connect(GtkWidget *widget, gpointer data)
{
counter = counter_create(dev, measure, range);
if (counter != NULL)
fd_tag = gdk_input_add(counter->port->fd, GDK_INPUT_READ, counter_callback, NULL);
}
/*
* Initialize dlr_waiting_list and return out storage handles.
*/
struct dlr_storage *dlr_init_spool(Cfg *cfg)
{
CfgGroup *grp;
if (!(grp = cfg_get_single_group(cfg, octstr_imm("core"))))
panic(0, "DLR: spool: group 'core' is not specified!");
if (!(spool_dir = cfg_get(grp, octstr_imm("dlr-spool"))))
panic(0, "DLR: spool: directive 'dlr-spool' is not specified!");
#ifdef HAVE_LIBSSL
OpenSSL_add_all_digests();
#endif
counter = counter_create();
/* we need to traverse the DLR spool to determine how
* many entries we have. */
#ifdef VERIFIED
for_each_file(spool_dir, 1, verified_file);
#else
for_each_file(spool_dir, 1, non_verified_file);
#endif
return &handles;
}
static void init_batch(Octstr *cfilename, Octstr *rfilename)
{
Octstr *receivers;
long lineno = 0;
content = octstr_read_file(octstr_get_cstr(cfilename));
octstr_strip_crlfs(content);
if (content == NULL)
panic(0,"Can not read content file `%s'.",
octstr_get_cstr(cfilename));
info(0,"SMS-Text: <%s>", octstr_get_cstr(content));
info(0,"Loading receiver list. This may take a while...");
receivers = octstr_read_file(octstr_get_cstr(rfilename));
if (receivers == NULL)
panic(0,"Can not read receivers file `%s'.",
octstr_get_cstr(rfilename));
lines = octstr_split(receivers, octstr_imm("\n"));
lineno = gwlist_len(lines);
if (lineno <= 0)
panic(0,"Receiver file seems empty!");
info(0,"Receivers file `%s' contains %ld destination numbers.",
octstr_get_cstr(rfilename), lineno);
counter = counter_create();
}
static SMASI *smasi_create(SMSCConn *conn)
{
SMASI *smasi = gw_malloc(sizeof(SMASI));
smasi->conn = conn;
smasi->thread_handle = -1;
smasi->msgs_to_send = gwlist_create();
smasi->sent_msgs = dict_create(16, NULL);
smasi->received_msgs = gwlist_create();
smasi->message_id_counter = counter_create();
smasi->host = NULL;
smasi->username = NULL;
smasi->password = NULL;
smasi->source_addr_ton = -1;
smasi->source_addr_npi = -1;
smasi->dest_addr_ton = -1;
smasi->dest_addr_npi = -1;
smasi->my_number = NULL;
smasi->port = 21500;
smasi->quitting = 0;
smasi->logged_off = 0;
smasi->priority = 0;
smasi->throttling_err_time = 0;
smasi->enquire_link_interval = 30;
gwlist_add_producer(smasi->msgs_to_send);
return smasi;
}
int smsbox_start(Cfg *cfg)
{
CfgGroup *grp;
if (smsbox_running) return -1;
debug("bb", 0, "starting smsbox connection module");
grp = cfg_get_single_group(cfg, octstr_imm("core"));
if (cfg_get_integer(&smsbox_port, grp, octstr_imm("smsbox-port")) == -1) {
error(0, "Missing smsbox-port variable, cannot start smsboxes");
return -1;
}
#ifdef HAVE_LIBSSL
cfg_get_bool(&smsbox_port_ssl, grp, octstr_imm("smsbox-port-ssl"));
#endif /* HAVE_LIBSSL */
if (smsbox_port_ssl)
debug("bb", 0, "smsbox connection module is SSL-enabled");
if (cfg_get_integer(&smsbox_max_pending, grp, octstr_imm("smsbox-max-pending")) == -1) {
smsbox_max_pending = SMSBOX_MAX_PENDING;
info(0, "BOXC: 'smsbox-max-pending' not set, using default (%ld).", smsbox_max_pending);
}
smsbox_list = gwlist_create(); /* have a list of connections */
smsbox_list_rwlock = gw_rwlock_create();
if (!boxid)
boxid = counter_create();
/* the smsbox routing specific inits */
smsbox_by_id = dict_create(10, NULL); /* and a hash directory of identified */
smsbox_by_smsc = dict_create(30, (void(*)(void *)) octstr_destroy);
smsbox_by_receiver = dict_create(50, (void(*)(void *)) octstr_destroy);
smsbox_by_smsc_receiver = dict_create(50, (void(*)(void *)) octstr_destroy);
/* load the defined smsbox routing rules */
init_smsbox_routes(cfg);
gwlist_add_producer(outgoing_sms);
gwlist_add_producer(smsbox_list);
smsbox_running = 1;
if ((sms_dequeue_thread = gwthread_create(sms_to_smsboxes, NULL)) == -1)
panic(0, "Failed to start a new thread for smsbox routing");
if (gwthread_create(smsboxc_run, &smsbox_port) == -1)
panic(0, "Failed to start a new thread for smsbox connections");
return 0;
}
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 wtls_init(wtls_dispatch_func_t *responder_dispatch)
{
/* Initialise our various lists and counters */
wtls_machines = gwlist_create();
wtls_machine_id_counter = counter_create();
wtls_queue = gwlist_create();
gwlist_add_producer(wtls_queue);
dispatch_resp_to_bb = responder_dispatch;
/* Idiot check - ensure that we are able to start running */
gw_assert(wtls_run_status == limbo);
wtls_run_status = running;
gwthread_create(main_thread, NULL);
}
int main(void) {
Counter *c;
long threads[THREADS];
long i;
gwlib_init();
log_set_output_level(GW_INFO);
c = counter_create();
for (i = 0; i < THREADS; ++i)
threads[i] = gwthread_create(check, c);
for (i = 0; i < THREADS; ++i)
gwthread_join(threads[i]);
return 0;
}
void wsp_session_init(wap_dispatch_func_t *responder_dispatch,
wap_dispatch_func_t *initiator_dispatch,
wap_dispatch_func_t *application_dispatch,
wap_dispatch_func_t *push_ota_dispatch) {
queue = gwlist_create();
gwlist_add_producer(queue);
session_machines = gwlist_create();
session_id_counter = counter_create();
dispatch_to_wtp_resp = responder_dispatch;
dispatch_to_wtp_init = initiator_dispatch;
dispatch_to_appl = application_dispatch;
dispatch_to_ota = push_ota_dispatch;
wsp_strings_init();
run_status = running;
gwthread_create(main_thread, NULL);
}
void wsp_push_client_init(wap_dispatch_func_t *dispatch_self,
wap_dispatch_func_t *dispatch_wtp_resp)
{
push_client_machines = gwlist_create();
push_client_machine_id_counter = counter_create();
push_client_queue = gwlist_create();
gwlist_add_producer(push_client_queue);
dispatch_to_self = dispatch_self;
dispatch_to_wtp_resp = dispatch_wtp_resp;
gw_assert(push_client_run_status == limbo);
push_client_run_status = running;
gwthread_create(main_thread, NULL);
}
void wtp_initiator_init(wap_dispatch_func_t *datagram_dispatch,
wap_dispatch_func_t *session_dispatch, long timer_freq)
{
init_machines = gwlist_create();
init_machine_id_counter = counter_create();
queue = gwlist_create();
gwlist_add_producer(queue);
dispatch_to_wdp = datagram_dispatch;
dispatch_to_wsp = session_dispatch;
timers_init();
init_timer_freq = timer_freq;
gw_assert(initiator_run_status == limbo);
initiator_run_status = running;
gwthread_create(main_thread, NULL);
}
int wapbox_start(Cfg *cfg)
{
CfgGroup *grp;
if (wapbox_running) return -1;
debug("bb", 0, "starting wapbox connection module");
grp = cfg_get_single_group(cfg, octstr_imm("core"));
if (cfg_get_integer(&wapbox_port, grp, octstr_imm("wapbox-port")) == -1) {
error(0, "Missing wapbox-port variable, cannot start WAP");
return -1;
}
#ifdef HAVE_LIBSSL
cfg_get_bool(&wapbox_port_ssl, grp, octstr_imm("wapbox-port-ssl"));
#endif /* HAVE_LIBSSL */
box_allow_ip = cfg_get(grp, octstr_imm("box-allow-ip"));
if (box_allow_ip == NULL)
box_allow_ip = octstr_create("");
box_deny_ip = cfg_get(grp, octstr_imm("box-deny-ip"));
if (box_deny_ip == NULL)
box_deny_ip = octstr_create("");
if (box_allow_ip != NULL && box_deny_ip == NULL)
info(0, "Box connection allowed IPs defined without any denied...");
wapbox_list = gwlist_create(); /* have a list of connections */
gwlist_add_producer(outgoing_wdp);
if (!boxid)
boxid = counter_create();
if (gwthread_create(wdp_to_wapboxes, NULL) == -1)
panic(0, "Failed to start a new thread for wapbox routing");
if (gwthread_create(wapboxc_run, &wapbox_port) == -1)
panic(0, "Failed to start a new thread for wapbox connections");
wapbox_running = 1;
return 0;
}
static Cfg *init_bearerbox(Cfg *cfg)
{
CfgGroup *grp;
Octstr *log, *val;
long loglevel;
int lf, m;
#ifdef HAVE_LIBSSL
Octstr *ssl_server_cert_file;
Octstr *ssl_server_key_file;
int ssl_enabled = 0;
#endif /* HAVE_LIBSSL */
/* defaults: use localtime and markers for access-log */
lf = m = 1;
grp = cfg_get_single_group(cfg, octstr_imm("core"));
log = cfg_get(grp, octstr_imm("log-file"));
if (log != NULL) {
if (cfg_get_integer(&loglevel, grp, octstr_imm("log-level")) == -1)
loglevel = 0;
log_open(octstr_get_cstr(log), loglevel, GW_NON_EXCL);
octstr_destroy(log);
}
if (check_config(cfg) == -1)
panic(0, "Cannot start with corrupted configuration");
/* determine which timezone we use for access logging */
if ((log = cfg_get(grp, octstr_imm("access-log-time"))) != NULL) {
lf = (octstr_case_compare(log, octstr_imm("gmt")) == 0) ? 0 : 1;
octstr_destroy(log);
}
/* should predefined markers be used, ie. prefixing timestamp */
cfg_get_bool(&m, grp, octstr_imm("access-log-clean"));
/* custom access-log format */
if ((log = cfg_get(grp, octstr_imm("access-log-format"))) != NULL) {
bb_alog_init(log);
octstr_destroy(log);
}
/* open access-log file */
if ((log = cfg_get(grp, octstr_imm("access-log"))) != NULL) {
alog_open(octstr_get_cstr(log), lf, m ? 0 : 1);
octstr_destroy(log);
}
log = cfg_get(grp, octstr_imm("store-file"));
/* initialize the store file */
if (log != NULL) {
store_init(log);
octstr_destroy(log);
}
conn_config_ssl (grp);
/*
* Make sure we have "ssl-server-cert-file" and "ssl-server-key-file" specified
* in the core group since we need it to run SSL-enabled internal box
* connections configured via "smsbox-port-ssl = yes" and "wapbox-port-ssl = yes".
* Check only these, because for "admin-port-ssl" and "sendsms-port-ssl" for the
* SSL-enabled HTTP servers are probed within gw/bb_http.c:httpadmin_start()
*/
#ifdef HAVE_LIBSSL
ssl_server_cert_file = cfg_get(grp, octstr_imm("ssl-server-cert-file"));
ssl_server_key_file = cfg_get(grp, octstr_imm("ssl-server-key-file"));
if (ssl_server_cert_file != NULL && ssl_server_key_file != NULL) {
/* we are fine, at least files are specified in the configuration */
} else {
cfg_get_bool(&ssl_enabled, grp, octstr_imm("smsbox-port-ssl"));
cfg_get_bool(&ssl_enabled, grp, octstr_imm("wapbox-port-ssl"));
if (ssl_enabled) {
panic(0, "You MUST specify cert and key files within core group for SSL-enabled inter-box connections!");
}
}
octstr_destroy(ssl_server_cert_file);
octstr_destroy(ssl_server_key_file);
#endif /* HAVE_LIBSSL */
/* if all seems to be OK by the first glimpse, real start-up */
outgoing_sms = list_create();
incoming_sms = list_create();
outgoing_wdp = list_create();
incoming_wdp = list_create();
outgoing_sms_counter = counter_create();
incoming_sms_counter = counter_create();
outgoing_wdp_counter = counter_create();
incoming_wdp_counter = counter_create();
status_mutex = mutex_create();
setup_signal_handlers();
/* http-admin is REQUIRED */
httpadmin_start(cfg);
if (cfg_get_integer(&max_incoming_sms_qlength, grp,
octstr_imm("maximum-queue-length")) == -1)
max_incoming_sms_qlength = -1;
else {
warning(0, "Option 'maximum-queue-length' is deprecated! Please use"
" 'sms-incoming-queue-limit' instead!");
}
if (max_incoming_sms_qlength == -1 &&
cfg_get_integer(&max_incoming_sms_qlength, grp,
octstr_imm("sms-incoming-queue-limit")) == -1)
max_incoming_sms_qlength = -1;
#ifndef NO_SMS
{
List *list;
list = cfg_get_multi_group(cfg, octstr_imm("smsc"));
if (list != NULL) {
start_smsc(cfg);
list_destroy(list, NULL);
}
}
#endif
#ifndef NO_WAP
grp = cfg_get_single_group(cfg, octstr_imm("core"));
val = cfg_get(grp, octstr_imm("wdp-interface-name"));
if (val != NULL && octstr_len(val) > 0)
start_udp(cfg);
octstr_destroy(val);
if (cfg_get_single_group(cfg, octstr_imm("wapbox")) != NULL)
start_wap(cfg);
#endif
return cfg;
}
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;
}
SMSCConn *smscconn_create(CfgGroup *grp, int start_as_stopped)
{
SMSCConn *conn;
Octstr *smsc_type;
int ret;
Octstr *allowed_smsc_id_regex;
Octstr *denied_smsc_id_regex;
Octstr *allowed_prefix_regex;
Octstr *denied_prefix_regex;
Octstr *preferred_prefix_regex;
Octstr *tmp;
if (grp == NULL)
return NULL;
conn = gw_malloc(sizeof(*conn));
memset(conn, 0, sizeof(*conn));
conn->why_killed = SMSCCONN_ALIVE;
conn->status = SMSCCONN_CONNECTING;
conn->connect_time = -1;
conn->is_stopped = start_as_stopped;
conn->received = counter_create();
conn->received_dlr = counter_create();
conn->sent = counter_create();
conn->sent_dlr = counter_create();
conn->failed = counter_create();
conn->flow_mutex = mutex_create();
conn->outgoing_sms_load = load_create();
/* add 60,300,-1 entries */
load_add_interval(conn->outgoing_sms_load, 60);
load_add_interval(conn->outgoing_sms_load, 300);
load_add_interval(conn->outgoing_sms_load, -1);
conn->incoming_sms_load = load_create();
/* add 60,300,-1 entries */
load_add_interval(conn->incoming_sms_load, 60);
load_add_interval(conn->incoming_sms_load, 300);
load_add_interval(conn->incoming_sms_load, -1);
conn->incoming_dlr_load = load_create();
/* add 60,300,-1 entries to dlr */
load_add_interval(conn->incoming_dlr_load, 60);
load_add_interval(conn->incoming_dlr_load, 300);
load_add_interval(conn->incoming_dlr_load, -1);
conn->outgoing_dlr_load = load_create();
/* add 60,300,-1 entries to dlr */
load_add_interval(conn->outgoing_dlr_load, 60);
load_add_interval(conn->outgoing_dlr_load, 300);
load_add_interval(conn->outgoing_dlr_load, -1);
#define GET_OPTIONAL_VAL(x, n) x = cfg_get(grp, octstr_imm(n))
#define SPLIT_OPTIONAL_VAL(x, n) \
do { \
Octstr *tmp = cfg_get(grp, octstr_imm(n)); \
if (tmp) x = octstr_split(tmp, octstr_imm(";")); \
else x = NULL; \
octstr_destroy(tmp); \
}while(0)
GET_OPTIONAL_VAL(conn->id, "smsc-id");
SPLIT_OPTIONAL_VAL(conn->allowed_smsc_id, "allowed-smsc-id");
SPLIT_OPTIONAL_VAL(conn->denied_smsc_id, "denied-smsc-id");
SPLIT_OPTIONAL_VAL(conn->preferred_smsc_id, "preferred-smsc-id");
GET_OPTIONAL_VAL(conn->allowed_prefix, "allowed-prefix");
GET_OPTIONAL_VAL(conn->denied_prefix, "denied-prefix");
GET_OPTIONAL_VAL(conn->preferred_prefix, "preferred-prefix");
GET_OPTIONAL_VAL(conn->unified_prefix, "unified-prefix");
GET_OPTIONAL_VAL(conn->our_host, "our-host");
GET_OPTIONAL_VAL(conn->log_file, "log-file");
cfg_get_bool(&conn->alt_dcs, grp, octstr_imm("alt-dcs"));
GET_OPTIONAL_VAL(allowed_smsc_id_regex, "allowed-smsc-id-regex");
if (allowed_smsc_id_regex != NULL)
if ((conn->allowed_smsc_id_regex = gw_regex_comp(allowed_smsc_id_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(allowed_smsc_id_regex));
GET_OPTIONAL_VAL(denied_smsc_id_regex, "denied-smsc-id-regex");
if (denied_smsc_id_regex != NULL)
if ((conn->denied_smsc_id_regex = gw_regex_comp(denied_smsc_id_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(denied_smsc_id_regex));
GET_OPTIONAL_VAL(allowed_prefix_regex, "allowed-prefix-regex");
if (allowed_prefix_regex != NULL)
if ((conn->allowed_prefix_regex = gw_regex_comp(allowed_prefix_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(allowed_prefix_regex));
GET_OPTIONAL_VAL(denied_prefix_regex, "denied-prefix-regex");
if (denied_prefix_regex != NULL)
if ((conn->denied_prefix_regex = gw_regex_comp(denied_prefix_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(denied_prefix_regex));
GET_OPTIONAL_VAL(preferred_prefix_regex, "preferred-prefix-regex");
if (preferred_prefix_regex != NULL)
if ((conn->preferred_prefix_regex = gw_regex_comp(preferred_prefix_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(preferred_prefix_regex));
if ((tmp = cfg_get(grp, octstr_imm("throughput"))) != NULL) {
if (octstr_parse_double(&conn->throughput, tmp, 0) == -1)
conn->throughput = 0;
octstr_destroy(tmp);
info(0, "Set throughput to %.3f for smsc id <%s>", conn->throughput, octstr_get_cstr(conn->id));
}
/* Sets the admin_id. Equals to connection id if empty */
GET_OPTIONAL_VAL(conn->admin_id, "smsc-admin-id");
if (conn->admin_id == NULL)
conn->admin_id = octstr_duplicate(conn->id);
/* configure the internal rerouting rules for this smsc id */
init_reroute(conn, grp);
if (cfg_get_integer(&conn->log_level, grp, octstr_imm("log-level")) == -1)
conn->log_level = 0;
if (cfg_get_integer(&conn->max_sms_octets, grp, octstr_imm("max-sms-octets")) == -1)
conn->max_sms_octets = MAX_SMS_OCTETS;
if (cfg_get_bool(&conn->dead_start, grp, octstr_imm("dead-start")) == -1)
conn->dead_start = 0; /* default to connect at start-up time */
/* open a smsc-id specific log-file in exlusive mode */
if (conn->log_file)
conn->log_idx = log_open(octstr_get_cstr(conn->log_file),
conn->log_level, GW_EXCL);
#undef GET_OPTIONAL_VAL
#undef SPLIT_OPTIONAL_VAL
if (conn->allowed_smsc_id && conn->denied_smsc_id)
warning(0, "Both 'allowed-smsc-id' and 'denied-smsc-id' set, deny-list "
"automatically ignored");
if (conn->allowed_smsc_id_regex && conn->denied_smsc_id_regex)
warning(0, "Both 'allowed-smsc-id_regex' and 'denied-smsc-id_regex' set, deny-regex "
"automatically ignored");
if (cfg_get_integer(&conn->reconnect_delay, grp,
octstr_imm("reconnect-delay")) == -1)
conn->reconnect_delay = SMSCCONN_RECONNECT_DELAY;
smsc_type = cfg_get(grp, octstr_imm("smsc"));
if (smsc_type == NULL) {
error(0, "Required field 'smsc' missing for smsc group.");
smscconn_destroy(conn);
octstr_destroy(smsc_type);
return NULL;
}
if (octstr_compare(smsc_type, octstr_imm("fake")) == 0)
ret = smsc_fake_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("cimd2")) == 0)
ret = smsc_cimd2_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("emi")) == 0)
ret = smsc_emi2_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("http")) == 0)
ret = smsc_http_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("smpp")) == 0)
ret = smsc_smpp_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("at")) == 0)
ret = smsc_at2_create(conn,grp);
else if (octstr_compare(smsc_type, octstr_imm("cgw")) == 0)
ret = smsc_cgw_create(conn,grp);
else if (octstr_compare(smsc_type, octstr_imm("smasi")) == 0)
ret = smsc_smasi_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("oisd")) == 0)
ret = smsc_oisd_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("loopback")) == 0)
ret = smsc_loopback_create(conn, grp);
#ifdef HAVE_GSOAP
else if (octstr_compare(smsc_type, octstr_imm("parlayx")) == 0)
ret = smsc_soap_parlayx_create(conn, grp);
#endif
else
ret = smsc_wrapper_create(conn, grp);
octstr_destroy(smsc_type);
if (ret == -1) {
smscconn_destroy(conn);
return NULL;
}
gw_assert(conn->send_msg != NULL);
bb_smscconn_ready(conn);
return conn;
}
int smsc_http_create(SMSCConn *conn, CfgGroup *cfg)
{
ConnData *conndata = NULL;
Octstr *type;
int ssl = 0; /* indicate if SSL-enabled server should be used */
long max_ps;
if ((type = cfg_get(cfg, octstr_imm("system-type"))) == NULL) {
error(0, "HTTP[%s]: 'system-type' missing in smsc 'http' record.",
octstr_get_cstr(conn->id));
octstr_destroy(type);
return -1;
}
conndata = gw_malloc(sizeof(ConnData));
/* reset conndata */
memset(conndata, 0, sizeof(ConnData));
conn->data = conndata;
conndata->http_ref = NULL;
conndata->data = NULL;
if (cfg_get_integer(&conndata->port, cfg, octstr_imm("port")) == -1) {
warning(0, "HTTP[%s]: 'port' not set in smsc 'http' group.",
octstr_get_cstr(conn->id));
conndata->port = -1;
}
conndata->allow_ip = cfg_get(cfg, octstr_imm("connect-allow-ip"));
conndata->send_url = cfg_get(cfg, octstr_imm("send-url"));
conndata->username = cfg_get(cfg, octstr_imm("smsc-username"));
conndata->password = cfg_get(cfg, octstr_imm("smsc-password"));
conndata->system_id = cfg_get(cfg, octstr_imm("system-id"));
cfg_get_bool(&conndata->no_sender, cfg, octstr_imm("no-sender"));
cfg_get_bool(&conndata->no_coding, cfg, octstr_imm("no-coding"));
cfg_get_bool(&conndata->no_sep, cfg, octstr_imm("no-sep"));
conndata->proxy = cfg_get(cfg, octstr_imm("system-id"));
cfg_get_bool(&ssl, cfg, octstr_imm("use-ssl"));
conndata->dlr_url = cfg_get(cfg, octstr_imm("dlr-url"));
conndata->alt_charset = cfg_get(cfg, octstr_imm("alt-charset"));
if (cfg_get_integer(&max_ps, cfg, octstr_imm("max-pending-submits")) == -1 || max_ps < 1)
max_ps = 10;
conndata->max_pending_sends = semaphore_create(max_ps);
if (conndata->port <= 0 && conndata->send_url == NULL) {
error(0, "Sender and receiver disabled. Dummy SMSC not allowed.");
goto error;
}
if (conndata->send_url == NULL)
panic(0, "HTTP[%s]: Sending not allowed. No 'send-url' specified.",
octstr_get_cstr(conn->id));
if (octstr_case_compare(type, octstr_imm("kannel")) == 0) {
if (conndata->username == NULL || conndata->password == NULL) {
error(0, "HTTP[%s]: 'username' and 'password' required for Kannel http smsc",
octstr_get_cstr(conn->id));
goto error;
}
conndata->callbacks = &smsc_http_kannel_callback;
} else if (octstr_case_compare(type, octstr_imm("brunet")) == 0) {
conndata->callbacks = &smsc_http_brunet_callback;
} else if (octstr_case_compare(type, octstr_imm("xidris")) == 0) {
conndata->callbacks = &smsc_http_xidris_callback;
} else if (octstr_case_compare(type, octstr_imm("generic")) == 0) {
conndata->callbacks = &smsc_http_generic_callback;
} else if (octstr_case_compare(type, octstr_imm("clickatell")) == 0) {
conndata->callbacks = &smsc_http_clickatell_callback;
} else if (octstr_case_compare(type, octstr_imm("wapme")) == 0) {
conndata->callbacks = &smsc_http_wapme_callback;
}
/*
* ADD NEW HTTP SMSC TYPES HERE
*/
else {
error(0, "HTTP[%s]: system-type '%s' unknown smsc 'http' record.",
octstr_get_cstr(conn->id), octstr_get_cstr(type));
goto error;
}
if (conndata->callbacks != NULL && conndata->callbacks->init != NULL && conndata->callbacks->init(conn, cfg)) {
error(0, "HTTP[%s]: submodule '%s' init failed.", octstr_get_cstr(conn->id), octstr_get_cstr(type));
goto error;
}
conndata->open_sends = counter_create();
conndata->msg_to_send = gwlist_create();
gwlist_add_producer(conndata->msg_to_send);
conndata->http_ref = http_caller_create();
conn->name = octstr_format("HTTP%s:%S:%d", (ssl?"S":""), type, conndata->port);
if (conndata->send_url != NULL) {
conn->status = SMSCCONN_ACTIVE;
} else {
conn->status = SMSCCONN_ACTIVE_RECV;
}
conn->connect_time = time(NULL);
conn->shutdown = httpsmsc_shutdown;
conn->queued = httpsmsc_queued;
conn->send_msg = httpsmsc_send;
conndata->shutdown = 0;
/* start receiver thread */
if (conndata->port > 0) {
if (http_open_port(conndata->port, ssl) == -1)
goto error;
if ((conndata->receive_thread = gwthread_create(httpsmsc_receiver, conn)) == -1)
goto error;
} else
conndata->receive_thread = -1;
/* start sender threads */
if (conndata->send_url) {
if ((conndata->send_cb_thread =
gwthread_create(httpsmsc_send_cb, conn)) == -1)
goto error;
if ((conndata->sender_thread =
gwthread_create(httpsmsc_sender, conn)) == -1)
goto error;
}
else {
conndata->send_cb_thread = conndata->sender_thread = -1;
}
info(0, "HTTP[%s]: Initiated and ready", octstr_get_cstr(conn->id));
octstr_destroy(type);
return 0;
error:
error(0, "HTTP[%s]: Failed to create HTTP SMSC connection",
octstr_get_cstr(conn->id));
if (conndata->callbacks != NULL && conndata->callbacks->destroy != NULL)
conndata->callbacks->destroy(conn);
conn->data = NULL;
conndata_destroy(conndata);
conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
conn->status = SMSCCONN_DEAD;
octstr_destroy(type);
return -1;
}
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;
}
static Cfg *init_bearerbox(Cfg *cfg)
{
CfgGroup *grp;
Octstr *log, *val;
long loglevel, store_dump_freq, value;
int lf, m;
#ifdef HAVE_LIBSSL
Octstr *ssl_server_cert_file;
Octstr *ssl_server_key_file;
int ssl_enabled = 0;
#endif /* HAVE_LIBSSL */
Octstr *http_proxy_host = NULL;
long http_proxy_port = -1;
int http_proxy_ssl = 0;
List *http_proxy_exceptions = NULL;
Octstr *http_proxy_username = NULL;
Octstr *http_proxy_password = NULL;
Octstr *http_proxy_exceptions_regex = NULL;
/* defaults: use localtime and markers for access-log */
lf = m = 1;
grp = cfg_get_single_group(cfg, octstr_imm("core"));
log = cfg_get(grp, octstr_imm("log-file"));
if (log != NULL) {
if (cfg_get_integer(&loglevel, grp, octstr_imm("log-level")) == -1)
loglevel = 0;
log_open(octstr_get_cstr(log), loglevel, GW_NON_EXCL);
octstr_destroy(log);
}
if ((val = cfg_get(grp, octstr_imm("syslog-level"))) != NULL) {
long level;
Octstr *facility;
if ((facility = cfg_get(grp, octstr_imm("syslog-facility"))) != NULL) {
log_set_syslog_facility(octstr_get_cstr(facility));
octstr_destroy(facility);
}
if (octstr_compare(val, octstr_imm("none")) == 0) {
log_set_syslog(NULL, 0);
} else if (octstr_parse_long(&level, val, 0, 10) > 0) {
log_set_syslog("bearerbox", level);
}
octstr_destroy(val);
} else {
log_set_syslog(NULL, 0);
}
if (check_config(cfg) == -1)
panic(0, "Cannot start with corrupted configuration");
/* determine which timezone we use for access logging */
if ((log = cfg_get(grp, octstr_imm("access-log-time"))) != NULL) {
lf = (octstr_case_compare(log, octstr_imm("gmt")) == 0) ? 0 : 1;
octstr_destroy(log);
}
/* should predefined markers be used, ie. prefixing timestamp */
cfg_get_bool(&m, grp, octstr_imm("access-log-clean"));
/* custom access-log format */
if ((log = cfg_get(grp, octstr_imm("access-log-format"))) != NULL) {
bb_alog_init(log);
octstr_destroy(log);
}
/* open access-log file */
if ((log = cfg_get(grp, octstr_imm("access-log"))) != NULL) {
alog_open(octstr_get_cstr(log), lf, m ? 0 : 1);
octstr_destroy(log);
}
if (cfg_get_integer(&store_dump_freq, grp,
octstr_imm("store-dump-freq")) == -1)
store_dump_freq = -1;
log = cfg_get(grp, octstr_imm("store-file"));
/* initialize the store file */
if (log != NULL) {
warning(0, "'store-file' option deprecated, please use 'store-location' and 'store-type' instead.");
val = octstr_create("file");
} else {
log = cfg_get(grp, octstr_imm("store-location"));
val = cfg_get(grp, octstr_imm("store-type"));
}
if (store_init(val, log, store_dump_freq, msg_pack, msg_unpack_wrapper) == -1)
panic(0, "Could not start with store init failed.");
octstr_destroy(val);
octstr_destroy(log);
cfg_get_integer(&http_proxy_port, grp, octstr_imm("http-proxy-port"));
#ifdef HAVE_LIBSSL
cfg_get_bool(&http_proxy_ssl, grp, octstr_imm("http-proxy-ssl"));
#endif /* HAVE_LIBSSL */
http_proxy_host = cfg_get(grp,
octstr_imm("http-proxy-host"));
http_proxy_username = cfg_get(grp,
octstr_imm("http-proxy-username"));
http_proxy_password = cfg_get(grp,
octstr_imm("http-proxy-password"));
http_proxy_exceptions = cfg_get_list(grp,
octstr_imm("http-proxy-exceptions"));
http_proxy_exceptions_regex = cfg_get(grp,
octstr_imm("http-proxy-exceptions-regex"));
conn_config_ssl (grp);
/*
* Make sure we have "ssl-server-cert-file" and "ssl-server-key-file" specified
* in the core group since we need it to run SSL-enabled internal box
* connections configured via "smsbox-port-ssl = yes" and "wapbox-port-ssl = yes".
* Check only these, because for "admin-port-ssl" and "sendsms-port-ssl" for the
* SSL-enabled HTTP servers are probed within gw/bb_http.c:httpadmin_start()
*/
#ifdef HAVE_LIBSSL
ssl_server_cert_file = cfg_get(grp, octstr_imm("ssl-server-cert-file"));
ssl_server_key_file = cfg_get(grp, octstr_imm("ssl-server-key-file"));
if (ssl_server_cert_file != NULL && ssl_server_key_file != NULL) {
/* we are fine, at least files are specified in the configuration */
} else {
cfg_get_bool(&ssl_enabled, grp, octstr_imm("smsbox-port-ssl"));
cfg_get_bool(&ssl_enabled, grp, octstr_imm("wapbox-port-ssl"));
if (ssl_enabled) {
panic(0, "You MUST specify cert and key files within core group for SSL-enabled inter-box connections!");
}
}
octstr_destroy(ssl_server_cert_file);
octstr_destroy(ssl_server_key_file);
#endif /* HAVE_LIBSSL */
/* if all seems to be OK by the first glimpse, real start-up */
outgoing_sms = gwlist_create();
incoming_sms = gwlist_create();
outgoing_wdp = gwlist_create();
incoming_wdp = gwlist_create();
outgoing_sms_counter = counter_create();
incoming_sms_counter = counter_create();
incoming_dlr_counter = counter_create();
outgoing_dlr_counter = counter_create();
outgoing_wdp_counter = counter_create();
incoming_wdp_counter = counter_create();
status_mutex = mutex_create();
outgoing_sms_load = load_create();
/* add 60,300,-1 entries */
load_add_interval(outgoing_sms_load, 60);
load_add_interval(outgoing_sms_load, 300);
load_add_interval(outgoing_sms_load, -1);
incoming_sms_load = load_create();
/* add 60,300,-1 entries */
load_add_interval(incoming_sms_load, 60);
load_add_interval(incoming_sms_load, 300);
load_add_interval(incoming_sms_load, -1);
incoming_dlr_load = load_create();
/* add 60,300,-1 entries to dlr */
load_add_interval(incoming_dlr_load, 60);
load_add_interval(incoming_dlr_load, 300);
load_add_interval(incoming_dlr_load, -1);
outgoing_dlr_load = load_create();
/* add 60,300,-1 entries to dlr */
load_add_interval(outgoing_dlr_load, 60);
load_add_interval(outgoing_dlr_load, 300);
load_add_interval(outgoing_dlr_load, -1);
setup_signal_handlers();
/* http-admin is REQUIRED */
httpadmin_start(cfg);
if (cfg_get_integer(&max_incoming_sms_qlength, grp,
octstr_imm("maximum-queue-length")) == -1)
max_incoming_sms_qlength = -1;
else {
warning(0, "Option 'maximum-queue-length' is deprecated! Please use"
" 'sms-incoming-queue-limit' instead!");
}
if (max_incoming_sms_qlength == -1 &&
cfg_get_integer(&max_incoming_sms_qlength, grp,
octstr_imm("sms-incoming-queue-limit")) == -1)
max_incoming_sms_qlength = -1;
if (cfg_get_integer(&max_outgoing_sms_qlength, grp,
octstr_imm("sms-outgoing-queue-limit")) == -1)
max_outgoing_sms_qlength = -1;
if (max_outgoing_sms_qlength < 0)
max_outgoing_sms_qlength = DEFAULT_OUTGOING_SMS_QLENGTH;
if (cfg_get_integer(&value, grp, octstr_imm("http-timeout")) == 0)
http_set_client_timeout(value);
#ifndef NO_SMS
{
List *list;
list = cfg_get_multi_group(cfg, octstr_imm("smsc"));
if (list != NULL) {
gwlist_destroy(list, NULL);
if (start_smsc(cfg) == -1) {
panic(0, "Unable to start SMSCs.");
return NULL;
}
}
}
#endif
#ifndef NO_WAP
grp = cfg_get_single_group(cfg, octstr_imm("core"));
val = cfg_get(grp, octstr_imm("wdp-interface-name"));
if (val != NULL && octstr_len(val) > 0)
start_udp(cfg);
octstr_destroy(val);
if (cfg_get_single_group(cfg, octstr_imm("wapbox")) != NULL)
start_wap(cfg);
#endif
if (http_proxy_host != NULL && http_proxy_port > 0) {
http_use_proxy(http_proxy_host, http_proxy_port, http_proxy_ssl,
http_proxy_exceptions, http_proxy_username,
http_proxy_password, http_proxy_exceptions_regex);
}
octstr_destroy(http_proxy_host);
octstr_destroy(http_proxy_username);
octstr_destroy(http_proxy_password);
octstr_destroy(http_proxy_exceptions_regex);
gwlist_destroy(http_proxy_exceptions, octstr_destroy_item);
return cfg;
}
SMSCConn *smscconn_create(CfgGroup *grp, int start_as_stopped)
{
SMSCConn *conn;
Octstr *smsc_type;
int ret;
long throughput;
Octstr *allowed_smsc_id_regex;
Octstr *denied_smsc_id_regex;
Octstr *allowed_prefix_regex;
Octstr *denied_prefix_regex;
Octstr *preferred_prefix_regex;
if (grp == NULL)
return NULL;
conn = gw_malloc(sizeof(*conn));
memset(conn, 0, sizeof(*conn));
conn->why_killed = SMSCCONN_ALIVE;
conn->status = SMSCCONN_CONNECTING;
conn->connect_time = -1;
conn->is_stopped = start_as_stopped;
conn->received = counter_create();
conn->sent = counter_create();
conn->failed = counter_create();
conn->flow_mutex = mutex_create();
#define GET_OPTIONAL_VAL(x, n) x = cfg_get(grp, octstr_imm(n))
#define SPLIT_OPTIONAL_VAL(x, n) \
do { \
Octstr *tmp = cfg_get(grp, octstr_imm(n)); \
if (tmp) x = octstr_split(tmp, octstr_imm(";")); \
else x = NULL; \
octstr_destroy(tmp); \
}while(0)
GET_OPTIONAL_VAL(conn->id, "smsc-id");
SPLIT_OPTIONAL_VAL(conn->allowed_smsc_id, "allowed-smsc-id");
SPLIT_OPTIONAL_VAL(conn->denied_smsc_id, "denied-smsc-id");
SPLIT_OPTIONAL_VAL(conn->preferred_smsc_id, "preferred-smsc-id");
GET_OPTIONAL_VAL(conn->allowed_prefix, "allowed-prefix");
GET_OPTIONAL_VAL(conn->denied_prefix, "denied-prefix");
GET_OPTIONAL_VAL(conn->preferred_prefix, "preferred-prefix");
GET_OPTIONAL_VAL(conn->unified_prefix, "unified-prefix");
GET_OPTIONAL_VAL(conn->our_host, "our-host");
GET_OPTIONAL_VAL(conn->log_file, "log-file");
cfg_get_bool(&conn->alt_dcs, grp, octstr_imm("alt-dcs"));
GET_OPTIONAL_VAL(allowed_smsc_id_regex, "allowed-smsc-id-regex");
if (allowed_smsc_id_regex != NULL)
if ((conn->allowed_smsc_id_regex = gw_regex_comp(allowed_smsc_id_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(allowed_smsc_id_regex));
GET_OPTIONAL_VAL(denied_smsc_id_regex, "denied-smsc-id-regex");
if (denied_smsc_id_regex != NULL)
if ((conn->denied_smsc_id_regex = gw_regex_comp(denied_smsc_id_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(denied_smsc_id_regex));
GET_OPTIONAL_VAL(allowed_prefix_regex, "allowed-prefix-regex");
if (allowed_prefix_regex != NULL)
if ((conn->allowed_prefix_regex = gw_regex_comp(allowed_prefix_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(allowed_prefix_regex));
GET_OPTIONAL_VAL(denied_prefix_regex, "denied-prefix-regex");
if (denied_prefix_regex != NULL)
if ((conn->denied_prefix_regex = gw_regex_comp(denied_prefix_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(denied_prefix_regex));
GET_OPTIONAL_VAL(preferred_prefix_regex, "preferred-prefix-regex");
if (preferred_prefix_regex != NULL)
if ((conn->preferred_prefix_regex = gw_regex_comp(preferred_prefix_regex, REG_EXTENDED)) == NULL)
panic(0, "Could not compile pattern '%s'", octstr_get_cstr(preferred_prefix_regex));
if (cfg_get_integer(&throughput, grp, octstr_imm("throughput")) == -1)
conn->throughput = 0; /* defaults to no throughtput limitation */
else
conn->throughput = (int) throughput;
/* configure the internal rerouting rules for this smsc id */
init_reroute(conn, grp);
if (cfg_get_integer(&conn->log_level, grp, octstr_imm("log-level")) == -1)
conn->log_level = 0;
/* open a smsc-id specific log-file in exlusive mode */
if (conn->log_file)
conn->log_idx = log_open(octstr_get_cstr(conn->log_file),
conn->log_level, GW_EXCL);
#undef GET_OPTIONAL_VAL
#undef SPLIT_OPTIONAL_VAL
if (conn->allowed_smsc_id && conn->denied_smsc_id)
warning(0, "Both 'allowed-smsc-id' and 'denied-smsc-id' set, deny-list "
"automatically ignored");
if (conn->allowed_smsc_id_regex && conn->denied_smsc_id_regex)
warning(0, "Both 'allowed-smsc-id_regex' and 'denied-smsc-id_regex' set, deny-regex "
"automatically ignored");
if (cfg_get_integer(&conn->reconnect_delay, grp,
octstr_imm("reconnect-delay")) == -1)
conn->reconnect_delay = SMSCCONN_RECONNECT_DELAY;
smsc_type = cfg_get(grp, octstr_imm("smsc"));
if (smsc_type == NULL) {
error(0, "Required field 'smsc' missing for smsc group.");
smscconn_destroy(conn);
octstr_destroy(smsc_type);
return NULL;
}
if (octstr_compare(smsc_type, octstr_imm("fake")) == 0)
ret = smsc_fake_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("cimd2")) == 0)
ret = smsc_cimd2_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("emi")) == 0)
ret = smsc_emi2_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("http")) == 0)
ret = smsc_http_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("smpp")) == 0)
ret = smsc_smpp_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("at")) == 0)
ret = smsc_at2_create(conn,grp);
else if (octstr_compare(smsc_type, octstr_imm("cgw")) == 0)
ret = smsc_cgw_create(conn,grp);
else if (octstr_compare(smsc_type, octstr_imm("smasi")) == 0)
ret = smsc_smasi_create(conn, grp);
else if (octstr_compare(smsc_type, octstr_imm("oisd")) == 0)
ret = smsc_oisd_create(conn, grp);
else
ret = smsc_wrapper_create(conn, grp);
octstr_destroy(smsc_type);
if (ret == -1) {
smscconn_destroy(conn);
return NULL;
}
gw_assert(conn->send_msg != NULL);
bb_smscconn_ready(conn);
return conn;
}
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);
}
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;
}
