smsc_emi.c File Reference

#include <sys/types.h>
#include <sys/socket.h>
#include <unistd.h>
#include <errno.h>
#include <time.h>
#include <limits.h>
#include <float.h>
#include "gwlib/gwlib.h"
#include "smscconn.h"
#include "smscconn_p.h"
#include "bb_smscconn_cb.h"
#include "msg.h"
#include "sms.h"
#include "emimsg.h"
#include "dlr.h"
#include "alt_charsets.h"

Go to the source code of this file.

Data Structures
struct	privdata

Macros
#define	EMI2_MAX_TRN   100
#define	PRIVDATA(conn)   ((PrivData *)((conn)->data))
#define	SLOTBUSY(conn, i)   (PRIVDATA(conn)->slots[(i)].sendtime != 0)
#define	CONNECTIONIDLE(conn)
#define	emi2_can_send(conn)
#define	emi2_needs_keepalive(conn)
#define	INC_TRN(x)   ((x)=((x) + 1) % EMI2_MAX_TRN)

Typedefs
typedef struct privdata	PrivData

Enumerations
enum	EMI2Event { EMI2_SENDREQ, EMI2_SMSCREQ, EMI2_CONNERR, EMI2_TIMEOUT }

Functions
static int	emi2_emimsg_send (SMSCConn *conn, Connection *server, struct emimsg *emimsg)
static int	wait_for_ack (PrivData *privdata, Connection *server, int ot, int t)
static struct emimsg *	make_emi31 (PrivData *privdata, int trn)
static struct emimsg *	make_emi60 (PrivData *privdata)
static Connection *	open_send_connection (SMSCConn *conn)
static void	pack_7bit (Octstr *str)
static struct emimsg *	msg_to_emimsg (Msg *msg, int trn, PrivData *privdata)
static int	handle_operation (SMSCConn *conn, Connection *server, struct emimsg *emimsg)
static void	clear_sent (PrivData *privdata)
static EMI2Event	emi2_wait (SMSCConn *conn, Connection *server, double seconds)
static int	emi2_next_trn (SMSCConn *conn)
static int	emi2_keepalive_handling (SMSCConn *conn, Connection *server)
static int	emi2_do_send (SMSCConn *conn, Connection *server)
static int	emi2_handle_smscreq (SMSCConn *conn, Connection *server)
static void	emi2_idleprocessing (SMSCConn *conn, Connection **server)
static void	emi2_idletimeout_handling (SMSCConn *conn, Connection **server)
static double	emi2_get_timeouttime (SMSCConn *conn, Connection *server)
static void	emi2_send_loop (SMSCConn *conn, Connection **server)
static void	emi2_sender (void *arg)
static void	emi2_receiver (SMSCConn *conn, Connection *server)
static int	emi2_open_listening_socket (SMSCConn *conn, PrivData *privdata)
static void	emi2_listener (void *arg)
static int	add_msg_cb (SMSCConn *conn, Msg *sms)
static int	shutdown_cb (SMSCConn *conn, int finish_sending)
static void	start_cb (SMSCConn *conn)
static long	queued_cb (SMSCConn *conn)
int	smsc_emi2_create (SMSCConn *conn, CfgGroup *cfg)

Macro Definition Documentation

CONNECTIONIDLE

#define CONNECTIONIDLE

(

conn

)

Value:

((PRIVDATA(conn)->unacked == 0) &&                          \
 (PRIVDATA(conn)->idle_timeout ?                            \
  (PRIVDATA(conn)->last_activity_time + PRIVDATA(conn)->idle_timeout) <= time(0):0))

Definition at line 148 of file smsc_emi.c.

Referenced by emi2_idletimeout_handling().

emi2_can_send

#define emi2_can_send

(

conn

)

Value:

((PRIVDATA(conn)->can_write || !PRIVDATA(conn)->flowcontrol) && \
 (PRIVDATA(conn)->unacked < PRIVDATA(conn)->window) &&      \
 (!PRIVDATA(conn)->shutdown))

Definition at line 153 of file smsc_emi.c.

Referenced by emi2_do_send(), and emi2_wait().

EMI2_MAX_TRN

#define EMI2_MAX_TRN   100

Definition at line 93 of file smsc_emi.c.

Referenced by clear_sent(), and smsc_emi2_create().

emi2_needs_keepalive

#define emi2_needs_keepalive

(

conn

)

Value:

(emi2_can_send(conn) &&                                 \
 (PRIVDATA(conn)->keepalive > 0) &&                         \
 (time(NULL) > (PRIVDATA(conn)->last_activity_time + PRIVDATA(conn)->keepalive)))

Definition at line 158 of file smsc_emi.c.

Referenced by emi2_send_loop().

INC_TRN

#define INC_TRN

(

x

)

((x)=((x) + 1) % EMI2_MAX_TRN)

Referenced by emi2_next_trn().

PRIVDATA

#define PRIVDATA

(

conn

)

((PrivData *)((conn)->data))

Definition at line 144 of file smsc_emi.c.

Referenced by emi2_do_send(), emi2_emimsg_send(), emi2_get_timeouttime(), emi2_handle_smscreq(), emi2_idleprocessing(), emi2_keepalive_handling(), emi2_next_trn(), emi2_send_loop(), emi2_wait(), and handle_operation().

SLOTBUSY

#define SLOTBUSY	(		conn,
			i
	)		(PRIVDATA(conn)->slots[(i)].sendtime != 0)

Definition at line 146 of file smsc_emi.c.

Referenced by emi2_handle_smscreq(), emi2_idleprocessing(), and emi2_next_trn().

Typedef Documentation

PrivData

typedef struct privdata PrivData

Enumeration Type Documentation

EMI2Event

enum EMI2Event

Enumerator
EMI2_SENDREQ
EMI2_SMSCREQ
EMI2_CONNERR
EMI2_TIMEOUT

Definition at line 137 of file smsc_emi.c.

             {
    EMI2_SENDREQ,  /* somebody asked this driver to send a SMS message */
    EMI2_SMSCREQ,  /* the SMSC wants something from us */
    EMI2_CONNERR,  /* an error condition in the SMSC main connection */
    EMI2_TIMEOUT,  /* timeout on the SMSC main connection */
} EMI2Event;

Function Documentation

add_msg_cb()

static int add_msg_cb ( SMSCConn *  conn, Msg *  sms  )

static

Definition at line 1560 of file smsc_emi.c.

References smscconn::data, gw_prioqueue_produce, gwthread_wakeup(), msg_duplicate(), privdata::outgoing_queue, and privdata::sender_thread.

Referenced by smsc_emi2_create().

{
    PrivData *privdata = conn->data;
    Msg *copy;

    copy = msg_duplicate(sms);
    gw_prioqueue_produce(privdata->outgoing_queue, copy);
    gwthread_wakeup(privdata->sender_thread);

    return 0;
}

clear_sent()

static void clear_sent ( PrivData *  privdata )

static

Definition at line 921 of file smsc_emi.c.

References debug(), EMI2_MAX_TRN, gw_prioqueue_produce, privdata::name, octstr_get_cstr, privdata::outgoing_queue, privdata::sendmsg, privdata::sendtime, privdata::sendtype, privdata::slots, and privdata::unacked.

Referenced by emi2_sender().

{
    int i;
    debug("smsc.emi2", 0, "EMI2[%s]: clear_sent called",
      octstr_get_cstr(privdata->name));
    for (i = 0; i < EMI2_MAX_TRN; i++) {
    if (privdata->slots[i].sendtime && privdata->slots[i].sendtype == 51)
        gw_prioqueue_produce(privdata->outgoing_queue, privdata->slots[i].sendmsg);
    privdata->slots[i].sendtime = 0;
    }
    privdata->unacked = 0;
}

emi2_do_send()

static int emi2_do_send ( SMSCConn *  conn, Connection *  server  )

static

Definition at line 1005 of file smsc_emi.c.

References delay, emi2_can_send, emi2_emimsg_send(), emi2_next_trn(), emimsg_destroy(), gw_prioqueue_remove(), gwthread_sleep(), msg, msg_to_emimsg(), PRIVDATA, server(), and smscconn::throughput.

Referenced by emi2_send_loop().

{
    struct emimsg *emimsg;
    Msg *msg;
    double delay = 0;

    if (conn->throughput > 0) {
        delay = 1.0 / conn->throughput;
    }
    
    /* Send messages if there's room in the sending window */
    while (emi2_can_send(conn) &&
           (msg = gw_prioqueue_remove(PRIVDATA(conn)->outgoing_queue)) != NULL) {
        int nexttrn = emi2_next_trn(conn);

        if (conn->throughput > 0)
            gwthread_sleep(delay);

        /* convert the generic Kannel message into an EMI type message */
        emimsg = msg_to_emimsg(msg, nexttrn, PRIVDATA(conn));

        /* remember the message for retransmission or DLR */
        PRIVDATA(conn)->slots[nexttrn].sendmsg = msg;
        PRIVDATA(conn)->slots[nexttrn].sendtype = 51;
        PRIVDATA(conn)->slots[nexttrn].sendtime = time(NULL);

        /* send the message */
        if (emi2_emimsg_send(conn, server, emimsg) == -1) {
            emimsg_destroy(emimsg);
            return -1;
        }

        /* we just sent a message */
        PRIVDATA(conn)->unacked++;

        emimsg_destroy(emimsg);

        /*
         * remember that there is an open request for stop-wait flow control
         * FIXME: couldn't this be done with the unacked field as well? After
         * all stop-wait is just a window of size 1.
         */
        PRIVDATA(conn)->can_write = 0;
    }

    return 0;
}

