smsc_p.h File Reference

#include <stddef.h>
#include <stdio.h>
#include <signal.h>
#include <time.h>
#include "smsc.h"

Go to the source code of this file.

Data Structures
struct	SMSCenter

Macros
#define	DIAL_PREFIX_MAX_LEN   1024

Enumerations
enum	{   SMSC_TYPE_DELETED, SMSC_TYPE_CIMD, SMSC_TYPE_EMI_X25, SMSC_TYPE_SEMA_X28,   SMSC_TYPE_OIS }

Functions
SMSCenter *	smscenter_construct (void)
void	smscenter_destruct (SMSCenter *smsc)
int	smscenter_read_into_buffer (SMSCenter *)
void	smscenter_remove_from_buffer (SMSCenter *smsc, size_t n)
int	smscenter_submit_msg (SMSCenter *smsc, Msg *msg)
int	smscenter_receive_msg (SMSCenter *smsc, Msg **msg)
int	smscenter_pending_smsmessage (SMSCenter *smsc)
SMSCenter *	cimd_open (char *hostname, int port, char *username, char *password)
int	cimd_reopen (SMSCenter *smsc)
int	cimd_close (SMSCenter *smsc)
int	cimd_pending_smsmessage (SMSCenter *smsc)
int	cimd_submit_msg (SMSCenter *smsc, Msg *msg)
int	cimd_receive_msg (SMSCenter *smsc, Msg **msg)
SMSCenter *	emi_open (char *phonenum, char *serialdevice, char *username, char *password)
int	emi_reopen (SMSCenter *smsc)
int	emi_close (SMSCenter *smsc)
SMSCenter *	emi_open_ip (char *hostname, int port, char *username, char *password, int receive_port, char *allow_ip, int our_port)
int	emi_reopen_ip (SMSCenter *smsc)
int	emi_close_ip (SMSCenter *smsc)
int	emi_pending_smsmessage (SMSCenter *smsc)
int	emi_submit_msg (SMSCenter *smsc, Msg *msg)
int	emi_receive_msg (SMSCenter *smsc, Msg **msg)
SMSCenter *	sema_open (char *smscnua, char *homenua, char *serialdevice, int waitreport)
int	sema_reopen (SMSCenter *smsc)
int	sema_close (SMSCenter *smsc)
int	sema_pending_smsmessage (SMSCenter *smsc)
int	sema_submit_msg (SMSCenter *smsc, Msg *msg)
int	sema_receive_msg (SMSCenter *smsc, Msg **msg)
SMSCenter *	ois_open (int receiveport, const char *hostname, int port, int debug_level)
int	ois_reopen (SMSCenter *smsc)
int	ois_close (SMSCenter *smsc)
int	ois_pending_smsmessage (SMSCenter *smsc)
int	ois_submit_msg (SMSCenter *smsc, const Msg *msg)
int	ois_receive_msg (SMSCenter *smsc, Msg **msg)
void	ois_delete_queue (SMSCenter *smsc)

Macro Definition Documentation

DIAL_PREFIX_MAX_LEN

#define DIAL_PREFIX_MAX_LEN   1024

Definition at line 90 of file smsc_p.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
SMSC_TYPE_DELETED
SMSC_TYPE_CIMD
SMSC_TYPE_EMI_X25
SMSC_TYPE_SEMA_X28
SMSC_TYPE_OIS

Definition at line 79 of file smsc_p.h.

     {
    SMSC_TYPE_DELETED,
    SMSC_TYPE_CIMD,
    SMSC_TYPE_EMI_X25,
    SMSC_TYPE_SEMA_X28,
    SMSC_TYPE_OIS,
};

Function Documentation

cimd_close()

int cimd_close

(

SMSCenter *

smsc

)

Definition at line 228 of file smsc_cimd.c.

References debug(), error(), SMSCenter::socket, and write_to_socket().

Referenced by cimd_open_connection(), cimd_reopen(), and smsc_close().

{

    char *cbuff = NULL;
    int sum;
    int ret;

    if (smsc->socket == -1) {
        debug("bb.sms.cimd", 0, "Trying to close cimd while already closed!");
        return 0;
    }
    cbuff = gw_malloc(2 * 1024);

    sprintf(cbuff, "%c%s%c%s%c%c", 0x02, "02", 0x09, "11", 0x03, 0x0A);

    sum = write_to_socket(smsc->socket, cbuff);
    if (sum < 0) goto error;

    /* this time we don't block waiting for acknowledge */
    recv(smsc->socket, cbuff, 2*1024, 0);

    gw_free(cbuff);

    ret = close(smsc->socket);
    smsc->socket = -1;
    return ret;

error:
    gw_free(cbuff);
    return -1;
}

cimd_open()

SMSCenter* cimd_open	(	char *	hostname,
		int	port,
		char *	username,
		char *	password
	)

Definition at line 174 of file smsc_cimd.c.

References SMSCenter::cimd_hostname, cimd_open_connection(), SMSCenter::cimd_password, SMSCenter::cimd_port, SMSCenter::cimd_username, error(), SMSCenter::hostname, hostname, SMSCenter::name, password, port, SMSC_TYPE_CIMD, smscenter_construct(), smscenter_destruct(), SMSCenter::type, and username.

Referenced by smsc_open().

{

    SMSCenter *smsc = NULL;
    int ret = 0;

    /* create a SMSCenter structure */
    smsc = smscenter_construct();
    if (smsc == NULL) goto error;
    smsc->type = SMSC_TYPE_CIMD;
    smsc->cimd_hostname = gw_strdup(hostname);
    smsc->hostname = gw_strdup(hostname); /* Needed by read_into_buffer() */
    smsc->cimd_port = port;
    smsc->cimd_username = gw_strdup(username);
    smsc->cimd_password = gw_strdup(password);

    ret = cimd_open_connection(smsc);
    if (ret < 0)
        goto error;

    sprintf(smsc->name, "CIMD:%s:%d:%s", smsc->cimd_hostname,
            smsc->cimd_port, smsc->cimd_username);
    return smsc;

error:
    error(0, "cimd_open: could not open!");
    smscenter_destruct(smsc);
    return NULL;
}

