smscconn_p.h File Reference

#include <signal.h>
#include "gwlib/gwlib.h"
#include "gwlib/gw-regex.h"
#include "smscconn.h"
#include "load.h"

Go to the source code of this file.

Data Structures
struct	smscconn
struct	pattern_route

Typedefs
typedef struct pattern_route	pattern_route

Functions
int	smsc_wrapper_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_fake_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_cimd2_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_emi2_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_http_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_smpp_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_cgw_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_at2_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_smasi_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_oisd_create (SMSCConn *conn, CfgGroup *cfg)
int	smsc_loopback_create (SMSCConn *conn, CfgGroup *cfg)

Typedef Documentation

pattern_route

typedef struct pattern_route pattern_route

Function Documentation

smsc_at2_create()

int smsc_at2_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 1519 of file smsc_at.c.

References at2_add_msg_cb(), AT2_DEFAULT_SMS_POLL_INTERVAL, at2_device_thread(), at2_queued_cb(), at2_read_modems(), at2_shutdown_cb(), at2_start_cb(), cfg, cfg_get, cfg_get_bool(), cfg_get_configfile(), cfg_get_integer(), privdata::conn, smscconn::connect_time, smscconn::data, error(), gw_prioqueue_create(), gw_prioqueue_destroy(), gwlist_create, gwthread_create, info(), privdata::keepalive, load_add_interval(), load_create_real(), privdata::my_number, privdata::name, smscconn::name, O_DESTROY, octstr_compare(), octstr_create, octstr_duplicate, octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), octstr_str_compare(), privdata::outgoing_queue, privdata::password, smscconn::queued, smscconn::send_msg, privdata::shutdown, smscconn::shutdown, sms_priority_compare(), SMSCCONN_CONNECTING, SMSCCONN_DEAD, SMSCCONN_KILLED_CANNOT_CONNECT, smscconn::start_conn, smscconn::status, privdata::username, privdata::validityperiod, and smscconn::why_killed.

Referenced by smscconn_create().

{
    PrivAT2data *privdata;
    Octstr *modem_type_string;
    long portno;   /* has to be long because of cfg_get_integer */

    privdata = gw_malloc(sizeof(PrivAT2data));
    memset(privdata, 0, sizeof(PrivAT2data));
    privdata->outgoing_queue = gw_prioqueue_create(sms_priority_compare);
    privdata->pending_incoming_messages = gwlist_create();

    privdata->configfile = cfg_get_configfile(cfg);

    privdata->device = cfg_get(cfg, octstr_imm("device"));
    if (privdata->device == NULL) {
        error(0, "AT2[-]: 'device' missing in at2 configuration.");
        goto error;
    }
    
    if (octstr_str_compare(privdata->device, "rawtcp") == 0) {
        privdata->rawtcp_host = cfg_get(cfg, octstr_imm("host"));
        if (privdata->rawtcp_host == NULL) {
            error(0, "AT2[-]: 'host' missing in at2 rawtcp configuration.");
            goto error;
        }
        if (cfg_get_integer(&portno, cfg, octstr_imm("port")) == -1) {
            error(0, "AT2[-]: 'port' missing in at2 rawtcp configuration.");
            goto error;
        }
        privdata->rawtcp_port = portno;
        privdata->is_serial = 0;
        privdata->use_telnet = 0;
    } else if (octstr_str_compare(privdata->device, "telnet") == 0) {
        privdata->rawtcp_host = cfg_get(cfg, octstr_imm("host"));
        if (privdata->rawtcp_host == NULL) {
            error(0, "AT2[-]: 'host' missing in at2 telnet configuration.");
            goto error;
        }
        if (cfg_get_integer(&portno, cfg, octstr_imm("port")) == -1) {
            error(0, "AT2[-]: 'port' missing in at2 telnet configuration.");
            goto error;
        }
        privdata->rawtcp_port = portno;
        privdata->is_serial = 0;
        privdata->use_telnet = 1;
    } else {
        privdata->is_serial = 1;
        privdata->use_telnet = 0;
    }

    privdata->name = cfg_get(cfg, octstr_imm("smsc-id"));
    if (privdata->name == NULL) {
        privdata->name = octstr_duplicate(privdata->device);
    }

    privdata->speed = 0;
    cfg_get_integer(&privdata->speed, cfg, octstr_imm("speed"));

    privdata->keepalive = 0;
    cfg_get_integer(&privdata->keepalive, cfg, octstr_imm("keepalive"));

    cfg_get_bool(&privdata->sms_memory_poll_interval, cfg, octstr_imm("sim-buffering"));
    if (privdata->sms_memory_poll_interval) {
        if (privdata->keepalive)
            privdata->sms_memory_poll_interval = privdata->keepalive;
        else
            privdata->sms_memory_poll_interval = AT2_DEFAULT_SMS_POLL_INTERVAL;
    }

    privdata->my_number       = cfg_get(cfg, octstr_imm("my-number"));
    privdata->sms_center      = cfg_get(cfg, octstr_imm("sms-center"));
    privdata->username        = cfg_get(cfg, octstr_imm("smsc-username"));
    privdata->password        = cfg_get(cfg, octstr_imm("smsc-password"));
    privdata->login_prompt    = cfg_get(cfg, octstr_imm("login-prompt"));
    privdata->password_prompt = cfg_get(cfg, octstr_imm("password-prompt"));
    modem_type_string = cfg_get(cfg, octstr_imm("modemtype"));

    privdata->modem = NULL;

    if (modem_type_string != NULL) {
        if (octstr_compare(modem_type_string, octstr_imm("auto")) == 0 ||
            octstr_compare(modem_type_string, octstr_imm("autodetect")) == 0)
            O_DESTROY(modem_type_string);
    }

    if (octstr_len(modem_type_string) == 0) {
        info(0, "AT2[%s]: configuration doesn't show modemtype. will autodetect",
             octstr_get_cstr(privdata->name));
    } else {
        info(0, "AT2[%s]: configuration shows modemtype <%s>",
             octstr_get_cstr(privdata->name),
             octstr_get_cstr(modem_type_string));
        privdata->modem = at2_read_modems(privdata, privdata->configfile,
                                          modem_type_string, 0);
        if (privdata->modem == NULL) {
            info(0, "AT2[%s]: modemtype not found, revert to autodetect",
                 octstr_get_cstr(privdata->name));
        } else {
            info(0, "AT2[%s]: read modem definition for <%s>",
                 octstr_get_cstr(privdata->name),
                 octstr_get_cstr(privdata->modem->name));
        }
        O_DESTROY(modem_type_string);
    }

    privdata->ilb = octstr_create("");
    privdata->fd = -1;
    privdata->lines = NULL;
    privdata->pin = cfg_get(cfg, octstr_imm("pin"));
    privdata->pin_ready = 0;
    privdata->conn = conn;
    privdata->phase2plus = 0;
    privdata->validityperiod = cfg_get(cfg, octstr_imm("validityperiod"));
    if (cfg_get_integer((long *) &privdata->max_error_count,  cfg, octstr_imm("max-error-count")) == -1)
        privdata->max_error_count = -1;

    privdata->load = load_create_real(0);
    load_add_interval(privdata->load, 1);

    conn->data = privdata;
    conn->name = octstr_format("AT2[%s]", octstr_get_cstr(privdata->name));
    conn->status = SMSCCONN_CONNECTING;
    conn->connect_time = time(NULL);

    privdata->shutdown = 0;

    if ((privdata->device_thread = gwthread_create(at2_device_thread, conn)) == -1) {
        privdata->shutdown = 1;
        goto error;
    }

    conn->shutdown = at2_shutdown_cb;
    conn->queued = at2_queued_cb;
    conn->start_conn = at2_start_cb;
    conn->send_msg = at2_add_msg_cb;
    return 0;

error:
    error(0, "AT2[%s]: Failed to create at2 smsc connection",
          octstr_len(privdata->name) ? octstr_get_cstr(privdata->name) : "");
    if (privdata != NULL) {
        gw_prioqueue_destroy(privdata->outgoing_queue, NULL);
    }
    gw_free(privdata);
    conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
    conn->status = SMSCCONN_DEAD;
    info(0, "AT2[%s]: exiting", octstr_get_cstr(privdata->name));
    return -1;
}