emi2_emimsg_send()

static int emi2_emimsg_send ( SMSCConn *  conn, Connection *  server, struct emimsg *  emimsg  )

static

Definition at line 166 of file smsc_emi.c.

References emimsg_send(), name, emimsg::or, emimsg::ot, PRIVDATA, and server().

Referenced by emi2_do_send(), emi2_keepalive_handling(), handle_operation(), and open_send_connection().

{
    int result = emimsg_send(server, emimsg, PRIVDATA(conn)->name);

    if (result >= 0 && emimsg->or == 'O' && ( emimsg->ot == 31 || emimsg->ot == 51)) {
    PRIVDATA(conn)->last_activity_time = time (NULL);
    }

    return result;
}

emi2_get_timeouttime()

static double emi2_get_timeouttime ( SMSCConn *  conn, Connection *  server  )

static

Definition at line 1270 of file smsc_emi.c.

References PRIVDATA, and server().

Referenced by emi2_send_loop().

{
    double ka_timeouttime = PRIVDATA(conn)->keepalive ? PRIVDATA(conn)->keepalive + 1 : DBL_MAX;
    double idle_timeouttime = (PRIVDATA(conn)->idle_timeout && server) ? PRIVDATA(conn)->idle_timeout : DBL_MAX;
    double result = ka_timeouttime < idle_timeouttime ? ka_timeouttime : idle_timeouttime;

    if (result == DBL_MAX)
    result = 30;

    return result;
}

emi2_handle_smscreq()

static int emi2_handle_smscreq ( SMSCConn *  conn, Connection *  server  )

static

Definition at line 1053 of file smsc_emi.c.

References bb_smscconn_send_failed(), bb_smscconn_sent(), conn_eof(), conn_error(), conn_read_packet(), smscconn::data, debug(), dlr_add(), DLR_IS_ENABLED_DEVICE, emimsg_destroy(), error(), emimsg::fields, get_fields(), handle_operation(), smscconn::id, info(), smscconn::is_stopped, privdata::name, octstr_append(), octstr_append_char(), octstr_create, octstr_delete(), octstr_destroy(), octstr_duplicate, octstr_get_char(), octstr_get_cstr, octstr_len(), octstr_search_char(), octstr_truncate(), emimsg::or, emimsg::ot, panic, PRIVDATA, reply(), server(), SLOTBUSY, SMSCCONN_FAILED_REJECTED, and emimsg::trn.

Referenced by emi2_send_loop().

{
    Octstr *str;
    struct emimsg *emimsg;
    PrivData *privdata = conn->data;
    
    /* Read acks/nacks/ops from the server */
    while ((str = conn_read_packet(server, 2, 3))) {
    debug("smsc.emi2", 0, "EMI2[%s]: Got packet from the main socket",
          octstr_get_cstr(privdata->name));

    /* parse the msg */
    emimsg = get_fields(str, privdata->name);
    octstr_destroy(str);
    
    if (emimsg == NULL) {
        continue; /* The parse functions logged errors */
    }
    
    if (emimsg->or == 'O') {
        /* If the SMSC wants to send operations through this
         * socket, we'll have to read them because there
         * might be ACKs too. We just drop them while stopped,
         * hopefully the SMSC will resend them later. */
        if (!conn->is_stopped) {
        if (handle_operation(conn, server, emimsg) < 0)
            return -1; /* Connection broke */
        } else {
        info(0, "EMI2[%s]: Ignoring operation from main socket "
             "because the connection is stopped.",
             octstr_get_cstr(privdata->name));
        }
    } else {   /* Already checked to be 'O' or 'R' */
        if (!SLOTBUSY(conn,emimsg->trn) ||
        emimsg->ot != PRIVDATA(conn)->slots[emimsg->trn].sendtype) {
        error(0, "EMI2[%s]: Got ack for TRN %d, don't remember sending O?",
              octstr_get_cstr(privdata->name), emimsg->trn);
        } else {
        PRIVDATA(conn)->can_write = 1;
        PRIVDATA(conn)->slots[emimsg->trn].sendtime = 0;
        PRIVDATA(conn)->unacked--;

        if (emimsg->ot == 51) {
            if (octstr_get_char(emimsg->fields[0], 0) == 'A') {
            /* we got an ack back. We might have to store the */
            /* timestamp for delivery notifications now */
            Octstr *ts, *adc;
            int i;
            Msg *m;

            ts = octstr_duplicate(emimsg->fields[2]);
            if (octstr_len(ts)) {
                i = octstr_search_char(ts,':',0);
                if (i>0) {
                octstr_delete(ts,0,i+1);
                adc = octstr_duplicate(emimsg->fields[2]);
                octstr_truncate(adc,i);

                m = PRIVDATA(conn)->slots[emimsg->trn].sendmsg;
                if(m == NULL) {
                    info(0,"EMI2[%s]: uhhh m is NULL, very bad",
                     octstr_get_cstr(privdata->name));
                } else if (DLR_IS_ENABLED_DEVICE(m->sms.dlr_mask)) {
                    dlr_add((conn->id ? conn->id : privdata->name), ts, m, 1);
                }
                octstr_destroy(ts);
                octstr_destroy(adc);
                } else {
                octstr_destroy(ts);
                }
            }
            /*
             * report the successful transmission to the generic bb code.
             */
            bb_smscconn_sent(conn,
                PRIVDATA(conn)->slots[emimsg->trn].sendmsg,
                NULL);
            } else {
                Octstr *reply;

                        /* create reply message */
                        reply = octstr_create("");
                        octstr_append(reply, emimsg->fields[1]);
                        octstr_append_char(reply, '-');
                        /* system message is optional */
                        if (emimsg->fields[2] != NULL)
                            octstr_append(reply, emimsg->fields[2]);

            /* XXX Process error code here
            long errorcode;
            octstr_parse_long(&errorcode, emimsg->fields[1], 0, 10);
            ... switch(errorcode) ...
            }

            else { */
                bb_smscconn_send_failed(conn,
                    PRIVDATA(conn)->slots[emimsg->trn].sendmsg,
                    SMSCCONN_FAILED_REJECTED, reply);
            /* } */
            }
        } else if (emimsg->ot == 31) {
            /* XXX Process error codes here
            if (octstr_get_char(emimsg->fields[0], 0) == 'N') {
            long errorcode;
            octstr_parse_long(&errorcode, emimsg->fields[1], 0, 10);
            ... switch errorcode ...
            }

            else { */
            ;
            /* } */
        } else {
            panic(0, "EMI2[%s]: Bug, ACK handler missing for sent packet",
              octstr_get_cstr(privdata->name));
        }
        }
    }
    emimsg_destroy(emimsg);
    }

    if (conn_error(server)) {
    error(0, "EMI2[%s]: Error trying to read ACKs from SMSC",
          octstr_get_cstr(privdata->name));
    return -1;
    }
    
    if (conn_eof(server)) {
    info(0, "EMI2[%s]: Main connection closed by SMSC",
         octstr_get_cstr(privdata->name));
    return -1;
    }

    return 0;
}

emi2_idleprocessing()

static void emi2_idleprocessing ( SMSCConn *  conn, Connection **  server  )

static

Definition at line 1188 of file smsc_emi.c.

References conn_destroy(), smscconn::data, gw_prioqueue_produce, gwthread_wakeup(), info(), privdata::name, octstr_get_cstr, panic, PRIVDATA, server(), SLOTBUSY, and warning().

Referenced by emi2_send_loop().