cimd_pending_smsmessage()

int cimd_pending_smsmessage

(

SMSCenter *

smsc

)

Definition at line 264 of file smsc_cimd.c.

References SMSCenter::buffer, SMSCenter::buflen, SMSCenter::cimd_last_spoke, connect_tcpip(), debug(), error(), smscenter_read_into_buffer(), smscenter_remove_from_buffer(), SMSCenter::socket, and write_to_socket().

Referenced by smscenter_pending_smsmessage().

{

    char *tmpbuff = NULL, *newline = NULL;
    int ret = 0;
    time_t thetime = 0;

    /* check for input sanity */
    if (smsc == NULL)
        goto error;

    /* we can only query every 5 seconds */
    thetime = time(NULL);
    if ((smsc->cimd_last_spoke + 5) > thetime) goto no_messages;
    smsc->cimd_last_spoke = thetime;

    /* allocate some spare space */
    tmpbuff = gw_malloc(10 * 1024);
    memset(tmpbuff, 0, 10*1024);

    sprintf(tmpbuff, "%c%s%c%s%c%c",
            0x02,         /* stx */
            "05", 0x09,   /* request for message, tab */
            "11",         /* dummy chksum */
            0x03, 0x0A);  /* etx, lf */

    /* send the poll message to determine if we have messages in queue */
    ret = write_to_socket(smsc->socket, tmpbuff);
    if (ret < 0) {
        debug("bb.sms.cimd", 0, "sending poll message failed");
        goto error;
    }
    /* block while waiting for answer that dataset ends to a 0x0A */
    for (;;) {

        newline = memchr(smsc->buffer, 0x0A, smsc->buflen);
        if (newline != NULL) break;

        newline = memchr(smsc->buffer, 0x03, smsc->buflen);
        if (newline != NULL) break;

        ret = smscenter_read_into_buffer(smsc);
        if (ret <= 0) {
            debug("bb.sms.cimd", 0, "read_into_buffer failed!, ret=%d", ret);
            goto error;
        }

        usleep(500);

        /* Reconnect if no results in 30 seconds */
        if (time(NULL) > (thetime + 30)) {

            error(0, "timeout occurred, maybe the connection was broken?");

            /* Reconnect if neccessary, this catches most of them */
            /* XXX this is an ugly kludge, but then again,
               CIMD 1.3 is an ugly kludge. */
            connect_tcpip(smsc);
            goto no_messages;

        }

    }

    /* if we got an nck, cut the message out and return 0 */
    newline = memchr(smsc->buffer, 0x15, smsc->buflen);
    if (newline != NULL) {
        newline = memchr(smsc->buffer, 0x0A, smsc->buflen);
        if (newline == NULL)
            newline = memchr(smsc->buffer, 0x03, smsc->buflen);
        smscenter_remove_from_buffer(smsc, newline - smsc->buffer + 1);
        goto no_messages;
    }

    /* miracle of miracles, we got a message */
    gw_free(tmpbuff);
    return 1;

no_messages:
    gw_free(tmpbuff);
    return 0;

error:

    debug("bb.sms.cimd", 0, "smscenter_pending_smsmessage: returning error");
    gw_free(tmpbuff);
    return -1;
}

cimd_receive_msg()

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

Definition at line 470 of file smsc_cimd.c.

References SMSCenter::buffer, SMSCenter::buflen, SMSCenter::cimd_last_spoke, debug(), error(), msg, msg_create, octstr_create, parse_cimd_to_iso88591(), send_acknowledge(), smscenter_remove_from_buffer(), and text.

Referenced by smscenter_receive_msg().

{

    char *tmpbuff = NULL, *sender = NULL;
    char *receiver = NULL, *text = NULL, *scts = NULL;
    char *tmpchar = NULL;

    debug("bb.sms.cimd", 0, "cimd_receive_smsmessage: starting");

    /* the PENDING function has previously requested for
       the message and checked that it safely found its 
       way into the memory buffer (smsc->buffer) */

    /* we want to temporarily store some data */
    tmpbuff = gw_malloc(10 * 1024);
    sender = gw_malloc(10 * 1024);
    receiver = gw_malloc(10 * 1024);
    text = gw_malloc(10 * 1024);
    scts = gw_malloc(10 * 1024);

    memset(tmpbuff, 0, 10 * 1024);
    memset(sender, 0, 10 * 1024);
    memset(receiver, 0, 10 * 1024);
    memset(text, 0, 10 * 1024);
    memset(scts, 0, 10 * 1024);

    /* cut the raw message out from the message buffer */
    tmpchar = memchr(smsc->buffer, 0x0A, smsc->buflen);
    if (tmpchar == NULL) {
        tmpchar = memchr(smsc->buffer, 0x03, smsc->buflen);
        if (tmpchar == NULL) goto error;
    }

    strncpy(tmpbuff, smsc->buffer, tmpchar - smsc->buffer);
    smscenter_remove_from_buffer(smsc, tmpchar - smsc->buffer + 1);

    /* Parse the raw message */
    sscanf(tmpbuff,
           "\x02\x06\tC:05\t%[^\t]\t%[^\t]\t%[^\t]\t%[^\t]\t11\x03\x0A",
           receiver, sender, text, scts);

    sscanf(tmpbuff,
           "\x02\x06\tC:05\t%[^\t]\t%[^\t]\t%[^\t]\t%[^\t]\t11\x03",
           receiver, sender, text, scts);

    /* Translate from the CIMD character set to iso8859-1 */
    parse_cimd_to_iso88591(text, tmpbuff, 10*1024);
    strncpy(text, tmpbuff, 480);

    /* create a smsmessage structure out of the components */
    *msg = msg_create(sms);
    if (*msg == NULL) return -1;
    (*msg)->sms.sender = octstr_create(sender);
    (*msg)->sms.receiver = octstr_create(receiver);
    (*msg)->sms.msgdata = octstr_create(text);

    /* Send acknowledge */
    send_acknowledge(smsc);

    /* We got a message so we can instantly check for a new one. */
    smsc->cimd_last_spoke -= 5;

    /* Free and Finish */

    gw_free(tmpbuff);
    gw_free(sender);
    gw_free(receiver);
    gw_free(text);
    gw_free(scts);

    debug("bb.sms.cimd", 0, "cimd_receive_smsmessage: return ok");

    return 1;

error:
    debug("bb.sms.cimd", 0, "cimd_receive_smsmessage: failed");
    gw_free(tmpbuff);
    gw_free(sender);
    gw_free(receiver);
    gw_free(text);
    gw_free(scts);

    debug("bb.sms.cimd", 0, "cimd_receive_smsmessage: return failed");

    return -1;
}