smsc_cgw_create()

int smsc_cgw_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 431 of file smsc_cgw.c.

References allow_ip, privdata::allow_ip, privdata::appname, cfg, cfg_get, cfg_get_integer(), cgw_add_msg_cb(), CGW_DEFPORT, cgw_listener(), cgw_open_listening_socket(), cgw_queued_cb(), cgw_sender(), cgw_shutdown_cb(), cgw_start_cb(), CGW_TRN_MAX, privdata::check_time, smscconn::connect_time, smscconn::data, deny_ip, privdata::deny_ip, privdata::dlr, error(), gwlist_create, gwlist_destroy(), gwthread_create, host, privdata::host, info(), privdata::listening_socket, smscconn::name, privdata::nexttrn, octstr_create, octstr_destroy(), octstr_format(), octstr_imm(), our_port, privdata::our_port, privdata::outgoing_queue, privdata::port, smscconn::queued, privdata::receiver_thread, privdata::rport, smscconn::send_msg, privdata::sender_thread, privdata::sendtime, privdata::shutdown, smscconn::shutdown, SMSCCONN_CONNECTING, SMSCCONN_DEAD, SMSCCONN_KILLED_CANNOT_CONNECT, smscconn::start_conn, smscconn::status, privdata::waitack, and smscconn::why_killed.

Referenced by smscconn_create().

{
    PrivData *privdata;
    Octstr *allow_ip, *deny_ip, *host, *appname;
    long portno, our_port, waitack;
    int i;

    privdata = gw_malloc(sizeof(PrivData));
    privdata->outgoing_queue = gwlist_create();
    privdata->listening_socket = -1;

    if (cfg_get_integer(&portno, cfg, octstr_imm("port")) == -1)
        portno = 0;
    privdata->port = portno;

    if (cfg_get_integer(&portno, cfg, octstr_imm("receive-port")) < 0)
        portno = 0;
    privdata->rport = portno;

    host = cfg_get(cfg, octstr_imm("host"));
    appname = cfg_get(cfg, octstr_imm("appname"));

    if (cfg_get_integer(&our_port, cfg, octstr_imm("our-port")) == -1)
        privdata->our_port = 0;     /* 0 means use any port */
    else
        privdata->our_port = our_port;

    allow_ip = cfg_get(cfg, octstr_imm("connect-allow-ip"));
    if (allow_ip)
        deny_ip = octstr_create("*.*.*.*");
    else
        deny_ip = NULL;

    if (cfg_get_integer(&waitack, cfg, octstr_imm("wait-ack")) < 0)
        privdata->waitack = 60;
    else
        privdata->waitack = waitack;

    if (privdata->port <= 0 || privdata->port > 65535) {
        info(1, "No port defined for cgw -> using default (%d)", CGW_DEFPORT);
        privdata->port = CGW_DEFPORT;
    }


    if (host == NULL) {
        error(0, "'host' missing in cgw configuration.");
        goto error;
    }

    if (appname == NULL)
        appname = octstr_create("send");

    privdata->allow_ip = allow_ip;
    privdata->deny_ip = deny_ip;
    privdata->host = host;
    privdata->appname = appname;
    privdata->nexttrn = 0;
    privdata->check_time = 0;

    for (i = 0; i < CGW_TRN_MAX; i++) {
        privdata->sendtime[i] = 0;
        privdata->dlr[i] = 0;
    }

    if (privdata->rport > 0 && cgw_open_listening_socket(conn,privdata) < 0) {
        gw_free(privdata);
        privdata = NULL;
        goto error;
    }


    conn->data = privdata;

    conn->name = octstr_format("CGW:%d", privdata->port);

    privdata->shutdown = 0;

    conn->status = SMSCCONN_CONNECTING;
    conn->connect_time = time(NULL);

    if (privdata->rport > 0 && (privdata->receiver_thread = gwthread_create(cgw_listener, conn)) == -1)
        goto error;

    if ((privdata->sender_thread = gwthread_create(cgw_sender, conn)) == -1) {
        privdata->shutdown = 1;
        goto error;
    }

    conn->shutdown = cgw_shutdown_cb;
    conn->queued = cgw_queued_cb;
    conn->start_conn = cgw_start_cb;
    conn->send_msg = cgw_add_msg_cb;

    return 0;

error:
    error(0, "Failed to create CGW smsc connection");
    if (privdata != NULL)
        gwlist_destroy(privdata->outgoing_queue, NULL);

    gw_free(privdata);
    octstr_destroy(host);
    octstr_destroy(allow_ip);
    octstr_destroy(deny_ip);
    octstr_destroy(appname);

    conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
    conn->status = SMSCCONN_DEAD;
    info(0, "exiting");
    return -1;
}

smsc_cimd2_create()

int smsc_cimd2_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 2321 of file smsc_cimd2.c.

References cfg_get, cfg_get_bool(), cfg_get_integer(), cimd2_add_msg_cb(), cimd2_destroy(), cimd2_queued_cb(), cimd2_shutdown_cb(), cimd2_start_cb(), cimd2_stop_cb(), privdata::conn, smscconn::data, debug(), error(), gwlist_add_producer(), gwlist_create, gwthread_create, gwthread_join(), gwthread_wakeup(), privdata::host, smscconn::id, privdata::inbuffer, privdata::io_thread, io_thread(), smscconn::is_stopped, privdata::keepalive, maxlen, privdata::my_number, smscconn::name, privdata::next_ping, privdata::no_dlr, octstr_create, octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), octstr_truncate(), ok, privdata::our_port, privdata::outgoing_queue, P_PASSWORD, P_USER_IDENTITY, parm_maxlen(), privdata::password, privdata::port, smscconn::queued, privdata::quitting, privdata::receive_seq, privdata::received, smscconn::send_msg, privdata::send_seq, smscconn::shutdown, privdata::socket, smscconn::start_conn, smscconn::stop_conn, privdata::stopped, privdata::username, and warning().

Referenced by smscconn_create().