{
    time_t current_time;
    int i;
    PrivData *privdata = conn->data;
    
    /*
     * Check whether there are messages the server hasn't acked in a
     * reasonable time
     */
    current_time = time(NULL);
    
    if (PRIVDATA(conn)->unacked && (current_time > (PRIVDATA(conn)->check_time + 30))) {
    PRIVDATA(conn)->check_time = current_time;
        for (i = 0; i < PRIVDATA(conn)->window; i++) {
        if (SLOTBUSY(conn,i)
        && PRIVDATA(conn)->slots[i].sendtime < (current_time - PRIVDATA(conn)->waitack)) {

                if (PRIVDATA(conn)->slots[i].sendtype == 51) {
                    if (PRIVDATA(conn)->waitack_expire == 0x00) {
                        /* 0x00 - disconnect/reconnect */
                        warning(0, "EMI2[%s]: received neither ACK nor NACK for message %d "
                            "in %d seconds, disconnecting and reconnection",
                            octstr_get_cstr(privdata->name), i, PRIVDATA(conn)->waitack);
        PRIVDATA(conn)->slots[i].sendtime = 0;
        PRIVDATA(conn)->unacked--;
                        info(0, "EMI2[%s]: closing connection.",
                                  octstr_get_cstr(privdata->name));
                        conn_destroy(*server);
                        *server = NULL;
                        break;
                    } else if (PRIVDATA(conn)->waitack_expire == 0x01) {
                        /* 0x01 - resend */
            warning(0, "EMI2[%s]: received neither ACK nor NACK for message %d " 
                "in %d seconds, resending message", octstr_get_cstr(privdata->name),
                i, PRIVDATA(conn)->waitack);
            gw_prioqueue_produce(PRIVDATA(conn)->outgoing_queue,
                 PRIVDATA(conn)->slots[i].sendmsg);
                        PRIVDATA(conn)->slots[i].sendtime = 0;
                        PRIVDATA(conn)->unacked--;
            if (PRIVDATA(conn)->flowcontrol) PRIVDATA(conn)->can_write=1;
            /* Wake up this same thread to send again
             * (simpler than avoiding sleep) */
            gwthread_wakeup(PRIVDATA(conn)->sender_thread);
                    } else if (PRIVDATA(conn)->waitack_expire == 0x02) {
                        /* 0x02 - carry on waiting */
                           warning(0, "EMI2[%s]: received neither ACK nor NACK for message %d "
                                "in %d seconds, carrying on waiting", octstr_get_cstr(privdata->name),
                                i, PRIVDATA(conn)->waitack);
                    }
        } else if (PRIVDATA(conn)->slots[i].sendtype == 31) {
            warning(0, "EMI2[%s]: Alert (operation 31) was not "
                "ACKed within %d seconds", octstr_get_cstr(privdata->name),
                PRIVDATA(conn)->waitack);
            if (PRIVDATA(conn)->flowcontrol) PRIVDATA(conn)->can_write=1;
        } else {
            panic(0, "EMI2[%s]: Bug, no timeout handler for sent packet",
              octstr_get_cstr(privdata->name));
        }
        }
    }
    }
}

emi2_idletimeout_handling()

static void emi2_idletimeout_handling ( SMSCConn *  conn, Connection **  server  )

static

Definition at line 1252 of file smsc_emi.c.

References conn_destroy(), CONNECTIONIDLE, smscconn::data, info(), privdata::name, octstr_get_cstr, and server().

Referenced by emi2_send_loop().

{
    PrivData *privdata = conn->data;

    /*
     * close the connection if there was no activity.
     */
    if ((*server != NULL) && CONNECTIONIDLE(conn)) {
    info(0, "EMI2[%s]: closing idle connection.",
         octstr_get_cstr(privdata->name));
    conn_destroy(*server);
    *server = NULL;
    }
}

emi2_keepalive_handling()

static int emi2_keepalive_handling ( SMSCConn *  conn, Connection *  server  )

static

Definition at line 978 of file smsc_emi.c.

References emi2_emimsg_send(), emi2_next_trn(), emimsg_destroy(), make_emi31(), PRIVDATA, and server().

Referenced by emi2_send_loop().

{
    struct emimsg *emimsg;
    int nexttrn = emi2_next_trn (conn);
    
    emimsg = make_emi31(PRIVDATA(conn), nexttrn);
    if(emimsg) {
        PRIVDATA(conn)->slots[nexttrn].sendtype= 31;
        PRIVDATA(conn)->slots[nexttrn].sendtime = time(NULL);
        PRIVDATA(conn)->unacked++;
    
        if (emi2_emimsg_send(conn, server, emimsg) == -1) {
           emimsg_destroy(emimsg);
           return -1;
        }
        emimsg_destroy(emimsg);
    }
    
    PRIVDATA(conn)->can_write = 0;

    return 0;
}

emi2_listener()

static void emi2_listener ( void *  arg )

static

Definition at line 1479 of file smsc_emi.c.

References privdata::allow_ip, conn_claim(), conn_destroy(), conn_wrap_fd(), smscconn::connect_time, smscconn::data, privdata::deny_ip, emi2_receiver(), error(), smscconn::flow_mutex, gwthread_pollfd(), gwthread_wakeup(), privdata::host, host_ip(), info(), is_allowed_ip(), privdata::listening_socket, smscconn::log_idx, log_thread_to(), mutex_lock, mutex_unlock, privdata::name, octstr_destroy(), octstr_get_cstr, POLLIN, privdata::sender_thread, server(), privdata::shutdown, SMSCCONN_ACTIVE, SMSCCONN_CONNECTING, smscconn::status, and warning().

Referenced by smsc_emi2_create().

{
    SMSCConn *conn = arg;
    PrivData *privdata = conn->data;
    struct sockaddr_in server_addr;
    socklen_t server_addr_len;
    Octstr *ip;
    Connection *server;
    int s, ret;

    /* Make sure we log into our own log-file if defined */
    log_thread_to(conn->log_idx);

    while (!privdata->shutdown) {

        if (!privdata->host) {
            mutex_lock(conn->flow_mutex);
            conn->status = SMSCCONN_CONNECTING;
            conn->connect_time = time(NULL);
            mutex_unlock(conn->flow_mutex);
        }

        server_addr_len = sizeof(server_addr);
        ret = gwthread_pollfd(privdata->listening_socket, POLLIN, -1);
        if (ret == -1) {
            if (errno == EINTR)
                continue;
            error(0, "EMI2[%s]: Poll for emi2 smsc connections failed, shutting down",
                  octstr_get_cstr(privdata->name));
            break;
        }
        if (privdata->shutdown)
            break;
        if (ret == 0) /* This thread was woken up from elsewhere, but
                         if we're not shutting down nothing to do here. */
            continue;
        s = accept(privdata->listening_socket, (struct sockaddr *)&server_addr, &server_addr_len);
        if (s == -1) {
            warning(errno, "EMI2[%s]: emi2_listener: accept() failed, retrying...",
                    octstr_get_cstr(privdata->name));
            continue;
        }
        ip = host_ip(server_addr);
        if (!is_allowed_ip(privdata->allow_ip, privdata->deny_ip, ip)) {
            info(0, "EMI2[%s]: smsc connection tried from denied host <%s>,"
                    " disconnected", octstr_get_cstr(privdata->name),
                 octstr_get_cstr(ip));
            octstr_destroy(ip);
            close(s);
            continue;
        }
        server = conn_wrap_fd(s, 0);
        if (server == NULL) {
            error(0, "EMI2[%s]: emi2_listener: conn_wrap_fd failed on accept()ed fd",
                  octstr_get_cstr(privdata->name));
            octstr_destroy(ip);
            close(s);
            continue;
        }
        conn_claim(server);
        info(0, "EMI2[%s]: smsc connected from %s",
             octstr_get_cstr(privdata->name), octstr_get_cstr(ip));
        octstr_destroy(ip);

        if (!privdata->host) {
            mutex_lock(conn->flow_mutex);
            conn->status = SMSCCONN_ACTIVE;
            conn->connect_time = time(NULL);
            mutex_unlock(conn->flow_mutex);
        }

        emi2_receiver(conn, server);
        conn_destroy(server);
    }
    if (close(privdata->listening_socket) == -1)
        warning(errno, "EMI2[%s]: couldn't close listening socket at shutdown",
                octstr_get_cstr(privdata->name));
    gwthread_wakeup(privdata->sender_thread);
}

emi2_next_trn()

static int emi2_next_trn ( SMSCConn *  conn )

static

Definition at line 960 of file smsc_emi.c.

References INC_TRN, PRIVDATA, and SLOTBUSY.

Referenced by emi2_do_send(), and emi2_keepalive_handling().

{
#define INC_TRN(x) ((x)=((x) + 1) % EMI2_MAX_TRN)
    int result;
    
    while (SLOTBUSY(conn,PRIVDATA(conn)->priv_nexttrn))
    INC_TRN(PRIVDATA(conn)->priv_nexttrn); /* pick unused TRN */
    
    result = PRIVDATA(conn)->priv_nexttrn;
    INC_TRN(PRIVDATA(conn)->priv_nexttrn);

    return result;
#undef INC_TRN
}

emi2_open_listening_socket()

static int emi2_open_listening_socket ( SMSCConn *  conn, PrivData *  privdata  )

static

Definition at line 1459 of file smsc_emi.c.

References error(), privdata::listening_socket, make_server_socket(), privdata::name, octstr_get_cstr, smscconn::our_host, privdata::rport, and socket_set_blocking().

Referenced by smsc_emi2_create().

{
    int s;

    if ( (s = make_server_socket(privdata->rport, (conn->our_host ? octstr_get_cstr(conn->our_host) : NULL))) == -1) {
    error(0, "EMI2[%s]: could not create listening socket in port %d",
          octstr_get_cstr(privdata->name), privdata->rport);
    return -1;
    }
    if (socket_set_blocking(s, 0) == -1) {
    error(0, "EMI2[%s]: couldn't make listening socket port %d "
         "non-blocking", octstr_get_cstr(privdata->name), privdata->rport);
    close(s);
    return -1;
    }
    privdata->listening_socket = s;
    return 0;
}