cimd_reopen()

int cimd_reopen

(

SMSCenter *

smsc

)

Definition at line 210 of file smsc_cimd.c.

References cimd_close(), cimd_open_connection(), and error().

Referenced by smsc_reopen().

{

    cimd_close(smsc);

    if (cimd_open_connection(smsc) < 0) {
        error(0, "Failed to re-open the connection!");
        return -1;
    }
    return 0;
}

cimd_submit_msg()

int cimd_submit_msg	(	SMSCenter *	smsc,
		Msg *	msg
	)

Definition at line 358 of file smsc_cimd.c.

References SMSCenter::alt_charset, SMSCenter::buffer, debug(), error(), expect_acknowledge(), msg, octstr_append_from_hex(), octstr_create, octstr_get_cstr, octstr_get_many_chars(), octstr_len(), parse_iso88591_to_cimd(), send_acknowledge(), SMSCenter::socket, warning(), and write_to_socket().

Referenced by smscenter_submit_msg().

{

    char *tmpbuff = NULL, *tmptext = NULL;
    char msgtext[1024];
    int ret;
    int cmd = 0, err = 0;

    /* Fix these by implementing a could-not-send-because-
       protocol-does-not-allow in smsc.c or smsgateway.c */
    if (octstr_len(msg->sms.msgdata) + octstr_len(msg->sms.udhdata) < 1) {
    if (msg->sms.msgdata == NULL)
        msg->sms.msgdata = octstr_create("");
    octstr_append_from_hex(msg->sms.msgdata, "20");
    }
    if (octstr_len(msg->sms.sender) < 1) {
        warning(0, "cimd_submit_smsmessage: ignoring message with 0-length field");
        goto okay;  /* THIS IS NOT OKAY!!!! XXX */
    }
    if (octstr_len(msg->sms.receiver) < 1) {
        warning(0, "cimd_submit_smsmessage: ignoring message with 0-length field");
        goto okay;  /* THIS IS NOT OKAY!!!! XXX */
    }

    tmpbuff = gw_malloc(10 * 1024);
    tmptext = gw_malloc(10 * 1024);

    memset(tmpbuff, 0, 10*1024);
    memset(tmptext, 0, 10*1024);
    memset(msgtext, 0, sizeof(msgtext));

    if (octstr_len(msg->sms.udhdata)) {
        octstr_get_many_chars(msgtext, msg->sms.udhdata, 0, octstr_len(msg->sms.udhdata));
        octstr_get_many_chars(msgtext + octstr_len(msg->sms.udhdata),
                              msg->sms.msgdata, 0,
                              140 - octstr_len(msg->sms.udhdata));
    } else {
        octstr_get_many_chars(msgtext, msg->sms.msgdata, 0,
                              octstr_len(msg->sms.msgdata));
    }

    /* XXX parse_iso88591_to_cimd should use Octstr
     * directly, or get a char* and a length, instead of using NUL
     * terminated strings.
     */
    parse_iso88591_to_cimd(msgtext, tmptext, 10*1024, smsc->alt_charset);

    /* If messages has UDHs, add the magic number 31 to the right spot */
    sprintf(tmpbuff, "%c%s%c%s%c%s%c%s%c%s%c%s%c%s%c%c",
            0x02,
            "03", 0x09,
            octstr_get_cstr(msg->sms.receiver), 0x09,
            tmptext, 0x09,
            "", 0x09,
            "", 0x09,
            (octstr_len(msg->sms.udhdata)) ? "31" : "", 0x09,
            "11", 0x03, 0x0A);

    ret = write_to_socket(smsc->socket, tmpbuff);
    if (ret < 0) {
        debug("bb.sms.cimd", 0, "cimd_submit_smsmessage: socket write error");
        goto error;
    }

    /* The Nokia SMSC MAY be configured to send delivery
       information, which we then will HAVE to acknowledge.
       Naturally the CIMD 1.3 protocol does not include any
       kind of negotiation mechanism. */
    ret = expect_acknowledge(smsc, &cmd, &err);

    if (ret >= 1) {

        if (cmd == 4) {
            send_acknowledge(smsc);
            goto okay;
        } else if (cmd == 3) {
            goto okay;
        }

    } else if (ret == 0) {

        if (cmd == 4) {
            send_acknowledge(smsc);
            goto okay;  /* FIXME XXX THIS IS BOGUS, FIX SMSGATEWAY.C */
            goto error;
        } else if (cmd == 3) {
            goto okay;  /* FIXME XXX THIS IS BOGUS, FIX SMSGATEWAY.C */
            goto error;
        } else {
            error(0, "Unexpected behaviour from the CIMD server");
            debug("bb.sms.cimd", 0, "cimd_submit_smsmessage: acknowledge was <%i>", ret);
            debug("bb.sms.cimd", 0, "cimd_submit_smsmessage: buffer==<%s>", smsc->buffer);
            goto error;
        }

    }

okay:
    gw_free(tmpbuff);
    gw_free(tmptext);
    return 0;

error:
    debug("bb.sms.cimd", 0, "cimd_submit_smsmessage: returning error");
    gw_free(tmpbuff);
    gw_free(tmptext);
    return -1;

}