{
    PrivData *pdata;
    int ok;
    int maxlen;

    pdata = gw_malloc(sizeof(PrivData));
    conn->data = pdata;
    pdata->conn = conn;
   
    pdata->no_dlr = 0;
    pdata->quitting = 0;
    pdata->socket = -1;
    pdata->received = gwlist_create();
    pdata->inbuffer = octstr_create("");
    pdata->send_seq = 1;
    pdata->receive_seq = 0;
    pdata->outgoing_queue = gwlist_create();
    pdata->stopped = gwlist_create();
    gwlist_add_producer(pdata->outgoing_queue);

    if (conn->is_stopped)
      gwlist_add_producer(pdata->stopped);

    pdata->host = cfg_get(grp, octstr_imm("host"));
    if (cfg_get_integer(&(pdata->port), grp, octstr_imm("port")) == -1)
      pdata->port = 0;
    if (cfg_get_integer(&(pdata->our_port), grp, octstr_imm("our-port")) == -1)
      pdata->our_port = 0;
    pdata->username = cfg_get(grp, octstr_imm("smsc-username"));
    pdata->password = cfg_get(grp, octstr_imm("smsc-password"));
    pdata->my_number = cfg_get(grp, octstr_imm("my-number"));
    if (cfg_get_integer(&(pdata->keepalive), grp,octstr_imm("keepalive")) == -1)
        pdata->keepalive = 0;

    cfg_get_bool(&pdata->no_dlr, grp, octstr_imm("no-dlr"));
    
    /* Check that config is OK */
    ok = 1;
    if (pdata->host == NULL) {
        error(0,"CIMD2[%s]: Configuration file doesn't specify host",
              octstr_get_cstr(conn->id));
        ok = 0;
    }
    if (pdata->port == 0) {
        error(0,"CIMD2[%s]: Configuration file doesn't specify port",
              octstr_get_cstr(conn->id));
        ok = 0;
    }
    if (pdata->username == NULL) {
        error(0, "CIMD2[%s]: Configuration file doesn't specify username.",
              octstr_get_cstr(conn->id));
        ok = 0;
    }
    if (pdata->password == NULL) {
        error(0, "CIMD2[%s]: Configuration file doesn't specify password.",
              octstr_get_cstr(conn->id));
        ok = 0;
    }

    if (!ok) {
        cimd2_destroy(pdata);
        return -1;
    }

    conn->name = octstr_format("CIMD2:%s:%d:%s",
                     octstr_get_cstr(pdata->host),
                     pdata->port,
                     octstr_get_cstr(pdata->username));


    if (pdata->keepalive > 0) {
      debug("bb.sms.cimd2", 0, "CIMD2[%s]: Keepalive set to %ld seconds", 
            octstr_get_cstr(conn->id),
            pdata->keepalive);
        pdata->next_ping = time(NULL) + pdata->keepalive;
    }

    maxlen = parm_maxlen(P_USER_IDENTITY);
    if (octstr_len(pdata->username) > maxlen) {
        octstr_truncate(pdata->username, maxlen);
        warning(0, "CIMD2[%s]: Truncating username to %d chars", 
                octstr_get_cstr(conn->id),
                maxlen);
    }

    maxlen = parm_maxlen(P_PASSWORD);
    if (octstr_len(pdata->password) > maxlen) {
        octstr_truncate(pdata->password, maxlen);
        warning(0, "CIMD2[%s]: Truncating password to %d chars", 
                octstr_get_cstr(conn->id),
                maxlen);
    }

    pdata->io_thread = gwthread_create(io_thread, conn);

    if (pdata->io_thread == -1) {  

        error(0,"CIMD2[%s]: Couldn't start I/O thread.",
              octstr_get_cstr(conn->id));
        pdata->quitting = 1;
        gwthread_wakeup(pdata->io_thread);
        gwthread_join(pdata->io_thread);
        cimd2_destroy(pdata);
        return -1;  
    } 

    conn->send_msg = cimd2_add_msg_cb;
    conn->shutdown = cimd2_shutdown_cb;
    conn->queued = cimd2_queued_cb;
    conn->start_conn = cimd2_start_cb;
    conn->stop_conn = cimd2_stop_cb;

    return 0;
}

smsc_emi2_create()

int smsc_emi2_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 1629 of file smsc_emi.c.

References add_msg_cb(), allow_ip, privdata::allow_ip, alt_charset, privdata::alt_charset, privdata::alt_host, privdata::alt_port, privdata::can_write, cfg, cfg_get, cfg_get_integer(), privdata::check_time, smscconn::connect_time, smscconn::data, deny_ip, privdata::deny_ip, emi2_listener(), EMI2_MAX_TRN, emi2_open_listening_socket(), emi2_sender(), error(), privdata::flowcontrol, gw_prioqueue_create(), gw_prioqueue_destroy(), gwthread_create, gwthread_join(), gwthread_wakeup(), host, privdata::host, privdata::idle_timeout, info(), privdata::keepalive, privdata::last_activity_time, privdata::listening_socket, privdata::my_number, privdata::nadc, privdata::name, smscconn::name, privdata::npid, octstr_append(), octstr_append_char(), octstr_append_decimal(), octstr_create, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), smscconn::our_host, our_port, privdata::our_port, privdata::outgoing_queue, privdata::password, privdata::port, privdata::priv_nexttrn, smscconn::queued, queued_cb(), privdata::receiver_thread, privdata::rport, smscconn::send_msg, privdata::sender_thread, privdata::sendtime, privdata::shutdown, smscconn::shutdown, shutdown_cb(), privdata::slots, sms_priority_compare(), SMSCCONN_CONNECTING, SMSCCONN_DEAD, SMSCCONN_KILLED_CANNOT_CONNECT, start_cb(), smscconn::start_conn, smscconn::status, privdata::unacked, privdata::username, privdata::waitack, privdata::waitack_expire, warning(), smscconn::why_killed, and privdata::window.

Referenced by smscconn_create().