emi2_receiver()

static void emi2_receiver ( SMSCConn *  conn, Connection *  server  )

static

Definition at line 1412 of file smsc_emi.c.

References conn_eof(), conn_error(), conn_read_packet(), conn_wait(), smscconn::data, debug(), emimsg_destroy(), error(), get_fields(), handle_operation(), info(), smscconn::is_stopped, privdata::name, octstr_destroy(), octstr_get_cstr, emimsg::or, server(), and privdata::shutdown.

Referenced by emi2_listener().

{
    PrivData *privdata = conn->data;
    Octstr *str;
    struct emimsg *emimsg;

    while (1) {
    if (conn_eof(server)) {
        info(0, "EMI2[%s]: receive connection closed by SMSC",
         octstr_get_cstr(privdata->name));
        return;
    }
    if (conn_error(server)) {
        error(0, "EMI2[%s]: receive connection broken",
          octstr_get_cstr(privdata->name));
        return;
    }
    if (conn->is_stopped)
        str = NULL;
    else
        str = conn_read_packet(server, 2, 3);
    if (str) {
        debug("smsc.emi2", 0, "EMI2[%s]: Got packet from the receive connection.",
          octstr_get_cstr(privdata->name));
        if ( (emimsg = get_fields(str, privdata->name)) ) {
        if (emimsg->or == 'O') {
            if (handle_operation(conn, server, emimsg) < 0) {
            emimsg_destroy(emimsg);
            return;
            }
        }
        else
            error(0, "EMI2[%s]: No ACKs expected on receive connection!",
              octstr_get_cstr(privdata->name));
        emimsg_destroy(emimsg);
        }
        octstr_destroy(str);
    }
    else
        conn_wait(server, -1);
    if (privdata->shutdown)
        break;
    }
    return;
}

emi2_send_loop()

static void emi2_send_loop ( SMSCConn *  conn, Connection **  server  )

static

Definition at line 1285 of file smsc_emi.c.

References conn_eof(), conn_error(), smscconn::data, EMI2_CONNERR, emi2_do_send(), emi2_get_timeouttime(), emi2_handle_smscreq(), emi2_idleprocessing(), emi2_idletimeout_handling(), emi2_keepalive_handling(), emi2_needs_keepalive, EMI2_SENDREQ, EMI2_SMSCREQ, EMI2_TIMEOUT, emi2_wait(), info(), privdata::name, octstr_get_cstr, PRIVDATA, server(), and warning().

Referenced by emi2_sender().

{
    PrivData *privdata = conn->data;

    for (;;) {
    double timeouttime;
    EMI2Event event;
    
    if (emi2_needs_keepalive (conn)) {
        if (*server == NULL) {
        return; /* reopen the connection */
        }
        
        emi2_keepalive_handling (conn, *server);
    }
    
    timeouttime = emi2_get_timeouttime (conn, *server);
    
    event = emi2_wait (conn, *server, timeouttime);
    
    switch (event) {
    case EMI2_CONNERR:
        return;
        
    case EMI2_SENDREQ:
        if (*server == NULL) {
        return; /* reopen the connection */
        }
        
        if (emi2_do_send (conn, *server) < 0) {
        return; /* reopen the connection */
        }
        break;
        
    case EMI2_SMSCREQ:
        if (emi2_handle_smscreq (conn, *server) < 0) {
        return; /* reopen the connection */
        }
        break;
        
    case EMI2_TIMEOUT:
        break;
    }

        if ((*server !=NULL) && (emi2_handle_smscreq (conn, *server) < 0)) {
            return; /* reopen the connection */
        }
    
    emi2_idleprocessing (conn, server);
    emi2_idletimeout_handling (conn, server);

    if (PRIVDATA(conn)->shutdown && (PRIVDATA(conn)->unacked == 0)) {
        /* shutdown and no open messages */
        break;
    }

    if (*server != NULL) {
        if (conn_error(*server)) {
        warning(0, "EMI2[%s]: Error reading from the main connection",
            octstr_get_cstr(privdata->name));
        break;
        }
    
        if (conn_eof(*server)) {
        info(0, "EMI2[%s]: Main connection closed by SMSC",
             octstr_get_cstr(privdata->name));
        break;
        }
    }
    }
}

emi2_sender()

static void emi2_sender ( void *  arg )

static

Definition at line 1357 of file smsc_emi.c.

References privdata::allow_ip, privdata::alt_host, bb_smscconn_killed(), bb_smscconn_send_failed(), clear_sent(), conn_destroy(), smscconn::data, debug(), privdata::deny_ip, emi2_send_loop(), smscconn::flow_mutex, gw_prioqueue_destroy(), gw_prioqueue_remove(), gwthread_join(), gwthread_wakeup(), privdata::host, smscconn::log_idx, log_thread_to(), msg, mutex_lock, mutex_unlock, privdata::my_number, privdata::nadc, privdata::name, privdata::npid, octstr_destroy(), octstr_get_cstr, open_send_connection(), privdata::outgoing_queue, privdata::password, privdata::receiver_thread, privdata::rport, server(), privdata::shutdown, SMSCCONN_DEAD, SMSCCONN_FAILED_SHUTDOWN, smscconn::status, and privdata::username.

Referenced by smsc_emi2_create().

{
    SMSCConn *conn = arg;
    PrivData *privdata = conn->data;
    Msg *msg;
    Connection *server;

    /* Make sure we log into our own log-file if defined */
    log_thread_to(conn->log_idx);

    while (!privdata->shutdown) {
    if ((server = open_send_connection(conn)) == NULL) {
        privdata->shutdown = 1;
        if (privdata->rport > 0)
        gwthread_wakeup(privdata->receiver_thread);
        break;
    }
    emi2_send_loop(conn, &server);
    clear_sent(privdata);

    if (server != NULL) {
        conn_destroy(server);
    }
    }

    while((msg = gw_prioqueue_remove(privdata->outgoing_queue)) != NULL)
    bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN, NULL);
    if (privdata->rport > 0)
    gwthread_join(privdata->receiver_thread);
    mutex_lock(conn->flow_mutex);

    conn->status = SMSCCONN_DEAD;

    debug("bb.sms", 0, "EMI2[%s]: connection has completed shutdown.",
      octstr_get_cstr(privdata->name));

    gw_prioqueue_destroy(privdata->outgoing_queue, NULL);
    octstr_destroy(privdata->name);
    octstr_destroy(privdata->allow_ip);
    octstr_destroy(privdata->deny_ip);
    octstr_destroy(privdata->host);
    octstr_destroy(privdata->alt_host);
    octstr_destroy(privdata->my_number);
    octstr_destroy(privdata->username);
    octstr_destroy(privdata->password);
    octstr_destroy(privdata->npid);
    octstr_destroy(privdata->nadc);
    gw_free(privdata);
    conn->data = NULL;

    mutex_unlock(conn->flow_mutex);
    bb_smscconn_killed();
}

emi2_wait()

static EMI2Event emi2_wait ( SMSCConn *  conn, Connection *  server, double  seconds  )

static

Definition at line 939 of file smsc_emi.c.

References conn_wait(), emi2_can_send, EMI2_CONNERR, EMI2_SENDREQ, EMI2_SMSCREQ, EMI2_TIMEOUT, gw_prioqueue_len(), gwthread_sleep(), PRIVDATA, and server().

Referenced by emi2_send_loop().

{
    if (emi2_can_send(conn) && gw_prioqueue_len(PRIVDATA(conn)->outgoing_queue)) {
    return EMI2_SENDREQ;
    }
    
    if (server != NULL) {
    switch (conn_wait(server, seconds)) {
    case 1: return gw_prioqueue_len(PRIVDATA(conn)->outgoing_queue) ? EMI2_SENDREQ : EMI2_TIMEOUT;
    case 0: return EMI2_SMSCREQ;
    default: return EMI2_CONNERR;
    }
    } else {
    gwthread_sleep(seconds);
    return gw_prioqueue_len(PRIVDATA(conn)->outgoing_queue) ? EMI2_SENDREQ : EMI2_TIMEOUT;
    }
}

handle_operation()

static int handle_operation ( SMSCConn *  conn, Connection *  server, struct emimsg *  emimsg  )

static

Definition at line 578 of file smsc_emi.c.