emi_close()

int emi_close

(

SMSCenter *

smsc

)

Definition at line 194 of file smsc_emi_x25.c.

References emi_close_ip().

Referenced by emi_reopen(), and smsc_close().

{
    return emi_close_ip(smsc);
}

emi_close_ip()

int emi_close_ip

(

SMSCenter *

smsc

)

Definition at line 302 of file smsc_emi_x25.c.

References SMSCenter::emi_fd, and info().

Referenced by emi_close(), and emi_reopen_ip().

{

    if (smsc->emi_fd == -1) {
        info(0, "Trying to close already closed EMI, ignoring");
        return 0;
    }
    close(smsc->emi_fd);
    smsc->emi_fd = -1;

    return 0;
}

emi_open()

SMSCenter* emi_open	(	char *	phonenum,
		char *	serialdevice,
		char *	username,
		char *	password
	)

Definition at line 153 of file smsc_emi_x25.c.

References SMSCenter::emi_current_msg_number, emi_open_connection(), SMSCenter::emi_password, SMSCenter::emi_phonenum, SMSCenter::emi_serialdevice, SMSCenter::emi_username, error(), SMSCenter::name, password, SMSC_TYPE_EMI_X25, smscenter_construct(), smscenter_destruct(), SMSCenter::type, and username.

Referenced by smsc_open().

{
    SMSCenter *smsc;

    smsc = smscenter_construct();
    if (smsc == NULL)
        goto error;

    smsc->type = SMSC_TYPE_EMI_X25;

    smsc->emi_phonenum = gw_strdup(phonenum);
    smsc->emi_serialdevice = gw_strdup(serialdevice);
    smsc->emi_username = gw_strdup(username);
    smsc->emi_password = gw_strdup(password);

    smsc->emi_current_msg_number = 0;

    if (emi_open_connection(smsc) < 0)
        goto error;

    sprintf(smsc->name, "EMI:%s:%s", smsc->emi_phonenum,
            smsc->emi_username);
    return smsc;

error:
    error(0, "emi_open failed");
    smscenter_destruct(smsc);
    return NULL;
}

emi_open_ip()

SMSCenter* emi_open_ip	(	char *	hostname,
		int	port,
		char *	username,
		char *	password,
		int	receive_port,
		char *	allow_ip,
		int	our_port
	)

emi_pending_smsmessage()

int emi_pending_smsmessage

(

SMSCenter *

smsc

)

Definition at line 319 of file smsc_emi_x25.c.

References get_data(), guarantee_link(), memorybuffer_cut_rawmessage(), memorybuffer_has_rawmessage(), and memorybuffer_insert_data().

Referenced by smscenter_pending_smsmessage().

{

    char *tmpbuff;
    int n = 0;
    /*  time_t timenow; */

    /* Block until we have a connection */
    guarantee_link(smsc);

    /* If we have MO-message, then act (return 1) */
    if (memorybuffer_has_rawmessage(smsc, 52, 'O') > 0 ||
        memorybuffer_has_rawmessage(smsc, 1, 'O') > 0 )
        return 1;

    tmpbuff = gw_malloc(10 * 1024);
    memset(tmpbuff, 0, 10*1024);

    /* check for data */
    n = get_data(smsc, tmpbuff, 10 * 1024);
    if (n > 0)
        memorybuffer_insert_data(smsc, tmpbuff, n);

    /* delete all ACKs/NACKs/whatever */
    while (memorybuffer_has_rawmessage(smsc, 51, 'R') > 0 ||
           memorybuffer_has_rawmessage(smsc, 1, 'R') > 0)
        memorybuffer_cut_rawmessage(smsc, tmpbuff, 10*1024);

    gw_free(tmpbuff);

    /* If we have MO-message, then act (return 1) */

    if (memorybuffer_has_rawmessage(smsc, 52, 'O') > 0 ||
        memorybuffer_has_rawmessage(smsc, 1, 'O') > 0)
        return 1;

    /*
        time(&timenow);
        if( (smsc->emi_last_spoke + 60*20) < timenow) {
            time(&smsc->emi_last_spoke);
        }
    */

    return 0;

}

emi_receive_msg()

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

Definition at line 408 of file smsc_emi_x25.c.

References acknowledge_from_rawmessage(), error(), memorybuffer_cut_rawmessage(), msg, msg_destroy(), and parse_rawmessage_to_msg().

Referenced by smscenter_receive_msg().

{
    char *tmpbuff;
    Msg *msg = NULL;

    *tmsg = NULL;

    tmpbuff = gw_malloc(10 * 1024);
    memset(tmpbuff, 0, 10*1024);

    /* get and delete message from buffer */
    memorybuffer_cut_rawmessage(smsc, tmpbuff, 10*1024);
    parse_rawmessage_to_msg(smsc, &msg, tmpbuff, strlen(tmpbuff));

    /* yeah yeah, I got the message... */
    acknowledge_from_rawmessage(smsc, tmpbuff, strlen(tmpbuff));

    /* return with the joyful news */
    gw_free(tmpbuff);

    if (msg == NULL) goto error;

    *tmsg = msg;

    return 1;

error:
    gw_free(tmpbuff);
    msg_destroy(msg);
    return -1;
}

emi_reopen()

int emi_reopen

(

SMSCenter *

smsc

)

