smsc.c File Reference

#include <errno.h>
#include <signal.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>
#include <sys/time.h>
#include "gwlib/gwlib.h"
#include "smsc.h"
#include "smsc_p.h"
#include "msg.h"

Go to the source code of this file.

Macros
#define	MAX_READ_INTO_BUFFER   (1024)

Functions
static void	smscenter_lock (SMSCenter *smsc)
static void	smscenter_unlock (SMSCenter *smsc)
SMSCenter *	smscenter_construct (void)
void	smscenter_destruct (SMSCenter *smsc)
int	smscenter_submit_msg (SMSCenter *smsc, Msg *msg)
int	smscenter_receive_msg (SMSCenter *smsc, Msg **msg)
int	smscenter_pending_smsmessage (SMSCenter *smsc)
int	smscenter_read_into_buffer (SMSCenter *smsc)
void	smscenter_remove_from_buffer (SMSCenter *smsc, size_t n)
SMSCenter *	smsc_open (CfgGroup *grp)
int	smsc_reopen (SMSCenter *smsc)
char *	smsc_name (SMSCenter *smsc)
int	smsc_close (SMSCenter *smsc)

Macro Definition Documentation

MAX_READ_INTO_BUFFER

#define MAX_READ_INTO_BUFFER   (1024)

Definition at line 84 of file smsc.c.

Referenced by smscenter_read_into_buffer().

Function Documentation

smsc_close()

int smsc_close

(

SMSCenter *

smsc

)

Definition at line 648 of file smsc.c.

References cimd_close(), emi_close(), ois_close(), sema_close(), SMSC_TYPE_CIMD, SMSC_TYPE_EMI_X25, SMSC_TYPE_OIS, SMSC_TYPE_SEMA_X28, smscenter_lock(), and SMSCenter::type.

Referenced by smscwrapper_destroy().

{
    int errors = 0;

    if (smsc == NULL)
        return 0;

    smscenter_lock(smsc);

    switch (smsc->type) {
    case SMSC_TYPE_CIMD:
        if (cimd_close(smsc) == -1)
            errors = 1;
        break;

    case SMSC_TYPE_EMI_X25:
        if (emi_close(smsc) == -1)
            errors = 1;
        break;

    case SMSC_TYPE_SEMA_X28:
        if (sema_close(smsc) == -1)
            errors = 1;
        break;

    case SMSC_TYPE_OIS:
        if (ois_close(smsc) == -1)
            errors = 1;
        break;

        /* add new SMSCes here */

    default:        /* Unknown SMSC type */
        break;
    }
    /*
     smsc->type = SMSC_TYPE_DELETED;
     smscenter_unlock(smsc);
    */
    if (errors)
        return -1;

    return 0;
}

smsc_name()

char* smsc_name

(

SMSCenter *

smsc

)

Definition at line 643 of file smsc.c.

References SMSCenter::name.

Referenced by smsc_wrapper_create().

{
    return smsc->name;
}

smsc_open()

SMSCenter* smsc_open

(

CfgGroup *

grp

)

Definition at line 444 of file smsc.c.

References allow_ip, SMSCenter::allowed_prefix, SMSCenter::alt_charset, cfg_get, cfg_get_integer(), cimd_open(), SMSCenter::denied_prefix, emi_open(), error(), host, octstr_compare(), octstr_create, octstr_destroy(), octstr_get_cstr, octstr_imm(), octstr_parse_long(), ois_open(), our_port, password, port, SMSCenter::preferred_prefix, sema_open(), SMSC_TYPE_CIMD, SMSC_TYPE_EMI_X25, SMSC_TYPE_OIS, SMSC_TYPE_SEMA_X28, type, and username.

Referenced by smsc_wrapper_create().