References privdata::alt_charset, bb_smscconn_receive(), charset_gsm_to_utf8(), charset_nrc_iso_21_german_to_gsm(), smscconn::data, date_convert_universal(), universaltime::day, dcs_to_fields(), DLR_BUFFERED, DLR_FAIL, dlr_find(), DLR_SUCCESS, E01_ADC, E01_AMSG, E01_MT, E01_OADC, E50_ADC, E50_AMSG, E50_DST, E50_MT, E50_OADC, E50_SCTS, E50_TMSG, E50_XSER, emi2_emimsg_send(), EMI_NRC_ISO_21, emimsg_create_reply(), emimsg_destroy(), error(), emimsg::fields, universaltime::hour, smscconn::id, info(), universaltime::minute, universaltime::month, msg, msg_create, privdata::name, octstr_copy, octstr_create, octstr_delete(), octstr_destroy(), octstr_duplicate, octstr_get_char(), octstr_get_cstr, octstr_hex_to_binary(), octstr_len(), octstr_parse_long(), emimsg::ot, PRIVDATA, reply(), universaltime::second, server(), emimsg::trn, type, warning(), and universaltime::year.

Referenced by emi2_handle_smscreq(), and emi2_receiver().

{
    struct emimsg *reply;
    Octstr *tempstr, *xser;
    int type, len;
    Msg *msg = NULL;
    struct universaltime unitime;
    int st_code;
    PrivData *privdata = conn->data;


    switch(emimsg->ot) {

    /*
     * Handle OP/01 call input operation. This operation delivery MO messages
     * from SMSC to SMT according to [1], section 4.2, p. 9.
     */
    case 01:
    msg = msg_create(sms);
    if (emimsg->fields[E01_AMSG] == NULL)
        emimsg->fields[E01_AMSG] = octstr_create("");
    else if (octstr_hex_to_binary(emimsg->fields[E01_AMSG]) == -1)
        warning(0, "EMI2[%s]: Couldn't decode message text",
            octstr_get_cstr(privdata->name));

    if (emimsg->fields[E01_MT] == NULL) {
        warning(0, "EMI2[%s]: required field MT missing",
            octstr_get_cstr(privdata->name));
        /* This guess could be incorrect, maybe the message should just
           be dropped */
        emimsg->fields[E01_MT] = octstr_create("3");
    }

    if (octstr_get_char(emimsg->fields[E01_MT], 0) == '3') {
        msg->sms.msgdata = emimsg->fields[E01_AMSG];
        emimsg->fields[E01_AMSG] = NULL; /* So it's not freed */

        /* obey the NRC (national replacement codes) */
        if (privdata->alt_charset == EMI_NRC_ISO_21)
            charset_nrc_iso_21_german_to_gsm(msg->sms.msgdata);

        charset_gsm_to_utf8(msg->sms.msgdata);
    }
    else {
        error(0, "EMI2[%s]: MT == %s isn't supported for operation type 01",
          octstr_get_cstr(privdata->name),
          octstr_get_cstr(emimsg->fields[E01_MT]));
        msg->sms.msgdata = octstr_create("");
    }

    msg->sms.sender = octstr_duplicate(emimsg->fields[E01_OADC]);
    if (msg->sms.sender == NULL) {
        warning(0, "EMI2[%s]: Empty sender field in received message",
            octstr_get_cstr(privdata->name));
        msg->sms.sender = octstr_create("");
    }

    if(octstr_len(PRIVDATA(conn)->my_number)) {
        msg->sms.receiver = octstr_duplicate(PRIVDATA(conn)->my_number);
    }
    else {
        msg->sms.receiver = octstr_duplicate(emimsg->fields[E01_ADC]);
    }
    if (msg->sms.receiver == NULL) {
        warning(0, "EMI2[%s]: Empty receiver field in received message",
            octstr_get_cstr(privdata->name));
        msg->sms.receiver = octstr_create("");
    }

    /* Operation type 01 doesn't have a time stamp field */
    time(&msg->sms.time);

    msg->sms.smsc_id = octstr_duplicate(conn->id);
    bb_smscconn_receive(conn, msg);
    reply = emimsg_create_reply(01, emimsg->trn, 1, privdata->name);
    if (emi2_emimsg_send(conn, server, reply) < 0) {
        emimsg_destroy(reply);
        return -1;
    }
    emimsg_destroy(reply);
    return 1;

    /*
     * Handle OP/52 delivery short message. This is the MO side of the protocol
     * implementation. See [1], section 5.4, p. 40.
     */
    case 52:
    msg = msg_create(sms);
    /* AMSG is the same field as TMSG */
    if (emimsg->fields[E50_AMSG] == NULL)
        emimsg->fields[E50_AMSG] = octstr_create("");
    else if (octstr_hex_to_binary(emimsg->fields[E50_AMSG]) == -1)
        warning(0, "EMI2[%s]: Couldn't decode message text",
              octstr_get_cstr(privdata->name));

    /* Process XSer fields */
    xser = emimsg->fields[E50_XSER];
    while (octstr_len(xser) > 0) {
        int tempint;
        tempstr = octstr_copy(xser, 0, 4);
        if (octstr_hex_to_binary(tempstr) == -1)
        error(0, "EMI2[%s]: Invalid XSer",
              octstr_get_cstr(privdata->name));
        type = octstr_get_char(tempstr, 0);
        len = octstr_get_char(tempstr, 1);
        octstr_destroy(tempstr);
        if (len < 0) {
        error(0, "EMI2[%s]: Malformed emi XSer field",
              octstr_get_cstr(privdata->name));
        break;
        }

        /* Handle supported XSer fields */
        switch (type) {

            case 0x01:  /* XSer 01, GSM UDH information */
                tempstr = octstr_copy(xser, 4, len * 2);
                if (octstr_hex_to_binary(tempstr) == -1)
                    error(0, "EMI2[%s]: Invalid UDH contents",
                          octstr_get_cstr(privdata->name));
                msg->sms.udhdata = tempstr;
                break;

            case 0x02:  /* XSer 02, GSM DCS information */
                tempstr = octstr_copy(xser, 4, 2);
                octstr_hex_to_binary(tempstr);
                tempint = octstr_get_char(tempstr, 0);
                octstr_destroy(tempstr);
                if (!dcs_to_fields(&msg, tempint)) {
                    error(0, "EMI2[%s]: Invalid DCS received",
                          octstr_get_cstr(privdata->name));
                    /* XXX Should we discard message ? */
                    dcs_to_fields(&msg, 0);
                }
                break;

            /* 
             * XSer 03-0b are for CDMA/TDMA information exchange and are currently
             * not implemented in this EMI interface. See CMG EMI/UCP spec 4.6,
             * section 5.1.2.4 for more information.
             */

            case 0x0c:  /* XSer 0c, billing identifier */
                tempstr = octstr_copy(xser, 4, len * 2);
                if (octstr_hex_to_binary(tempstr) == -1) {
                    error(0, "EMI2[%s] Invalid XSer 0c billing identifier <%s>",
                          octstr_get_cstr(privdata->name), 
                          octstr_get_cstr(tempstr));
                } else {
                    msg->sms.binfo = tempstr;
                }
                break;
                
            case 0x0d:  /* XSer 0d, single shot indicator */
                tempstr = octstr_copy(xser, 4, 2);
                octstr_hex_to_binary(tempstr);
                tempint = octstr_get_char(tempstr, 0);
                octstr_destroy(tempstr);
                if (tempint) 
                    info(0, "EMI2[%s]: Single shot indicator set.",
                         octstr_get_cstr(privdata->name));
                break;

            /* XSer fields 0e-ff are reserved for future use and should not be used. */

            default:
                warning(0, "EMI2[%s]: Unsupported EMI XSer field %d",
                        octstr_get_cstr(privdata->name), type);
                break;
        }

        octstr_delete(xser, 0, 2 * len + 4);
    }

    if (emimsg->fields[E50_MT] == NULL) {
        warning(0, "EMI2[%s]: required field MT missing",
            octstr_get_cstr(privdata->name));
        /* This guess could be incorrect, maybe the message should just
           be dropped */
        emimsg->fields[E50_MT] = octstr_create("3");
    }
    if (octstr_get_char(emimsg->fields[E50_MT], 0) == '3') {
        msg->sms.msgdata = emimsg->fields[E50_AMSG];
        emimsg->fields[E50_AMSG] = NULL; /* So it's not freed */

        /* obey the NRC (national replacement codes) */
        if (privdata->alt_charset == EMI_NRC_ISO_21)
            charset_nrc_iso_21_german_to_gsm(msg->sms.msgdata);

        charset_gsm_to_utf8(msg->sms.msgdata);
    }
    else if (octstr_get_char(emimsg->fields[E50_MT], 0) == '4') {
        msg->sms.msgdata = emimsg->fields[E50_TMSG];
        emimsg->fields[E50_TMSG] = NULL;
    }
    else {
        error(0, "EMI2[%s]: MT == %s isn't supported yet",
          octstr_get_cstr(privdata->name),
          octstr_get_cstr(emimsg->fields[E50_MT]));
        msg->sms.msgdata = octstr_create("");
    }

    msg->sms.sender = octstr_duplicate(emimsg->fields[E50_OADC]);
    if (msg->sms.sender == NULL) {
        warning(0, "EMI2[%s]: Empty sender field in received message",
            octstr_get_cstr(privdata->name));
        msg->sms.sender = octstr_create("");
    }

    if(octstr_len(PRIVDATA(conn)->my_number)) {
        msg->sms.receiver = octstr_duplicate(PRIVDATA(conn)->my_number);
    }
    else {
        msg->sms.receiver = octstr_duplicate(emimsg->fields[E50_ADC]);
    }
    if (msg->sms.receiver == NULL) {
        warning(0, "EMI2[%s]: Empty receiver field in received message",
            octstr_get_cstr(privdata->name));
        msg->sms.receiver = octstr_create("");
    }

    tempstr = emimsg->fields[E50_SCTS]; /* Just a shorter name */
    if (tempstr == NULL) {
        warning(0, "EMI2[%s]: Received EMI message doesn't have required timestamp",
            octstr_get_cstr(privdata->name));
        goto notime;
    }
    if (octstr_len(tempstr) != 12) {
        warning(0, "EMI2[%s]: EMI SCTS field must have length 12, now %ld",
            octstr_get_cstr(privdata->name), octstr_len(tempstr));
        goto notime;
    }
    if (octstr_parse_long(&unitime.second, tempstr, 10, 10) != 12 ||
        (octstr_delete(tempstr, 10, 2),
         octstr_parse_long(&unitime.minute, tempstr, 8, 10) != 10) ||
        (octstr_delete(tempstr, 8, 2),
         octstr_parse_long(&unitime.hour, tempstr, 6, 10) != 8) ||
        (octstr_delete(tempstr, 6, 2),
         octstr_parse_long(&unitime.year, tempstr, 4, 10) != 6) ||
        (octstr_delete(tempstr, 4, 2),
         octstr_parse_long(&unitime.month, tempstr, 2, 10) != 4) ||
        (octstr_delete(tempstr, 2, 2),
         octstr_parse_long(&unitime.day, tempstr, 0, 10) != 2)) {
        error(0, "EMI2[%s]: EMI delivery time stamp looks malformed",
          octstr_get_cstr(privdata->name));
    notime:
        time(&msg->sms.time);
    }
    else {
        unitime.year += 2000; /* Conversion function expects full year */
            unitime.month -= 1; /* conversion function expects 0-based months */
        msg->sms.time = date_convert_universal(&unitime);
    }

    msg->sms.smsc_id = octstr_duplicate(conn->id);
    bb_smscconn_receive(conn, msg);
    reply = emimsg_create_reply(52, emimsg->trn, 1, privdata->name);
    if (emi2_emimsg_send(conn, server, reply) < 0) {
        emimsg_destroy(reply);
        return -1;
    }
    emimsg_destroy(reply);
    return 1;

    /*
     * Handle OP/53 delivery notification. See [1], section 5.5, p. 43.
     */
    case 53:        
    st_code = atoi(octstr_get_cstr(emimsg->fields[E50_DST]));
    switch(st_code)
    {
    case 0: /* delivered */
        msg = dlr_find((conn->id ? conn->id : privdata->name),
            emimsg->fields[E50_SCTS], /* timestamp */
            emimsg->fields[E50_OADC], /* destination */
            DLR_SUCCESS, 1);
        break;
    case 1: /* buffered */
        msg = dlr_find((conn->id ? conn->id : privdata->name),
            emimsg->fields[E50_SCTS], /* timestamp */
            emimsg->fields[E50_OADC], /* destination */
            DLR_BUFFERED, 1);
        break;
    case 2: /* not delivered */
        msg = dlr_find((conn->id ? conn->id : privdata->name),
            emimsg->fields[E50_SCTS], /* timestamp */
            emimsg->fields[E50_OADC], /* destination */
            DLR_FAIL, 1);
        break;
    }
    if (msg != NULL) {     
        /*
         * Recode the msg structure with the given msgdata.
         * Note: the DLR URL is delivered in msg->sms.dlr_url already.
         */
        if ((emimsg->fields[E50_AMSG]) == NULL)
            msg->sms.msgdata = octstr_create("Delivery Report without text");
        else
            msg->sms.msgdata = octstr_duplicate(emimsg->fields[E50_AMSG]);
        octstr_hex_to_binary(msg->sms.msgdata);
        if (octstr_get_char(emimsg->fields[E50_MT], 0) == '3') {
            /* obey the NRC (national replacement codes) */
            if (privdata->alt_charset == EMI_NRC_ISO_21)
                charset_nrc_iso_21_german_to_gsm(msg->sms.msgdata);
            charset_gsm_to_utf8(msg->sms.msgdata);
        }
        bb_smscconn_receive(conn, msg);
    }
    reply = emimsg_create_reply(53, emimsg->trn, 1, privdata->name);
    if (emi2_emimsg_send(conn, server, reply) < 0) {
        emimsg_destroy(reply);
        return -1;
    }
    emimsg_destroy(reply);
    return 1;

    /* 
     * Handle OP/31 from SMSC side. This is not "purely" spec conform since,
     * the protocol says "This operation can be used by a SMT to alert the SC.",
     * which implies semantically only the opposite way. For the sake of EMI/UCP
     * server implementations that send alert messages to SMTs we handle this 
     * without breaking any core protocol concept.
     *
     * See [1], section 4.6, p. 19.
     */
    case 31:
        reply = emimsg_create_reply(31, emimsg->trn, 1, privdata->name);
        st_code = emi2_emimsg_send(conn, server, reply);
        emimsg_destroy(reply);
        return (st_code < 0 ? -1 : 1);

    default:
    error(0, "EMI2[%s]: I don't know how to handle operation type %d", 
          octstr_get_cstr(privdata->name), emimsg->ot);
    return 0;
    }
}