Definition at line 183 of file smsc_emi_x25.c.

References emi_close(), emi_open_connection(), and error().

Referenced by smsc_reopen().

{
    emi_close(smsc);

    if (emi_open_connection(smsc) < 0) {
        error(0, "emi_reopen failed");
        return -1;
    }
    return 0;
}

emi_reopen_ip()

int emi_reopen_ip

(

SMSCenter *

smsc

)

Definition at line 294 of file smsc_emi_x25.c.

References emi_close_ip(), and emi_open_connection_ip().

{
    emi_close_ip(smsc);

    return emi_open_connection_ip(smsc);
}

emi_submit_msg()

int emi_submit_msg	(	SMSCenter *	smsc,
		Msg *	msg
	)

Definition at line 372 of file smsc_emi_x25.c.

References debug(), error(), info(), parse_msg_to_rawmessage(), put_data(), and wait_for_ack().

Referenced by smscenter_submit_msg().

{
    char *tmpbuff = NULL;

    if (smsc == NULL) goto error;
    if (omsg == NULL) goto error;

    tmpbuff = gw_malloc(10 * 1024);
    memset(tmpbuff, 0, 10*1024);

    if (parse_msg_to_rawmessage(smsc, omsg, tmpbuff, 10*1024) < 1)
        goto error;

    if (put_data(smsc, tmpbuff, strlen(tmpbuff), 0) < 0) {
        info(0, "put_data failed!");
        goto error;
    }

    wait_for_ack(smsc, 51);

    /*  smsc->emi_current_msg_number += 1; */
    debug("bb.sms.emi", 0, "Submit Ok...");

    gw_free(tmpbuff);
    return 0;

error:
    debug("bb.sms.emi", 0, "Submit Error...");

    gw_free(tmpbuff);
    return -1;
}

ois_close()

int ois_close

(

SMSCenter *

smsc

)

Definition at line 263 of file smsc_ois.c.

References SMSCenter::buflen, ois_debug_level, ois_disconnect_all(), OIS_FLAG_DEBUG, SMSCenter::ois_flags, ois_swap_buffering(), SAY, SMSC_TYPE_OIS, smscenter_remove_from_buffer(), SMSCenter::type, and warning().

Referenced by ois_open_listener(), ois_reopen(), and smsc_close().

{
    ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
    SAY(2, "ois_close");

    if (smsc->type != SMSC_TYPE_OIS) {
    warning(0, "ois_close: closing a not-ois connection...");
    }

    ois_swap_buffering(smsc);
    smscenter_remove_from_buffer(smsc, smsc->buflen);
    ois_swap_buffering(smsc);
    smscenter_remove_from_buffer(smsc, smsc->buflen);
    SAY(4, "ois_close: ois_disconnect_all");
    ois_disconnect_all(smsc);

    return 0;
}

ois_delete_queue()

void ois_delete_queue

(

SMSCenter *

smsc

)

Definition at line 423 of file smsc_ois.c.

References msg, ois_debug_level, OIS_FLAG_DEBUG, SMSCenter::ois_flags, ois_receive_msg(), and SAY.

Referenced by smscenter_destruct().

{
    Msg *msg;

    ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
    SAY(2, "ois_delete_queue");

    while (ois_receive_msg(smsc, &msg) > 0) {
    gw_free(msg);
    }
    return;
}

ois_open()

SMSCenter* ois_open	(	int	receiveport,
		const char *	hostname,
		int	port,
		int	debug_level
	)

Definition at line 222 of file smsc_ois.c.

References error(), SMSCenter::hostname, hostname, SMSCenter::name, ois_debug_level, OIS_FLAG_DEBUG, SMSCenter::ois_flags, ois_open_listener(), port, SMSCenter::port, SMSCenter::receive_port, SAY, SMSC_TYPE_OIS, smscenter_construct(), smscenter_destruct(), and SMSCenter::type.

Referenced by smsc_open().

{
    SMSCenter *smsc;
    int ret;

    ois_debug_level = debug_level & OIS_FLAG_DEBUG;
    SAY(2, "ois_open");

    /* create a SMSCenter structure */

    smsc = smscenter_construct();
    if (smsc == NULL) {
    goto error;
    }

    smsc->type = SMSC_TYPE_OIS;
    smsc->receive_port = receiveport;
    smsc->hostname = gw_strdup(hostname);
    smsc->port = port;
    smsc->ois_flags = ois_debug_level;

    ret = ois_open_listener(smsc);
    if (ret < 0) {
    goto error;
    }
    sprintf(smsc->name, "OIS:TCP/X.25-Translator:localhost:%d:TCP:%.512s:%d",
        smsc->receive_port, smsc->hostname, smsc->port);

    return smsc;

 error:
    error(0, "ois_open: could not open");
    smscenter_destruct(smsc);
    return NULL;
}

ois_pending_smsmessage()

int ois_pending_smsmessage

(

SMSCenter *

smsc

)

Definition at line 318 of file smsc_ois.c.

References SMSCenter::ois_ack_debt, ois_check_incoming(), ois_check_input(), ois_debug_level, OIS_FLAG_DEBUG, SMSCenter::ois_flags, OIS_NOWAIT, SMSCenter::ois_socket, ois_swap_buffering(), SAY, SMSCenter::socket, and warning().

Referenced by smscenter_pending_smsmessage().

{
    int ret;

    ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
    SAY(8, "ois_pending_smsmessage");

    ret = ois_check_incoming(smsc, OIS_NOWAIT);
    if (ret == 0 && smsc->socket != -1) {
    ret = ois_check_input(smsc, OIS_NOWAIT);
    }
    if (ret == 0 && smsc->ois_socket != -1) {
    ois_swap_buffering(smsc);
    ret = ois_check_input(smsc, OIS_NOWAIT);
    ois_swap_buffering(smsc);
    if (smsc->ois_socket == -1 && smsc->ois_ack_debt != 0) {
        warning(0, "ois_pending_smsmessage: missing %d ack(s)...",
            smsc->ois_ack_debt);
    }
    }
    return ret;
}

