smscconn.h File Reference

#include "gwlib/gwlib.h"
#include "gw/msg.h"

Go to the source code of this file.

Data Structures
struct	smsc_state

Typedefs
typedef struct smscconn	SMSCConn
typedef struct smsc_state	StatusInfo

Enumerations
enum	smscconn_status_t {   SMSCCONN_CONNECTING, SMSCCONN_ACTIVE, SMSCCONN_ACTIVE_RECV, SMSCCONN_RECONNECTING,   SMSCCONN_DISCONNECTED, SMSCCONN_DEAD }
enum	smscconn_killed_t { SMSCCONN_ALIVE = 0, SMSCCONN_KILLED_WRONG_PASSWORD = 1, SMSCCONN_KILLED_CANNOT_CONNECT = 2, SMSCCONN_KILLED_SHUTDOWN = 3 }

Functions
SMSCConn *	smscconn_create (CfgGroup *cfg, int start_as_stopped)
void	smscconn_shutdown (SMSCConn *smscconn, int finish_sending)
int	smscconn_destroy (SMSCConn *smscconn)
int	smscconn_stop (SMSCConn *smscconn)
void	smscconn_start (SMSCConn *smscconn)
const Octstr *	smscconn_name (SMSCConn *smscconn)
const Octstr *	smscconn_id (SMSCConn *conn)
const Octstr *	smscconn_admin_id (SMSCConn *conn)
int	smscconn_usable (SMSCConn *conn, Msg *msg)
int	smscconn_send (SMSCConn *smsccconn, Msg *msg)
int	smscconn_status (SMSCConn *smscconn)
int	smscconn_info (SMSCConn *smscconn, StatusInfo *infotable)
unsigned int	smscconn_instances (CfgGroup *grp)
void	smscconn_reconfig (SMSCConn *conn, CfgGroup *grp)

Typedef Documentation

SMSCConn

typedef struct smscconn SMSCConn

Definition at line 94 of file smscconn.h.

StatusInfo

typedef struct smsc_state StatusInfo

Enumeration Type Documentation

smscconn_killed_t

enum smscconn_killed_t

Enumerator
SMSCCONN_ALIVE
SMSCCONN_KILLED_WRONG_PASSWORD
SMSCCONN_KILLED_CANNOT_CONNECT
SMSCCONN_KILLED_SHUTDOWN

Definition at line 105 of file smscconn.h.

             {
    SMSCCONN_ALIVE = 0,
    SMSCCONN_KILLED_WRONG_PASSWORD = 1,
    SMSCCONN_KILLED_CANNOT_CONNECT = 2,
    SMSCCONN_KILLED_SHUTDOWN = 3
} smscconn_killed_t;

smscconn_status_t

enum smscconn_status_t

Enumerator
SMSCCONN_CONNECTING
SMSCCONN_ACTIVE
SMSCCONN_ACTIVE_RECV
SMSCCONN_RECONNECTING
SMSCCONN_DISCONNECTED
SMSCCONN_DEAD

Definition at line 96 of file smscconn.h.

             {
    SMSCCONN_CONNECTING,
    SMSCCONN_ACTIVE,
    SMSCCONN_ACTIVE_RECV,
    SMSCCONN_RECONNECTING,
    SMSCCONN_DISCONNECTED,
    SMSCCONN_DEAD   /* ready to be cleaned */
} smscconn_status_t;

Function Documentation

smscconn_admin_id()

const Octstr* smscconn_admin_id

(

SMSCConn *

conn

)

Definition at line 566 of file smscconn.c.

References smscconn::admin_id, and gw_assert().

Referenced by smsc2_status().

{
    gw_assert(conn != NULL);
    return conn->admin_id;
}

smscconn_create()

SMSCConn* smscconn_create	(	CfgGroup *	cfg,
		int	start_as_stopped
	)

Definition at line 210 of file smscconn.c.