make_emi31()

static struct emimsg* make_emi31 ( PrivData *  privdata, int  trn  )

static

Definition at line 232 of file smsc_emi.c.

References emimsg_create_op(), emimsg::fields, privdata::my_number, privdata::name, octstr_create, octstr_duplicate, octstr_len(), emimsg::trn, and privdata::username.

Referenced by emi2_keepalive_handling().

{
    struct emimsg *emimsg;

    if(octstr_len(privdata->username) || octstr_len(privdata->my_number)) {
        emimsg = emimsg_create_op(31, trn, privdata->name);
        if(octstr_len(privdata->username)) {
            emimsg->fields[0] = octstr_duplicate(privdata->username);
    } else {
            emimsg->fields[0] = octstr_duplicate(privdata->my_number);
    }
        emimsg->fields[1] = octstr_create("0539");
        return emimsg;
    } else {
        return NULL;
    }
}

make_emi60()

static struct emimsg* make_emi60 ( PrivData *  privdata )

static

Definition at line 251 of file smsc_emi.c.

References E60_OADC, E60_ONPI, E60_OTON, E60_PWD, E60_STYP, E60_VERS, emimsg_create_op(), emimsg::fields, privdata::name, octstr_binary_to_hex(), octstr_create, octstr_duplicate, privdata::password, and privdata::username.

Referenced by open_send_connection().

{
    struct emimsg *emimsg;

    emimsg = emimsg_create_op(60, 0, privdata->name);
    emimsg->fields[E60_OADC] = octstr_duplicate(privdata->username);
    emimsg->fields[E60_OTON] = octstr_create("6");
    emimsg->fields[E60_ONPI] = octstr_create("5");
    emimsg->fields[E60_STYP] = octstr_create("1");
    emimsg->fields[E60_PWD] = octstr_duplicate(privdata->password);
    octstr_binary_to_hex(emimsg->fields[E60_PWD], 1);
    emimsg->fields[E60_VERS] = octstr_create("0100");
    return emimsg;
}

msg_to_emimsg()

static struct emimsg* msg_to_emimsg ( Msg *  msg, int  trn, PrivData *  privdata  )

static

Definition at line 413 of file smsc_emi.c.

References privdata::alt_charset, charset_gsm_to_nrc_iso_21_german(), charset_gsm_truncate(), charset_utf8_to_gsm(), DC_8BIT, DC_UCS2, DLR_IS_BUFFERED, DLR_IS_ENABLED_DEVICE, E50_ADC, E50_AMSG, E50_DD, E50_DDT, E50_MCLS, E50_MT, E50_NADC, E50_NB, E50_NPID, E50_NRQ, E50_NT, E50_OADC, E50_OTOA, E50_RPI, E50_RPID, E50_TMSG, E50_VP, E50_XSER, EMI_NRC_ISO_21, emimsg_create_op(), error(), emimsg::fields, fields_to_dcs(), gw_isdigit(), gw_localtime(), msg, privdata::nadc, privdata::name, privdata::npid, octstr_append(), octstr_append_char(), octstr_append_decimal(), octstr_binary_to_hex(), octstr_check_range(), octstr_create, octstr_delete(), octstr_destroy(), octstr_duplicate, octstr_format(), octstr_get_char(), octstr_get_cstr, octstr_insert_data(), octstr_len(), octstr_truncate(), pack_7bit(), and SMS_PARAM_UNDEFINED.

Referenced by emi2_do_send().

