bearerbox.h File Reference

#include "gwlib/gwlib.h"
#include "msg.h"
#include "smscconn.h"
#include "bb_store.h"

Go to the source code of this file.

Macros
#define	DEFAULT_OUTGOING_SMS_QLENGTH   1000000

Enumerations
enum	{   BB_RUNNING = 0, BB_ISOLATED = 1, BB_SUSPENDED = 2, BB_SHUTDOWN = 3,   BB_DEAD = 4, BB_FULL = 5 }
enum	{ BBSTATUS_HTML = 0, BBSTATUS_TEXT = 1, BBSTATUS_WML = 2, BBSTATUS_XML = 3 }

Functions
int	smsbox_start (Cfg *config)
int	smsbox_restart (Cfg *config)
int	wapbox_start (Cfg *config)
Octstr *	boxc_status (int status_type)
int	boxc_incoming_wdp_queue (void)
void	boxc_cleanup (void)
int	route_incoming_to_boxc (Msg *msg)
int	udp_start (Cfg *config)
int	udp_shutdown (void)
int	udp_die (void)
int	udp_addwdp (Msg *msg)
int	udp_outgoing_queue (void)
int	smsc2_start (Cfg *config)
int	smsc2_restart (Cfg *config)
int	smsc2_graceful_restart (Cfg *config)
void	smsc2_suspend (void)
void	smsc2_resume (int is_init)
int	smsc2_shutdown (void)
void	smsc2_cleanup (void)
Octstr *	smsc2_status (int status_type)
long	smsc2_rout (Msg *msg, int resend)
int	smsc2_stop_smsc (Octstr *id)
int	smsc2_restart_smsc (Octstr *id)
int	smsc2_add_smsc (Octstr *id)
int	smsc2_remove_smsc (Octstr *id)
int	smsc2_reload_lists (void)
int	httpadmin_start (Cfg *config)
void	httpadmin_stop (void)
void	bb_alog_init (const Octstr *format)
void	bb_alog_shutdown (void)
void	bb_alog_sms (SMSCConn *conn, Msg *sms, const char *message)
int	bb_shutdown (void)
int	bb_isolate (void)
int	bb_suspend (void)
int	bb_resume (void)
int	bb_restart (void)
int	bb_graceful_restart (void)
int	bb_flush_dlr (void)
int	bb_stop_smsc (Octstr *id)
int	bb_add_smsc (Octstr *id)
int	bb_remove_smsc (Octstr *id)
int	bb_restart_smsc (Octstr *id)
int	bb_remove_message (Octstr *id)
int	bb_reload_lists (void)
int	bb_reload_smsc_groups (void)
Octstr *	bb_print_status (int status_type)
char *	bb_status_linebreak (int status_type)

Macro Definition Documentation

DEFAULT_OUTGOING_SMS_QLENGTH

#define DEFAULT_OUTGOING_SMS_QLENGTH   1000000

Definition at line 69 of file bearerbox.h.

Referenced by init_bearerbox().

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
BB_RUNNING
BB_ISOLATED
BB_SUSPENDED
BB_SHUTDOWN
BB_DEAD
BB_FULL

Definition at line 73 of file bearerbox.h.

     {
    BB_RUNNING = 0,
    BB_ISOLATED = 1,    /* do not receive new messgaes from UDP/SMSC */
    BB_SUSPENDED = 2,   /* do not transfer any messages */
    BB_SHUTDOWN = 3,
    BB_DEAD = 4,
    BB_FULL = 5         /* message queue too long, do not accept new messages */
};

anonymous enum

anonymous enum

Enumerator
BBSTATUS_HTML
BBSTATUS_TEXT
BBSTATUS_WML
BBSTATUS_XML

Definition at line 84 of file bearerbox.h.

     {
    BBSTATUS_HTML = 0,
    BBSTATUS_TEXT = 1,
    BBSTATUS_WML = 2,
    BBSTATUS_XML = 3
};

Function Documentation

bb_add_smsc()

int bb_add_smsc

(

Octstr *

id

)

Definition at line 938 of file bearerbox.c.

References smsc2_add_smsc().

Referenced by httpd_add_smsc().

{
    return smsc2_add_smsc(id);
}

bb_alog_init()

void bb_alog_init

(

const Octstr *

format

)

Definition at line 359 of file bb_alog.c.

References custom_log_format, gw_assert(), and octstr_duplicate.

Referenced by init_bearerbox().

{
    gw_assert(format != NULL);

    custom_log_format = octstr_duplicate(format);
}

bb_alog_shutdown()

void bb_alog_shutdown

(

void

)

Definition at line 367 of file bb_alog.c.

References custom_log_format, and octstr_destroy().

Referenced by main().

{
    octstr_destroy(custom_log_format);
    custom_log_format = NULL;
}

bb_alog_sms()

void bb_alog_sms	(	SMSCConn *	conn,
		Msg *	sms,
		const char *	message
	)

Definition at line 374 of file bb_alog.c.

References alog(), custom_log_format, DC_8BIT, DC_UCS2, get_pattern(), gw_assert(), msg, octstr_binary_to_hex(), octstr_convert_printable(), octstr_create, octstr_destroy(), octstr_duplicate, octstr_get_cstr, octstr_imm(), octstr_len(), smscconn_id(), smscconn_name(), and text.

Referenced by bb_smscconn_receive(), bb_smscconn_receive_internal(), bb_smscconn_send_failed(), bb_smscconn_sent(), and handle_pdu().

{
    Octstr *text = NULL;
    
    gw_assert(msg_type(msg) == sms);

    /* if we don't have any custom log, then use our "default" one */
    
    if (custom_log_format == NULL) {
        Octstr *udh;
        const Octstr *cid;

        text = msg->sms.msgdata ? octstr_duplicate(msg->sms.msgdata) : octstr_create("");
        udh = msg->sms.udhdata ? octstr_duplicate(msg->sms.udhdata) : octstr_create("");

        if (conn && smscconn_id(conn))
            cid = smscconn_id(conn);
        else if (conn && smscconn_name(conn))
            cid = smscconn_name(conn);
        else if (msg->sms.smsc_id)
            cid = msg->sms.smsc_id;
        else
            cid = octstr_imm("");

        if ((msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2))
            octstr_binary_to_hex(text, 1);
        else
            octstr_convert_printable(text);
        octstr_binary_to_hex(udh, 1);

        alog("%s [SMSC:%s] [SVC:%s] [ACT:%s] [BINF:%s] [FID:%s] [META:%s] [from:%s] [to:%s] [flags:%ld:%ld:%ld:%ld:%ld] "
             "[msg:%ld:%s] [udh:%ld:%s]",
             message,
             octstr_get_cstr(cid),
             msg->sms.service ? octstr_get_cstr(msg->sms.service) : "",
             msg->sms.account ? octstr_get_cstr(msg->sms.account) : "",
             msg->sms.binfo ? octstr_get_cstr(msg->sms.binfo) : "",
             msg->sms.foreign_id ? octstr_get_cstr(msg->sms.foreign_id) : "",
             msg->sms.meta_data ? octstr_get_cstr(msg->sms.meta_data) : "",
             msg->sms.sender ? octstr_get_cstr(msg->sms.sender) : "",
             msg->sms.receiver ? octstr_get_cstr(msg->sms.receiver) : "",
             msg->sms.mclass, msg->sms.coding, msg->sms.mwi, msg->sms.compress,
             msg->sms.dlr_mask, 
             octstr_len(msg->sms.msgdata), octstr_get_cstr(text),
             octstr_len(msg->sms.udhdata), octstr_get_cstr(udh)
        );

        octstr_destroy(udh);
    } else {
        text = get_pattern(conn, msg, message);
        alog("%s", octstr_get_cstr(text));
    }

    octstr_destroy(text);
}

bb_flush_dlr()

int bb_flush_dlr

(

void

)

Definition at line 916 of file bearerbox.c.

References bb_status, BB_SUSPENDED, and dlr_flush().

Referenced by httpd_flush_dlr().

{
    /* beware that mutex locking is done in dlr_foobar() routines */
    if (bb_status != BB_SUSPENDED) {
        return -1;
    }
    dlr_flush();
    return 0;
}

bb_graceful_restart()

int bb_graceful_restart

(

void

)

Definition at line 954 of file bearerbox.c.

References cfg, cfg_create(), cfg_filename, cfg_read(), error(), info(), octstr_get_cstr, smsbox_restart(), and smsc2_graceful_restart().

Referenced by httpd_graceful_restart(), and main().

{
    Cfg *cfg;

    info(0, "Reloading configuration resource `%s'.", octstr_get_cstr(cfg_filename));
    cfg = cfg_create(cfg_filename);
    if (cfg_read(cfg) == -1) {
        error(0, "Error processing configuration resource `%s'. Continue with existing configuration.",
              octstr_get_cstr(cfg_filename));
        return -1;
    }

    smsc2_graceful_restart(cfg);
    smsbox_restart(cfg);
    return 0;
}

bb_isolate()

int bb_isolate

(

void

)

Definition at line 861 of file bearerbox.c.

References BB_ISOLATED, BB_RUNNING, bb_status, BB_SUSPENDED, gwlist_add_producer(), gwlist_remove_producer(), isolated, mutex_lock, mutex_unlock, smsc2_suspend(), status_mutex, and suspended.

Referenced by httpd_isolate().

{
    mutex_lock(status_mutex);
    if (bb_status != BB_RUNNING && bb_status != BB_SUSPENDED) {
        mutex_unlock(status_mutex);
        return -1;
    }
    if (bb_status == BB_RUNNING) {
        smsc2_suspend();
        gwlist_add_producer(isolated);
    } else
    gwlist_remove_producer(suspended);

    bb_status = BB_ISOLATED;
    mutex_unlock(status_mutex);
    return 0;
}

bb_print_status()

Octstr* bb_print_status

(

int

status_type

)

Definition at line 998 of file bearerbox.c.