ois_receive_msg()

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

Definition at line 396 of file smsc_ois.c.

References msg, ois_listentry::msg, ois_listentry::next, ois_debug_level, OIS_FLAG_DEBUG, OIS_FLAG_ERROR, SMSCenter::ois_flags, SMSCenter::ois_received_mo, and SAY.

Referenced by ois_delete_queue(), and smscenter_receive_msg().

{
    ois_listentry *item;

    ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
    SAY(2, "ois_receive_msg");

    item = smsc->ois_received_mo;
    if (item == NULL) { /* no mo messages */
    if ((smsc->ois_flags & OIS_FLAG_ERROR) == 0) {
        return 0;   /* should actually not happen */
    } else {
        return -1;  /* error pending, reopen? */
    }
    } else {            /* we have a message waiting */
    smsc->ois_received_mo = item->next;
    *msg = item->msg;
    gw_free(item);
    return 1;       /* got the message */
    }
}

ois_reopen()

int ois_reopen

(

SMSCenter *

smsc

)

Definition at line 287 of file smsc_ois.c.

References error(), ois_close(), ois_debug_level, OIS_FLAG_DEBUG, SMSCenter::ois_flags, ois_open_listener(), SAY, SMSC_TYPE_OIS, and SMSCenter::type.

Referenced by smsc_reopen().

{
    int ret;

    ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
    SAY(2, "ois_reopen");

    ois_close(smsc);

    if (smsc->type == SMSC_TYPE_OIS) {
    ret = ois_open_listener(smsc);
    if (ret < 0) {
        goto error;
    }
    } else {
    error(0, "ois_reopen: wrong smsc type");
    goto error;
    }
    return 0;

 error:
    error(0, "ois_reopen: could not open");
    return -1;
}

ois_submit_msg()

int ois_submit_msg	(	SMSCenter *	smsc,
		const Msg *	msg
	)

Definition at line 346 of file smsc_ois.c.

References error(), msg, SMSCenter::ois_ack_debt, SMSCenter::ois_alive, ois_debug_level, ois_disconnect(), OIS_FLAG_DEBUG, SMSCenter::ois_flags, ois_open_sender(), ois_submit_sm_invoke(), ois_swap_buffering(), SAY, SMSCenter::socket, and warning().

Referenced by smscenter_submit_msg().

{
    int ret;

    ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
    SAY(2, "ois_submit_msg");
    ois_swap_buffering(smsc);

    if (msg_type((Msg *)msg) != sms) {
    error(0, "ois_submit_msg: can not handle message types other than smart_msg");
    goto error;
    }

    if (smsc->socket == -1) {
    ret = ois_open_sender(smsc);
    if (ret < 0) {
        goto error;
    }
    }

    ret = ois_submit_sm_invoke(smsc, msg);
    if (ret < 0) {
    goto error_close;
    }

    ++smsc->ois_ack_debt;
    time(&smsc->ois_alive);
    ret = 0;
    goto out;

 error_close:
    if (smsc->ois_ack_debt != 0) {
    warning(0, "ois_submit_msg: missing %d ack(s)...",
        smsc->ois_ack_debt);
    }
    SAY(4, "ois_submit_msg: ois_disconnect in error_close");
    ois_disconnect(smsc);
 error:
    SAY(2, "ois_submit_msg error");
    ret = -1;
 out:
    ois_swap_buffering(smsc);
    return ret;
}

sema_close()

int sema_close

(

SMSCenter *

smsc

)

Definition at line 199 of file smsc_sema.c.

References SMSCenter::sema_fd, SMSCenter::sema_mo, sema_msglist_free(), and SMSCenter::sema_mt.

Referenced by smsc_close().

{
    if(smsc->sema_fd > 0)
    close(smsc->sema_fd);
    /*deallocate*/
    sema_msglist_free(smsc->sema_mt);
    sema_msglist_free(smsc->sema_mo);
    return 0;
}

sema_open()

SMSCenter* sema_open	(	char *	smscnua,
		char *	homenua,
		char *	serialdevice,
		int	waitreport
	)

Definition at line 113 of file smsc_sema.c.

References debug(), error(), SMSCenter::name, SMSCenter::sema_fd, SMSCenter::sema_homenua, SMSCenter::sema_mo, sema_msglist_new(), SMSCenter::sema_mt, SMSCenter::sema_serialdevice, SMSCenter::sema_smscnua, sema_wait_report, SMSC_TYPE_SEMA_X28, smscenter_construct(), smscenter_destruct(), SMSCenter::type, X28_close_send_link(), X28_open_data_link(), and X28_open_send_link().

Referenced by smsc_open().

{
    SMSCenter *smsc;
    int nret = -1;

    smsc = smscenter_construct();
    if(smsc == NULL)
      goto error;

    sprintf(smsc->name, "SEMA:X28:"); 

    smsc->type = SMSC_TYPE_SEMA_X28;
    smsc->sema_smscnua = gw_strdup(smscnua);
    smsc->sema_homenua = gw_strdup(homenua);
    smsc->sema_serialdevice = gw_strdup(serialdevice);
    sema_wait_report = waitreport;

    smsc->sema_mt = sema_msglist_new();
    if(smsc->sema_mt == NULL) goto error;
    
    smsc->sema_mo = sema_msglist_new();
    if(smsc->sema_mo == NULL) goto error;

    /* Open the device properly. Remember to set the
       access codes correctly. */
    debug("smsc.sema", 0, "sema_open: open datalink");
    smsc->sema_fd = X28_open_data_link(smsc->sema_serialdevice);
    if(smsc->sema_fd == -1) goto error;

    /*  test the outgoing callX28 to smsc center */
        debug("smsc.sema", 0, "sema_open: test send link");
    nret = X28_open_send_link(smsc->sema_fd, smsc->sema_smscnua);
    if(nret < 1){
      sleep(2);
      nret = X28_open_send_link(smsc->sema_fd, smsc->sema_smscnua);  
      if(nret < 1)
        goto error;
    }
    X28_close_send_link(smsc->sema_fd);
    return smsc;

error:
    error(0, "sema_open: could not open");
    smscenter_destruct(smsc);
    return NULL;
}