{
    Octstr *str;
    struct emimsg *emimsg;
    int dcs;
    struct tm tm;
    char p[20];

    emimsg = emimsg_create_op(51, trn, privdata->name);
    str = octstr_duplicate(msg->sms.sender);
    if(octstr_get_char(str,0) == '+') {
        /* either alphanum or international */
        if (!octstr_check_range(str, 1, 256, gw_isdigit)) {
        /* alphanumeric sender address with + in front*/
        charset_utf8_to_gsm(str);
        octstr_truncate(str, 11); /* max length of alphanumeric OaDC */
        emimsg->fields[E50_OTOA] = octstr_create("5039");
        pack_7bit(str);
    }
    else {
        /* international number. Set format and remove + */
        emimsg->fields[E50_OTOA] = octstr_create("1139");
        octstr_delete(str, 0, 1);
        octstr_truncate(str, 22);  /* max length of numeric OaDC */
    }
    }
    else {
    if (!octstr_check_range(str, 0, 256, gw_isdigit)) {
        /* alphanumeric sender address */
            charset_utf8_to_gsm(str);
        octstr_truncate(str, 11); /* max length of alphanumeric OaDC */
        emimsg->fields[E50_OTOA] = octstr_create("5039");
        pack_7bit(str);
    }
    }
 
    emimsg->fields[E50_OADC] = str;

    /* set protocol id */
    if (msg->sms.pid >= 0) {
        emimsg->fields[E50_RPID] = octstr_format("%04d", msg->sms.pid);
    }

    /* set reply path indicator */
    if (msg->sms.rpi == 2)
        emimsg->fields[E50_RPI] = octstr_create("2");
    else if (msg->sms.rpi > 0)
        emimsg->fields[E50_RPI] = octstr_create("1");

    str = octstr_duplicate(msg->sms.receiver);
    if(octstr_get_char(str,0) == '+') {
         /* international number format */
         /* EMI doesnt understand + so we have to replace it with something useful */
         /* we try 00 here. Should really be done in the config instead so this */
         /* is only a workaround to make wrong configs work  */
     octstr_delete(str, 0, 1);
     octstr_insert_data(str, 0, "00",2);
    }
    octstr_truncate(str, 16); /* max length of ADC */
    emimsg->fields[E50_ADC] = str;
   
    emimsg->fields[E50_XSER] = octstr_create("");

    /* XSer 01: UDH */
    if (octstr_len(msg->sms.udhdata)) {
        str = octstr_create("");
        octstr_append_char(str, 0x01);
        octstr_append_char(str, octstr_len(msg->sms.udhdata));
        octstr_append(str, msg->sms.udhdata);
        octstr_binary_to_hex(str, 1);
        octstr_append(emimsg->fields[E50_XSER], str);
        octstr_destroy(str);
    }
    
    /* XSer 02: DCS */
    dcs = fields_to_dcs(msg, msg->sms.alt_dcs);
    if (dcs != 0 && dcs != 4) {
        str = octstr_create("");
        octstr_append_char(str, 0x02);
        octstr_append_char(str, 1); /* len 01 */
        octstr_append_char(str, dcs);
        octstr_binary_to_hex(str, 1);
        octstr_append(emimsg->fields[E50_XSER], str);
        octstr_destroy(str);
    }

    /* XSer 0c: billing identifier */
    if (octstr_len(msg->sms.binfo)) {
        str = octstr_create("");
        octstr_append_char(str, 0x0c);
        octstr_append_char(str, octstr_len(msg->sms.binfo));
        octstr_append(str, msg->sms.binfo);
        octstr_binary_to_hex(str, 1);
        octstr_append(emimsg->fields[E50_XSER], str);
        octstr_destroy(str);
    }

    if (msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2) {
    emimsg->fields[E50_MT] = octstr_create("4");
    emimsg->fields[E50_MCLS] = octstr_create("1");
    str = octstr_duplicate(msg->sms.msgdata);
    emimsg->fields[E50_NB] =
        octstr_format("%04d", 8 * octstr_len(str));
    octstr_binary_to_hex(str, 1);
    emimsg->fields[E50_TMSG] = str;
    }
    else {
    emimsg->fields[E50_MT] = octstr_create("3");
    str = octstr_duplicate(msg->sms.msgdata);
    charset_utf8_to_gsm(str);

    /*
     * Check if we have to apply some after GSM transcoding kludges
     */
    if (privdata->alt_charset == EMI_NRC_ISO_21)
        charset_gsm_to_nrc_iso_21_german(str);

    /* Could still be too long after truncation if there's an UDH part,
     * but this is only to notice errors elsewhere (should never happen).*/
    if (charset_gsm_truncate(str, 160))
        error(0, "EMI2[%s]: Message to send is longer "
          "than 160 gsm characters",
          octstr_get_cstr(privdata->name));
    octstr_binary_to_hex(str, 1);
    emimsg->fields[E50_AMSG] = str;
    }

    if (msg->sms.validity != SMS_PARAM_UNDEFINED) {
    tm = gw_localtime(msg->sms.validity);
    sprintf(p, "%02d%02d%02d%02d%02d",
        tm.tm_mday, tm.tm_mon + 1, tm.tm_year % 100, 
        tm.tm_hour, tm.tm_min);
    str = octstr_create(p);
    emimsg->fields[E50_VP] = str;
    }
    if (msg->sms.deferred != SMS_PARAM_UNDEFINED) {
    str = octstr_create("1");
    emimsg->fields[E50_DD] = str;
    tm = gw_localtime(msg->sms.deferred);
    sprintf(p, "%02d%02d%02d%02d%02d",
        tm.tm_mday, tm.tm_mon + 1, tm.tm_year % 100, 
        tm.tm_hour, tm.tm_min);
    str = octstr_create(p);
    emimsg->fields[E50_DDT] = str;
    }

    /* if delivery reports are asked, lets ask for them too */
    /* even the sender might not be interested in delivery or non delivery */
    /* we still need them back to clear out the memory after the message */
    /* has been delivered or non delivery has been confirmed */
    if (DLR_IS_ENABLED_DEVICE(msg->sms.dlr_mask)) {
    emimsg->fields[E50_NRQ] = octstr_create("1");
    emimsg->fields[E50_NT] = octstr_create("");
    octstr_append_decimal(emimsg->fields[E50_NT], 3 + (DLR_IS_BUFFERED(msg->sms.dlr_mask) ? 4 : 0));
    if (privdata->npid)
        emimsg->fields[E50_NPID] = octstr_duplicate(privdata->npid);
    if (privdata->nadc)
        emimsg->fields[E50_NADC] = octstr_duplicate(privdata->nadc); 
    }
    return emimsg;
}

open_send_connection()

static Connection* open_send_connection ( SMSCConn *  conn )

static

Definition at line 267 of file smsc_emi.c.

References privdata::alt_host, privdata::alt_port, bb_smscconn_connected(), bb_smscconn_send_failed(), privdata::can_write, conn_destroy(), conn_open_tcp_with_port(), smscconn::connect_time, smscconn::data, emi2_emimsg_send(), emimsg_destroy(), error(), smscconn::flow_mutex, gw_prioqueue_remove(), gwthread_sleep(), privdata::host, info(), privdata::last_activity_time, make_emi60(), msg, mutex_lock, mutex_unlock, privdata::name, smscconn::name, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_len(), smscconn::our_host, privdata::our_port, privdata::outgoing_queue, privdata::password, privdata::port, smscconn::reconnect_delay, server(), privdata::shutdown, SMSCCONN_ACTIVE, SMSCCONN_FAILED_TEMPORARILY, SMSCCONN_RECONNECTING, smscconn::status, privdata::username, wait_for_ack(), and privdata::waitack.

Referenced by emi2_sender().