References append_status, BB_FULL, BB_ISOLATED, BB_RUNNING, bb_status, bb_status_linebreak(), BB_SUSPENDED, BBSTATUS_HTML, BBSTATUS_WML, BBSTATUS_XML, boxc_incoming_wdp_queue(), boxc_status(), counter_value(), dlr_messages(), dlr_type(), gwlist_len(), incoming_dlr_counter, incoming_dlr_load, incoming_sms, incoming_sms_counter, incoming_sms_load, incoming_wdp, incoming_wdp_counter, load_get(), octstr_append_cstr(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, outgoing_dlr_counter, outgoing_dlr_load, outgoing_sms, outgoing_sms_counter, outgoing_sms_load, outgoing_wdp, outgoing_wdp_counter, smsc2_status(), start_time, store_messages, udp_outgoing_queue(), and version_report_string().

Referenced by httpd_status().

{
    char *s, *lb;
    char *frmt, *footer;
    Octstr *ret, *str, *version;
    time_t t;

    if ((lb = bb_status_linebreak(status_type)) == NULL)
        return octstr_create("Un-supported format");

    t = time(NULL) - start_time;
    
    if (bb_status == BB_RUNNING)
        s = "running";
    else if (bb_status == BB_ISOLATED)
        s = "isolated";
    else if (bb_status == BB_SUSPENDED)
        s = "suspended";
    else if (bb_status == BB_FULL)
        s = "filled";
    else
        s = "going down";

    version = version_report_string("bearerbox");

    if (status_type == BBSTATUS_HTML) {
        frmt = "%s</p>\n\n"
               " <p>Status: %s, uptime %ldd %ldh %ldm %lds</p>\n\n"
               " <p>WDP: received %ld (%ld queued), sent %ld "
               "(%ld queued)</p>\n\n"
               " <p>SMS: received %ld (%ld queued), sent %ld "
               "(%ld queued), store size %ld<br>\n"
               " SMS: inbound (%.2f,%.2f,%.2f) msg/sec, "
               "outbound (%.2f,%.2f,%.2f) msg/sec</p>\n\n"
               " <p>DLR: received %ld, sent %ld<br>\n"
               " DLR: inbound (%.2f,%.2f,%.2f) msg/sec, outbound (%.2f,%.2f,%.2f) msg/sec<br>\n"
               " DLR: %ld queued, using %s storage</p>\n\n";
        footer = "<p>";
    } else if (status_type == BBSTATUS_WML) {
        frmt = "%s</p>\n\n"
               "   <p>Status: %s, uptime %ldd %ldh %ldm %lds</p>\n\n"
               "   <p>WDP: received %ld (%ld queued)<br/>\n"
               "      WDP: sent %ld (%ld queued)</p>\n\n"
               "   <p>SMS: received %ld (%ld queued)<br/>\n"
               "      SMS: sent %ld (%ld queued)<br/>\n"
               "      SMS: store size %ld<br/>\n"
               "      SMS: inbound (%.2f,%.2f,%.2f) msg/sec<br/>\n"
               "      SMS: outbound (%.2f,%.2f,%.2f) msg/sec</p>\n"
               "   <p>DLR: received %ld<br/>\n"
               "      DLR: sent %ld<br/>\n"
               "      DLR: inbound (%.2f,%.2f,%.2f) msg/sec<br/>\n"
               "      DLR: outbound (%.2f,%.2f,%.2f) msg/sec<br/>\n"
               "      DLR: %ld queued<br/>\n"
               "      DLR: using %s storage</p>\n\n";
        footer = "<p>";
    } else if (status_type == BBSTATUS_XML) {
        frmt = "<version>%s</version>\n"
               "<status>%s, uptime %ldd %ldh %ldm %lds</status>\n"
               "\t<wdp>\n\t\t<received><total>%ld</total><queued>%ld</queued>"
               "</received>\n\t\t<sent><total>%ld</total><queued>%ld</queued>"
               "</sent>\n\t</wdp>\n"
               "\t<sms>\n\t\t<received><total>%ld</total><queued>%ld</queued>"
               "</received>\n\t\t<sent><total>%ld</total><queued>%ld</queued>"
               "</sent>\n\t\t<storesize>%ld</storesize>\n\t\t"
               "<inbound>%.2f,%.2f,%.2f</inbound>\n\t\t"
               "<outbound>%.2f,%.2f,%.2f</outbound>\n\t\t"
               "</sms>\n"
               "\t<dlr>\n\t\t<received><total>%ld</total></received>\n\t\t"
               "<sent><total>%ld</total></sent>\n\t\t"
               "<inbound>%.2f,%.2f,%.2f</inbound>\n\t\t"
               "<outbound>%.2f,%.2f,%.2f</outbound>\n\t\t"
               "<queued>%ld</queued>\n\t\t<storage>%s</storage>\n\t</dlr>\n";
        footer = "";
    } else {
        frmt = "%s\n\nStatus: %s, uptime %ldd %ldh %ldm %lds\n\n"
               "WDP: received %ld (%ld queued), sent %ld (%ld queued)\n\n"
               "SMS: received %ld (%ld queued), sent %ld (%ld queued), store size %ld\n"
               "SMS: inbound (%.2f,%.2f,%.2f) msg/sec, "
               "outbound (%.2f,%.2f,%.2f) msg/sec\n\n"
               "DLR: received %ld, sent %ld\n"
               "DLR: inbound (%.2f,%.2f,%.2f) msg/sec, outbound (%.2f,%.2f,%.2f) msg/sec\n"
               "DLR: %ld queued, using %s storage\n\n";
        footer = "";
    }
    
    ret = octstr_format(frmt,
        octstr_get_cstr(version),
        s, t/3600/24, t/3600%24, t/60%60, t%60,
        counter_value(incoming_wdp_counter),
        gwlist_len(incoming_wdp) + boxc_incoming_wdp_queue(),
        counter_value(outgoing_wdp_counter), gwlist_len(outgoing_wdp) + udp_outgoing_queue(),
        counter_value(incoming_sms_counter), gwlist_len(incoming_sms),
        counter_value(outgoing_sms_counter), gwlist_len(outgoing_sms),
        store_messages(),
        load_get(incoming_sms_load,0), load_get(incoming_sms_load,1), load_get(incoming_sms_load,2),
        load_get(outgoing_sms_load,0), load_get(outgoing_sms_load,1), load_get(outgoing_sms_load,2),
        counter_value(incoming_dlr_counter), counter_value(outgoing_dlr_counter),
        load_get(incoming_dlr_load,0), load_get(incoming_dlr_load,1), load_get(incoming_dlr_load,2),
        load_get(outgoing_dlr_load,0), load_get(outgoing_dlr_load,1), load_get(outgoing_dlr_load,2),
        dlr_messages(), dlr_type());

    octstr_destroy(version);
    
    append_status(ret, str, boxc_status, status_type);
    append_status(ret, str, smsc2_status, status_type);
    octstr_append_cstr(ret, footer);
    
    return ret;
}

bb_reload_lists()

int bb_reload_lists

(

void

)

Definition at line 971 of file bearerbox.c.

References smsc2_reload_lists().

Referenced by httpd_reload_lists().

{
    return smsc2_reload_lists();
}

bb_reload_smsc_groups()

int bb_reload_smsc_groups

(

void

)

Definition at line 627 of file bb_smscconn.c.

References cfg_create(), cfg_destroy(), cfg_filename, cfg_get_multi_group(), cfg_read(), cfg_reloaded, debug(), gwlist_destroy(), octstr_get_cstr, octstr_imm(), smsc_groups, and warning().

Referenced by smsc2_add_smsc(), and smsc2_restart_smsc().

{
    debug("bb.sms", 0, "Reloading smsc groups list from config resource");
    cfg_destroy(cfg_reloaded);
    cfg_reloaded = cfg_create(cfg_filename);
    if (cfg_read(cfg_reloaded) == -1) {
        warning(0, "Error opening configuration file %s", octstr_get_cstr(cfg_filename));
        return -1;
    }
    gwlist_destroy(smsc_groups, NULL);
    smsc_groups = cfg_get_multi_group(cfg_reloaded, octstr_imm("smsc"));

    return 0;
}

bb_remove_message()

int bb_remove_message

(

Octstr *

id

)

Definition at line 976 of file bearerbox.c.

References ack_failed, error(), msg, msg_create, msg_destroy(), octstr_get_cstr, store_save, and uuid_parse().

Referenced by httpd_remove_message().

{
    Msg *msg;
    int ret;

    msg = msg_create(ack);
    msg->ack.nack = ack_failed;
    msg->ack.time = time(NULL);
    uuid_parse(octstr_get_cstr(message_id), msg->ack.id);
    ret = store_save(msg);
    msg_destroy(msg);
    if (ret != 0) {
        error(0, "Could not delete message %s", octstr_get_cstr(message_id));
        return -1;
    }
    return 0;
}

bb_remove_smsc()

int bb_remove_smsc

(

Octstr *

id

)

Definition at line 943 of file bearerbox.c.

References smsc2_remove_smsc().

Referenced by httpd_remove_smsc().

{
    return smsc2_remove_smsc(id);
}

bb_restart()

int bb_restart

(

void

)

Definition at line 948 of file bearerbox.c.

References bb_shutdown(), and restart.

Referenced by httpd_graceful_restart(), and httpd_restart().

{
    restart = 1;
    return bb_shutdown();
}

bb_restart_smsc()

int bb_restart_smsc

(

Octstr *

id

)

Definition at line 933 of file bearerbox.c.

References smsc2_restart_smsc().

Referenced by httpd_restart_smsc().

{
    return smsc2_restart_smsc(id);
}

bb_resume()

int bb_resume

(

void

)

Definition at line 898 of file bearerbox.c.

References BB_ISOLATED, BB_RUNNING, bb_status, BB_SUSPENDED, gwlist_remove_producer(), isolated, mutex_lock, mutex_unlock, smsc2_resume(), status_mutex, and suspended.

Referenced by httpd_resume().

{
    mutex_lock(status_mutex);
    if (bb_status != BB_SUSPENDED && bb_status != BB_ISOLATED) {
        mutex_unlock(status_mutex);
        return -1;
    }
    if (bb_status == BB_SUSPENDED)
        gwlist_remove_producer(suspended);

    smsc2_resume(0);
    bb_status = BB_RUNNING;
    gwlist_remove_producer(isolated);
    mutex_unlock(status_mutex);
    return 0;
}

bb_shutdown()

int bb_shutdown

(

void

)

Definition at line 832 of file bearerbox.c.

References debug(), mutex_lock, mutex_unlock, set_shutdown_status(), smsc2_shutdown(), status_mutex, and udp_shutdown().

Referenced by bb_restart(), httpadmin_run(), httpd_shutdown(), and main().

{
    static int called = 0;
    
    mutex_lock(status_mutex);
    
    if (called) {
        mutex_unlock(status_mutex);
        return -1;
    }
    debug("bb", 0, "Shutting down " GW_NAME "...");

    called = 1;
    set_shutdown_status();
    mutex_unlock(status_mutex);

#ifndef NO_SMS
    debug("bb", 0, "shutting down smsc");
    smsc2_shutdown();
#endif
#ifndef NO_WAP
    debug("bb", 0, "shutting down udp");
    udp_shutdown();
#endif
    
    return 0;
}

bb_status_linebreak()

char* bb_status_linebreak

(

int

status_type

)

Definition at line 1109 of file bearerbox.c.

References BBSTATUS_HTML, BBSTATUS_TEXT, BBSTATUS_WML, and BBSTATUS_XML.

Referenced by bb_print_status(), boxc_status(), httpd_serve(), and smsc2_status().

{
    switch (status_type) {
        case BBSTATUS_HTML:
            return "<br>\n";
        case BBSTATUS_WML:
            return "<br/>\n";
        case BBSTATUS_TEXT:
            return "\n";
        case BBSTATUS_XML:
            return "\n";
        default:
            return NULL;
    }
}

bb_stop_smsc()

int bb_stop_smsc

(

Octstr *

id

)

Definition at line 927 of file bearerbox.c.

References smsc2_stop_smsc().

Referenced by httpd_stop_smsc().

{
    return smsc2_stop_smsc(id);
}

bb_suspend()

int bb_suspend

(

void

)

Definition at line 880 of file bearerbox.c.

References BB_ISOLATED, BB_RUNNING, bb_status, BB_SUSPENDED, gwlist_add_producer(), isolated, mutex_lock, mutex_unlock, smsc2_suspend(), status_mutex, and suspended.

Referenced by httpd_suspend().

{
    mutex_lock(status_mutex);
    if (bb_status != BB_RUNNING && bb_status != BB_ISOLATED) {
        mutex_unlock(status_mutex);
        return -1;
    }
    if (bb_status != BB_ISOLATED) {
        smsc2_suspend();
        gwlist_add_producer(isolated);
    }
    bb_status = BB_SUSPENDED;
    gwlist_add_producer(suspended);
    mutex_unlock(status_mutex);
    return 0;
}

boxc_cleanup()

void boxc_cleanup

(

void

)

Definition at line 1527 of file bb_boxc.c.

References box_allow_ip, box_deny_ip, boxid, counter_destroy(), octstr_destroy(), and smsbox_interface.

Referenced by main().

{
    octstr_destroy(box_allow_ip);
    octstr_destroy(box_deny_ip);
    box_allow_ip = NULL;
    box_deny_ip = NULL;
    counter_destroy(boxid);
    boxid = NULL;
    octstr_destroy(smsbox_interface);
    smsbox_interface = NULL;
}

boxc_incoming_wdp_queue()

int boxc_incoming_wdp_queue

(

void

)

Definition at line 1510 of file bb_boxc.c.

References gwlist_get(), gwlist_len(), gwlist_lock(), gwlist_unlock(), _boxc::incoming, and wapbox_list.

Referenced by bb_print_status().

{
    int i, q = 0;
    Boxc *boxc;

    if (wapbox_list) {
        gwlist_lock(wapbox_list);
        for(i=0; i < gwlist_len(wapbox_list); i++) {
            boxc = gwlist_get(wapbox_list, i);
            q += gwlist_len(boxc->incoming);
        }
        gwlist_unlock(wapbox_list);
    }
    return q;
}

boxc_status()

Octstr* boxc_status

(

int

status_type

)

Definition at line 1386 of file bb_boxc.c.

References _boxc::alive, bb_status_linebreak(), BBSTATUS_HTML, BBSTATUS_TEXT, BBSTATUS_WML, BBSTATUS_XML, _boxc::boxc_id, _boxc::client_ip, _boxc::conn, _boxc::connect_time, dict_key_count(), gw_rwlock_rdlock(), gw_rwlock_unlock(), gwlist_get(), gwlist_len(), gwlist_lock(), gwlist_unlock(), _boxc::incoming, octstr_append_cstr(), octstr_create, octstr_destroy(), octstr_format(), octstr_format_append(), octstr_get_cstr, _boxc::sent, smsbox_list, smsbox_list_rwlock, and wapbox_list.

Referenced by bb_print_status().

{
    Octstr *tmp;
    char *lb, *ws;
    int i, boxes, para = 0;
    time_t orig, t;
    Boxc *bi;

    orig = time(NULL);

    /*
     * XXX: this will cause segmentation fault if this is called
     *    between 'destroy_list and setting list to NULL calls.
     *    Ok, this has to be fixed, but now I am too tired.
     */

    if ((lb = bb_status_linebreak(status_type))==NULL)
        return octstr_create("Un-supported format");

    if (status_type == BBSTATUS_HTML)
        ws = "    ";
    else if (status_type == BBSTATUS_TEXT)
        ws = "    ";
    else
        ws = "";

    if (status_type == BBSTATUS_HTML || status_type == BBSTATUS_WML)
        para = 1;

    if (status_type == BBSTATUS_XML) {
        tmp = octstr_create ("");
        octstr_append_cstr(tmp, "<boxes>\n\t");
    }
    else
        tmp = octstr_format("%sBox connections:%s", para ? "<p>" : "", lb);
    boxes = 0;

    if (wapbox_list) {
        gwlist_lock(wapbox_list);
        for(i=0; i < gwlist_len(wapbox_list); i++) {
            bi = gwlist_get(wapbox_list, i);
            if (bi->alive == 0)
                continue;
            t = orig - bi->connect_time;
            if (status_type == BBSTATUS_XML)
                octstr_format_append(tmp,
                "<box>\n\t\t<type>wapbox</type>\n\t\t<IP>%s</IP>\n"
                "\t\t<status>on-line %ldd %ldh %ldm %lds</status>\n"
                "\t\t<ssl>%s</ssl>\n\t</box>\n",
                octstr_get_cstr(bi->client_ip),
                t/3600/24, t/3600%24, t/60%60, t%60,
#ifdef HAVE_LIBSSL
                conn_get_ssl(bi->conn) != NULL ? "yes" : "no"
#else
                "not installed"
#endif
                );
            else
                octstr_format_append(tmp,
                "%swapbox, IP %s (on-line %ldd %ldh %ldm %lds) %s %s",
                ws, octstr_get_cstr(bi->client_ip),
                t/3600/24, t/3600%24, t/60%60, t%60,
#ifdef HAVE_LIBSSL
                conn_get_ssl(bi->conn) != NULL ? "using SSL" : "",
#else
                "",
#endif
                lb);
                boxes++;
           }
           gwlist_unlock(wapbox_list);
        }
        if (smsbox_list) {
            gw_rwlock_rdlock(smsbox_list_rwlock);
        for(i=0; i < gwlist_len(smsbox_list); i++) {
            bi = gwlist_get(smsbox_list, i);
            if (bi->alive == 0)
                continue;
            t = orig - bi->connect_time;
            if (status_type == BBSTATUS_XML)
                octstr_format_append(tmp, "<box>\n\t\t<type>smsbox</type>\n"
                    "\t\t<id>%s</id>\n\t\t<IP>%s</IP>\n"
                    "\t\t<queue>%ld</queue>\n"
                    "\t\t<status>on-line %ldd %ldh %ldm %lds</status>\n"
                    "\t\t<ssl>%s</ssl>\n\t</box>",
                    (bi->boxc_id ? octstr_get_cstr(bi->boxc_id) : ""),
                    octstr_get_cstr(bi->client_ip),
                    gwlist_len(bi->incoming) + dict_key_count(bi->sent),
                    t/3600/24, t/3600%24, t/60%60, t%60,
#ifdef HAVE_LIBSSL
                    conn_get_ssl(bi->conn) != NULL ? "yes" : "no"
#else
                    "not installed"
#endif
                    );
            else
                octstr_format_append(tmp, "%ssmsbox:%s, IP %s (%ld queued), (on-line %ldd %ldh %ldm %lds) %s %s",
                    ws, (bi->boxc_id ? octstr_get_cstr(bi->boxc_id) : "(none)"),
                    octstr_get_cstr(bi->client_ip), gwlist_len(bi->incoming) + dict_key_count(bi->sent),
                    t/3600/24, t/3600%24, t/60%60, t%60,
#ifdef HAVE_LIBSSL
                    conn_get_ssl(bi->conn) != NULL ? "using SSL" : "",
#else
                    "",
#endif
                    lb);
           boxes++;
        }
        gw_rwlock_unlock(smsbox_list_rwlock);
    }
    if (boxes == 0 && status_type != BBSTATUS_XML) {
        octstr_destroy(tmp);
        tmp = octstr_format("%sNo boxes connected", para ? "<p>" : "");
    }
    if (para)
        octstr_append_cstr(tmp, "</p>");
    if (status_type == BBSTATUS_XML)
        octstr_append_cstr(tmp, "</boxes>\n");
    else
        octstr_append_cstr(tmp, "\n\n");
    return tmp;
}

httpadmin_start()

int httpadmin_start

(

Cfg *

config

)

Definition at line 557 of file bb_http.c.

References cfg, cfg_get, cfg_get_bool(), cfg_get_integer(), cfg_get_single_group(), gwthread_create, ha_allow_ip, ha_deny_ip, ha_interface, ha_password, ha_port, ha_status_pw, http_open_port_if(), httpadmin_run(), httpadmin_running, octstr_destroy(), octstr_imm(), panic, and ssl.

Referenced by init_bearerbox().

{
    CfgGroup *grp;
    int ssl = 0; 
#ifdef HAVE_LIBSSL
    Octstr *ssl_server_cert_file;
    Octstr *ssl_server_key_file;
#endif /* HAVE_LIBSSL */
    
    if (httpadmin_running) return -1;


    grp = cfg_get_single_group(cfg, octstr_imm("core"));
    if (cfg_get_integer(&ha_port, grp, octstr_imm("admin-port")) == -1)
    panic(0, "Missing admin-port variable, cannot start HTTP admin");

    ha_interface = cfg_get(grp, octstr_imm("admin-interface"));
    ha_password = cfg_get(grp, octstr_imm("admin-password"));
    if (ha_password == NULL)
    panic(0, "You MUST set HTTP admin-password");
    
    ha_status_pw = cfg_get(grp, octstr_imm("status-password"));

    ha_allow_ip = cfg_get(grp, octstr_imm("admin-allow-ip"));
    ha_deny_ip = cfg_get(grp, octstr_imm("admin-deny-ip"));

#ifdef HAVE_LIBSSL
    cfg_get_bool(&ssl, grp, octstr_imm("admin-port-ssl"));
    
    /*
     * check if SSL is desired for HTTP servers and then
     * load SSL client and SSL server public certificates 
     * and private keys
     */    
    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 here, the following call is now in conn_config_ssl(),
         * so there is no reason to do this twice.

        use_global_server_certkey_file(ssl_server_cert_file, 
            ssl_server_key_file);
        */
    } else if (ssl) {
       panic(0, "You MUST specify cert and key files within core group for SSL-enabled HTTP servers!");
    }

    octstr_destroy(ssl_server_cert_file);
    octstr_destroy(ssl_server_key_file);
#endif /* HAVE_LIBSSL */

    http_open_port_if(ha_port, ssl, ha_interface);

    if (gwthread_create(httpadmin_run, NULL) == -1)
    panic(0, "Failed to start a new thread for HTTP admin");

    httpadmin_running = 1;
    return 0;
}