{
    PrivData *privdata;
    Octstr *allow_ip, *deny_ip, *host, *alt_host;
    long portno, our_port, keepalive, flowcontrol, waitack, 
         idle_timeout, alt_portno, alt_charset, waitack_expire;
    long window;
        /* has to be long because of cfg_get_integer */
    int i;

    allow_ip = deny_ip = host = alt_host = NULL; 

    privdata = gw_malloc(sizeof(PrivData));
    privdata->outgoing_queue = gw_prioqueue_create(sms_priority_compare);
    privdata->listening_socket = -1;
    privdata->can_write = 1;
    privdata->priv_nexttrn = 0;
    privdata->last_activity_time = 0;
    privdata->check_time = 0;

    /* host may be empty if receive-port is used */
    host = cfg_get(cfg, octstr_imm("host"));
    privdata->host = host;

    if (cfg_get_integer(&portno, cfg, octstr_imm("port")) == -1)
        portno = 0;
    privdata->port = portno;
    if (host && (privdata->port <= 0 || privdata->port > 65535)) {
        error(0, "EMI2[%s]: 'port' missing/invalid in emi2 configuration.",
              octstr_get_cstr(host));
        goto error;
    }

    if (cfg_get_integer(&our_port, cfg, octstr_imm("our-port")) == -1)
        privdata->our_port = 0; /* 0 means use any port */
    else
        privdata->our_port = our_port;

    privdata->name = cfg_get(cfg, octstr_imm("smsc-id"));
    if (privdata->name == NULL) {
        privdata->name = octstr_create("");

        /* Add our_host */
        if (octstr_len(conn->our_host)) {
            octstr_append(privdata->name, conn->our_host);
        }

        /* Add our_port */
        if (privdata->our_port != 0) {
            /* if we have our_port but not our_host, add kannel:our_port */
            if(octstr_len(privdata->name) == 0) {
                octstr_append(privdata->name, octstr_imm("kannel"));
            }
            octstr_append_char(privdata->name, ':');
            octstr_append_decimal(privdata->name, privdata->our_port);
        } else {
            if(octstr_len(privdata->name) != 0) {
                octstr_append(privdata->name, octstr_imm(":*"));
            }
        }
        
        /* if we have our_host neither our_port */
        if (octstr_len(privdata->name) != 0)
            octstr_append(privdata->name, octstr_imm("->"));

        if (privdata->host) {
            octstr_append(privdata->name, privdata->host);
            octstr_append_char(privdata->name, ':');
            octstr_append_decimal(privdata->name, privdata->port);
        }
    }

    if (cfg_get_integer(&idle_timeout, cfg, octstr_imm("idle-timeout")) == -1)
        idle_timeout = 0;
    
    privdata->idle_timeout = idle_timeout;

    alt_host = cfg_get(cfg, octstr_imm("alt-host"));
    privdata->alt_host = alt_host;

    if (cfg_get_integer(&portno, cfg, octstr_imm("receive-port")) < 0)
        portno = 0;
    privdata->rport = portno;

    /* if neither host, nor receive-port is defined */
    if (privdata->host == NULL && privdata->rport == 0) {
        error(0, "EMI2[-]: 'receive-port' missing/invalid in emi2 configuration, "
                 "while no 'host' and 'port' defined.");
        goto error;
    }

    if (cfg_get_integer(&alt_portno, cfg, octstr_imm("alt-port")) < 0) 
        alt_portno = 0;
    privdata->alt_port = alt_portno;

    allow_ip = cfg_get(cfg, octstr_imm("connect-allow-ip"));
    if (allow_ip)
        deny_ip = octstr_create("*.*.*.*");
    else
        deny_ip = NULL;
    privdata->username = cfg_get(cfg, octstr_imm("smsc-username"));
    privdata->password = cfg_get(cfg, octstr_imm("smsc-password"));

    privdata->my_number = cfg_get(cfg, octstr_imm("my-number"));

    privdata->npid = cfg_get(cfg, octstr_imm("notification-pid"));
    privdata->nadc = cfg_get(cfg, octstr_imm("notification-addr"));
    
    if ( (privdata->username == NULL && privdata->my_number == NULL) ||
            cfg_get_integer(&keepalive, cfg, octstr_imm("keepalive")) < 0)
        privdata->keepalive = 0;
    else
        privdata->keepalive = keepalive;

    if (cfg_get_integer(&flowcontrol, cfg, octstr_imm("flow-control")) < 0)
        privdata->flowcontrol = 0;
    else
        privdata->flowcontrol = flowcontrol;
    if (privdata->flowcontrol < 0 || privdata->flowcontrol > 1) {
        error(0, "EMI2[%s]: 'flow-control' invalid in emi2 configuration.",
              octstr_get_cstr(privdata->name));
        goto error;
    }

    if (cfg_get_integer(&window, cfg, octstr_imm("window")) < 0)
        privdata->window = EMI2_MAX_TRN;
    else
        privdata->window = window;
    if (privdata->window > EMI2_MAX_TRN) {
        warning(0, "EMI2[%s]: Value of 'window' should be lesser or equal to %d..",
                octstr_get_cstr(privdata->name), EMI2_MAX_TRN);
        privdata->window = EMI2_MAX_TRN;
    }

    if (cfg_get_integer(&waitack, cfg, octstr_imm("wait-ack")) < 0)
        privdata->waitack = 60;
    else
        privdata->waitack = waitack;
    if (privdata->waitack < 30 ) {
        error(0, "EMI2[%s]: 'wait-ack' invalid in emi2 configuration.",
              octstr_get_cstr(privdata->name));
        goto error;
    }

    if (cfg_get_integer(&waitack_expire, cfg, octstr_imm("wait-ack-expire")) < 0)
        privdata->waitack_expire = 0;
    else
        privdata->waitack_expire = waitack_expire;
    if (privdata->waitack_expire >3) {
        error(0, "EMI2[%s]: 'wait-ack-expire' invalid in emi2 configuration.",
              octstr_get_cstr(privdata->name));
        goto error;
    }

    if (privdata->rport < 0 || privdata->rport > 65535) {
        error(0, "EMI2[%s]: 'receive-port' missing/invalid in emi2 configuration.",
              octstr_get_cstr(privdata->name));
        goto error;
    }

    if (cfg_get_integer(&alt_charset, cfg, octstr_imm("alt-charset")) < 0)
        privdata->alt_charset = 0;
    else
        privdata->alt_charset = alt_charset;    

    privdata->allow_ip = allow_ip;
    privdata->deny_ip = deny_ip;

    if (privdata->rport > 0 && emi2_open_listening_socket(conn,privdata) < 0) {
        gw_free(privdata);
        privdata = NULL;
        goto error;
    }

    conn->data = privdata;

    if (privdata->host) {
        conn->name = octstr_format("EMI2:%S:%d:%S", privdata->host, privdata->port,
                                   privdata->username ? privdata->username : octstr_imm("null"));
    } else {
        conn->name = octstr_format("EMI2:localhost:%d:%S", privdata->rport,
                                   privdata->username ? privdata->username : octstr_imm("null"));
    }

    privdata->shutdown = 0;

    for (i = 0; i < EMI2_MAX_TRN; i++)
        privdata->slots[i].sendtime = 0;
    privdata->unacked = 0;

    conn->status = SMSCCONN_CONNECTING;
    conn->connect_time = time(NULL);

    if (privdata->rport > 0 && (privdata->receiver_thread = gwthread_create(emi2_listener, conn)) == -1)
        goto error;

    if (privdata->host && (privdata->sender_thread = gwthread_create(emi2_sender, conn)) == -1) {
        privdata->shutdown = 1;
        if (privdata->rport > 0) {
            gwthread_wakeup(privdata->receiver_thread);
            gwthread_join(privdata->receiver_thread);
        }
        goto error;
    }

    conn->shutdown = shutdown_cb;
    conn->queued = queued_cb;
    conn->start_conn = start_cb;
    conn->send_msg = add_msg_cb;

    return 0;

error:
    error(0, "EMI2[%s]: Failed to create emi2 smsc connection",
            (privdata ? octstr_get_cstr(privdata->name) : "-"));
    if (privdata != NULL) {
        gw_prioqueue_destroy(privdata->outgoing_queue, NULL);
    }
    gw_free(privdata);
    octstr_destroy(allow_ip);
    octstr_destroy(deny_ip);
    octstr_destroy(host);
    conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
    conn->status = SMSCCONN_DEAD;
    info(0, "EMI2[%s]: exiting", (privdata ? octstr_get_cstr(privdata->name) : "-"));
    return -1;
}