{
    SMSCenter *smsc;
    Octstr *type, *host, *username, *password, *phone, *device;
    Octstr *preferred_prefix, *allowed_prefix, *denied_prefix;
    Octstr *alt_chars, *allow_ip;
    Octstr *sema_smscnua, *sema_homenua, *sema_report;
    Octstr *sender_prefix;

    long iwaitreport;
    long port, receive_port, our_port;
    long keepalive;
    long ois_debug;
    long alt_dcs;
    int typeno;


    type = cfg_get(grp, octstr_imm("smsc"));
    if (type == NULL) {
    error(0, "Required field 'smsc' missing for smsc group.");
    return NULL;
    }
    if (octstr_compare(type, octstr_imm("cimd")) == 0)
        typeno = SMSC_TYPE_CIMD;
    else if (octstr_compare(type, octstr_imm("emi_x25")) == 0)
        typeno = SMSC_TYPE_EMI_X25;
    else if (octstr_compare(type, octstr_imm("sema")) == 0)
        typeno = SMSC_TYPE_SEMA_X28;
    else if (octstr_compare(type, octstr_imm("ois")) == 0)
        typeno = SMSC_TYPE_OIS;
    else {
    error(0, "Unknown SMSC type '%s'", octstr_get_cstr(type));
    octstr_destroy(type);
    return NULL;
    }

    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;
    username = cfg_get(grp, octstr_imm("smsc-username"));
    password = cfg_get(grp, octstr_imm("smsc-password"));
    phone = cfg_get(grp, octstr_imm("phone"));
    device = cfg_get(grp, octstr_imm("device"));
    preferred_prefix = cfg_get(grp, octstr_imm("preferred-prefix"));
    allowed_prefix = cfg_get(grp, octstr_imm("allowed-prefix"));
    denied_prefix = cfg_get(grp, octstr_imm("denied-prefix"));
    alt_chars = cfg_get(grp, octstr_imm("alt-charset"));

    allow_ip = cfg_get(grp, octstr_imm("connect-allow-ip"));

    sema_smscnua = cfg_get(grp, octstr_imm("smsc_nua"));
    sema_homenua = cfg_get(grp, octstr_imm("home_nua"));
    sema_report = cfg_get(grp, octstr_imm("wait_report"));
    if (sema_report == NULL)
        iwaitreport = 1;
    else
        octstr_parse_long(&iwaitreport, sema_report, 0, 0);

    if (cfg_get_integer(&keepalive, grp, octstr_imm("keepalive")) == -1)
        keepalive = 0;

    if (cfg_get_integer(&alt_dcs, grp, octstr_imm("alt-dcs")) == -1)
        alt_dcs = 0;
    if (alt_dcs > 1)
        alt_dcs = 1;

    if (cfg_get_integer(&ois_debug, grp, octstr_imm("ois-debug-level")) == -1)
        ois_debug = 0;

    sender_prefix = cfg_get(grp, octstr_imm("sender-prefix"));
    if (sender_prefix == NULL)
        sender_prefix = octstr_create("never");

    smsc = NULL;

    switch (typeno) {
    case SMSC_TYPE_CIMD:
        if (host == NULL || port == 0 || username == NULL || password == NULL)
            error(0, "Required field missing for CIMD center.");
        else
            smsc = cimd_open(octstr_get_cstr(host),
                         port, 
                         octstr_get_cstr(username), 
                 octstr_get_cstr(password));
        break;

    case SMSC_TYPE_EMI_X25:
        if (phone == NULL || device == NULL || username == NULL ||
            password == NULL)
            error(0, "Required field missing for EMI_X25 center.");
        else
            smsc = emi_open(octstr_get_cstr(phone), 
                        octstr_get_cstr(device), 
                octstr_get_cstr(username), 
                octstr_get_cstr(password));
        break;

    case SMSC_TYPE_SEMA_X28:
        if (device == NULL || sema_smscnua == NULL || sema_homenua == NULL)
            error(0, "Required field missing for SEMA center.");
        else
            smsc = sema_open(octstr_get_cstr(sema_smscnua), 
                         octstr_get_cstr(sema_homenua), 
                 octstr_get_cstr(device),
                             iwaitreport);
        break;

    case SMSC_TYPE_OIS:
        if (host == NULL || port == 0 || receive_port == 0)
            error(0, "Required field missing for OIS center.");
        else
            smsc = ois_open(receive_port, 
                        octstr_get_cstr(host), 
                port, 
                        ois_debug);
        break;

        /* add new SMSCes here */

    default:        /* Unknown SMSC type */
        break;
    }

    if (smsc != NULL) {
    if (cfg_get_integer(&smsc->alt_charset, grp, 
                        octstr_imm("alt-charset")) == -1)
        smsc->alt_charset = 0;
        if (preferred_prefix == NULL)
        smsc->preferred_prefix = NULL;
    else
        smsc->preferred_prefix = 
            gw_strdup(octstr_get_cstr(preferred_prefix));
        if (allowed_prefix == NULL)
        smsc->allowed_prefix = NULL;
    else
        smsc->allowed_prefix = gw_strdup(octstr_get_cstr(allowed_prefix));
        if (denied_prefix == NULL)
        smsc->denied_prefix = NULL;
    else
        smsc->denied_prefix = gw_strdup(octstr_get_cstr(denied_prefix));
    }

    octstr_destroy(type);
    octstr_destroy(host);
    octstr_destroy(username);
    octstr_destroy(password);
    octstr_destroy(phone);
    octstr_destroy(device);
    octstr_destroy(preferred_prefix);
    octstr_destroy(denied_prefix);
    octstr_destroy(allowed_prefix);
    octstr_destroy(alt_chars);
    octstr_destroy(allow_ip);
    octstr_destroy(sema_smscnua);
    octstr_destroy(sema_homenua);
    octstr_destroy(sema_report);
    octstr_destroy(sender_prefix);
    return smsc;
}