httpadmin_stop()

void httpadmin_stop

(

void

)

Definition at line 618 of file bb_http.c.

References gwthread_join_every(), ha_allow_ip, ha_deny_ip, ha_interface, ha_password, ha_status_pw, http_close_all_ports(), httpadmin_run(), and octstr_destroy().

Referenced by main().

{
    http_close_all_ports();
    gwthread_join_every(httpadmin_run);
    octstr_destroy(ha_interface);    
    octstr_destroy(ha_password);
    octstr_destroy(ha_status_pw);
    octstr_destroy(ha_allow_ip);
    octstr_destroy(ha_deny_ip);
    ha_password = NULL;
    ha_status_pw = NULL;
    ha_allow_ip = NULL;
    ha_deny_ip = NULL;
}

route_incoming_to_boxc()

int route_incoming_to_boxc

(

Msg *

msg

)

Definition at line 1549 of file bb_boxc.c.

References _boxc::boxc_id, dict_get(), gw_assert(), gw_rand(), gw_rwlock_rdlock(), gw_rwlock_unlock(), gwlist_get(), gwlist_len(), gwlist_produce(), _boxc::incoming, incoming_sms, _boxc::load, max_incoming_sms_qlength, msg, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_len(), _boxc::routable, smsbox_by_default, smsbox_by_id, smsbox_by_receiver, smsbox_by_smsc, smsbox_by_smsc_receiver, smsbox_list, smsbox_list_rwlock, and warning().

Referenced by bb_smscconn_receive_internal(), and sms_to_smsboxes().

{
    Boxc *bc = NULL;
    Octstr *s, *r, *rs, *boxc_id = NULL;
    long len, b, i;
    int full_found = 0;

    gw_assert(msg_type(msg) == sms);

    /* msg_dump(msg, 0); */

    /* Check we have at least one smsbox connected! */
    gw_rwlock_rdlock(smsbox_list_rwlock);
    if (gwlist_len(smsbox_list) == 0) {
        gw_rwlock_unlock(smsbox_list_rwlock);
        warning(0, "smsbox_list empty!");
        if (max_incoming_sms_qlength < 0 || max_incoming_sms_qlength > gwlist_len(incoming_sms)) {
            gwlist_produce(incoming_sms, msg);
            return 0;
        } else {
            return -1;
        }
    }

    /*
     * Do we have a specific smsbox-id route to pass this msg to?
     */
    if (octstr_len(msg->sms.boxc_id) > 0) {
        boxc_id = msg->sms.boxc_id;
    } else {
        /*
         * Check if we have a "smsbox-route" for this msg.
         * Where the shortcode route has a higher priority then the smsc-id rule.
         * Highest priority has the combined <shortcode>:<smsc-id> route.
         */
        Octstr *os = octstr_format("%s:%s",
                                   octstr_get_cstr(msg->sms.receiver),
                                   octstr_get_cstr(msg->sms.smsc_id));
        s = (msg->sms.smsc_id ? dict_get(smsbox_by_smsc, msg->sms.smsc_id) : NULL);
        r = (msg->sms.receiver ? dict_get(smsbox_by_receiver, msg->sms.receiver) : NULL);
        rs = (os ? dict_get(smsbox_by_smsc_receiver, os) : NULL);
        octstr_destroy(os);

        if (rs)
            boxc_id = rs;
        else if (r)
            boxc_id = r;
        else if (s)
            boxc_id = s;
        else if (smsbox_by_default)
            boxc_id = smsbox_by_default;
    }

    /* We have a specific smsbox-id to use */
    if (boxc_id != NULL) {

        List *boxc_id_list = dict_get(smsbox_by_id, boxc_id);
        if (gwlist_len(boxc_id_list) == 0) {
            /*
             * something is wrong, this was the smsbox connection we used
             * for sending, so it seems this smsbox is gone
             */
            warning(0, "Could not route message to smsbox id <%s>, smsbox is gone!",
                    octstr_get_cstr(boxc_id));
            gw_rwlock_unlock(smsbox_list_rwlock);
            if (max_incoming_sms_qlength < 0 || max_incoming_sms_qlength > gwlist_len(incoming_sms)) {
                gwlist_produce(incoming_sms, msg);
                return 0;
            } else {
                return -1;
            }
        }
        
        /* 
         * Take random smsbox from list, as long as it has space we will use it,
         * otherwise check the next one.
         */
        len = gwlist_len(boxc_id_list);
        b = gw_rand() % len;

        for (i = 0; i < len; i++) {
            bc = gwlist_get(boxc_id_list, (i+b) % len);

            if (bc != NULL && max_incoming_sms_qlength > 0 &&
                    gwlist_len(bc->incoming) > max_incoming_sms_qlength) {
                bc = NULL;
            }

            if (bc != NULL) {
                break;
            }
        }

        if (bc != NULL) {
            bc->load++;
            gwlist_produce(bc->incoming, msg);
            gw_rwlock_unlock(smsbox_list_rwlock);
            return 1; /* we are done */
        }
        else {
            /*
             * we have routing defined, but no smsbox connected at the moment.
             * put msg into global incoming queue and wait until smsbox with
             * such boxc_id connected.
             */
            gw_rwlock_unlock(smsbox_list_rwlock);
            if (max_incoming_sms_qlength < 0 || max_incoming_sms_qlength > gwlist_len(incoming_sms)) {
                gwlist_produce(incoming_sms, msg);
                return 0;
            } else {
                return -1;
            }
        }
    }

    /*
     * Ok, none of the specific routing things applied previously, 
     * so route it to a random smsbox.
     * Take random smsbox from list, as long as it has space we will 
     * use it, therwise check the next one.
     */
    len = gwlist_len(smsbox_list);
    b = gw_rand() % len;

    for (i = 0; i < len; i++) {
        bc = gwlist_get(smsbox_list, (i+b) % len);

        if (bc->boxc_id != NULL || bc->routable == 0)
            bc = NULL;

        if (bc != NULL && max_incoming_sms_qlength > 0 &&
            gwlist_len(bc->incoming) > max_incoming_sms_qlength) {
            full_found = 1;
            bc = NULL;
        }

        if (bc != NULL) {
            break;
        }
    }

    if (bc != NULL) {
        bc->load++;
        gwlist_produce(bc->incoming, msg);
    }

    gw_rwlock_unlock(smsbox_list_rwlock);

    if (bc == NULL && full_found == 0) {
        warning(0, "smsbox_list empty!");
        if (max_incoming_sms_qlength < 0 || max_incoming_sms_qlength > gwlist_len(incoming_sms)) {
            gwlist_produce(incoming_sms, msg);
               return 0;
         } else {
             return -1;
         }
    } else if (bc == NULL && full_found == 1) {
        return -1;
    }

    return 1;
}