smsc_fake_create()

int smsc_fake_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 540 of file smsc_fake.c.

References add_msg_cb(), allow_ip, privdata::allow_ip, cfg, cfg_get, cfg_get_integer(), smscconn::connect_time, privdata::connection_thread, smscconn::data, deny_ip, privdata::deny_ip, error(), fake_listener(), fake_open_connection(), gwlist_create, gwlist_destroy(), gwthread_create, privdata::listening_socket, smscconn::name, octstr_create, octstr_destroy(), octstr_format(), octstr_imm(), privdata::outgoing_queue, privdata::port, smscconn::queued, queued_cb(), smscconn::send_msg, privdata::shutdown, smscconn::shutdown, shutdown_cb(), SMSCCONN_CONNECTING, SMSCCONN_DEAD, SMSCCONN_KILLED_CANNOT_CONNECT, start_cb(), smscconn::start_conn, smscconn::status, and smscconn::why_killed.

Referenced by smscconn_create().

{
    PrivData *privdata = NULL;
    Octstr *allow_ip, *deny_ip;
    long portno;   /* has to be long because of cfg_get_integer */

    if (cfg_get_integer(&portno, cfg, octstr_imm("port")) == -1)
        portno = 0;
    allow_ip = cfg_get(cfg, octstr_imm("connect-allow-ip"));
    if (allow_ip)
        deny_ip = octstr_create("*.*.*.*");
    else
        deny_ip = NULL;

    if (portno == 0) {
        error(0, "'port' invalid in 'fake' record.");
        goto error;
    }
    privdata = gw_malloc(sizeof(PrivData));
    privdata->listening_socket = -1;

    privdata->port = portno;
    privdata->allow_ip = allow_ip;
    privdata->deny_ip = deny_ip;

    if (fake_open_connection(conn, privdata) < 0) {
        gw_free(privdata);
        privdata = NULL;
        goto error;
    }

    conn->data = privdata;

    conn->name = octstr_format("FAKE:%d", privdata->port);

    privdata->outgoing_queue = gwlist_create();
    privdata->shutdown = 0;

    conn->status = SMSCCONN_CONNECTING;
    conn->connect_time = time(NULL);

    if ((privdata->connection_thread = gwthread_create(fake_listener, conn)) == -1)
        goto error;

    conn->shutdown = shutdown_cb;
    conn->queued = queued_cb;
    conn->start_conn = start_cb;
    conn->send_msg = add_msg_cb;

    return 0;

error:
    error(0, "Failed to create fake smsc connection");
    if (privdata != NULL) {
        gwlist_destroy(privdata->outgoing_queue, NULL);
        if (close(privdata->listening_socket == -1)) {
            error(errno, "smsc_fake: closing listening socket port %d failed",
                  privdata->listening_socket);
        }
    }
    gw_free(privdata);
    octstr_destroy(allow_ip);
    octstr_destroy(deny_ip);
    conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
    conn->status = SMSCCONN_DEAD;
    return -1;
}

smsc_http_create()

int smsc_http_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 489 of file smsc_http.c.

References conndata::allow_ip, conndata::alt_charset, conndata::callbacks, cfg, cfg_get, cfg_get_bool(), cfg_get_integer(), conndata_destroy(), smscconn::connect_time, counter_create(), conndata::data, smscconn::data, smsc_http_fn_callbacks::destroy, conndata::dlr_url, error(), gw_dlopen_get_symbol(), gwlist_add_producer(), gwlist_create, gwthread_create, http_caller_create(), http_open_port(), conndata::http_ref, httpsmsc_queued(), httpsmsc_receiver(), httpsmsc_send(), httpsmsc_send_cb(), httpsmsc_sender(), httpsmsc_shutdown(), smscconn::id, info(), smsc_http_fn_callbacks::init, conndata::max_pending_sends, conndata::mobile_originated, conndata::msg_to_send, smscconn::name, conndata::no_coding, conndata::no_sender, conndata::no_sep, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), conndata::open_sends, conndata::password, conndata::port, smscconn::queued, conndata::receive_thread, semaphore_create(), conndata::send_cb_thread, smscconn::send_msg, conndata::send_url, conndata::sender_thread, conndata::shutdown, smscconn::shutdown, SMSCCONN_ACTIVE, SMSCCONN_ACTIVE_RECV, SMSCCONN_DEAD, SMSCCONN_KILLED_CANNOT_CONNECT, ssl, smscconn::status, conndata::system_id, type, conndata::use_post, conndata::username, warning(), and smscconn::why_killed.

Referenced by smscconn_create().

{
    ConnData *conndata = NULL;
    Octstr *type = NULL, *callbackname = NULL;
    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"));
    cfg_get_bool(&conndata->mobile_originated, cfg, octstr_imm("mobile-originated"));
    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"));
    cfg_get_bool(&conndata->use_post, cfg, octstr_imm("use-post"));

    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, "HTTP[%s]: Sender and receiver disabled. Dummy SMSC not allowed.",
              octstr_get_cstr(conn->id));
        goto error;
    }
    if (conndata->send_url == NULL) {
        error(0, "HTTP[%s]: Sending not allowed. No 'send-url' specified.",
              octstr_get_cstr(conn->id));
        goto error;
    }

    /* callback struct is always in the format: smsc_http_XXX_callback where XXX is our type */
    callbackname = octstr_format("smsc_http_%S_callback", type);
    /* try to find the struct */
    if (gw_dlopen_get_symbol(NULL, octstr_get_cstr(callbackname), (void**)&conndata->callbacks) == -1 || conndata->callbacks == NULL) {
        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(callbackname);
    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(callbackname);
    octstr_destroy(type);
    return -1;
}

smsc_loopback_create()

int smsc_loopback_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 165 of file smsc_loopback.c.

References smscconn::connect_time, smscconn::data, smscconn::id, msg_cb(), smscconn::name, octstr_format(), smscconn::queued, queued_cb(), smscconn::send_msg, smscconn::shutdown, shutdown_cb(), SMSCCONN_CONNECTING, start_cb(), smscconn::start_conn, and smscconn::status.

Referenced by smscconn_create().

{
    conn->data = NULL;
    conn->name = octstr_format("LOOPBACK:%S", conn->id);
  
    conn->status = SMSCCONN_CONNECTING;
    conn->connect_time = time(NULL);

    conn->shutdown = shutdown_cb;
    conn->queued = queued_cb;
    conn->start_conn = start_cb;
    conn->send_msg = msg_cb;

    return 0;
}

smsc_oisd_create()

int smsc_oisd_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 1498 of file smsc_oisd.c.