References smscconn::admin_id, smscconn::allowed_prefix, smscconn::allowed_prefix_regex, smscconn::allowed_smsc_id, smscconn::allowed_smsc_id_regex, smscconn::alt_dcs, bb_smscconn_ready(), cfg_get, cfg_get_bool(), cfg_get_group_checksum(), cfg_get_integer(), smscconn::chksum, smscconn::chksum_conn, smscconn::connect_time, counter_create(), smscconn::dead_start, smscconn::denied_prefix, smscconn::denied_prefix_regex, smscconn::denied_smsc_id, smscconn::denied_smsc_id_regex, error(), smscconn::failed, smscconn::flow_mutex, GET_OPTIONAL_VAL, gw_assert(), GW_EXCL, smscconn::id, smscconn::incoming_dlr_load, smscconn::incoming_sms_load, info(), init_reroute(), smscconn::is_stopped, load_add_interval(), load_create, smscconn::log_file, smscconn::log_idx, smscconn::log_level, log_open(), MAX_SMS_OCTETS, smscconn::max_sms_octets, mutex_create, OCTSTR, octstr_compare(), octstr_destroy(), octstr_duplicate, octstr_get_cstr, octstr_imm(), octstr_parse_double(), smscconn::our_host, smscconn::outgoing_dlr_load, smscconn::outgoing_sms_load, panic, smscconn::preferred_prefix, smscconn::preferred_prefix_regex, smscconn::preferred_smsc_id, smscconn::received, smscconn::received_dlr, smscconn::reconnect_delay, smscconn::send_msg, smscconn::sent, smscconn::sent_dlr, smsc_at2_create(), smsc_cgw_create(), smsc_cimd2_create(), smsc_emi2_create(), smsc_fake_create(), smsc_http_create(), smsc_loopback_create(), smsc_oisd_create(), smsc_smasi_create(), smsc_smpp_create(), smsc_wrapper_create(), SMSCCONN_ALIVE, SMSCCONN_CONNECTING, smscconn_destroy(), SMSCCONN_RECONNECT_DELAY, SPLIT_OPTIONAL_VAL, smscconn::status, smscconn::throughput, smscconn::unified_prefix, warning(), and smscconn::why_killed.

Referenced by smsc2_add_smsc(), smsc2_graceful_restart(), smsc2_restart_smsc(), and smsc2_start().