smsbox_restart()

int smsbox_restart

(

Cfg *

config

)

Definition at line 1316 of file bb_boxc.c.

References cfg, dict_create(), dict_destroy(), gw_rwlock_unlock(), gw_rwlock_wrlock(), init_smsbox_routes(), octstr_destroy(), smsbox_by_default, smsbox_by_receiver, smsbox_by_smsc, smsbox_by_smsc_receiver, smsbox_list_rwlock, and smsbox_running.

Referenced by bb_graceful_restart().

{
    if (!smsbox_running) return -1;

    gw_rwlock_wrlock(smsbox_list_rwlock);
    dict_destroy(smsbox_by_smsc);
    dict_destroy(smsbox_by_receiver);
    dict_destroy(smsbox_by_smsc_receiver);
    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);
    octstr_destroy(smsbox_by_default);
    smsbox_by_default = NULL;
    init_smsbox_routes(cfg, 1);
    gw_rwlock_unlock(smsbox_list_rwlock);

    return 0;
}

smsbox_start()

int smsbox_start

(

Cfg *

config

)

Definition at line 1250 of file bb_boxc.c.

References box_allow_ip, box_deny_ip, boxc_gwlist_destroy(), boxid, cfg, cfg_get, cfg_get_bool(), cfg_get_integer(), cfg_get_single_group(), counter_create(), debug(), dict_create(), error(), gw_rwlock_create(), gwlist_add_producer(), gwlist_create, gwthread_create, info(), init_smsbox_routes(), octstr_create, octstr_destroy(), octstr_imm(), outgoing_sms, panic, sms_dequeue_thread, sms_to_smsboxes(), smsbox_by_default, smsbox_by_id, smsbox_by_receiver, smsbox_by_smsc, smsbox_by_smsc_receiver, smsbox_interface, smsbox_list, smsbox_list_rwlock, SMSBOX_MAX_PENDING, smsbox_max_pending, smsbox_port, smsbox_port_ssl, smsbox_running, and smsboxc_run().

Referenced by start_smsc().

{
    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");

    smsbox_interface = cfg_get(grp, octstr_imm("smsbox-interface"));

    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);
    }

    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...");

    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, (void(*)(void *)) boxc_gwlist_destroy);
    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);
    smsbox_by_default = NULL;

    /* load the defined smsbox routing rules */
    init_smsbox_routes(cfg, 0);

    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, NULL) == -1)
        panic(0, "Failed to start a new thread for smsbox connections");

    return 0;
}

smsc2_add_smsc()

int smsc2_add_smsc

(

Octstr *

id

)

Definition at line 1112 of file bb_smscconn.c.

References bb_reload_smsc_groups(), cfg_get, smscconn::dead_start, error(), gw_rwlock_unlock(), gw_rwlock_wrlock(), gwlist_add_producer(), gwlist_append(), gwlist_get(), gwlist_len(), gwlist_remove_producer(), octstr_compare(), octstr_destroy(), octstr_get_cstr, octstr_imm(), smsc2_find(), smsc_groups, smsc_list, smsc_list_lock, smsc_running, smscconn_create(), smscconn_instances(), smscconn_shutdown(), smscconn_start(), and warning().

Referenced by bb_add_smsc().

{
    CfgGroup *grp;
    SMSCConn *conn = NULL;
    Octstr *smscid = NULL;
    long i, m, j;
    int success = 0;

    if (!smsc_running)
        return -1;

    gw_rwlock_wrlock(&smsc_list_lock);
    if (bb_reload_smsc_groups() != 0) {
        gw_rwlock_unlock(&smsc_list_lock);
        return -1;
    }
    
    if (smsc2_find(id, 0) != -1) {
        warning(0, "Could not add already existing SMSC %s", octstr_get_cstr(id));
        gw_rwlock_unlock(&smsc_list_lock);
        return -1;
    }

    gwlist_add_producer(smsc_list);
    grp = NULL;
    for (i = 0; i < gwlist_len(smsc_groups) &&
        (grp = gwlist_get(smsc_groups, i)) != NULL; i++) {
        smscid = cfg_get(grp, octstr_imm("smsc-admin-id"));
        if (smscid == NULL)
            smscid = cfg_get(grp, octstr_imm("smsc-id"));

        if (smscid != NULL && octstr_compare(smscid, id) == 0) {
            /* multiple instances for the same group? */
            m = smscconn_instances(grp);
            for (j = 0; j < m; j++) {
                conn = smscconn_create(grp, 1);
                if (conn != NULL) {
                    gwlist_append(smsc_list, conn);
                    if (conn->dead_start) {
                        /* Shutdown connection if it's not configured to connect at start-up time */
                        smscconn_shutdown(conn, 0);
                    } else {
                        smscconn_start(conn);
                    }
                    success = 1;
                } else {
                    error(0, "Cannot start with SMSC %s connection failing", octstr_get_cstr(id));
                }
            }
        }
        octstr_destroy(smscid);
        smscid = NULL;
    }
    gwlist_remove_producer(smsc_list);
    gw_rwlock_unlock(&smsc_list_lock);
    if (success == 0) {
        error(0, "SMSC %s not found", octstr_get_cstr(id));
        return -1;
    }
    return 0;
}

smsc2_cleanup()

void smsc2_cleanup

(

void

)

Definition at line 1314 of file bb_smscconn.c.

References black_list_receiver, black_list_receiver_regex, black_list_receiver_url, black_list_sender, black_list_sender_regex, black_list_sender_url, concat_handling_cleanup(), counter_destroy(), debug(), gw_rwlock_destroy(), gw_rwlock_unlock(), gw_rwlock_wrlock(), gwlist_destroy(), gwlist_get(), gwlist_len(), numhash_destroy(), octstr_destroy(), smsc_groups, smsc_list, smsc_list_lock, smsc_running, smscconn_destroy(), split_msg_counter, unified_prefix, white_black_list_lock, white_list_receiver, white_list_receiver_regex, white_list_receiver_url, white_list_sender, white_list_sender_regex, and white_list_sender_url.

Referenced by main().

{
    SMSCConn *conn;
    long i;

    if (!smsc_running)
        return;

    debug("smscconn", 0, "final clean-up for SMSCConn");
    
    gw_rwlock_wrlock(&smsc_list_lock);
    for (i = 0; i < gwlist_len(smsc_list); i++) {
        conn = gwlist_get(smsc_list, i);
        smscconn_destroy(conn);
    }
    gwlist_destroy(smsc_list, NULL);
    smsc_list = NULL;
    gw_rwlock_unlock(&smsc_list_lock);
    gwlist_destroy(smsc_groups, NULL);
    octstr_destroy(unified_prefix);    
    numhash_destroy(white_list_sender);
    numhash_destroy(black_list_sender);
    octstr_destroy(white_list_sender_url);
    octstr_destroy(black_list_sender_url);
    if (white_list_sender_regex != NULL)
        gw_regex_destroy(white_list_sender_regex);
    if (black_list_sender_regex != NULL)
        gw_regex_destroy(black_list_sender_regex);
    numhash_destroy(white_list_receiver);
    numhash_destroy(black_list_receiver);
    octstr_destroy(white_list_receiver_url);
    octstr_destroy(black_list_receiver_url);
    if (white_list_receiver_regex != NULL)
        gw_regex_destroy(white_list_receiver_regex);
    if (black_list_receiver_regex != NULL)
        gw_regex_destroy(black_list_receiver_regex);
    /* destroy msg split counter */
    counter_destroy(split_msg_counter);
    gw_rwlock_destroy(&smsc_list_lock);
    gw_rwlock_destroy(&white_black_list_lock);

    /* Stop concat handling */
    concat_handling_cleanup();

    smsc_running = 0;
}

smsc2_graceful_restart()

int smsc2_graceful_restart

(

Cfg *

config

)

Definition at line 1530 of file bb_smscconn.c.

References cfg, cfg_get_multi_group(), cmp_conn_grp_checksum(), cmp_conn_grp_id(), cmp_rout_grp_checksum(), gw_rwlock_unlock(), gw_rwlock_wrlock(), gwlist_add_producer(), gwlist_append(), gwlist_create, gwlist_delete(), gwlist_destroy(), gwlist_extract_first(), gwlist_get(), gwlist_len(), gwlist_remove_producer(), gwlist_search_all(), gwlist_search_equal(), gwthread_sleep(), gwthread_wakeup(), smscconn::id, info(), octstr_get_cstr, octstr_imm(), router_thread, smsc_groups, smsc_list, smsc_list_lock, smsc_running, smscconn_create(), smscconn_destroy(), smscconn_instances(), smscconn_reconfig(), smscconn_shutdown(), and smscconn_start().

Referenced by bb_graceful_restart().