References cfg_get, cfg_get_bool(), cfg_get_integer(), privdata::conn, smscconn::data, debug(), error(), gwlist_add_producer(), gwlist_create, gwthread_create, gwthread_join(), gwthread_wakeup(), privdata::host, smscconn::id, privdata::inbuffer, privdata::io_thread, io_thread(), smscconn::is_stopped, privdata::keepalive, privdata::my_number, smscconn::name, privdata::next_ping, privdata::no_dlr, octstr_create, octstr_format(), octstr_get_cstr, octstr_imm(), oisd_add_msg_cb(), oisd_destroy(), oisd_queued_cb(), oisd_shutdown_cb(), oisd_start_cb(), oisd_stop_cb(), ok, privdata::outgoing_queue, privdata::port, smscconn::queued, privdata::quitting, privdata::received, smscconn::send_msg, privdata::send_seq, smscconn::shutdown, SMS_PARAM_UNDEFINED, privdata::socket, smscconn::start_conn, smscconn::stop_conn, privdata::stopped, and privdata::validityperiod.

Referenced by smscconn_create().

{
    PrivData *pdata;
    int ok;

    pdata = gw_malloc(sizeof(PrivData));
    conn->data = pdata;
    pdata->conn = conn;

    pdata->no_dlr = 0;
    pdata->quitting = 0;
    pdata->socket = -1;
    pdata->received = gwlist_create();
    pdata->inbuffer = octstr_create("");
    pdata->send_seq = 1;
    pdata->outgoing_queue = gwlist_create();
    pdata->stopped = gwlist_create();
    gwlist_add_producer(pdata->outgoing_queue);

    if (conn->is_stopped)
        gwlist_add_producer(pdata->stopped);

    pdata->host = cfg_get(grp, octstr_imm("host"));
    if (cfg_get_integer(&(pdata->port), grp, octstr_imm("port")) == -1)
        pdata->port = 0;
    pdata->my_number = cfg_get(grp, octstr_imm("my-number"));
    if (cfg_get_integer(&(pdata->keepalive), grp, octstr_imm("keepalive")) == -1)
        pdata->keepalive = 0;
    if (cfg_get_integer(&(pdata->validityperiod), grp, octstr_imm("validityperiod")) == -1)
        pdata->validityperiod = SMS_PARAM_UNDEFINED;

    cfg_get_bool(&pdata->no_dlr, grp, octstr_imm("no-dlr"));

    /* Check that config is OK */
    ok = 1;
    if (pdata->host == NULL) {
        error(0, "OISD[%s]: Configuration file doesn't specify host",
              octstr_get_cstr(conn->id));
        ok = 0;
    }
    if (pdata->port == 0) {
        error(0, "OISD[%s]: Configuration file doesn't specify port",
              octstr_get_cstr(conn->id));
        ok = 0;
    }
    if (pdata->my_number == NULL && pdata->keepalive > 0) {
        error(0, "OISD[%s]: Configuration file doesn't specify my-number.",
              octstr_get_cstr(conn->id));
        ok = 0;
    }

    if (!ok) {
        oisd_destroy(pdata);
        return -1;
    }

    conn->name = octstr_format("OISD:%s:%d",
                     octstr_get_cstr(pdata->host),
                     pdata->port);


    if (pdata->keepalive > 0) {
        debug("bb.sms.oisd", 0, "OISD[%s]: Keepalive set to %ld seconds",
              octstr_get_cstr(conn->id),
              pdata->keepalive);
        pdata->next_ping = time(NULL) + pdata->keepalive;
    }

    if (pdata->validityperiod > 0) {
        debug("bb.sms.oisd", 0, "OISD[%s]: Validity-Period set to %ld",
              octstr_get_cstr(conn->id),
              pdata->validityperiod);
    }

    pdata->io_thread = gwthread_create(io_thread, conn);

    if (pdata->io_thread == -1) {

        error(0, "OISD[%s]: Couldn't start I/O thread.",
              octstr_get_cstr(conn->id));
        pdata->quitting = 1;
        gwthread_wakeup(pdata->io_thread);
        gwthread_join(pdata->io_thread);
        oisd_destroy(pdata);
        return -1;
    }

    conn->send_msg = oisd_add_msg_cb;
    conn->shutdown = oisd_shutdown_cb;
    conn->queued = oisd_queued_cb;
    conn->start_conn = oisd_start_cb;
    conn->stop_conn = oisd_stop_cb;

    return 0;
}

smsc_smasi_create()

int smsc_smasi_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 1129 of file smsc_smasi.c.

References assign, colon, comma, SMASI::conn, cr, smscconn::data, error(), gwthread_create, smscconn::id, init_configuration(), lf, octstr_create, octstr_get_cstr, panic, smscconn::queued, queued_cb(), smscconn::send_msg, send_msg_cb(), smscconn::shutdown, shutdown_cb(), smasi_create(), smasi_destroy(), smasi_thread(), SMSCCONN_CONNECTING, smscconn::status, and SMASI::thread_handle.

Referenced by smscconn_create().

{
    SMASI *smasi = NULL;

    /* Initialize data encoding subsystem. */
    colon = octstr_create(":3a");
    assign = octstr_create(":3d");
    comma = octstr_create(":2c");
    cr = octstr_create(":0a");
    lf = octstr_create(":0d");

    /* Create main SMASI structure and initialize it with configuration
     * settings.
     */
    smasi = smasi_create(conn);

    if (init_configuration(smasi, config) != 0)
        panic(0, "SMASI SMSC module configuration invalid.");

    conn->status = SMSCCONN_CONNECTING;

    /* Port is always set to a configured value or defaults to 21500.
     * Therefore, threads are always started.
     */
    smasi->thread_handle = gwthread_create(smasi_thread, smasi);

    if (smasi->thread_handle == -1) {
        error(0, "SMASI[%s]: Couldn't start SMASI thread.",
              octstr_get_cstr(smasi->conn->id));
        smasi_destroy(conn->data);
        return -1;
    } 

    /* Setup control function pointers. */
    conn->shutdown = shutdown_cb;
    conn->queued = queued_cb;
    conn->send_msg = send_msg_cb;

    return 0;
}

smsc_smpp_create()

int smsc_smpp_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 2599 of file smsc_smpp.c.

References alt_charset, SMPP::bind_addr_npi, SMPP::bind_addr_ton, cfg_get, cfg_get_bool(), cfg_get_integer(), SMPP::conn, smscconn::data, error(), ESM_CLASS_SUBMIT_STORE_AND_FORWARD_MODE, gwthread_create, gwthread_join(), gwthread_wakeup(), host, smscconn::id, io_arg_create(), io_thread(), SMPP::log_format, smscconn::name, octstr_destroy(), octstr_duplicate, octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), ok, our_port, panic, password, port, smscconn::queued, queued_cb(), SMPP::quitting, SMPP::receiver, SMPP::retry, smscconn::send_msg, send_msg_cb(), smscconn::shutdown, shutdown_cb(), smpp_create(), SMPP_DEFAULT_CONNECTION_TIMEOUT, SMPP_DEFAULT_PORT, SMPP_DEFAULT_PRIORITY, SMPP_DEFAULT_VERSION, SMPP_DEFAULT_WAITACK, smpp_destroy(), SMPP_ENQUIRE_LINK_INTERVAL, SMPP_MAX_PENDING_SUBMITS, SMPP_PDU_DUMP_MULTILINE, SMPP_WAITACK_REQUEUE, SMS_PARAM_UNDEFINED, smsc_id, SMSCCONN_CONNECTING, SMPP::ssl_client_certkey_file, smscconn::status, SMPP::transmitter, SMPP::use_ssl, username, and warning().