{
    SMSCConn *conn;
    Octstr *smsc_type;
    int ret;
    Octstr *allowed_smsc_id_regex;
    Octstr *denied_smsc_id_regex;
    Octstr *allowed_prefix_regex;
    Octstr *denied_prefix_regex;
    Octstr *preferred_prefix_regex;
    Octstr *tmp;

    if (grp == NULL)
    return NULL;

    conn = gw_malloc(sizeof(*conn));
    memset(conn, 0, sizeof(*conn));

    conn->why_killed = SMSCCONN_ALIVE;
    conn->status = SMSCCONN_CONNECTING;
    conn->connect_time = -1;
    conn->is_stopped = start_as_stopped;

#define OCTSTR(os)  octstr_imm(#os)

    /* checksum of the whole config, without instance multiplier */
    conn->chksum = cfg_get_group_checksum(grp,
            NULL
    );

    /* checksum of the connection related part, without routing
     * and without instance multiplier */
    conn->chksum_conn = cfg_get_group_checksum(grp,
            OCTSTR(denied-smsc-id),
            OCTSTR(allowed-smsc-id),
            OCTSTR(preferred-smsc-id),
            OCTSTR(allowed-prefix),
            OCTSTR(denied-prefix),
            OCTSTR(preferred-prefix),
            OCTSTR(unified-prefix),
            OCTSTR(reroute),
            OCTSTR(reroute-smsc-id),
            OCTSTR(reroute-receiver),
            OCTSTR(reroute-receiver-regex),
            OCTSTR(reroute-dlr),
            OCTSTR(allowed-smsc-id-regex),
            OCTSTR(denied-smsc-id-regex),
            OCTSTR(preferred-smsc-id-regex),
            OCTSTR(allowed-prefix-regex),
            OCTSTR(denied-prefix-regex),
            OCTSTR(preferred-prefix-regex),
            NULL
    );

    conn->received = counter_create();
    conn->received_dlr = counter_create();
    conn->sent = counter_create();
    conn->sent_dlr = counter_create();
    conn->failed = counter_create();
    conn->flow_mutex = mutex_create();

    conn->outgoing_sms_load = load_create();
    /* add 60,300,-1 entries */
    load_add_interval(conn->outgoing_sms_load, 60);
    load_add_interval(conn->outgoing_sms_load, 300);
    load_add_interval(conn->outgoing_sms_load, -1);

    conn->incoming_sms_load = load_create();
    /* add 60,300,-1 entries */
    load_add_interval(conn->incoming_sms_load, 60);
    load_add_interval(conn->incoming_sms_load, 300);
    load_add_interval(conn->incoming_sms_load, -1);

    conn->incoming_dlr_load = load_create();
    /* add 60,300,-1 entries to dlr */
    load_add_interval(conn->incoming_dlr_load, 60);
    load_add_interval(conn->incoming_dlr_load, 300);
    load_add_interval(conn->incoming_dlr_load, -1);

    conn->outgoing_dlr_load = load_create();
    /* add 60,300,-1 entries to dlr */
    load_add_interval(conn->outgoing_dlr_load, 60);
    load_add_interval(conn->outgoing_dlr_load, 300);
    load_add_interval(conn->outgoing_dlr_load, -1);


#define GET_OPTIONAL_VAL(x, n) x = cfg_get(grp, octstr_imm(n))
#define SPLIT_OPTIONAL_VAL(x, n) \
        do { \
                Octstr *tmp = cfg_get(grp, octstr_imm(n)); \
                if (tmp) x = octstr_split(tmp, octstr_imm(";")); \
                else x = NULL; \
                octstr_destroy(tmp); \
        }while(0)

    GET_OPTIONAL_VAL(conn->id, "smsc-id");
    SPLIT_OPTIONAL_VAL(conn->allowed_smsc_id, "allowed-smsc-id");
    SPLIT_OPTIONAL_VAL(conn->denied_smsc_id, "denied-smsc-id");
    SPLIT_OPTIONAL_VAL(conn->preferred_smsc_id, "preferred-smsc-id");
    GET_OPTIONAL_VAL(conn->allowed_prefix, "allowed-prefix");
    GET_OPTIONAL_VAL(conn->denied_prefix, "denied-prefix");
    GET_OPTIONAL_VAL(conn->preferred_prefix, "preferred-prefix");
    GET_OPTIONAL_VAL(conn->unified_prefix, "unified-prefix");
    GET_OPTIONAL_VAL(conn->our_host, "our-host");
    GET_OPTIONAL_VAL(conn->log_file, "log-file");
    cfg_get_bool(&conn->alt_dcs, grp, octstr_imm("alt-dcs"));

    GET_OPTIONAL_VAL(allowed_smsc_id_regex, "allowed-smsc-id-regex");
    if (allowed_smsc_id_regex != NULL) 
        if ((conn->allowed_smsc_id_regex = gw_regex_comp(allowed_smsc_id_regex, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(allowed_smsc_id_regex));
    GET_OPTIONAL_VAL(denied_smsc_id_regex, "denied-smsc-id-regex");
    if (denied_smsc_id_regex != NULL) 
        if ((conn->denied_smsc_id_regex = gw_regex_comp(denied_smsc_id_regex, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(denied_smsc_id_regex));
    GET_OPTIONAL_VAL(allowed_prefix_regex, "allowed-prefix-regex");
    if (allowed_prefix_regex != NULL) 
        if ((conn->allowed_prefix_regex = gw_regex_comp(allowed_prefix_regex, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(allowed_prefix_regex));
    GET_OPTIONAL_VAL(denied_prefix_regex, "denied-prefix-regex");
    if (denied_prefix_regex != NULL) 
        if ((conn->denied_prefix_regex = gw_regex_comp(denied_prefix_regex, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(denied_prefix_regex));
    GET_OPTIONAL_VAL(preferred_prefix_regex, "preferred-prefix-regex");
    if (preferred_prefix_regex != NULL) 
        if ((conn->preferred_prefix_regex = gw_regex_comp(preferred_prefix_regex, REG_EXTENDED)) == NULL)
            panic(0, "Could not compile pattern '%s'", octstr_get_cstr(preferred_prefix_regex));

    if ((tmp = cfg_get(grp, octstr_imm("throughput"))) != NULL) {
        if (octstr_parse_double(&conn->throughput, tmp, 0) == -1)
            conn->throughput = 0;
        octstr_destroy(tmp);
        info(0, "Set throughput to %.3f for smsc id <%s>", conn->throughput, octstr_get_cstr(conn->id));
    }
    /* Sets the admin_id. Equals to connection id if empty */
    GET_OPTIONAL_VAL(conn->admin_id, "smsc-admin-id");
    if (conn->admin_id == NULL)
        conn->admin_id = octstr_duplicate(conn->id);

    /* configure the internal rerouting rules for this smsc id */
    init_reroute(conn, grp);

    if (cfg_get_integer(&conn->log_level, grp, octstr_imm("log-level")) == -1)
        conn->log_level = 0;

    if (cfg_get_integer(&conn->max_sms_octets, grp, octstr_imm("max-sms-octets")) == -1)
        conn->max_sms_octets = MAX_SMS_OCTETS;

    if (cfg_get_bool(&conn->dead_start, grp, octstr_imm("dead-start")) == -1)
        conn->dead_start = 0;   /* default to connect at start-up time */

    /* open a smsc-id specific log-file in exlusive mode */
    if (conn->log_file)
        conn->log_idx = log_open(octstr_get_cstr(conn->log_file), 
                                 conn->log_level, GW_EXCL); 
#undef GET_OPTIONAL_VAL
#undef SPLIT_OPTIONAL_VAL

    if (conn->allowed_smsc_id && conn->denied_smsc_id)
    warning(0, "Both 'allowed-smsc-id' and 'denied-smsc-id' set, deny-list "
        "automatically ignored");
    if (conn->allowed_smsc_id_regex && conn->denied_smsc_id_regex)
        warning(0, "Both 'allowed-smsc-id_regex' and 'denied-smsc-id_regex' set, deny-regex "
                "automatically ignored");

    if (cfg_get_integer(&conn->reconnect_delay, grp,
                        octstr_imm("reconnect-delay")) == -1)
        conn->reconnect_delay = SMSCCONN_RECONNECT_DELAY;

    smsc_type = cfg_get(grp, octstr_imm("smsc"));
    if (smsc_type == NULL) {
        error(0, "Required field 'smsc' missing for smsc group.");
        smscconn_destroy(conn);
        octstr_destroy(smsc_type);
        return NULL;
    }

    if (octstr_compare(smsc_type, octstr_imm("fake")) == 0)
        ret = smsc_fake_create(conn, grp);
    else if (octstr_compare(smsc_type, octstr_imm("cimd2")) == 0)
    ret = smsc_cimd2_create(conn, grp);
    else if (octstr_compare(smsc_type, octstr_imm("emi")) == 0)
    ret = smsc_emi2_create(conn, grp);
    else if (octstr_compare(smsc_type, octstr_imm("http")) == 0)
        ret = smsc_http_create(conn, grp);
    else if (octstr_compare(smsc_type, octstr_imm("smpp")) == 0)
    ret = smsc_smpp_create(conn, grp);
    else if (octstr_compare(smsc_type, octstr_imm("at")) == 0)
    ret = smsc_at2_create(conn,grp);
    else if (octstr_compare(smsc_type, octstr_imm("cgw")) == 0)
        ret = smsc_cgw_create(conn,grp);
    else if (octstr_compare(smsc_type, octstr_imm("smasi")) == 0)
        ret = smsc_smasi_create(conn, grp);
    else if (octstr_compare(smsc_type, octstr_imm("oisd")) == 0)
        ret = smsc_oisd_create(conn, grp);
    else if (octstr_compare(smsc_type, octstr_imm("loopback")) == 0)
        ret = smsc_loopback_create(conn, grp);
#ifdef HAVE_GSOAP
    else if (octstr_compare(smsc_type, octstr_imm("parlayx")) == 0)
        ret = smsc_soap_parlayx_create(conn, grp);
#endif
    else
        ret = smsc_wrapper_create(conn, grp);

    octstr_destroy(smsc_type);
    if (ret == -1) {
        smscconn_destroy(conn);
        return NULL;
    }
    gw_assert(conn->send_msg != NULL);

    bb_smscconn_ready(conn);

    return conn;
}

smscconn_destroy()

int smscconn_destroy

(

SMSCConn *

smscconn

)

Definition at line 464 of file smscconn.c.

References smscconn::admin_id, smscconn::allowed_prefix, smscconn::allowed_prefix_regex, smscconn::allowed_smsc_id, smscconn::allowed_smsc_id_regex, smscconn::chksum, smscconn::chksum_conn, counter_destroy(), smscconn::denied_prefix, smscconn::denied_prefix_regex, smscconn::denied_smsc_id, smscconn::denied_smsc_id_regex, dict_destroy(), smscconn::failed, smscconn::flow_mutex, gwlist_destroy(), smscconn::id, smscconn::incoming_dlr_load, smscconn::incoming_sms_load, load_destroy(), smscconn::log_file, mutex_destroy(), mutex_lock, mutex_unlock, smscconn::name, octstr_destroy(), octstr_destroy_item(), smscconn::our_host, smscconn::outgoing_dlr_load, smscconn::outgoing_sms_load, pattern_route_destroy(), smscconn::preferred_prefix, smscconn::preferred_prefix_regex, smscconn::preferred_smsc_id, smscconn::received, smscconn::received_dlr, smscconn::reroute_by_receiver, smscconn::reroute_by_receiver_regex, smscconn::reroute_to_smsc, smscconn::sent, smscconn::sent_dlr, SMSCCONN_DEAD, smscconn::status, and smscconn::unified_prefix.

Referenced by smsc2_cleanup(), smsc2_graceful_restart(), smsc2_remove_smsc(), smsc2_restart_smsc(), and smscconn_create().

{
    if (conn == NULL)
    return 0;
    if (conn->status != SMSCCONN_DEAD)
    return -1;
    mutex_lock(conn->flow_mutex);

    counter_destroy(conn->received);
    counter_destroy(conn->received_dlr);
    counter_destroy(conn->sent);
    counter_destroy(conn->sent_dlr);
    counter_destroy(conn->failed);

    load_destroy(conn->incoming_sms_load);
    load_destroy(conn->incoming_dlr_load);
    load_destroy(conn->outgoing_sms_load);
    load_destroy(conn->outgoing_dlr_load);

    octstr_destroy(conn->name);
    octstr_destroy(conn->id);
    octstr_destroy(conn->admin_id);
    gwlist_destroy(conn->allowed_smsc_id, octstr_destroy_item);
    gwlist_destroy(conn->denied_smsc_id, octstr_destroy_item);
    gwlist_destroy(conn->preferred_smsc_id, octstr_destroy_item);
    octstr_destroy(conn->denied_prefix);
    octstr_destroy(conn->allowed_prefix);
    octstr_destroy(conn->preferred_prefix);
    octstr_destroy(conn->unified_prefix);
    octstr_destroy(conn->our_host);
    octstr_destroy(conn->log_file);
    octstr_destroy(conn->chksum);
    octstr_destroy(conn->chksum_conn);

    if (conn->denied_smsc_id_regex != NULL) gw_regex_destroy(conn->denied_smsc_id_regex);
    if (conn->allowed_smsc_id_regex != NULL) gw_regex_destroy(conn->allowed_smsc_id_regex);
    if (conn->preferred_prefix_regex != NULL) gw_regex_destroy(conn->preferred_prefix_regex);
    if (conn->denied_prefix_regex != NULL) gw_regex_destroy(conn->denied_prefix_regex);
    if (conn->allowed_prefix_regex != NULL) gw_regex_destroy(conn->allowed_prefix_regex);

    octstr_destroy(conn->reroute_to_smsc);
    dict_destroy(conn->reroute_by_receiver);
    gwlist_destroy(conn->reroute_by_receiver_regex, pattern_route_destroy);

    mutex_unlock(conn->flow_mutex);
    mutex_destroy(conn->flow_mutex);

    gw_free(conn);
    return 0;
}

smscconn_id()

const Octstr* smscconn_id

(

SMSCConn *

conn

)

Definition at line 559 of file smscconn.c.

References gw_assert(), and smscconn::id.

Referenced by bb_alog_sms(), get_pattern(), and smsc2_status().

{
    gw_assert(conn != NULL);
    return conn->id;
}

smscconn_info()

int smscconn_info	(	SMSCConn *	smscconn,
		StatusInfo *	infotable
	)

Definition at line 732 of file smscconn.c.

References smscconn::connect_time, counter_value(), smsc_state::failed, smscconn::failed, smscconn::flow_mutex, smsc_state::is_stopped, smscconn::is_stopped, smsc_state::killed, smsc_state::load, smscconn::load, mutex_lock, mutex_unlock, smsc_state::online, smsc_state::queued, smscconn::queued, smsc_state::received, smscconn::received, smsc_state::received_dlr, smscconn::received_dlr, smsc_state::sent, smscconn::sent, smsc_state::sent_dlr, smscconn::sent_dlr, smsc_state::status, smscconn::status, and smscconn::why_killed.

Referenced by smsc2_rout(), and smsc2_status().

{
    if (conn == NULL || infotable == NULL)
    return -1;

    mutex_lock(conn->flow_mutex);

    infotable->status = conn->status;
    infotable->killed = conn->why_killed;
    infotable->is_stopped = conn->is_stopped;
    infotable->online = time(NULL) - conn->connect_time;
    
    infotable->sent = counter_value(conn->sent);
    infotable->received = counter_value(conn->received);
    infotable->sent_dlr = counter_value(conn->sent_dlr);
    infotable->received_dlr = counter_value(conn->received_dlr);
    infotable->failed = counter_value(conn->failed);

    if (conn->queued)
    infotable->queued = conn->queued(conn);
    else
    infotable->queued = -1;

    infotable->load = conn->load;
    
    mutex_unlock(conn->flow_mutex);

    return 0;
}

smscconn_instances()

unsigned int smscconn_instances

(

CfgGroup *

grp

)

Definition at line 197 of file smscconn.c.

References cfg_get_integer(), and octstr_imm().

Referenced by smsc2_add_smsc(), smsc2_graceful_restart(), and smsc2_start().

{
    long i;

    if (cfg_get_integer(&i, grp, octstr_imm("instances")) == -1)
        i = 1;
    else if (i < 0)
        i = 0;

    return i;
}

smscconn_name()

const Octstr* smscconn_name

(

SMSCConn *

smscconn

)

Definition at line 552 of file smscconn.c.

References gw_assert(), and smscconn::name.

Referenced by bb_alog_sms(), get_pattern(), and smsc2_status().

{
    gw_assert(conn != NULL);
    return conn->name;
}

smscconn_reconfig()

void smscconn_reconfig	(	SMSCConn *	conn,
		CfgGroup *	grp
	)

Definition at line 763 of file smscconn.c.

References smscconn::allowed_prefix, smscconn::allowed_prefix_regex, smscconn::allowed_smsc_id, smscconn::allowed_smsc_id_regex, cfg_get_group_checksum(), smscconn::chksum, smscconn::denied_prefix, smscconn::denied_prefix_regex, smscconn::denied_smsc_id, smscconn::denied_smsc_id_regex, dict_destroy(), GET_OPTIONAL_REGEX, GET_OPTIONAL_VAL, gw_assert(), gwlist_destroy(), init_reroute(), octstr_destroy(), pattern_route_destroy(), smscconn::preferred_prefix, smscconn::preferred_prefix_regex, smscconn::preferred_smsc_id, smscconn::preferred_smsc_id_regex, smscconn::reroute_by_receiver, smscconn::reroute_by_receiver_regex, smscconn::reroute_to_smsc, SPLIT_OPTIONAL_VAL, and smscconn::unified_prefix.

Referenced by smsc2_graceful_restart().

{
    Octstr *tmp;

    gw_assert(conn != NULL);

    if (grp == NULL)
        return;

#define GET_OPTIONAL_VAL(x, n) \
        octstr_destroy(x); \
        x = cfg_get(grp, octstr_imm(n))
#define SPLIT_OPTIONAL_VAL(x, n) \
        gwlist_destroy(x, octstr_destroy_item); \
        if ((tmp = cfg_get(grp, octstr_imm(n))) != NULL) \
            x = octstr_split(tmp, octstr_imm(";")); \
        else \
            x = NULL; \
        octstr_destroy(tmp);
#define GET_OPTIONAL_REGEX(x, n) \
        gw_regex_destroy(x); \
        if ((tmp = cfg_get(grp, octstr_imm(n))) != NULL) { \
            if ((x = gw_regex_comp(tmp, REG_EXTENDED)) == NULL) \
                error(0, "Could not compile pattern '%s'", octstr_get_cstr(tmp)); \
            octstr_destroy(tmp); \
        }

    SPLIT_OPTIONAL_VAL(conn->allowed_smsc_id, "allowed-smsc-id");
    SPLIT_OPTIONAL_VAL(conn->denied_smsc_id, "denied-smsc-id");
    SPLIT_OPTIONAL_VAL(conn->preferred_smsc_id, "preferred-smsc-id");
    GET_OPTIONAL_VAL(conn->allowed_prefix, "allowed-prefix");
    GET_OPTIONAL_VAL(conn->denied_prefix, "denied-prefix");
    GET_OPTIONAL_VAL(conn->preferred_prefix, "preferred-prefix");
    GET_OPTIONAL_VAL(conn->unified_prefix, "unified-prefix");
    GET_OPTIONAL_REGEX(conn->allowed_smsc_id_regex, "allowed-smsc-id-regex");
    GET_OPTIONAL_REGEX(conn->denied_smsc_id_regex, "denied-smsc-id-regex");
    GET_OPTIONAL_REGEX(conn->preferred_smsc_id_regex, "preferred-smsc-id-regex");
    GET_OPTIONAL_REGEX(conn->allowed_prefix_regex, "allowed-prefix-regex");
    GET_OPTIONAL_REGEX(conn->denied_prefix_regex, "denied-prefix-regex");
    GET_OPTIONAL_REGEX(conn->preferred_prefix_regex, "preferred-prefix-regex");

    octstr_destroy(conn->reroute_to_smsc);
    dict_destroy(conn->reroute_by_receiver);
    gwlist_destroy(conn->reroute_by_receiver_regex, pattern_route_destroy);
    init_reroute(conn, grp);

    /*
     * Since we applied changes, we need to re-compute
     * at least the overall checksum. The other one
     * is not changed as the routing values are excluded.
     * also the checksum hash values.
     */
    octstr_destroy(conn->chksum);
    conn->chksum = cfg_get_group_checksum(grp, NULL);
}

smscconn_send()

int smscconn_send	(	SMSCConn *	smsccconn,
		Msg *	msg
	)

Definition at line 655 of file smscconn.c.

References counter_create(), counter_destroy(), counter_increase(), counter_increase_with(), counter_set(), debug(), smscconn::flow_mutex, gw_assert(), gwlist_destroy(), gwlist_get(), gwlist_len(), smscconn::max_sms_octets, msg, msg_destroy_item(), msg_duplicate(), mutex_lock, mutex_unlock, normalize_number(), octstr_get_cstr, smscconn::send_msg, sms_split(), SMSCCONN_ALIVE, SMSCCONN_DEAD, SMSCCONN_FAILED_REJECTED, SMSCCONN_SUCCESS, split, split_msg_counter, smscconn::status, smscconn::unified_prefix, warning(), and smscconn::why_killed.

Referenced by smsc2_rout().

{
    int ret = -1;
    List *parts = NULL;
    
    gw_assert(conn != NULL);
    mutex_lock(conn->flow_mutex);
    if (conn->status == SMSCCONN_DEAD || conn->why_killed != SMSCCONN_ALIVE) {
        mutex_unlock(conn->flow_mutex);
        return -1;
    }

    /* if this a retry of splitted message, don't unify prefix and don't try to split */
    if (msg->sms.split_parts == NULL) {    
        /* normalize the destination number for this smsc */
        char *uf = conn->unified_prefix ? octstr_get_cstr(conn->unified_prefix) : NULL;
        normalize_number(uf, &(msg->sms.receiver));

        /* split msg */
        parts = sms_split(msg, NULL, NULL, NULL, NULL, 1, 
            counter_increase(split_msg_counter) & 0xff, 0xff, conn->max_sms_octets);
        if (gwlist_len(parts) == 1) {
            /* don't create split_parts of sms fit into one */
            gwlist_destroy(parts, msg_destroy_item);
            parts = NULL;
        }
    }
    
    if (parts == NULL)
        ret = conn->send_msg(conn, msg);
    else {
        long i, parts_len = gwlist_len(parts);
        struct split_parts *split = gw_malloc(sizeof(*split));
         /* must duplicate, because smsc2_route will destroy this msg */
        split->orig = msg_duplicate(msg);
        split->parts_left = counter_create();
        split->status = SMSCCONN_SUCCESS;
        counter_set(split->parts_left, parts_len);
        split->smsc_conn = conn;
        debug("bb.sms.splits", 0, "new split_parts created %p", split);
        for (i = 0; i < parts_len; i++) {
            msg = gwlist_get(parts, i);
            msg->sms.split_parts = split;
            ret = conn->send_msg(conn, msg);
            if (ret < 0) {
                if (i == 0) {
                    counter_destroy(split->parts_left);
                    gwlist_destroy(parts, msg_destroy_item);
                    gw_free(split);
                    mutex_unlock(conn->flow_mutex);
                    return ret;
                }
                /*
                 * Some parts were sent. So handle this within
                 * bb_smscconn_XXX().
                 */
                split->status = SMSCCONN_FAILED_REJECTED;
                counter_increase_with(split->parts_left, -(parts_len - i));
                warning(0, "Could not send all parts of a split message");
                break;
            }
        }
        gwlist_destroy(parts, msg_destroy_item);
    }
    mutex_unlock(conn->flow_mutex);
    return ret;
}

smscconn_shutdown()

void smscconn_shutdown	(	SMSCConn *	smscconn,
		int	finish_sending
	)

Definition at line 427 of file smscconn.c.

References smscconn::flow_mutex, gw_assert(), mutex_lock, mutex_unlock, smscconn::shutdown, SMSCCONN_DEAD, SMSCCONN_KILLED_SHUTDOWN, smscconn::status, and smscconn::why_killed.

Referenced by sms_receive(), sms_send(), smsc2_add_smsc(), smsc2_graceful_restart(), smsc2_remove_smsc(), smsc2_resume(), smsc2_shutdown(), and smsc2_stop_smsc().

{
    gw_assert(conn != NULL);

    mutex_lock(conn->flow_mutex);
    if (conn->status == SMSCCONN_DEAD) {
        mutex_unlock(conn->flow_mutex);
        return;
    }

    /* Call SMSC specific destroyer */
    if (conn->shutdown) {
        /* 
         * we must unlock here, because module manipulate their state
         * and will try to lock this mutex.Otherwise we have deadlock!
         */
        mutex_unlock(conn->flow_mutex);
        conn->shutdown(conn, finish_sending);
    }
    else {
        conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;
        mutex_unlock(conn->flow_mutex);
    }

    return;
}

smscconn_start()

void smscconn_start

(

SMSCConn *

smscconn

)

Definition at line 536 of file smscconn.c.

References smscconn::flow_mutex, gw_assert(), smscconn::is_stopped, mutex_lock, mutex_unlock, SMSCCONN_DEAD, smscconn::start_conn, and smscconn::status.

Referenced by smsc2_add_smsc(), smsc2_graceful_restart(), smsc2_restart_smsc(), and smsc2_resume().

{
    gw_assert(conn != NULL);
    mutex_lock(conn->flow_mutex);
    if (conn->status == SMSCCONN_DEAD || conn->is_stopped == 0) {
    mutex_unlock(conn->flow_mutex);
    return;
    }
    conn->is_stopped = 0;
    mutex_unlock(conn->flow_mutex);
    
     if (conn->start_conn)
    conn->start_conn(conn);
}

smscconn_status()

int smscconn_status

(

SMSCConn *

smscconn

)

Definition at line 724 of file smscconn.c.

References gw_assert(), and smscconn::status.

Referenced by bb_smscconn_send_failed(), handle_split(), smsc2_restart_smsc(), and smsc2_stop_smsc().

{
    gw_assert(conn != NULL);

    return conn->status;
}

smscconn_stop()

int smscconn_stop

(

SMSCConn *

smscconn

)

Definition at line 516 of file smscconn.c.

References smscconn::flow_mutex, gw_assert(), smscconn::is_stopped, mutex_lock, mutex_unlock, SMSCCONN_ALIVE, SMSCCONN_DEAD, smscconn::status, smscconn::stop_conn, and smscconn::why_killed.

Referenced by smsc2_suspend().

{
    gw_assert(conn != NULL);
    mutex_lock(conn->flow_mutex);
    if (conn->status == SMSCCONN_DEAD || conn->is_stopped != 0
    || conn->why_killed != SMSCCONN_ALIVE)
    {
    mutex_unlock(conn->flow_mutex);
    return -1;
    }
    conn->is_stopped = 1;
    mutex_unlock(conn->flow_mutex);

    if (conn->stop_conn)
    conn->stop_conn(conn);

    return 0;
}

smscconn_usable()

int smscconn_usable	(	SMSCConn *	conn,
		Msg *	msg
	)

Definition at line 573 of file smscconn.c.

References smscconn::allowed_prefix, smscconn::allowed_prefix_regex, smscconn::allowed_smsc_id, smscconn::allowed_smsc_id_regex, smscconn::denied_prefix, smscconn::denied_prefix_regex, smscconn::denied_smsc_id, smscconn::denied_smsc_id_regex, does_prefix_match(), gw_assert(), gwlist_search(), msg, octstr_item_match(), smscconn::preferred_prefix, smscconn::preferred_prefix_regex, smscconn::preferred_smsc_id, SMSCCONN_ACTIVE_RECV, SMSCCONN_ALIVE, SMSCCONN_DEAD, smscconn::status, and smscconn::why_killed.

Referenced by smsc2_rout().

{
    gw_assert(conn != NULL);
    gw_assert(msg != NULL && msg_type(msg) == sms);

    /* dead transmitter or active receiver connections are not feasible */
    if (conn->status == SMSCCONN_DEAD || conn->status == SMSCCONN_ACTIVE_RECV ||
            conn->why_killed != SMSCCONN_ALIVE)
        return -1;

    /* if allowed-smsc-id set, then only allow this SMSC if message
     * smsc-id matches any of its allowed SMSCes
     */
    if (conn->allowed_smsc_id && (msg->sms.smsc_id == NULL ||
            gwlist_search(conn->allowed_smsc_id, msg->sms.smsc_id, octstr_item_match) == NULL)) {
        return -1;
    }
    /* ..if no allowed-smsc-id set but denied-smsc-id and message smsc-id
     * is set, deny message if smsc-ids match */
    else if (conn->denied_smsc_id && msg->sms.smsc_id != NULL &&
            gwlist_search(conn->denied_smsc_id, msg->sms.smsc_id, octstr_item_match) != NULL) {
        return -1;
    }

    if (conn->allowed_smsc_id_regex) {
        if (msg->sms.smsc_id == NULL)
            return -1;
        
        if (gw_regex_match_pre(conn->allowed_smsc_id_regex, msg->sms.smsc_id) == 0) 
            return -1;
    }
    else if (conn->denied_smsc_id_regex && msg->sms.smsc_id != NULL) {
        if (gw_regex_match_pre(conn->denied_smsc_id_regex, msg->sms.smsc_id) == 1) 
            return -1;
    }

    /* Have allowed */
    if (conn->allowed_prefix && !conn->denied_prefix &&
            (does_prefix_match(conn->allowed_prefix, msg->sms.receiver) != 1))
        return -1;
    
    if (conn->allowed_prefix_regex && !conn->denied_prefix_regex &&
            gw_regex_match_pre(conn->allowed_prefix_regex, msg->sms.receiver) == 0)
        return -1;

    /* Have denied */
    if (conn->denied_prefix && !conn->allowed_prefix &&
            (does_prefix_match(conn->denied_prefix, msg->sms.receiver) == 1))
        return -1;

    if (conn->denied_prefix_regex && !conn->allowed_prefix_regex &&
            gw_regex_match_pre(conn->denied_prefix_regex, msg->sms.receiver) == 1)
        return -1;

    /* Have allowed and denied */
    if (conn->denied_prefix && conn->allowed_prefix &&
            (does_prefix_match(conn->allowed_prefix, msg->sms.receiver) != 1) &&
            (does_prefix_match(conn->denied_prefix, msg->sms.receiver) == 1))
        return -1;

    if (conn->allowed_prefix_regex && conn->denied_prefix_regex &&
            gw_regex_match_pre(conn->allowed_prefix_regex, msg->sms.receiver) == 0 &&
            gw_regex_match_pre(conn->denied_prefix_regex, msg->sms.receiver) == 1)
        return -1;
    
    /* then see if it is preferred one */
    if (conn->preferred_smsc_id && msg->sms.smsc_id != NULL &&
            gwlist_search(conn->preferred_smsc_id, msg->sms.smsc_id, octstr_item_match) != NULL)
        return 1;

    if (conn->preferred_prefix &&
            does_prefix_match(conn->preferred_prefix, msg->sms.receiver) == 1)
        return 1;

    if (conn->preferred_prefix_regex &&
            gw_regex_match_pre(conn->preferred_prefix_regex, msg->sms.receiver) == 1)
        return 1;
        
    return 0;
}