sema_pending_smsmessage()

int sema_pending_smsmessage

(

SMSCenter *

smsc

)

Definition at line 365 of file smsc_sema.c.

References SMSCenter::buffer, debug(), error(), sema_msglist::first, SMSCenter::sema_fd, SMSCenter::sema_mo, sema_msg_session_mo(), SMSCenter::sema_serialdevice, X28_data_read(), X28_msg_pop(), and X28_reopen_data_link().

Referenced by smscenter_pending_smsmessage().

{

    char data[1024];
    int ret = 0;
    char clrbuff[]="CLR\0";
    char errbuff[]="ERR\0";
    /* struct sema_msg* smsg = NULL;*/

  /* Receive raw data */
    ret = X28_data_read(smsc->sema_fd, smsc->buffer);
    if(ret == -1) {
    ret = X28_reopen_data_link(smsc->sema_fd, smsc->sema_serialdevice);
    if(ret == -1) goto error;
    return 0;
    } 

    /* Interpret the raw data */
    memset(data,0,sizeof(data));
    while(X28_msg_pop(smsc->buffer, data) == 0 ) {
    if(strlen(data) > 0){
        if(strstr(data,clrbuff) != NULL ||
           strstr(data,errbuff) != NULL){
        debug("smsc.sema", 0, "sema_pending_msg: Radio Pad Command line-%s",data);
        }
        else{   
          
        ret = sema_msg_session_mo(smsc, data);
        if(ret == -1) goto error;
        }
        memset(data,0,sizeof(data));
    }
    }

    /* Signal that we got a MO message if mo list is not empty*/
    if(smsc->sema_mo->first != NULL){
    return 1;
    }


    return 0;

error:
    error(0,"sema_pending message: device file error");
    return -1;
}

sema_receive_msg()

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

Definition at line 323 of file smsc_sema.c.

References DC_8BIT, sm_deliver_invoke::destadd, error(), msg, msg_create, sema_msg::msgbody, octstr_create, octstr_create_from_data, octstr_duplicate, octstr_get_cstr, octstr_len(), sm_deliver_invoke::origadd, SMSCenter::sema_mo, sema_msg_free(), sema_msglist_pop(), and sm_deliver_invoke::shortmsg.

Referenced by smscenter_receive_msg().

{

    struct sema_msg *rmsg = NULL;
    struct sm_deliver_invoke *recieve_sm = NULL;
 
    while(sema_msglist_pop(smsc->sema_mo, &rmsg) == 1 ) {
  
    *msg = msg_create(sms);
    if(*msg==NULL) goto error;
    
    recieve_sm = (struct sm_deliver_invoke*) rmsg->msgbody;
    if(recieve_sm==NULL) goto error;
          
    /* as IA5(8 bit character) is the default line encoding used by X28
     * and we do not support other line encoding scheme like binary or
     * hex encoding
     */
    (*msg)->sms.coding = DC_8BIT;
    /* OIS in X28 implementation does not include udh field */

    (*msg)->sms.sender = octstr_create_from_data(
        octstr_get_cstr(recieve_sm->origadd) +2,
        octstr_len(recieve_sm->origadd)-2);  
    (*msg)->sms.receiver = octstr_create_from_data(
        octstr_get_cstr(recieve_sm->destadd) +2,
        octstr_len(recieve_sm->destadd)-2);
  
    (*msg)->sms.msgdata = octstr_duplicate(recieve_sm->shortmsg);
    (*msg)->sms.udhdata = octstr_create("");
    gw_free(recieve_sm);
    sema_msg_free(rmsg);
    rmsg = NULL;
    }
    return 1;

error:
    error(0, "sema_receive_msg: can not create Smart Msg");
    return -1;
}

sema_reopen()

int sema_reopen

(

SMSCenter *

smsc

)

Definition at line 162 of file smsc_sema.c.

References SMSCenter::buffer, debug(), error(), SMSCenter::sema_fd, SMSCenter::sema_mo, sema_msglist_free(), sema_msglist_new(), SMSCenter::sema_mt, SMSCenter::sema_serialdevice, SMSCenter::sema_smscnua, X28_close_send_link(), X28_open_send_link(), and X28_reopen_data_link().

Referenced by smsc_reopen().

{
    int nret = 0;

    debug("smsc.sema", 0, "reopening the connection");

    /*deallocate*/
    sema_msglist_free(smsc->sema_mt);
    sema_msglist_free(smsc->sema_mo);
    /*reallocate*/
    smsc->sema_mt = sema_msglist_new();
    if(smsc->sema_mt == NULL) goto error;
    smsc->sema_mo = sema_msglist_new();
    if(smsc->sema_mo == NULL) goto error;
    memset(smsc->buffer,0,sizeof(smsc->buffer));

    /* Open the device properly. Remember to set the
     access codes correctly. */
    smsc->sema_fd = X28_reopen_data_link(smsc->sema_fd, smsc->sema_serialdevice);
    if(smsc->sema_fd == -1){
    error(0,"sema_reopen_data_link: device file error");
    goto error;
    }
    /*test outgoing call to the smsc */
    nret = X28_open_send_link(smsc->sema_fd, smsc->sema_smscnua);
    if(nret < 1){
    error(0,"test send data link failed");
    goto error;
    }
    X28_close_send_link(smsc->sema_fd);
    return 0;
error:
    error(0, "sema_reopen_data_link: failed");
    return -1;
  
}