smsc_reopen()

int smsc_reopen

(

SMSCenter *

smsc

)

Definition at line 610 of file smsc.c.

References cimd_reopen(), emi_reopen(), SMSCenter::killed, ois_reopen(), sema_reopen(), SMSC_TYPE_CIMD, SMSC_TYPE_EMI_X25, SMSC_TYPE_OIS, SMSC_TYPE_SEMA_X28, smscenter_lock(), smscenter_unlock(), and SMSCenter::type.

Referenced by reconnect().

{
    int ret;

    if (smsc->killed)
    return -2;

    smscenter_lock(smsc);

    switch (smsc->type) {
    case SMSC_TYPE_CIMD:
        ret = cimd_reopen(smsc);
    break;
    case SMSC_TYPE_EMI_X25:
        ret = emi_reopen(smsc);
    break;
    case SMSC_TYPE_SEMA_X28:
        ret = sema_reopen(smsc);
    break;
    case SMSC_TYPE_OIS:
        ret = ois_reopen(smsc);
    break;
        /* add new SMSCes here */
    default:        /* Unknown SMSC type */
        ret = -2;       /* no use */
    }

    smscenter_unlock(smsc);
    return ret;
}

smscenter_construct()

SMSCenter* smscenter_construct

(

void

)

Definition at line 101 of file smsc.c.

References SMSCenter::allowed_prefix, SMSCenter::alt_charset, SMSCenter::buffer, SMSCenter::buflen, SMSCenter::bufsize, SMSCenter::cimd_hostname, SMSCenter::cimd_password, SMSCenter::cimd_port, SMSCenter::cimd_username, SMSCenter::denied_prefix, SMSCenter::emi_password, SMSCenter::emi_phonenum, SMSCenter::emi_serialdevice, SMSCenter::emi_username, SMSCenter::hostname, SMSCenter::id, SMSCenter::keepalive, SMSCenter::killed, SMSCenter::mutex, mutex_create, SMSCenter::name, SMSCenter::ois_ack_debt, SMSCenter::ois_alive, SMSCenter::ois_alive2, SMSCenter::ois_buffer, SMSCenter::ois_buflen, SMSCenter::ois_bufsize, SMSCenter::ois_flags, SMSCenter::ois_listening_socket, SMSCenter::ois_received_mo, SMSCenter::ois_socket, SMSCenter::port, SMSCenter::preferred_prefix, SMSCenter::sema_fd, SMSCenter::sema_homenua, SMSCenter::sema_serialdevice, SMSCenter::sema_smscnua, SMSC_TYPE_DELETED, SMSCenter::socket, and SMSCenter::type.