Referenced by smscconn_create().

{
    Octstr *host;
    long port;
    long receive_port;
    Octstr *username;
    Octstr *password;
    Octstr *system_id;
    Octstr *system_type;
    Octstr *address_range;
    long source_addr_ton;
    long source_addr_npi;
    long dest_addr_ton;
    long dest_addr_npi;
    long our_port;
    long our_receiver_port;
    Octstr *my_number;
    Octstr *service_type;
    SMPP *smpp;
    int ok;
    int transceiver_mode;
    Octstr *smsc_id;
    long enquire_link_interval;
    long max_pending_submits;
    long version;
    long priority;
    long validity;
    long smpp_msg_id_type;
    int autodetect_addr;
    Octstr *alt_charset;
    Octstr *alt_addr_charset;
    long connection_timeout, wait_ack, wait_ack_action;
    long esm_class;

    my_number = alt_addr_charset = alt_charset = NULL;
    transceiver_mode = 0;
    autodetect_addr = 1;

    host = cfg_get(grp, octstr_imm("host"));
    if (cfg_get_integer(&port, grp, octstr_imm("port")) == -1)
        port = 0;
    if (cfg_get_integer(&receive_port, grp, octstr_imm("receive-port")) == -1)
        receive_port = 0;

    if (cfg_get_integer(&our_port, grp, octstr_imm("our-port")) == -1)
        our_port = 0;
    if (cfg_get_integer(&our_receiver_port, grp, octstr_imm("our-receiver-port")) == -1)
        our_receiver_port = 0;

    cfg_get_bool(&transceiver_mode, grp, octstr_imm("transceiver-mode"));
    username = cfg_get(grp, octstr_imm("smsc-username"));
    password = cfg_get(grp, octstr_imm("smsc-password"));
    system_type = cfg_get(grp, octstr_imm("system-type"));
    address_range = cfg_get(grp, octstr_imm("address-range"));
    my_number = cfg_get(grp, octstr_imm("my-number"));
    service_type = cfg_get(grp, octstr_imm("service-type"));

    system_id = cfg_get(grp, octstr_imm("system-id"));
    if (system_id != NULL) {
        warning(0, "SMPP: obsolete system-id variable is set, "
               "use smsc-username instead.");
        if (username == NULL) {
            warning(0, "SMPP: smsc-username not set, using system-id instead");
            username = system_id;
        } else
            octstr_destroy(system_id);
    }

    /*
     * check if timing values have been configured, otherwise
     * use the predefined default values.
     */
    if (cfg_get_integer(&enquire_link_interval, grp,
                        octstr_imm("enquire-link-interval")) == -1)
        enquire_link_interval = SMPP_ENQUIRE_LINK_INTERVAL;
    if (cfg_get_integer(&max_pending_submits, grp,
                        octstr_imm("max-pending-submits")) == -1)
        max_pending_submits = SMPP_MAX_PENDING_SUBMITS;

    /* Check that config is OK */
    ok = 1;
    if (host == NULL) {
        error(0, "SMPP: Configuration file doesn't specify host");
        ok = 0;
    }
    if (port == 0 && receive_port == 0) {
        port = SMPP_DEFAULT_PORT;
        warning(0, "SMPP: Configuration file doesn't specify port or receive-port. "
                   "Using 'port = %ld' as default.", port);
    }
    if (port != 0 && receive_port != 0) {
        error(0, "SMPP: Configuration file can only have port or receive-port. "
                 "Usage of both in one group is deprecated!");
        ok = 0;
    }
    if (username == NULL) {
        error(0, "SMPP: Configuration file doesn't specify username.");
        ok = 0;
    }
    if (password == NULL) {
         error(0, "SMPP: Configuration file doesn't specify password.");
         ok = 0;
    }
    if (system_type == NULL) {
        error(0, "SMPP: Configuration file doesn't specify system-type.");
        ok = 0;
    }
    if (octstr_len(service_type) > 6) {
        error(0, "SMPP: Service type must be 6 characters or less.");
        ok = 0;
    }
    if (transceiver_mode && receive_port != 0) {
        warning(0, "SMPP: receive-port for transceiver mode defined, ignoring.");
        receive_port = 0;
    } 

    if (!ok)
        return -1;

    /* if the ton and npi values are forced, set them, else set them to -1 */
    if (cfg_get_integer(&source_addr_ton, grp,
                        octstr_imm("source-addr-ton")) == -1)
        source_addr_ton = -1;
    if (cfg_get_integer(&source_addr_npi, grp,
                        octstr_imm("source-addr-npi")) == -1)
        source_addr_npi = -1;
    if (cfg_get_integer(&dest_addr_ton, grp,
                        octstr_imm("dest-addr-ton")) == -1)
        dest_addr_ton = -1;
    if (cfg_get_integer(&dest_addr_npi, grp,
                        octstr_imm("dest-addr-npi")) == -1)
        dest_addr_npi = -1;

    /* if source addr autodetection should be used set this to 1 */
    if (cfg_get_bool(&autodetect_addr, grp, octstr_imm("source-addr-autodetect")) == -1)
        autodetect_addr = 1; /* default is autodetect if no option defined */

    /* check for any specified interface version */
    if (cfg_get_integer(&version, grp, octstr_imm("interface-version")) == -1)
        version = SMPP_DEFAULT_VERSION;
    else
        /* convert decimal to BCD */
        version = ((version / 10) << 4) + (version % 10);

    /* check for any specified priority value in range [0-5] */
    if (cfg_get_integer(&priority, grp, octstr_imm("priority")) == -1)
        priority = SMPP_DEFAULT_PRIORITY;
    else if (priority < 0 || priority > 3)
        panic(0, "SMPP: Invalid value for priority directive in configuraton (allowed range 0-3).");

    /* check for message validity period */
    if (cfg_get_integer(&validity, grp, octstr_imm("validityperiod")) == -1)
        validity = SMS_PARAM_UNDEFINED;
    else if (validity < 0)
        panic(0, "SMPP: Invalid value for validity period (allowed value >= 0).");

    /* set the msg_id type variable for this SMSC */
    if (cfg_get_integer(&smpp_msg_id_type, grp, octstr_imm("msg-id-type")) == -1) {
        /*
         * defaults to C string "as-is" style
         */
        smpp_msg_id_type = -1;
    } else {
        if (smpp_msg_id_type < 0 || smpp_msg_id_type > 3)
            panic(0,"SMPP: Invalid value for msg-id-type directive in configuraton");
    }

    /* check for an alternative charset */
    alt_charset = cfg_get(grp, octstr_imm("alt-charset"));
    alt_addr_charset = cfg_get(grp, octstr_imm("alt-addr-charset"));

    /* check for connection timeout */
    if (cfg_get_integer(&connection_timeout, grp, octstr_imm("connection-timeout")) == -1)
        connection_timeout = SMPP_DEFAULT_CONNECTION_TIMEOUT;

    /* check if wait-ack timeout set */
    if (cfg_get_integer(&wait_ack, grp, octstr_imm("wait-ack")) == -1)
        wait_ack = SMPP_DEFAULT_WAITACK;

    if (cfg_get_integer(&wait_ack_action, grp, octstr_imm("wait-ack-expire")) == -1)
        wait_ack_action = SMPP_WAITACK_REQUEUE;
    else if (wait_ack_action > 0x03 || wait_ack_action < 0)
        panic(0, "SMPP: Invalid wait-ack-expire directive in configuration.");

    if (cfg_get_integer(&esm_class, grp, octstr_imm("esm-class")) == -1) {
        esm_class = ESM_CLASS_SUBMIT_STORE_AND_FORWARD_MODE;
    }

    smpp = smpp_create(conn, host, port, receive_port, our_port, our_receiver_port, system_type,
                       username, password, address_range,
                       source_addr_ton, source_addr_npi, dest_addr_ton,
                       dest_addr_npi, enquire_link_interval,
                       max_pending_submits, version, priority, validity, my_number,
                       smpp_msg_id_type, autodetect_addr, alt_charset, alt_addr_charset,
                       service_type, connection_timeout, wait_ack, wait_ack_action, esm_class);

    cfg_get_integer(&smpp->bind_addr_ton, grp, octstr_imm("bind-addr-ton"));
    cfg_get_integer(&smpp->bind_addr_npi, grp, octstr_imm("bind-addr-npi"));

    /* set connect retry, default false */
    if (cfg_get_bool(&smpp->retry, grp, octstr_imm("retry")) == -1)
        smpp->retry = 0;
    
    cfg_get_bool(&smpp->use_ssl, grp, octstr_imm("use-ssl"));
    if (smpp->use_ssl)
#ifndef HAVE_LIBSSL
        panic(0, "SMPP: Can not use 'use-ssl' without SSL support compiled in.");
#else
        smpp->ssl_client_certkey_file = cfg_get(grp, octstr_imm("ssl-client-certkey-file"));
#endif

    conn->data = smpp;
    conn->name = octstr_format("%sSMPP:%S:%d/%d:%S:%S",
                               (smpp->use_ssl ? "S" : ""), host, port,
                               (!receive_port && transceiver_mode  ? port : receive_port),
                               username, system_type);

    smsc_id = cfg_get(grp, octstr_imm("smsc-id"));
    if (smsc_id == NULL) {
        conn->id = octstr_duplicate(conn->name);
    }

    if (cfg_get_integer(&smpp->log_format, grp, octstr_imm("log-format")) == -1)
        smpp->log_format = SMPP_PDU_DUMP_MULTILINE;

    octstr_destroy(host);
    octstr_destroy(username);
    octstr_destroy(password);
    octstr_destroy(system_type);
    octstr_destroy(address_range);
    octstr_destroy(my_number);
    octstr_destroy(smsc_id);
    octstr_destroy(alt_charset);
    octstr_destroy(alt_addr_charset);
    octstr_destroy(service_type);

    conn->status = SMSCCONN_CONNECTING;

    /*
     * I/O threads are only started if the corresponding ports
     * have been configured with positive numbers. Use 0 to
     * disable the creation of the corresponding thread.
     */
    if (port != 0)
        smpp->transmitter = gwthread_create(io_thread, io_arg_create(smpp,
                                           (transceiver_mode ? 2 : 1)));
    if (receive_port != 0)
        smpp->receiver = gwthread_create(io_thread, io_arg_create(smpp, 0));

    if ((port != 0 && smpp->transmitter == -1) ||
        (receive_port != 0 && smpp->receiver == -1)) {
        error(0, "SMPP[%s]: Couldn't start I/O threads.",
              octstr_get_cstr(smpp->conn->id));
        smpp->quitting = 1;
        if (smpp->transmitter != -1) {
            gwthread_wakeup(smpp->transmitter);
            gwthread_join(smpp->transmitter);
        }
        if (smpp->receiver != -1) {
            gwthread_wakeup(smpp->receiver);
            gwthread_join(smpp->receiver);
        }
        smpp_destroy(conn->data);
        conn->data = NULL;
        return -1;
    }

    conn->shutdown = shutdown_cb;
    conn->queued = queued_cb;
    conn->send_msg = send_msg_cb;

    return 0;
}