sema_submit_msg()

int sema_submit_msg	(	SMSCenter *	smsc,
		Msg *	msg
	)

Definition at line 210 of file smsc_sema.c.

References sm_submit_invoke::DCS, debug(), sema_msg::encodetype, error(), increment_counter(), info(), LINE_ENCODE_IA5, msg, sema_msg::msgbody, sm_submit_invoke::msisdn, sm_submit_invoke::msisdnlen, octstr_copy, octstr_create_from_data, octstr_len(), sema_msg::optref, sm_submit_invoke::origadd, sm_submit_invoke::origaddlen, sm_submit_invoke::priority, sm_submit_invoke::protocal, sm_submit_invoke::replypath, sema_counter, sema_msg_free(), sema_msg_new(), sema_msg_session_mt(), sema_wait_report, SESSION_MT_RECEIVE_ERR, SESSION_MT_RECEIVE_SUCCESS, SESSION_MT_RECEIVE_TIMEOUT, sm_submit_invoke::shortmsg, sm_submit_invoke::smerefnum, sm_submit_invoke::smereftype, sm_submit_invoke::smscrefnum, sm_submit_invoke::statusreportrequest, sm_submit_invoke::textsizeoctect, sm_submit_invoke::textsizeseptet, sema_msg::type, sm_submit_invoke::validperiodrela, and sm_submit_invoke::validperiodtype.

Referenced by smscenter_submit_msg().

{
        int nret = 0;
        struct sema_msg *lmsg = NULL;
    struct sm_submit_invoke *submit_sm = NULL;
    char x28sender[2] = "A3";
        
    /* Validate msg */
    if(smsc == NULL){
        error(0,"sema_submit_msg: SMSC is empty");
        goto error;
    }
    if(msg == NULL){
        error(0, "sema_submit_msg: Msg is empty");
        goto error;
    }

    if(msg_type(msg) != sms) {
        error(0, "sema_submit_sms: Msg is WRONG TYPE");
        goto error;
    }
    /*  user data header is not supported in sm2000 X25 access
        if(msg->sms.coding == DC_7BIT ...|| DC_UNDEF?){
        error(0, "sema_submit_sms: submit invoke support in IA5 encoding(8 bits chars)");
        goto error;
        }

        if(octstr_len(msg->sms.udhdata)){
        error(0, "sema_submit_sms: submit invoke not support in IA5 encoding ");
        goto error;
        }
    */
    lmsg = sema_msg_new();
    
    submit_sm = gw_malloc(sizeof(struct sm_submit_invoke));
    memset(submit_sm, 0, sizeof(struct sm_submit_invoke));

    lmsg->type = 'S';
    lmsg->encodetype = LINE_ENCODE_IA5;

    /* set operation reference */
    increment_counter();
    memcpy(lmsg->optref,sema_counter,4);
    /*set sme reference number*/
    increment_counter();
    memcpy(submit_sm->smerefnum, sema_counter, 4);
    /*we send as not key type*/
    submit_sm->smereftype= 2; /*key type is 1*/
    /*we set prority as normal*/
    submit_sm->priority = 1; /*0 is high*/ 
    /*set valid period type as relative*/
    submit_sm->validperiodtype = 2; /* 1 is absolute */
    /*time*/
    submit_sm->validperiodrela = 1; /* from 0 to 143 , fomula is (V+1)*5 min*/
    /*send msg without 00 header*/
    submit_sm->msisdnlen= octstr_len(msg->sms.receiver);
    submit_sm->msisdn = octstr_copy(msg->sms.receiver,0,submit_sm->msisdnlen);
    /* X25 access will always append sender during data transfer */
    submit_sm->origaddlen= 2; /* we need only to orignate address type */
    submit_sm->origadd = octstr_create_from_data(x28sender,2);
    /*data encoding scheme ,support only IA5 in current version*/
    submit_sm->DCS = 15; /*gsm is 0 ,IA5 is 15*/    
    /*protocal ,support only default value  0 in current version*/ 
    submit_sm->protocal = 0;
    /*replypath*/
    submit_sm->replypath= 0; /*gateway do not pay for reply*/
    /*status report*/
    if(sema_wait_report > 0)
        submit_sm->statusreportrequest =4; /* deliver success, in bin form 00000100*/
    else
        submit_sm->statusreportrequest = 0;/* no report */
    /* we support submit invoke only in IA5 line encoding*/
    submit_sm->textsizeoctect = submit_sm->textsizeseptet =
        octstr_len(msg->sms.msgdata);
    /*copy msg buffer*/
    submit_sm->shortmsg = octstr_copy(msg->sms.msgdata,
                      0, submit_sm->textsizeoctect);
    
    memset(submit_sm->smscrefnum,0,sizeof(submit_sm->smscrefnum));  
        /*pack the message body in 2kmsg*/
    lmsg->msgbody = submit_sm;
    nret = sema_msg_session_mt(smsc, lmsg);

    gw_free(submit_sm);
    submit_sm = NULL;
    sema_msg_free(lmsg);
    lmsg = NULL;
    

    if(nret == SESSION_MT_RECEIVE_SUCCESS){
        debug("smsc.sema", 0, "sema_submit_msg: message is successfully delivered");
        return 1; /*success*/
    }
    else if(nret == SESSION_MT_RECEIVE_TIMEOUT){
        info(0, "sema_submit msg: session timed out without return");
        return 0;
    }
    else if(nret == SESSION_MT_RECEIVE_ERR){
        info(0, "sema_submit msg: smsc says submit failed!");
        return 0;
    }

    return 1;
    
error:
    if(submit_sm)
        gw_free(submit_sm);
    if(lmsg)
        sema_msg_free(lmsg);
    return -1;
}

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_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 *

)

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