{
    CfgGroup *grp;
    SMSCConn *conn;
    List *keep, *add, *remove;
    List *l;
    int i, m;

    if (!smsc_running)
        return -1;

    gw_rwlock_wrlock(&smsc_list_lock);

    /* load the smsc groups from the config resource */
    gwlist_destroy(smsc_groups, NULL);
    smsc_groups = cfg_get_multi_group(cfg, octstr_imm("smsc"));

    /* List of SMSCConn that we keep running */
    keep = gwlist_create();

    /* List of CfgGroup that we will add */
    add = gwlist_create();

    /* List of SMSCConnn that we will shutdown */
    remove = gwlist_create();

    /*
     * Loop through the loaded smsc groups
     */
    for (i = 0; i < gwlist_len(smsc_groups) &&
        (grp = gwlist_get(smsc_groups, i)) != NULL; i++) {
        /*
         * 1st check: Search for the same md5 hash of the whole group.
         * If we find it, then this group is already running, and no
         * routing information has changed, bail out.
         */
        if ((l = gwlist_search_all(smsc_list, grp, cmp_conn_grp_checksum)) != NULL) {
            while ((conn = gwlist_extract_first(l)) != NULL) {
                gwlist_append(keep, conn);
            }
            gwlist_destroy(l, NULL);
            continue;
        }
        /*
         * 2nd check: Search for the same md5 hash minus the routing
         * information. If we find it, then this group is already running
         * and the routing information changed, we'll apply only the new
         * routing information.
         */
        if ((l = gwlist_search_all(smsc_list, grp, cmp_rout_grp_checksum)) != NULL) {
            while ((conn = gwlist_extract_first(l)) != NULL) {
                gwlist_append(keep, conn);
                smscconn_reconfig(conn, grp);
                info(0, "Re-configured routing for smsc-id `%s'.", octstr_get_cstr(conn->id));
            }
            gwlist_destroy(l, NULL);
            continue;
        }
        /*
         * 3rd check: if the smsc-id is NOT in the running list, then
         * this is a new group, add it. If the smsc-id IS found, then
         * mark it/them to be removed, and add the new group.
         */
        if ((l = gwlist_search_all(smsc_list, grp, cmp_conn_grp_id)) == NULL) {
            gwlist_append(add, grp);
            continue;
        } else {
            while ((conn = gwlist_extract_first(l)) != NULL) {
                /* add them to the remove list only
                 * if they are not yet present inside. */
                if (gwlist_search_equal(remove, conn) != -1)
                    gwlist_append(remove, conn);
            }
            gwlist_destroy(l, NULL);
            gwlist_append(add, grp);
            continue;
        }
    }

    /*
     * TODO Effectively a change in the 'instances' multiplier will result in a
     * disconnect of all running instances, and re-connecting the number of
     * configured instances. The reason for this is that the change in the
     * 'instances' value causes the md5 hash to be different for that connection.
     * We MAY exclude the 'instances' directive from the while md5 checksum, this
     * makes the down-grading easier, allowing the rest to keep running. But the
     * up-grading is more difficult, since we can't use the 'add' list here, it
     * would create too much instances.
     */

    /*
     * We may have running smsc-ids now, that haven't been
     * re-loaded from the new config, hence add them to be removed.
     */
    for (i = 0; i < gwlist_len(smsc_list) &&
        (conn = gwlist_get(smsc_list, i)) != NULL; i++) {
        /* if this is already in the remove list, bail out. */
        if (gwlist_search_equal(remove, conn) != -1)
            continue;
        /* if this is in the keep list, bail out. */
        if (gwlist_search_equal(keep, conn) != -1)
            continue;
        /* mark it to be removed */
        gwlist_append(remove, conn);
    }
    gwlist_destroy(keep, NULL);

    /*
     * Stop any connections from the remove list.
     *
     * The smscconn_shutdown() only initiates the shutdown,
     * it is not guaranteed that the SMSC connection is stopped
     * and the status is SMSCCONN_DEAD when we return from the
     * function call. Therefore we pass the connection to a
     * retry list, in order to cleanly destroy all connection
     * structures that have been stopped and reached SMSSCONN_DEAD.
     */
    l = gwlist_create();
    gwlist_add_producer(smsc_list);
    while ((conn = gwlist_extract_first(remove)) != NULL) {
        if ((i = gwlist_search_equal(smsc_list, conn)) != -1) {
            gwlist_delete(smsc_list, i, 1);
            smscconn_shutdown(conn, 0);
            /* if smsc is still in shutdown, then add to retry list */
            if (smscconn_destroy(conn) == -1)
                gwlist_append(l, conn);
        }
    }
    gwlist_remove_producer(smsc_list);
    gwlist_destroy(remove, NULL);

    /*
     * Start any connections from the add list.
     */
    gwlist_add_producer(smsc_list);
    while ((grp = gwlist_extract_first(add)) != NULL) {
        /* multiple instances for the same group? */
        m = smscconn_instances(grp);
        for (i = 0; i < m; i++) {
            conn = smscconn_create(grp, 1);
            if (conn != NULL) {
                gwlist_append(smsc_list, conn);
                if (conn->dead_start) {
                    /* Shutdown connection if it's not configured to connect at start-up time */
                    smscconn_shutdown(conn, 0);
                } else {
                    smscconn_start(conn);
                }
            }
        }
    }
    gwlist_remove_producer(smsc_list);
    gwlist_destroy(add, NULL);

    gw_rwlock_unlock(&smsc_list_lock);

    /* wake-up the router */
    if (router_thread >= 0)
        gwthread_wakeup(router_thread);

    /*
     * We may still have pending connections in the retry list
     * that haven't been destroyed yet.
     */
    while ((conn = gwlist_extract_first(l)) != NULL) {
        if (smscconn_destroy(conn) == -1) {
            gwlist_append(l, conn);
            gwthread_sleep(2);
        }
    }
    gwlist_destroy(l, NULL);

    return 0;
}

smsc2_reload_lists()

int smsc2_reload_lists

(

void

)

Definition at line 1174 of file bb_smscconn.c.

References black_list_receiver, black_list_receiver_url, black_list_sender, black_list_sender_url, error(), gw_rwlock_unlock(), gw_rwlock_wrlock(), numhash_create(), numhash_destroy(), octstr_get_cstr, white_black_list_lock, white_list_receiver, white_list_receiver_url, white_list_sender, and white_list_sender_url.

Referenced by bb_reload_lists().

{
    Numhash *tmp;
    int rc = 1;

    if (white_list_sender_url != NULL) {
        tmp = numhash_create(octstr_get_cstr(white_list_sender_url));
        if (white_list_sender == NULL) {
            error(0, "Unable to reload white_list."),
            rc = -1;
        } else {
            gw_rwlock_wrlock(&white_black_list_lock);
            numhash_destroy(white_list_sender);
            white_list_sender = tmp;
            gw_rwlock_unlock(&white_black_list_lock);
        }
    }

    if (black_list_sender_url != NULL) {
        tmp = numhash_create(octstr_get_cstr(black_list_sender_url));
        if (black_list_sender == NULL) {
            error(0, "Unable to reload black_list");
            rc = -1;
        } else {
            gw_rwlock_wrlock(&white_black_list_lock);
            numhash_destroy(black_list_sender);
            black_list_sender = tmp;
            gw_rwlock_unlock(&white_black_list_lock);
        }
    }

    if (white_list_receiver_url != NULL) {
        tmp = numhash_create(octstr_get_cstr(white_list_receiver_url));
        if (white_list_receiver == NULL) {
            error(0, "Unable to reload white_list."),
            rc = -1;
        } else {
            gw_rwlock_wrlock(&white_black_list_lock);
            numhash_destroy(white_list_receiver);
            white_list_receiver = tmp;
            gw_rwlock_unlock(&white_black_list_lock);
        }
    }

    if (black_list_receiver_url != NULL) {
        tmp = numhash_create(octstr_get_cstr(black_list_receiver_url));
        if (black_list_receiver == NULL) {
            error(0, "Unable to reload black_list");
            rc = -1;
        } else {
            gw_rwlock_wrlock(&white_black_list_lock);
            numhash_destroy(black_list_receiver);
            black_list_receiver = tmp;
            gw_rwlock_unlock(&white_black_list_lock);
        }
    }

    return rc;
}

smsc2_remove_smsc()

int smsc2_remove_smsc

(

Octstr *

id

)

Definition at line 1083 of file bb_smscconn.c.

References error(), gw_rwlock_unlock(), gw_rwlock_wrlock(), gwlist_add_producer(), gwlist_delete(), gwlist_get(), gwlist_remove_producer(), octstr_get_cstr, smsc2_find(), smsc_list, smsc_list_lock, smsc_running, smscconn_destroy(), and smscconn_shutdown().

Referenced by bb_remove_smsc().

{
    SMSCConn *conn;
    long i = -1;
    int success = 0;

    if (!smsc_running)
        return -1;

    gw_rwlock_wrlock(&smsc_list_lock);

    gwlist_add_producer(smsc_list);
    while ((i = smsc2_find(id, ++i)) != -1) {
        conn = gwlist_get(smsc_list, i);
        gwlist_delete(smsc_list, i--, 1);
        smscconn_shutdown(conn, 0);
        smscconn_destroy(conn);
        success = 1;
    }
    gwlist_remove_producer(smsc_list);

    gw_rwlock_unlock(&smsc_list_lock);
    if (success == 0) {
        error(0, "SMSC %s not found", octstr_get_cstr(id));
        return -1;
    }
    return 0;
}

smsc2_restart()

int smsc2_restart

(

Cfg *

config

)

smsc2_restart_smsc()

int smsc2_restart_smsc

(

Octstr *

id

)

Definition at line 998 of file bb_smscconn.c.

References bb_reload_smsc_groups(), cfg_get, error(), gw_rwlock_unlock(), gw_rwlock_wrlock(), gwlist_delete(), gwlist_get(), gwlist_insert(), gwlist_len(), gwthread_wakeup(), info(), octstr_compare(), octstr_destroy(), octstr_get_cstr, octstr_imm(), router_thread, smsc2_find(), smsc_groups, smsc_list, smsc_list_lock, smsc_running, smscconn_create(), SMSCCONN_DEAD, smscconn_destroy(), smscconn_start(), smscconn_status(), and warning().

Referenced by bb_restart_smsc().

{
    CfgGroup *grp;
    SMSCConn *conn, *new_conn;
    Octstr *smscid = NULL;
    long i = -1;
    int hit;
    int num = 0;
    int success = 0;

    if (!smsc_running)
        return -1;

    gw_rwlock_wrlock(&smsc_list_lock);

    if (bb_reload_smsc_groups() != 0) {
        gw_rwlock_unlock(&smsc_list_lock);
        return -1;
    }
    /* find the specific smsc via id */
    while((i = smsc2_find(id, ++i)) != -1) {
        long group_index;
        /* check if smsc has online status already */
        conn = gwlist_get(smsc_list, i);
        if (conn != NULL && smscconn_status(conn) != SMSCCONN_DEAD) {
            warning(0, "HTTP: Could not re-start already running smsc-id `%s'",
                octstr_get_cstr(id));
            continue;
        }
        /* find the group with equal smsc (admin-)id */
        hit = -1;
        grp = NULL;
        for (group_index = 0; group_index < gwlist_len(smsc_groups) && 
             (grp = gwlist_get(smsc_groups, group_index)) != NULL; group_index++) {
            smscid = cfg_get(grp, octstr_imm("smsc-admin-id"));
            if (smscid == NULL)
            smscid = cfg_get(grp, octstr_imm("smsc-id"));
            if (smscid != NULL && octstr_compare(smscid, id) == 0) {
                if (hit < 0)
                    hit = 0;
                if (hit == num)
                    break;
                else
                    hit++;
            }
            octstr_destroy(smscid);
            smscid = NULL;
        }
        octstr_destroy(smscid);
        if (hit != num) {
            /* config group not found */
            error(0, "HTTP: Could not find config for smsc-id `%s'", octstr_get_cstr(id));
            break;
        }
        
        info(0,"HTTP: Re-starting smsc-id `%s'", octstr_get_cstr(id));

        new_conn = smscconn_create(grp, 1);
        if (new_conn == NULL) {
            error(0, "Start of SMSC connection failed, smsc-id `%s'", octstr_get_cstr(id));
            continue; /* keep old connection on the list */
        }
        
        /* drop old connection from the active smsc list */
        gwlist_delete(smsc_list, i, 1);
        /* destroy the connection */
        smscconn_destroy(conn);
        gwlist_insert(smsc_list, i, new_conn);
        smscconn_start(new_conn);
        success = 1;
        num++;
    }

    gw_rwlock_unlock(&smsc_list_lock);
    
    if (success == 0) {
        error(0, "SMSC %s not found", octstr_get_cstr(id));
        return -1;
    }
    /* wake-up the router */
    if (router_thread >= 0)
        gwthread_wakeup(router_thread);
    return 0;
}

smsc2_resume()

void smsc2_resume

(

int

is_init

)

Definition at line 1234 of file bb_smscconn.c.

References smscconn::dead_start, gw_rwlock_rdlock(), gw_rwlock_unlock(), gwlist_get(), gwlist_len(), gwthread_wakeup(), router_thread, smsc_list, smsc_list_lock, smsc_running, smscconn_shutdown(), and smscconn_start().

Referenced by bb_resume(), and main().

{
    SMSCConn *conn;
    long i;

    if (!smsc_running)
        return;

    gw_rwlock_rdlock(&smsc_list_lock);
    for (i = 0; i < gwlist_len(smsc_list); i++) {
        conn = gwlist_get(smsc_list, i);
        if (!is_init || !conn->dead_start) {
            smscconn_start(conn);
        } else {
            /* Shutdown the connections that are not configured to start at boot */
            smscconn_shutdown(conn, 0);
        }
    }
    gw_rwlock_unlock(&smsc_list_lock);
    
    if (router_thread >= 0)
        gwthread_wakeup(router_thread);
}

smsc2_rout()

long smsc2_rout	(	Msg *	msg,
		int	resend
	)

Definition at line 1716 of file bb_smscconn.c.