smsc_wrapper_create()

int smsc_wrapper_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 397 of file smsc_wrapper.c.

References cfg, smscconn::connect_time, smscconn::data, error(), gwlist_add_producer(), gwlist_create, gwthread_create, smscconn::is_stopped, mutex_create, smscconn::name, octstr_create, smsc_wrapper::outgoing_queue, smscconn::queued, smsc_wrapper::receiver_thread, smsc_wrapper::reconnect_mutex, smscconn::send_msg, smsc_wrapper::sender_thread, smscconn::shutdown, smsc_wrapper::smsc, smsc_name(), smsc_open(), SMSCCONN_ACTIVE, SMSCCONN_DEAD, SMSCCONN_KILLED_CANNOT_CONNECT, smscwrapper_destroy(), smscconn::start_conn, smscconn::status, smscconn::stop_conn, smsc_wrapper::stopped, smscconn::why_killed, wrapper_add_msg(), wrapper_queued(), wrapper_receiver(), wrapper_sender(), wrapper_shutdown(), wrapper_start(), and wrapper_stop().

Referenced by smscconn_create().

{
    /* 1. Call smsc_open()
     * 2. create sender/receiver threads
     * 3. fill up the conn
     *
     * XXX open() SHOULD be done in distinct thread, not here!
     */

    SmscWrapper *wrap;

    wrap = gw_malloc(sizeof(SmscWrapper));
    wrap->smsc = NULL;
    conn->data = wrap;
    conn->send_msg = wrapper_add_msg;
    
    
    wrap->outgoing_queue = gwlist_create();
    wrap->stopped = gwlist_create();
    wrap->reconnect_mutex = mutex_create();
    gwlist_add_producer(wrap->outgoing_queue);
    
    if ((wrap->smsc = smsc_open(cfg)) == NULL)
    goto error;

    conn->name = octstr_create(smsc_name(wrap->smsc));
    conn->status = SMSCCONN_ACTIVE;
    conn->connect_time = time(NULL);

    if (conn->is_stopped)
    gwlist_add_producer(wrap->stopped);
    

    /* XXX here we could fail things... specially if the second one
     *     fails.. so fix this ASAP
     *
     * moreover, open should be in sender/receiver, so that we can continue
     * while trying to open... maybe move this, or just wait for new
     * implementations of various SMSC protocols
     */
    
    if ((wrap->receiver_thread = gwthread_create(wrapper_receiver, conn))==-1)
    goto error;

    if ((wrap->sender_thread = gwthread_create(wrapper_sender, conn))==-1)
    goto error;

    conn->shutdown = wrapper_shutdown;
    conn->queued = wrapper_queued;
    conn->stop_conn = wrapper_stop;
    conn->start_conn = wrapper_start;
    
    return 0;

error:
    error(0, "Failed to create Smsc wrapper");
    conn->data = NULL;
    smscwrapper_destroy(wrap);
    conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
    conn->status = SMSCCONN_DEAD;
    return -1;
}