Referenced by cimd_open(), emi_open(), ois_open(), and sema_open().

{
    SMSCenter *smsc;
    static int next_id = 1;

    smsc = gw_malloc(sizeof(SMSCenter));

    smsc->killed = 0;
    smsc->type = SMSC_TYPE_DELETED;
    smsc->preferred_prefix = NULL;
    smsc->allowed_prefix = NULL;
    smsc->denied_prefix = NULL;
    smsc->alt_charset = 0;
    smsc->keepalive = 0;

    smsc->mutex = mutex_create();

    sprintf(smsc->name, "Unknown SMSC");
    smsc->id = next_id++;

    /* FAKE */
    smsc->hostname = NULL;
    smsc->port = -1;
    smsc->socket = -1;

    /* CIMD */
    smsc->cimd_hostname = NULL;
    smsc->cimd_port = -1;
    smsc->cimd_username = NULL;
    smsc->cimd_password = NULL;

    /* EMI_X25 */
    smsc->emi_phonenum = NULL;
    smsc->emi_serialdevice = NULL;
    smsc->emi_username = NULL;
    smsc->emi_password = NULL;

    /* SEMA SMS2000 */
    smsc->sema_smscnua = NULL;
    smsc->sema_homenua = NULL;
    smsc->sema_serialdevice = NULL;
    smsc->sema_fd = -1;

    /* SEMA SMS2000 OIS X.25 */
    smsc->ois_alive = 0;
    smsc->ois_alive2 = 0;
    smsc->ois_received_mo = NULL;
    smsc->ois_ack_debt = 0;
    smsc->ois_flags = 0;
    smsc->ois_listening_socket = -1;
    smsc->ois_socket = -1;
    smsc->ois_buflen = 0;
    smsc->ois_bufsize = 0;
    smsc->ois_buffer = 0;

    /* add new SMSCes here */

    /* Memory */
    smsc->buflen = 0;
    smsc->bufsize = 10*1024;
    smsc->buffer = gw_malloc(smsc->bufsize);
    memset(smsc->buffer, 0, smsc->bufsize);

    return smsc;
}

smscenter_destruct()

void smscenter_destruct

(

SMSCenter *

smsc

)

Definition at line 168 of file smsc.c.

References SMSCenter::buffer, SMSCenter::cimd_hostname, SMSCenter::cimd_password, SMSCenter::cimd_username, SMSCenter::emi_password, SMSCenter::emi_phonenum, SMSCenter::emi_serialdevice, SMSCenter::emi_username, SMSCenter::hostname, SMSCenter::mutex, mutex_destroy(), SMSCenter::ois_buffer, ois_delete_queue(), SMSCenter::sema_homenua, SMSCenter::sema_serialdevice, and SMSCenter::sema_smscnua.

Referenced by cimd_open(), emi_open(), ois_open(), and sema_open().

{
    if (smsc == NULL)
        return;

    /* FAKE */
    gw_free(smsc->hostname);

    /* CIMD */
    gw_free(smsc->cimd_hostname);
    gw_free(smsc->cimd_username);
    gw_free(smsc->cimd_password);

    /* EMI_X25 */
    gw_free(smsc->emi_phonenum);
    gw_free(smsc->emi_serialdevice);
    gw_free(smsc->emi_username);
    gw_free(smsc->emi_password);

    /* SEMA */
    gw_free(smsc->sema_smscnua);
    gw_free(smsc->sema_homenua);
    gw_free(smsc->sema_serialdevice);

    /* OIS */
    ois_delete_queue(smsc);
    gw_free(smsc->ois_buffer);

    /* add new SMSCes here */

    /* Other fields */
    mutex_destroy(smsc->mutex);

    /* Memory */
    gw_free(smsc->buffer);
    gw_free(smsc);
}

smscenter_lock()