References BB_SHUTDOWN, bb_smscconn_send_failed(), bb_status, black_list_receiver, black_list_receiver_regex, black_list_sender, black_list_sender_regex, debug(), error(), gw_rand(), gw_rwlock_rdlock(), gw_rwlock_unlock(), gwlist_get(), gwlist_len(), gwlist_produce(), gwlist_search_equal(), info(), smsc_state::load, max_outgoing_sms_qlength, msg, msg_destroy(), msg_duplicate(), normalize_number(), numhash_find_number(), octstr_create, octstr_get_cstr, outgoing_sms, smsc_state::queued, SMS_PARAM_UNDEFINED, smsc2_rout(), split_parts::smsc_conn, smsc_list, smsc_list_lock, SMSCCONN_ACTIVE, SMSCCONN_FAILED_DISCARDED, SMSCCONN_FAILED_EXPIRED, SMSCCONN_FAILED_QFULL, SMSCCONN_FAILED_REJECTED, smscconn_info(), SMSCCONN_QUEUED, smscconn_send(), SMSCCONN_SUCCESS, smscconn_usable(), smsc_state::status, unified_prefix, warning(), white_black_list_lock, white_list_receiver, white_list_receiver_regex, white_list_sender, and white_list_sender_regex.

Referenced by deliver_sms_to_queue(), route_incoming_to_smsc(), sms_router(), and smsc2_rout().

{
    StatusInfo stat;
    SMSCConn *conn, *best_preferred, *best_ok;
    long bp_load, bo_load;
    int i, s, ret, bad_found, full_found;
    long max_queue, queue_length;
    char *uf;

    /* XXX handle ack here? */
    if (msg_type(msg) != sms) {
        error(0, "Attempt to route non SMS message through smsc2_rout!");
        return SMSCCONN_FAILED_DISCARDED;
    }

    /* check if validity period has expired */
    if (msg->sms.validity != SMS_PARAM_UNDEFINED && time(NULL) > msg->sms.validity) {
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_EXPIRED, octstr_create("validity expired"));
        return SMSCCONN_FAILED_EXPIRED;
    }

    /* unify prefix of receiver, in case of it has not been
     * already done */
    uf = unified_prefix ? octstr_get_cstr(unified_prefix) : NULL;
    normalize_number(uf, &(msg->sms.receiver));

    /* check for white/back-listed sender/receiver */
    gw_rwlock_rdlock(&white_black_list_lock);
    if (white_list_sender && numhash_find_number(white_list_sender, msg->sms.sender) < 1) {
        gw_rwlock_unlock(&white_black_list_lock);
        info(0, "Number <%s> is not in white-list-sender, message rejected",
             octstr_get_cstr(msg->sms.sender));
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_REJECTED, octstr_create("sender not in white-list"));
        return SMSCCONN_FAILED_REJECTED;
    }

    if (white_list_sender_regex && gw_regex_match_pre(white_list_sender_regex, msg->sms.sender) == 0) {
        gw_rwlock_unlock(&white_black_list_lock);
        info(0, "Number <%s> is not in white-list-sender, message rejected",
             octstr_get_cstr(msg->sms.sender));
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_REJECTED, octstr_create("sender not in white-list"));
        return SMSCCONN_FAILED_REJECTED;
    }

    if (black_list_sender && numhash_find_number(black_list_sender, msg->sms.sender) == 1) {
        gw_rwlock_unlock(&white_black_list_lock);
        info(0, "Number <%s> is in black-list-sender, message rejected",
             octstr_get_cstr(msg->sms.sender));
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_REJECTED, octstr_create("sender in black-list"));
        return SMSCCONN_FAILED_REJECTED;
    }

    if (black_list_sender_regex && gw_regex_match_pre(black_list_sender_regex, msg->sms.sender) != 0) {
        gw_rwlock_unlock(&white_black_list_lock);
        info(0, "Number <%s> is in black-list-sender, message rejected",
             octstr_get_cstr(msg->sms.sender));
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_REJECTED, octstr_create("sender in black-list"));
        return SMSCCONN_FAILED_REJECTED;
    }

    if (white_list_receiver && numhash_find_number(white_list_receiver, msg->sms.receiver) < 1) {
        gw_rwlock_unlock(&white_black_list_lock);
        info(0, "Number <%s> is not in white-list-receiver, message rejected",
             octstr_get_cstr(msg->sms.receiver));
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_REJECTED, octstr_create("receiver not in white-list"));
        return SMSCCONN_FAILED_REJECTED;
    }

    if (white_list_receiver_regex && gw_regex_match_pre(white_list_receiver_regex, msg->sms.receiver) == 0) {
        gw_rwlock_unlock(&white_black_list_lock);
        info(0, "Number <%s> is not in white-list-receiver, message rejected",
             octstr_get_cstr(msg->sms.receiver));
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_REJECTED, octstr_create("receiver not in white-list"));
        return SMSCCONN_FAILED_REJECTED;
    }

    if (black_list_receiver && numhash_find_number(black_list_receiver, msg->sms.receiver) == 1) {
        gw_rwlock_unlock(&white_black_list_lock);
        info(0, "Number <%s> is in black-list-receiver, message rejected",
             octstr_get_cstr(msg->sms.receiver));
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_REJECTED, octstr_create("receiver in black-list"));
        return SMSCCONN_FAILED_REJECTED;
    }

    if (black_list_receiver_regex && gw_regex_match_pre(black_list_receiver_regex, msg->sms.receiver) != 0) {
        gw_rwlock_unlock(&white_black_list_lock);
        info(0, "Number <%s> is in black-list-receiver, message rejected",
             octstr_get_cstr(msg->sms.receiver));
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_REJECTED, octstr_create("receiver in black-list"));
        return SMSCCONN_FAILED_REJECTED;
    }
    gw_rwlock_unlock(&white_black_list_lock);

    /* select in which list to add this
     * start - from random SMSCConn, as they are all 'equal'
     */
    gw_rwlock_rdlock(&smsc_list_lock);
    if (gwlist_len(smsc_list) == 0) {
        warning(0, "No SMSCes to receive message");
        gw_rwlock_unlock(&smsc_list_lock);
        return SMSCCONN_FAILED_DISCARDED;
    }

    best_preferred = best_ok = NULL;
    bad_found = full_found = 0;
    bp_load = bo_load = queue_length = 0;

    if (msg->sms.split_parts == NULL) {
        /*
         * if global queue not empty then 20% reserved for old msgs
         * and 80% for new msgs. So we can guarantee that old msgs find
         * place in the SMSC's queue.
         */
        if (gwlist_len(outgoing_sms) > 0) {
            max_queue = (resend ? max_outgoing_sms_qlength :
            max_outgoing_sms_qlength * 0.8);
        } else
            max_queue = max_outgoing_sms_qlength;

        s = gw_rand() % gwlist_len(smsc_list);

        conn = NULL;
        for (i = 0; i < gwlist_len(smsc_list); i++) {
            conn = gwlist_get(smsc_list,  (i+s) % gwlist_len(smsc_list));

            smscconn_info(conn, &stat);
            queue_length += (stat.queued > 0 ? stat.queued : 0);

            ret = smscconn_usable(conn,msg);
            if (ret == -1)
                continue;

            /* if we already have a preferred one, skip non-preferred */
            if (ret != 1 && best_preferred)
                continue;

            /* If connection is not currently answering ... */
            if (stat.status != SMSCCONN_ACTIVE) {
                bad_found = 1;
                continue;
            }
            /* check queue length */
            if (stat.queued > max_queue) {
                full_found = 1;
                continue;
            }
            if (ret == 1) {          /* preferred */
                if (best_preferred == NULL || stat.load < bp_load) {
                    best_preferred = conn;
                    bp_load = stat.load;
                    continue;
                }
            }
            if (best_ok == NULL || stat.load < bo_load) {
                best_ok = conn;
                bo_load = stat.load;
            }
        }
        queue_length += gwlist_len(outgoing_sms);
        if (max_outgoing_sms_qlength > 0 && !resend &&
            queue_length > gwlist_len(smsc_list) * max_outgoing_sms_qlength) {
            gw_rwlock_unlock(&smsc_list_lock);
            debug("bb.sms", 0, "sum(#queues) limit");
            return SMSCCONN_FAILED_QFULL;
        }
    } else {
        struct split_parts *parts = msg->sms.split_parts;
        /* check whether this SMSCConn still on the list */
        if (gwlist_search_equal(smsc_list, parts->smsc_conn) != -1)
            best_preferred = parts->smsc_conn;
    }

    if (best_preferred)
        ret = smscconn_send(best_preferred, msg);
    else if (best_ok)
        ret = smscconn_send(best_ok, msg);
    else if (bad_found) {
        gw_rwlock_unlock(&smsc_list_lock);
        if (max_outgoing_sms_qlength < 0 || gwlist_len(outgoing_sms) < max_outgoing_sms_qlength) {
            gwlist_produce(outgoing_sms, msg);
            return SMSCCONN_QUEUED;
        }
        debug("bb.sms", 0, "bad_found queue full");
        return SMSCCONN_FAILED_QFULL; /* queue full */
    } else if (full_found) {
        gw_rwlock_unlock(&smsc_list_lock);
        debug("bb.sms", 0, "full_found queue full");
        return SMSCCONN_FAILED_QFULL;
    } else {
        gw_rwlock_unlock(&smsc_list_lock);
        if (bb_status == BB_SHUTDOWN) {
            msg_destroy(msg);
            return SMSCCONN_QUEUED;
        }
        warning(0, "Cannot find SMSCConn for message to <%s>, rejected.",
                    octstr_get_cstr(msg->sms.receiver));
        bb_smscconn_send_failed(NULL, msg_duplicate(msg), SMSCCONN_FAILED_DISCARDED, octstr_create("no SMSC"));
        return SMSCCONN_FAILED_DISCARDED;
    }

    gw_rwlock_unlock(&smsc_list_lock);
    /* check the status of sending operation */
    if (ret == -1)
        return smsc2_rout(msg, resend); /* re-try */

    msg_destroy(msg);
    return SMSCCONN_SUCCESS;
}

smsc2_shutdown()

int smsc2_shutdown

(

void

)

Definition at line 1276 of file bb_smscconn.c.

References concat_handling_shutdown(), gw_rwlock_rdlock(), gw_rwlock_unlock(), gwlist_get(), gwlist_len(), gwlist_remove_producer(), gwthread_wakeup(), incoming_sms, router_thread, smpp_pdu_shutdown(), smsc_list, smsc_list_lock, smsc_running, and smscconn_shutdown().

Referenced by bb_shutdown().

{
    SMSCConn *conn;
    long i;

    if (!smsc_running)
        return -1;

    /* stop concat handling */
    concat_handling_shutdown();

    /* Call shutdown for all SMSC Connections; they should
     * handle that they quit, by emptying queues and then dying off
     */
    gw_rwlock_rdlock(&smsc_list_lock);
    for(i=0; i < gwlist_len(smsc_list); i++) {
        conn = gwlist_get(smsc_list, i);
    smscconn_shutdown(conn, 1);
    }
    gw_rwlock_unlock(&smsc_list_lock);
    if (router_thread >= 0)
    gwthread_wakeup(router_thread);

    /* start avalanche by calling shutdown */

    /* XXX shouldn'w we be sure that all smsces have closed their
     * receive thingies? Is this guaranteed by setting bb_status
     * to shutdown before calling these?
     */
    gwlist_remove_producer(incoming_sms);

    /* shutdown low levele PDU things */
    smpp_pdu_shutdown();

    return 0;
}

smsc2_start()

int smsc2_start

(

Cfg *

config

)

Definition at line 806 of file bb_smscconn.c.

References black_list_receiver, black_list_receiver_regex, black_list_receiver_url, black_list_sender, black_list_sender_regex, black_list_sender_url, cfg, cfg_get, cfg_get_bool(), cfg_get_integer(), cfg_get_multi_group(), cfg_get_single_group(), cfg_reloaded, concat_handling_init(), concatenated_mo_timeout, counter_create(), gw_rwlock_init_static(), gwlist_add_producer(), gwlist_append(), gwlist_create, gwlist_get(), gwlist_len(), gwlist_remove_producer(), gwthread_create, handle_concatenated_mo, incoming_sms, info(), numhash_create(), octstr_destroy(), octstr_get_cstr, octstr_imm(), panic, router_thread, smpp_pdu_init(), sms_resend_frequency, sms_resend_retry, sms_router(), smsc_groups, smsc_list, smsc_list_lock, smsc_running, smscconn_create(), smscconn_instances(), split_msg_counter, unified_prefix, warning(), white_black_list_lock, white_list_receiver, white_list_receiver_regex, white_list_receiver_url, white_list_sender, white_list_sender_regex, and white_list_sender_url.

Referenced by start_smsc().