{
    PrivData *privdata = conn->data;
    int result, alt_host, do_alt_host;
    struct emimsg *emimsg;
    Connection *server;
    Msg *msg;
    int connect_error = 0;
    int wait_ack = 0;

    do_alt_host = octstr_len(privdata->alt_host) != 0 || privdata->alt_port != 0;

    alt_host = 0;

    mutex_lock(conn->flow_mutex);
    conn->status = SMSCCONN_RECONNECTING;
    mutex_unlock(conn->flow_mutex);

    while (!privdata->shutdown) {

    while ((msg = gw_prioqueue_remove(privdata->outgoing_queue))) {
        bb_smscconn_send_failed(conn, msg,
                         SMSCCONN_FAILED_TEMPORARILY, NULL);
    }

    /* if there is no alternative host, sleep and try to re-connect */
    if (alt_host == 0 && connect_error) {
        error(0, "EMI2[%s]: Couldn't connect to SMS center (retrying in %ld seconds).",
              octstr_get_cstr(privdata->name), conn->reconnect_delay);
        gwthread_sleep(conn->reconnect_delay);
    }

    if (alt_host != 1) {
        info(0, "EMI2[%s]: connecting to Primary SMSC",
                octstr_get_cstr(privdata->name));
        mutex_lock(conn->flow_mutex);
        octstr_destroy(conn->name);
        conn->name = octstr_format("EMI2:%S:%d:%S", privdata->host, privdata->port, privdata->username ? privdata->username : octstr_imm("null"));
        mutex_unlock(conn->flow_mutex);
        server = conn_open_tcp_with_port(privdata->host, privdata->port,
                         privdata->our_port,
                         conn->our_host);
        if(do_alt_host)
            alt_host=1;
        else
            alt_host=0;
    } else {
        info(0, "EMI2[%s]: connecting to Alternate SMSC",
                octstr_get_cstr(privdata->name));
        /* use alt_host or/and alt_port if defined */
        mutex_lock(conn->flow_mutex);
        octstr_destroy(conn->name);
        conn->name = octstr_format("EMI2:%S:%d:%S", octstr_len(privdata->alt_host) ? privdata->alt_host : privdata->host,
                                  privdata->alt_port ? privdata->alt_port : privdata->port,
                                  privdata->username ? privdata->username : octstr_imm("null"));
        mutex_unlock(conn->flow_mutex);
        server = conn_open_tcp_with_port(
        (octstr_len(privdata->alt_host) ? privdata->alt_host : privdata->host),
        (privdata->alt_port ? privdata->alt_port : privdata->port),
        privdata->our_port, conn->our_host);
        alt_host=0;
    }
    if (privdata->shutdown) {
        conn_destroy(server);
        return NULL;
    }
    if (server == NULL) {
        error(0, "EMI2[%s]: opening TCP connection to %s failed",
          octstr_get_cstr(privdata->name),
          octstr_get_cstr(privdata->host));
        connect_error = 1;  
        continue;
    }

    if (privdata->username && privdata->password) {
        emimsg = make_emi60(privdata);
        emi2_emimsg_send(conn, server, emimsg);
        emimsg_destroy(emimsg);
        wait_ack = privdata->waitack > 30 ? privdata->waitack : 30;
        result = wait_for_ack(privdata, server, 60, wait_ack);
        if (result == -2) {
            /* 
             * Are SMSCs going to return any temporary errors? If so,
             * testing for those error codes should be added here. 
             */
            error(0, "EMI2[%s]: Server rejected our login",
                  octstr_get_cstr(privdata->name));
            conn_destroy(server);
            connect_error = 1;
            continue;
        } else if (result == 0) {
            error(0, "EMI2[%s]: Got no reply to login attempt "
                     "within %d seconds", octstr_get_cstr(privdata->name),
                     wait_ack);
            conn_destroy(server);
            connect_error = 1;
            continue;
        } else if (result == -1) { /* Broken connection, already logged */
            conn_destroy(server);
            connect_error = 1;
            continue;
        }
        privdata->last_activity_time = 0; /* to force keepalive after login */
        privdata->can_write = 1;
    }

    mutex_lock(conn->flow_mutex);
    conn->status = SMSCCONN_ACTIVE;
    conn->connect_time = time(NULL);
    mutex_unlock(conn->flow_mutex);
    bb_smscconn_connected(conn);
    return server;
    }
    return NULL;
}

pack_7bit()

static void pack_7bit ( Octstr *  str )

static

Definition at line 384 of file smsc_emi.c.

References octstr_append(), octstr_append_char(), octstr_binary_to_hex(), octstr_create, octstr_delete(), octstr_destroy(), octstr_get_char(), octstr_len(), and octstr_set_char().

Referenced by msg_to_emimsg().

{
    Octstr *result;
    int len, i;
    int numbits, value;

    result = octstr_create("0");
    len = octstr_len(str);
    value = 0;
    numbits = 0;
    for (i = 0; i < len; i++) {
    value += octstr_get_char(str, i) << numbits;
    numbits += 7;
    if (numbits >= 8) {
        octstr_append_char(result, value & 0xff);
        value >>= 8;
        numbits -= 8;
    }
    }
    if (numbits > 0)
    octstr_append_char(result, value);
    octstr_set_char(result, 0, (len * 7 + 3) / 4);
    octstr_delete(str, 0, LONG_MAX);
    octstr_append(str, result);
    octstr_binary_to_hex(str, 1);
    octstr_destroy(result);
}

queued_cb()

static long queued_cb ( SMSCConn *  conn )

static

Definition at line 1615 of file smsc_emi.c.

References smscconn::data, gw_prioqueue_len(), smscconn::load, and privdata::outgoing_queue.

Referenced by smsc_emi2_create().

{
    PrivData *privdata = conn->data;
    long ret;

    ret = (privdata ? gw_prioqueue_len(privdata->outgoing_queue) : 0);

    /* use internal queue as load, maybe something else later */

    conn->load = ret;
    return ret;
}

shutdown_cb()

static int shutdown_cb ( SMSCConn *  conn, int  finish_sending  )

static

Definition at line 1573 of file smsc_emi.c.

References bb_smscconn_send_failed(), smscconn::data, debug(), gw_prioqueue_remove(), gwthread_wakeup(), privdata::host, msg, privdata::name, octstr_get_cstr, privdata::outgoing_queue, privdata::receiver_thread, privdata::rport, privdata::shutdown, SMSCCONN_FAILED_SHUTDOWN, SMSCCONN_KILLED_SHUTDOWN, and smscconn::why_killed.

Referenced by smsc_emi2_create().

{
    PrivData *privdata = conn->data;

    if (!privdata->host)
        finish_sending = 0;

    debug("bb.sms", 0, "EMI2[%s]: Shutting down SMSCConn EMI2, %s",
          octstr_get_cstr(privdata->name),
          finish_sending ? "slow" : "instant");

    /* Documentation claims this would have been done by smscconn.c,
       but isn't when this code is being written. */
    conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;
    privdata->shutdown = 1; /* Separate from why_killed to avoid locking, as
                               why_killed may be changed from outside? */

    if (finish_sending == 0) {
        Msg *msg;
        while ((msg = gw_prioqueue_remove(privdata->outgoing_queue)) != NULL) {
            bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN, NULL);
        }
    }

    if (privdata->rport > 0)
        gwthread_wakeup(privdata->receiver_thread);
    return 0;
}

smsc_emi2_create()

int smsc_emi2_create	(	SMSCConn *	conn,
		CfgGroup *	cfg
	)

Definition at line 1629 of file smsc_emi.c.

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

Referenced by smscconn_create().

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

    allow_ip = deny_ip = host = alt_host = NULL; 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    conn->data = privdata;

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

    privdata->shutdown = 0;

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

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

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

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

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

    return 0;

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

start_cb()

static void start_cb ( SMSCConn *  conn )

static

Definition at line 1603 of file smsc_emi.c.

References smscconn::data, debug(), gwthread_wakeup(), privdata::name, octstr_get_cstr, privdata::receiver_thread, and privdata::rport.

Referenced by smsc_emi2_create().

{
    PrivData *privdata = conn->data;

    /* in case there are messages in the buffer already */
    if (privdata->rport > 0)
    gwthread_wakeup(privdata->receiver_thread);
    debug("smsc.emi2", 0, "EMI2[%s]: start called",
      octstr_get_cstr(privdata->name));
}

wait_for_ack()

static int wait_for_ack ( PrivData *  privdata, Connection *  server, int  ot, int  t  )

static

Definition at line 182 of file smsc_emi.c.

References conn_eof(), conn_error(), conn_read_packet(), conn_wait(), emimsg_destroy(), error(), emimsg::fields, get_fields(), privdata::name, octstr_destroy(), octstr_get_char(), octstr_get_cstr, emimsg::or, emimsg::ot, server(), emimsg::trn, and warning().

Referenced by open_send_connection().

{
    time_t timeout_time;
    int time_left;
    Octstr *str;
    struct emimsg *emimsg;

    timeout_time = time(NULL) + t;
    while (1) {
    str = conn_read_packet(server, 2, 3);
    if (conn_eof(server)) {
        error(0, "EMI2[%s]: connection closed in wait_for_ack",
          octstr_get_cstr(privdata->name));
        return -1;
    }
    if (conn_error(server)) {
        error(0, "EMI2[%s]: connection error in wait_for_ack",
          octstr_get_cstr(privdata->name));
        return -1;
    }
    if (str) {
        emimsg = get_fields(str, privdata->name);
        if (emimsg == NULL) {
        octstr_destroy(str);
        continue;
        }
        if (emimsg->ot == ot && emimsg->trn == 0 && emimsg->or == 'R') {
        octstr_destroy(str);
        break;
        }
        warning(0, "EMI2[%s]: ignoring message %s while waiting for ack to"
            "ot:%d trn:%d", octstr_get_cstr(privdata->name),
            octstr_get_cstr(str), ot, 0);
        emimsg_destroy(emimsg);
        octstr_destroy(str);
    }
    time_left = timeout_time - time(NULL);
    if (time_left < 0 || privdata->shutdown)
        return 0;
    conn_wait(server, time_left);
    }
    if (octstr_get_char(emimsg->fields[0], 0) == 'N') {
    emimsg_destroy(emimsg);
    return -2;
    }
    emimsg_destroy(emimsg);
    return 1;
}