static void smscenter_lock ( SMSCenter *  smsc )

static

Definition at line 422 of file smsc.c.

References error(), SMSCenter::mutex, mutex_lock, SMSC_TYPE_DELETED, and SMSCenter::type.

Referenced by smsc_close(), smsc_reopen(), smscenter_pending_smsmessage(), smscenter_receive_msg(), and smscenter_submit_msg().

{
    if (smsc->type == SMSC_TYPE_DELETED)
        error(0, "smscenter_lock called on DELETED SMSC.");
    mutex_lock(smsc->mutex);
}

smscenter_pending_smsmessage()

int smscenter_pending_smsmessage

(

SMSCenter *

smsc

)

Definition at line 302 of file smsc.c.

References cimd_pending_smsmessage(), emi_pending_smsmessage(), error(), ois_pending_smsmessage(), sema_pending_smsmessage(), SMSC_TYPE_CIMD, SMSC_TYPE_EMI_X25, SMSC_TYPE_OIS, SMSC_TYPE_SEMA_X28, smscenter_lock(), smscenter_unlock(), and SMSCenter::type.

Referenced by sms_receive().

{
    int ret;

    smscenter_lock(smsc);

    switch (smsc->type) {

    case SMSC_TYPE_CIMD:
        ret = cimd_pending_smsmessage(smsc);
        if (ret == -1)
            goto error;
        break;

    case SMSC_TYPE_EMI_X25:
        ret = emi_pending_smsmessage(smsc);
        if (ret == -1)
            goto error;
        break;

    case SMSC_TYPE_SEMA_X28:
        ret = sema_pending_smsmessage(smsc);
        if (ret == -1)
            goto error;
        break;

    case SMSC_TYPE_OIS:
        ret = ois_pending_smsmessage(smsc);
        if (ret == -1)
            goto error;
        break;

    default:
        goto error;
    }

    smscenter_unlock(smsc);
    return ret;

error:
    error(0, "smscenter_pending_smsmessage is failing");
    smscenter_unlock(smsc);
    return -1;
}

smscenter_read_into_buffer()

int smscenter_read_into_buffer

(

SMSCenter *

smsc

)

Definition at line 348 of file smsc.c.

References SMSCenter::buffer, SMSCenter::buflen, SMSCenter::bufsize, error(), SMSCenter::hostname, MAX_READ_INTO_BUFFER, SMSCenter::port, and SMSCenter::socket.

Referenced by cimd_open_connection(), cimd_pending_smsmessage(), connect_tcpip(), expect_acknowledge(), and ois_read_into_buffer().

{
    char *p;
    int ret;
    fd_set read_fd;
    struct timeval tv, tvinit;
    size_t bytes_read;

    tvinit.tv_sec = 0;
    tvinit.tv_usec = 1000;

    bytes_read = 0;
    for (;;) {
        FD_ZERO(&read_fd);
        FD_SET(smsc->socket, &read_fd);
        tv = tvinit;
        ret = select(smsc->socket + 1, &read_fd, NULL, NULL, &tv);
        if (ret == -1) {
            if (errno == EINTR) goto got_data;
            if (errno == EAGAIN) goto got_data;
            error(errno, "Error doing select for socket");
            goto error;
        } else if (ret == 0)
            goto got_data;

        if (smsc->buflen == smsc->bufsize) {
            p = gw_realloc(smsc->buffer, smsc->bufsize * 2);
            smsc->buffer = p;
            smsc->bufsize *= 2;
        }

        ret = read(smsc->socket,
                   smsc->buffer + smsc->buflen,
                   1);
        if (ret == -1) {
            error(errno, "Reading from `%s' port `%d' failed.",
                  smsc->hostname, smsc->port);
            goto error;
        }
        if (ret == 0)
            goto eof;
        smsc->buflen += ret;
        bytes_read += ret;
        if (bytes_read >= MAX_READ_INTO_BUFFER)
            break;
    }

eof:
    ret = 0;
    goto unblock;

got_data:
    ret = 1;
    goto unblock;

error:
    ret = -1;
    goto unblock;

unblock:
    return ret;
}