{
    CfgGroup *grp;
    SMSCConn *conn;
    Octstr *os;
    int i, j, m;

    if (smsc_running) return -1;

    /* at start-up time there is no reloaded config */
    cfg_reloaded = NULL;

    /* create split sms counter */
    split_msg_counter = counter_create();
    
    /* create smsc list and rwlock for it */
    smsc_list = gwlist_create();
    gw_rwlock_init_static(&smsc_list_lock);

    grp = cfg_get_single_group(cfg, octstr_imm("core"));
    unified_prefix = cfg_get(grp, octstr_imm("unified-prefix"));

    gw_rwlock_init_static(&white_black_list_lock);
    white_list_sender = black_list_sender = NULL;
    white_list_sender_url = black_list_sender_url = NULL;
    if ((white_list_sender_url = cfg_get(grp, octstr_imm("white-list"))) != NULL)   /* TODO deprecated, remove */
        warning(0, "Option 'white-list' is deprecated! Please use 'white-list-sender' instead!");
    else
        white_list_sender_url = cfg_get(grp, octstr_imm("white-list-sender"));
    if (white_list_sender_url != NULL) {
        if ((white_list_sender = numhash_create(octstr_get_cstr(white_list_sender_url))) == NULL)
            panic(0, "Could not get white-list at URL <%s>", 
                  octstr_get_cstr(white_list_sender_url));
    }
    if ((os = cfg_get(grp, octstr_imm("white-list-regex"))) != NULL)                /* TODO deprecated, remove */
        warning(0, "Option 'white-list-regex' is deprecated! Please use 'white-list-sender-regex' instead!");
    else
        os = cfg_get(grp, octstr_imm("white-list-sender-regex"));
    if (os != NULL) {
        if ((white_list_sender_regex = gw_regex_comp(os, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(os));
        octstr_destroy(os);
    }
    
    if ((black_list_sender_url = cfg_get(grp, octstr_imm("black-list"))) != NULL)   /* TODO deprecated, remove */
        warning(0, "Option 'black-list' is deprecated! Please use 'black-list-sender' instead!");
    else
        black_list_sender_url = cfg_get(grp, octstr_imm("black-list-sender"));
    if (black_list_sender_url != NULL) {
        if ((black_list_sender = numhash_create(octstr_get_cstr(black_list_sender_url))) == NULL)
            panic(0, "Could not get black-list at URL <%s>", 
                  octstr_get_cstr(black_list_sender_url));
    }
    if ((os = cfg_get(grp, octstr_imm("black-list-regex"))) != NULL)                /* TODO deprecated, remove */
        warning(0, "Option 'black-list-regex' is deprecated! Please use 'black-list-sender-regex' instead!");
    else
        os = cfg_get(grp, octstr_imm("black-list-sender-regex"));
    if (os != NULL) {
        if ((black_list_sender_regex = gw_regex_comp(os, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(os));
        octstr_destroy(os);
    }

    white_list_receiver = black_list_receiver = NULL;
    white_list_receiver_url = black_list_receiver_url = NULL;
    white_list_receiver_url = cfg_get(grp, octstr_imm("white-list-receiver"));
    if (white_list_receiver_url != NULL) {
        if ((white_list_receiver = numhash_create(octstr_get_cstr(white_list_receiver_url))) == NULL)
            panic(0, "Could not get white-list-receiver at URL <%s>",
                  octstr_get_cstr(white_list_receiver_url));
    }
    if ((os = cfg_get(grp, octstr_imm("white-list-receiver-regex"))) != NULL) {
        if ((white_list_receiver_regex = gw_regex_comp(os, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(os));
        octstr_destroy(os);
    }

    black_list_receiver_url = cfg_get(grp, octstr_imm("black-list-receiver"));
    if (black_list_receiver_url != NULL) {
        if ((black_list_receiver = numhash_create(octstr_get_cstr(black_list_receiver_url))) == NULL)
            panic(0, "Could not get black-list-receiver at URL <%s>",
                  octstr_get_cstr(black_list_receiver_url));
    }
    if ((os = cfg_get(grp, octstr_imm("black-list-receiver-regex"))) != NULL) {
        if ((black_list_receiver_regex = gw_regex_comp(os, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(os));
        octstr_destroy(os);
    }

    if (cfg_get_integer(&sms_resend_frequency, grp,
            octstr_imm("sms-resend-freq")) == -1 || sms_resend_frequency <= 0) {
        sms_resend_frequency = 60;
    }
    info(0, "Set SMS resend frequency to %ld seconds.", sms_resend_frequency);
            
    if (cfg_get_integer(&sms_resend_retry, grp, octstr_imm("sms-resend-retry")) == -1) {
        sms_resend_retry = -1;
        info(0, "SMS resend retry set to unlimited.");
    }
    else
        info(0, "SMS resend retry set to %ld.", sms_resend_retry);

    if (cfg_get_bool((int*)&handle_concatenated_mo, grp, octstr_imm("sms-combine-concatenated-mo")) == -1)
        handle_concatenated_mo = 1; /* default is TRUE. */

    if (cfg_get_integer(&concatenated_mo_timeout, grp, octstr_imm("sms-combine-concatenated-mo-timeout")) == -1)
        concatenated_mo_timeout = 1800;

    if (handle_concatenated_mo)
        concat_handling_init();

    /* initialize low level PDUs */
    if (smpp_pdu_init(cfg) == -1)
        panic(0, "Connot start with PDU init failed.");

    smsc_groups = cfg_get_multi_group(cfg, octstr_imm("smsc"));
    gwlist_add_producer(smsc_list);
    for (i = 0; i < gwlist_len(smsc_groups) && 
        (grp = gwlist_get(smsc_groups, i)) != NULL; i++) {
        /* multiple instances for the same group? */
        m = smscconn_instances(grp);
        for (j = 0; j < m; j++) {
            conn = smscconn_create(grp, 1);
            if (conn == NULL)
                panic(0, "Cannot start with SMSC connection failing");
            gwlist_append(smsc_list, conn);
        }
    }
    gwlist_remove_producer(smsc_list);
    
    if ((router_thread = gwthread_create(sms_router, NULL)) == -1)
    panic(0, "Failed to start a new thread for SMS routing");
    
    gwlist_add_producer(incoming_sms);
    smsc_running = 1;
    return 0;
}

smsc2_status()

Octstr* smsc2_status

(

int

status_type

)

Definition at line 1362 of file bb_smscconn.c.

References bb_status_linebreak(), BBSTATUS_HTML, BBSTATUS_TEXT, BBSTATUS_WML, BBSTATUS_XML, gw_rwlock_rdlock(), gw_rwlock_unlock(), gwlist_get(), gwlist_len(), smscconn::incoming_dlr_load, smscconn::incoming_sms_load, info(), load_get(), octstr_append(), octstr_append_cstr(), octstr_create, octstr_format(), octstr_format_append(), octstr_imm(), smscconn::outgoing_dlr_load, smscconn::outgoing_sms_load, smsc_list, smsc_list_lock, smsc_running, SMSCCONN_ACTIVE, SMSCCONN_ACTIVE_RECV, smscconn_admin_id(), SMSCCONN_CONNECTING, SMSCCONN_DEAD, SMSCCONN_DISCONNECTED, smscconn_id(), smscconn_info(), smscconn_name(), and SMSCCONN_RECONNECTING.

Referenced by bb_print_status().

{
    Octstr *tmp;
    char tmp3[64];
    char *lb;
    long i;
    int para = 0;
    SMSCConn *conn;
    StatusInfo info;
    const Octstr *conn_id = NULL;
    const Octstr *conn_admin_id = NULL;
    const Octstr *conn_name = NULL;
    float incoming_sms_load_0, incoming_sms_load_1, incoming_sms_load_2;
    float outgoing_sms_load_0, outgoing_sms_load_1, outgoing_sms_load_2;
    float incoming_dlr_load_0, incoming_dlr_load_1, incoming_dlr_load_2;
    float outgoing_dlr_load_0, outgoing_dlr_load_1, outgoing_dlr_load_2;

    if ((lb = bb_status_linebreak(status_type)) == NULL)
        return octstr_create("Un-supported format");

    if (status_type == BBSTATUS_HTML || status_type == BBSTATUS_WML)
        para = 1;

    if (!smsc_running) {
        if (status_type == BBSTATUS_XML)
            return octstr_create ("<smscs>\n\t<count>0</count>\n</smscs>");
        else
            return octstr_format("%sNo SMSC connections%s\n\n", para ? "<p>" : "",
                                 para ? "</p>" : "");
    }

    if (status_type != BBSTATUS_XML)
        tmp = octstr_format("%sSMSC connections:%s", para ? "<p>" : "", lb);
    else
        tmp = octstr_format("<smscs><count>%d</count>\n\t", gwlist_len(smsc_list));

    gw_rwlock_rdlock(&smsc_list_lock);
    for (i = 0; i < gwlist_len(smsc_list); i++) {
        incoming_sms_load_0 = incoming_sms_load_1 = incoming_sms_load_2 = 0.0;
        outgoing_sms_load_0 = outgoing_sms_load_1 = outgoing_sms_load_2 = 0.0;
        incoming_dlr_load_0 = incoming_dlr_load_1 = incoming_dlr_load_2 = 0.0;
        outgoing_dlr_load_0 = outgoing_dlr_load_1 = outgoing_dlr_load_2 = 0.0;
        conn = gwlist_get(smsc_list, i);

        if ((smscconn_info(conn, &info) == -1)) {
            /* 
             * we do not delete SMSCs from the list 
             * this way we can show in the status which links are dead
             */
            continue;
        }

        conn_id = conn ? smscconn_id(conn) : octstr_imm("unknown");
        conn_id = conn_id ? conn_id : octstr_imm("unknown");
        conn_admin_id = conn ? smscconn_admin_id(conn) : octstr_imm("unknown");
        conn_admin_id = conn_admin_id ? conn_admin_id : octstr_imm("unknown");
        conn_name = conn ? smscconn_name(conn) : octstr_imm("unknown");

        if (status_type == BBSTATUS_HTML) {
            octstr_append_cstr(tmp, "&nbsp;&nbsp;&nbsp;&nbsp;<b>");
            octstr_append(tmp, conn_id);
            octstr_append_cstr(tmp, "</b>[");
            octstr_append(tmp, conn_admin_id);
            octstr_append_cstr(tmp, "]&nbsp;&nbsp;&nbsp;&nbsp;");
        } else if (status_type == BBSTATUS_TEXT) {
            octstr_append_cstr(tmp, "    ");
            octstr_append(tmp, conn_id);
            octstr_append_cstr(tmp, "[");
            octstr_append(tmp, conn_admin_id);
            octstr_append_cstr(tmp, "]    ");
        } 
        if (status_type == BBSTATUS_XML) {
            octstr_append_cstr(tmp, "<smsc>\n\t\t<name>");
            octstr_append(tmp, conn_name);
            octstr_append_cstr(tmp, "</name>\n\t\t<admin-id>");
            octstr_append(tmp, conn_admin_id);
            octstr_append_cstr(tmp, "</admin-id>\n\t\t<id>");
            octstr_append(tmp, conn_id);
            octstr_append_cstr(tmp, "</id>\n\t\t");
        } else
            octstr_append(tmp, conn_name);

        switch (info.status) {
            case SMSCCONN_ACTIVE:
            case SMSCCONN_ACTIVE_RECV:
                sprintf(tmp3, "online %lds", info.online);
                incoming_sms_load_0 = load_get(conn->incoming_sms_load,0);
                incoming_sms_load_1 = load_get(conn->incoming_sms_load,1);
                incoming_sms_load_2 = load_get(conn->incoming_sms_load,2);
                outgoing_sms_load_0 = load_get(conn->outgoing_sms_load,0);
                outgoing_sms_load_1 = load_get(conn->outgoing_sms_load,1);
                outgoing_sms_load_2 = load_get(conn->outgoing_sms_load,2);
                incoming_dlr_load_0 = load_get(conn->incoming_dlr_load,0);
                incoming_dlr_load_1 = load_get(conn->incoming_dlr_load,1);
                incoming_dlr_load_2 = load_get(conn->incoming_dlr_load,2);
                outgoing_dlr_load_0 = load_get(conn->outgoing_dlr_load,0);
                outgoing_dlr_load_1 = load_get(conn->outgoing_dlr_load,1);
                outgoing_dlr_load_2 = load_get(conn->outgoing_dlr_load,2);
                break;
            case SMSCCONN_DISCONNECTED:
                sprintf(tmp3, "disconnected");
                break;
            case SMSCCONN_CONNECTING:
                sprintf(tmp3, "connecting");
                break;
            case SMSCCONN_RECONNECTING:
                sprintf(tmp3, "re-connecting");
                break;
            case SMSCCONN_DEAD:
                sprintf(tmp3, "dead");
                break;
            default:
                sprintf(tmp3, "unknown");
                break;
        }

        if (status_type == BBSTATUS_XML)
            octstr_format_append(tmp, "<status>%s</status>\n"
                "\t\t<failed>%ld</failed>\n"
                "\t\t<queued>%ld</queued>\n"
                "\t\t<sms>\n"
                "\t\t\t<received>%ld</received>\n"
                "\t\t\t<sent>%ld</sent>\n"
                "\t\t\t<inbound>%.2f,%.2f,%.2f</inbound>\n"
                "\t\t\t<outbound>%.2f,%.2f,%.2f</outbound>\n"
                "\t\t</sms>\n\t\t<dlr>\n"
                "\t\t\t<received>%ld</received>\n"
                "\t\t\t<sent>%ld</sent>\n"
                "\t\t\t<inbound>%.2f,%.2f,%.2f</inbound>\n"
                "\t\t\t<outbound>%.2f,%.2f,%.2f</outbound>\n"
                "\t\t</dlr>\n"
                "\t</smsc>\n", tmp3,
                info.failed, info.queued, info.received, info.sent,
                incoming_sms_load_0, incoming_sms_load_1, incoming_sms_load_2,
                outgoing_sms_load_0, outgoing_sms_load_1, outgoing_sms_load_2,
                info.received_dlr, info.sent_dlr,
                incoming_dlr_load_0, incoming_dlr_load_1, incoming_dlr_load_2,
                outgoing_dlr_load_0, outgoing_dlr_load_1, outgoing_dlr_load_2);
        else
            octstr_format_append(tmp, " (%s, rcvd: sms %ld (%.2f,%.2f,%.2f) / dlr %ld (%.2f,%.2f,%.2f), "
                "sent: sms %ld (%.2f,%.2f,%.2f) / dlr %ld (%.2f,%.2f,%.2f), failed %ld, "
                "queued %ld msgs)%s",
                tmp3,
                info.received,
                incoming_sms_load_0, incoming_sms_load_1, incoming_sms_load_2,
                info.received_dlr,
                incoming_dlr_load_0, incoming_dlr_load_1, incoming_dlr_load_2,
                info.sent,
                outgoing_sms_load_0, outgoing_sms_load_1, outgoing_sms_load_2,
                info.sent_dlr,
                outgoing_dlr_load_0, outgoing_dlr_load_1, outgoing_dlr_load_2,
                info.failed,
                info.queued,
                lb);
    }

    gw_rwlock_unlock(&smsc_list_lock);

    if (para)
        octstr_append_cstr(tmp, "</p>");
    if (status_type == BBSTATUS_XML)
        octstr_append_cstr(tmp, "</smscs>\n");
    else
        octstr_append_cstr(tmp, "\n\n");
    return tmp;
}

smsc2_stop_smsc()

int smsc2_stop_smsc

(

Octstr *

id

)

Definition at line 968 of file bb_smscconn.c.

References error(), gw_rwlock_rdlock(), gw_rwlock_unlock(), gwlist_get(), info(), octstr_get_cstr, smsc2_find(), smsc_list, smsc_list_lock, smsc_running, SMSCCONN_DEAD, smscconn_shutdown(), and smscconn_status().

Referenced by bb_stop_smsc().

{
    SMSCConn *conn;
    long i = -1;
    int success = 0;

    if (!smsc_running)
        return -1;

    gw_rwlock_rdlock(&smsc_list_lock);
    /* find the specific smsc via id */
    while((i = smsc2_find(id, ++i)) != -1) {
        conn = gwlist_get(smsc_list, i);
        if (conn != NULL && smscconn_status(conn) == SMSCCONN_DEAD) {
            info(0, "HTTP: Could not shutdown already dead smsc-id `%s'",
                octstr_get_cstr(id));
        } else {
            info(0,"HTTP: Shutting down smsc-id `%s'", octstr_get_cstr(id));
            smscconn_shutdown(conn, 1);   /* shutdown the smsc */
            success = 1;
        }
    }
    gw_rwlock_unlock(&smsc_list_lock);
    if (success == 0) {
        error(0, "SMSC %s not found", octstr_get_cstr(id));
        return -1;
    }
    return 0;
}

smsc2_suspend()

void smsc2_suspend

(

void

)

Definition at line 1259 of file bb_smscconn.c.

References gw_rwlock_rdlock(), gw_rwlock_unlock(), gwlist_get(), gwlist_len(), smsc_list, smsc_list_lock, smsc_running, and smscconn_stop().

Referenced by bb_isolate(), and bb_suspend().

{
    SMSCConn *conn;
    long i;

    if (!smsc_running)
        return;

    gw_rwlock_rdlock(&smsc_list_lock);
    for (i = 0; i < gwlist_len(smsc_list); i++) {
        conn = gwlist_get(smsc_list, i);
        smscconn_stop(conn);
    }
    gw_rwlock_unlock(&smsc_list_lock);
}

udp_addwdp()

int udp_addwdp

(

Msg *

msg

)

Definition at line 385 of file bb_udp.c.

References _udpc::addr, gwlist_get(), gwlist_len(), gwlist_lock(), gwlist_produce(), gwlist_unlock(), msg, octstr_compare(), octstr_destroy(), _udpc::outgoing_list, udp_get_ip(), udp_get_port(), udp_running, and udpc_list.

Referenced by wdp_router().

{
    int i;
    Udpc *udpc, *def_udpc;
    Octstr *ip;
    
    def_udpc = NULL;
    if (!udp_running) return -1;
    assert(msg != NULL);
    assert(msg_type(msg) == wdp_datagram);
    
    gwlist_lock(udpc_list);
    /* select in which list to add this */
    for (i=0; i < gwlist_len(udpc_list); i++) {
        udpc = gwlist_get(udpc_list, i);

        if (msg->wdp_datagram.source_port == udp_get_port(udpc->addr)) {
                    def_udpc = udpc;
                    ip = udp_get_ip(udpc->addr);
            if (octstr_compare(msg->wdp_datagram.source_address, ip) == 0) {
                        octstr_destroy(ip);
                gwlist_produce(udpc->outgoing_list, msg);
                gwlist_unlock(udpc_list);
                return 0;
            }
                    octstr_destroy(ip);
        }
    }

    if (NULL != def_udpc) {
    gwlist_produce(def_udpc->outgoing_list, msg);
    gwlist_unlock(udpc_list);
    return 0;
    }

    gwlist_unlock(udpc_list);
    return -1;
}

udp_die()

int udp_die

(

void

)

Definition at line 434 of file bb_udp.c.

References allow_ip, debug(), deny_ip, gwlist_consume(), gwlist_destroy(), gwlist_remove_producer(), octstr_destroy(), _udpc::outgoing_list, udp_running, and udpc_list.

Referenced by wdp_router().

{
    Udpc *udpc;

    if (!udp_running) return -1;
    
    /*
     * remove producers from all outgoing lists.
     */
    debug("bb.udp", 0, "udp_die: removing producers from udp-lists");

    while((udpc = gwlist_consume(udpc_list)) != NULL) {
    gwlist_remove_producer(udpc->outgoing_list);
    }
    gwlist_destroy(udpc_list, NULL);
    udp_running = 0;
    
    octstr_destroy(allow_ip);
    octstr_destroy(deny_ip);
    allow_ip = NULL;
    deny_ip = NULL;
    
    return 0;
}

udp_outgoing_queue()

int udp_outgoing_queue

(

void

)

Definition at line 460 of file bb_udp.c.

References gwlist_get(), gwlist_len(), gwlist_lock(), gwlist_unlock(), _udpc::outgoing_list, udp_running, and udpc_list.

Referenced by bb_print_status().

{
    int i, q = 0;
    Udpc *udpc;

    if (!udp_running || udpc_list == NULL)
    return 0;

    gwlist_lock(udpc_list);
    for (i=0; i < gwlist_len(udpc_list); i++) {
    udpc = gwlist_get(udpc_list, i);
    q += gwlist_len(udpc->outgoing_list);
    }
    gwlist_unlock(udpc_list);
    return q;
}

udp_shutdown()

int udp_shutdown

(

void

)

Definition at line 424 of file bb_udp.c.

References debug(), gwlist_remove_producer(), incoming_wdp, and udp_running.

Referenced by bb_shutdown().

{
    if (!udp_running) return -1;

    debug("bb.thread", 0, "udp_shutdown: Starting avalanche");
    gwlist_remove_producer(incoming_wdp);
    return 0;
}

udp_start()

int udp_start

(

Cfg *

config

)

Definition at line 323 of file bb_udp.c.

References add_service(), allow_ip, cfg, cfg_get, cfg_get_single_group(), debug(), deny_ip, error(), gwlist_add_producer(), gwlist_create, gwlist_destroy(), gwlist_extract_first(), gwlist_len(), incoming_wdp, info(), octstr_destroy(), octstr_get_cstr, octstr_imm(), octstr_split(), udp_running, and udpc_list.

Referenced by start_udp().

{
    CfgGroup *grp;
    Octstr *iface;
    List *ifs;
    int allow_wtls;
    
    if (udp_running) return -1;
    
    debug("bb.udp", 0, "starting UDP sender/receiver module");

    grp = cfg_get_single_group(cfg, octstr_imm("core"));
    iface = cfg_get(grp, octstr_imm("wdp-interface-name"));
    if (iface == NULL) {
        error(0, "Missing wdp-interface-name variable, cannot start UDP");
        return -1;
    }

    allow_ip = cfg_get(grp, octstr_imm("udp-allow-ip"));
    deny_ip = cfg_get(grp, octstr_imm("udp-deny-ip"));

    /*  we'll activate WTLS as soon as we have a 'wtls' config group */
    grp = cfg_get_single_group(cfg, octstr_imm("wtls"));
    allow_wtls = grp != NULL ? 1 : 0;

    udpc_list = gwlist_create();    /* have a list of running systems */

    ifs = octstr_split(iface, octstr_imm(";"));
    octstr_destroy(iface);
    while (gwlist_len(ifs) > 0) {
        iface = gwlist_extract_first(ifs);
    info(0, "Adding interface %s", octstr_get_cstr(iface));
        add_service(9200, octstr_get_cstr(iface));   /* wsp     */
        add_service(9201, octstr_get_cstr(iface));   /* wsp/wtp */
    
#ifdef HAVE_WTLS_OPENSSL
        if (allow_wtls) {
             add_service(9202, octstr_get_cstr(iface));   /* wsp/wtls   */
             add_service(9203, octstr_get_cstr(iface));   /* wsp/wtp/wtls */
        }
#else
        if (allow_wtls)
             error(0, "These is a 'wtls' group in configuration, but no WTLS support compiled in!");
#endif
    /* add_service(9204, octstr_get_cstr(interface_name));  * vcard */
    /* add_service(9205, octstr_get_cstr(interface_name));  * vcal  */
    /* add_service(9206, octstr_get_cstr(interface_name));  * vcard/wtls */
    /* add_service(9207, octstr_get_cstr(interface_name));  * vcal/wtls */
        octstr_destroy(iface);
    }
    gwlist_destroy(ifs, NULL);
    
    gwlist_add_producer(incoming_wdp);
    udp_running = 1;
    return 0;
}

wapbox_start()

int wapbox_start

(

Cfg *

config

)

Definition at line 1339 of file bb_boxc.c.

References box_allow_ip, box_deny_ip, boxid, cfg, cfg_get, cfg_get_bool(), cfg_get_integer(), cfg_get_single_group(), counter_create(), debug(), error(), gwlist_add_producer(), gwlist_create, gwthread_create, info(), octstr_create, octstr_imm(), outgoing_wdp, panic, wapbox_list, wapbox_port, wapbox_port_ssl, wapbox_running, wapboxc_run(), and wdp_to_wapboxes().

Referenced by start_wap().

{
    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 */

    if (box_allow_ip == NULL) {
        box_allow_ip = cfg_get(grp, octstr_imm("box-allow-ip"));
        if (box_allow_ip == NULL)
            box_allow_ip = octstr_create("");
    }
    if (box_deny_ip == NULL) {
        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;
}