smscenter_receive_msg()

int smscenter_receive_msg	(	SMSCenter *	smsc,
		Msg **	msg
	)

Definition at line 251 of file smsc.c.

References cimd_receive_msg(), emi_receive_msg(), error(), msg, ois_receive_msg(), sema_receive_msg(), SMSC_TYPE_CIMD, SMSC_TYPE_EMI_X25, SMSC_TYPE_OIS, SMSC_TYPE_SEMA_X28, smscenter_lock(), smscenter_unlock(), and SMSCenter::type.

Referenced by sms_receive().

{
    int ret;

    smscenter_lock(smsc);

    switch (smsc->type) {

    case SMSC_TYPE_CIMD:
        ret = cimd_receive_msg(smsc, msg);
        if (ret == -1)
            goto error;
        break;

    case SMSC_TYPE_EMI_X25:
        ret = emi_receive_msg(smsc, msg);
        if (ret == -1)
            goto error;
        break;

    case SMSC_TYPE_OIS:
        ret = ois_receive_msg(smsc, msg);
        if (ret == -1)
            goto error;
        break;


    case SMSC_TYPE_SEMA_X28:
        ret = sema_receive_msg(smsc, msg);
        if (ret == -1)
            goto error;
        break;

    default:
        goto error;

    }
    smscenter_unlock(smsc);

    /* If the SMSC didn't set the timestamp, set it here. */
    if (ret == 1 && msg_type(*msg) == sms && (*msg)->sms.time == 0)
        time(&(*msg)->sms.time);

    return ret;

error:
    smscenter_unlock(smsc);
    return -1;
}

smscenter_remove_from_buffer()

void smscenter_remove_from_buffer	(	SMSCenter *	smsc,
		size_t	n
	)

Definition at line 412 of file smsc.c.

References SMSCenter::buffer, and SMSCenter::buflen.

Referenced by cimd_open_connection(), cimd_pending_smsmessage(), cimd_receive_msg(), connect_tcpip(), expect_acknowledge(), ois_close(), ois_extract_line_from_buffer(), and ois_extract_msg_from_buffer().

{
    memmove(smsc->buffer, smsc->buffer + n, smsc->buflen - n);
    smsc->buflen -= n;
}

smscenter_submit_msg()

int smscenter_submit_msg	(	SMSCenter *	smsc,
		Msg *	msg
	)

Definition at line 209 of file smsc.c.

References cimd_submit_msg(), emi_submit_msg(), error(), msg, ois_submit_msg(), sema_submit_msg(), SMSC_TYPE_CIMD, SMSC_TYPE_EMI_X25, SMSC_TYPE_OIS, SMSC_TYPE_SEMA_X28, smscenter_lock(), smscenter_unlock(), and SMSCenter::type.

Referenced by sms_send().

{
    smscenter_lock(smsc);

    switch (smsc->type) {

    case SMSC_TYPE_CIMD:
        if (cimd_submit_msg(smsc, msg) == -1)
            goto error;
        break;

    case SMSC_TYPE_EMI_X25:
        if (emi_submit_msg(smsc, msg) == -1)
            goto error;
        break;

    case SMSC_TYPE_SEMA_X28:
        if (sema_submit_msg(smsc, msg) == -1)
            goto error;
        break;

    case SMSC_TYPE_OIS:
        if (ois_submit_msg(smsc, msg) == -1)
            goto error;
        break;

        /* add new SMSCes here */

    default:
        goto error;
    }

    smscenter_unlock(smsc);
    return 0;

error:
    smscenter_unlock(smsc);
    return -1;
}

smscenter_unlock()

static void smscenter_unlock ( SMSCenter *  smsc )

static

Definition at line 433 of file smsc.c.

References SMSCenter::mutex, and mutex_unlock.

Referenced by smsc_reopen(), smscenter_pending_smsmessage(), smscenter_receive_msg(), and smscenter_submit_msg().

{
    mutex_unlock(smsc->mutex);
}