smsc_cimd2.c File Reference

#include <ctype.h>
#include <time.h>
#include <errno.h>
#include <limits.h>
#include <string.h>
#include <unistd.h>
#include "gwlib/gwlib.h"
#include "smscconn.h"
#include "smscconn_p.h"
#include "bb_smscconn_cb.h"
#include "shared.h"
#include "sms.h"
#include "dlr.h"

Go to the source code of this file.

Data Structures
struct	privdata
struct	packet

Macros
#define	RESPONSE_TIMEOUT   (60 * 1000000)
#define	STX   2 /* Start of packet */
#define	ETX   3 /* End of packet */
#define	TAB   9 /* End of parameter */
#define	STX_str   "\02"
#define	ETX_str   "\03"
#define	TAB_str   "\011"
#define	BOGUS_SEQUENCE   0

Typedefs
typedef struct privdata	PrivData

Enumerations
enum	{   LOGIN = 1, LOGOUT = 2, SUBMIT_MESSAGE = 3, ENQUIRE_MESSAGE_STATUS = 4,   DELIVERY_REQUEST = 5, CANCEL_MESSAGE = 6, SET_REQ = 8, GET_REQ = 9,   DELIVER_MESSAGE = 20, DELIVER_STATUS_REPORT = 23, ALIVE = 40, RESPONSE = 50,   GENERAL_ERROR_RESPONSE = 98, NACK = 99 }
enum	{   P_USER_IDENTITY = 10, P_PASSWORD = 11, P_DESTINATION_ADDRESS = 21, P_ORIGINATING_ADDRESS = 23,   P_ORIGINATING_IMSI = 26, P_ALPHANUMERIC_ORIGINATING_ADDRESS = 27, P_ORIGINATED_VISITED_MSC = 28, P_DATA_CODING_SCHEME = 30,   P_USER_DATA_HEADER = 32, P_USER_DATA = 33, P_USER_DATA_BINARY = 34, P_MORE_MESSAGES_TO_SEND = 44,   P_VALIDITY_PERIOD_RELATIVE = 50, P_VALIDITY_PERIOD_ABSOLUTE = 51, P_PROTOCOL_IDENTIFIER = 52, P_FIRST_DELIVERY_TIME_RELATIVE = 53,   P_FIRST_DELIVERY_TIME_ABSOLUTE = 54, P_REPLY_PATH = 55, P_STATUS_REPORT_REQUEST = 56, P_CANCEL_ENABLED = 58,   P_CANCEL_MODE = 59, P_MC_TIMESTAMP = 60, P_STATUS_CODE = 61, P_STATUS_ERROR_CODE = 62,   P_DISCHARGE_TIME = 63, P_TARIFF_CLASS = 64, P_SERVICE_DESCRIPTION = 65, P_MESSAGE_COUNT = 66,   P_PRIORITY = 67, P_DELIVERY_REQUEST_MODE = 68, P_SERVICE_CENTER_ADDRESS = 69, P_GET_PARAMETER = 500,   P_MC_TIME = 501, P_ERROR_CODE = 900, P_ERROR_TEXT = 901 }
enum	{   P_INT, P_STRING, P_ADDRESS, P_TIME,   P_HEX, P_SMS }

Functions
static int	parm_index (int parmno)
static int	parm_type (int parmno)
static int	parm_maxlen (int parmno)
static const char *	parm_name (int parmno)
static int	parm_in_range (int parmno, long value)
static int	isphonedigit (int c)
static int	parm_valid_address (Octstr *value)
static int	operation_find (int operation)
static Octstr *	operation_name (int operation)
static int	operation_can_send (int operation)
static int	operation_can_receive (int operation)
static Msg *	cimd2_accept_delivery_report_message (struct packet *request, SMSCConn *conn)
static void	packet_parse_header (struct packet *packet)
static struct packet *	packet_parse (Octstr *packet_data)
static void	packet_destroy (struct packet *packet)
static struct packet *	packet_extract (Octstr *in, SMSCConn *conn)
static Octstr *	packet_get_parm (struct packet *packet, int parmno)
static long	packet_get_int_parm (struct packet *packet, int parmno)
static Octstr *	packet_get_string_parm (struct packet *packet, int parmno)
static Octstr *	packet_get_address_parm (struct packet *packet, int parmno)
static Octstr *	packet_get_sms_parm (struct packet *packet, int parmno)
static Octstr *	packet_get_hex_parm (struct packet *packet, int parmno)
static int	packet_check_header (struct packet *packet, SMSCConn *conn)
static int	packet_check_parameter (struct packet *packet, long pos, long len, SMSCConn *conn)
static int	packet_check (struct packet *packet, SMSCConn *conn)
static void	packet_check_can_receive (struct packet *packet, SMSCConn *conn)
static int	packet_display_error (struct packet *packet, SMSCConn *conn)
static void	convert_cimd2_to_gsm (Octstr *text, SMSCConn *conn)
static void	convert_gsm_to_cimd2 (Octstr *text)
static struct packet *	packet_create (int operation, int seq)
static void	packet_add_parm (struct packet *packet, int parmtype, int parmno, Octstr *value, SMSCConn *conn)
static void	packet_add_string_parm (struct packet *packet, int parmno, Octstr *value, SMSCConn *conn)
static void	packet_add_address_parm (struct packet *packet, int parmno, Octstr *value, SMSCConn *conn)
static void	packet_add_sms_parm (struct packet *packet, int parmno, Octstr *value, SMSCConn *conn)
static void	packet_add_hex_parm (struct packet *packet, int parmno, Octstr *value, SMSCConn *conn)
static void	packet_add_int_parm (struct packet *packet, int parmno, long value, SMSCConn *conn)
static void	packet_set_checksum (struct packet *packet)
static void	packet_set_sequence (struct packet *packet, int seq)
static struct packet *	packet_encode_message (Msg *msg, Octstr *sender_prefix, SMSCConn *conn)
static void	packet_set_send_sequence (struct packet *packet, PrivData *pdata)
static struct packet *	cimd2_get_packet (PrivData *pdata, Octstr **ts)
static void	cimd2_send_response (struct packet *request, PrivData *pdata)
static Msg *	cimd2_accept_message (struct packet *request, SMSCConn *conn)
static void	cimd2_handle_request (struct packet *request, SMSCConn *conn)
static int	cimd2_request (struct packet *request, SMSCConn *conn, Octstr **ts)
static void	cimd2_close_socket (PrivData *pdata)
static int	cimd2_login (SMSCConn *conn)
static void	cimd2_logout (SMSCConn *conn)
static int	cimd2_send_alive (SMSCConn *conn)
static void	cimd2_destroy (PrivData *pdata)
static int	cimd2_submit_msg (SMSCConn *conn, Msg *msg)
static int	cimd2_receive_msg (SMSCConn *conn, Msg **msg)
static Msg *	sms_receive (SMSCConn *conn)
static void	io_thread (void *arg)
static int	cimd2_add_msg_cb (SMSCConn *conn, Msg *sms)
static int	cimd2_shutdown_cb (SMSCConn *conn, int finish_sending)
static void	cimd2_start_cb (SMSCConn *conn)
static void	cimd2_stop_cb (SMSCConn *conn)
static long	cimd2_queued_cb (SMSCConn *conn)
int	smsc_cimd2_create (SMSCConn *conn, CfgGroup *grp)

Variables
struct {
char *   name
int   number
int   maxlen
int   type
int   minval
int   maxval
}	parameters []
struct {
char *   name
int   code
int   can_send
int   can_receive
}	operations []
struct {
int   code
char *   text
}	cimd2_errors []
struct {
unsigned char   cimd1
unsigned char   cimd2
unsigned char   gsm
}	cimd_combinations []

Macro Definition Documentation

BOGUS_SEQUENCE

#define BOGUS_SEQUENCE   0

Definition at line 471 of file smsc_cimd2.c.

Referenced by cimd2_login(), cimd2_logout(), cimd2_send_alive(), and packet_encode_message().

ETX

#define ETX   3 /* End of packet */

Definition at line 462 of file smsc_cimd2.c.

Referenced by packet_extract().

ETX_str

#define ETX_str   "\03"

Definition at line 467 of file smsc_cimd2.c.

Referenced by packet_create(), and packet_extract().

RESPONSE_TIMEOUT

#define RESPONSE_TIMEOUT   (60 * 1000000)

Definition at line 128 of file smsc_cimd2.c.

Referenced by cimd2_get_packet().

STX

#define STX   2 /* Start of packet */

Definition at line 461 of file smsc_cimd2.c.

Referenced by packet_extract().

STX_str

#define STX_str   "\02"

Definition at line 466 of file smsc_cimd2.c.

Referenced by packet_create().

TAB

#define TAB   9 /* End of parameter */

Definition at line 463 of file smsc_cimd2.c.

Referenced by packet_check(), packet_check_header(), packet_get_parm(), and packet_set_checksum().

TAB_str

#define TAB_str   "\011"

Definition at line 468 of file smsc_cimd2.c.

Referenced by packet_add_parm(), and packet_create().

Typedef Documentation

PrivData

typedef struct privdata PrivData

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
LOGIN
LOGOUT
SUBMIT_MESSAGE
ENQUIRE_MESSAGE_STATUS
DELIVERY_REQUEST
CANCEL_MESSAGE
SET_REQ
GET_REQ
DELIVER_MESSAGE
DELIVER_STATUS_REPORT
ALIVE
RESPONSE
GENERAL_ERROR_RESPONSE
NACK

Definition at line 132 of file smsc_cimd2.c.

     {
    /* Requests from client */
    LOGIN = 1,
    LOGOUT = 2,
    SUBMIT_MESSAGE = 3,
    ENQUIRE_MESSAGE_STATUS = 4,
    DELIVERY_REQUEST = 5,
    CANCEL_MESSAGE = 6,
    SET_REQ = 8,
    GET_REQ = 9,

    /* Requests from server */
    DELIVER_MESSAGE = 20,
    DELIVER_STATUS_REPORT = 23,

    /* Requests from either */
    ALIVE = 40,

    /* Not a request; add to any request to make it a response */
    RESPONSE = 50,

    /* Responses not related to requests */
    GENERAL_ERROR_RESPONSE = 98,
    NACK = 99
};

anonymous enum

anonymous enum

Enumerator
P_USER_IDENTITY
P_PASSWORD
P_DESTINATION_ADDRESS
P_ORIGINATING_ADDRESS
P_ORIGINATING_IMSI
P_ALPHANUMERIC_ORIGINATING_ADDRESS
P_ORIGINATED_VISITED_MSC
P_DATA_CODING_SCHEME
P_USER_DATA_HEADER
P_USER_DATA
P_USER_DATA_BINARY
P_MORE_MESSAGES_TO_SEND
P_VALIDITY_PERIOD_RELATIVE
P_VALIDITY_PERIOD_ABSOLUTE
P_PROTOCOL_IDENTIFIER
P_FIRST_DELIVERY_TIME_RELATIVE
P_FIRST_DELIVERY_TIME_ABSOLUTE
P_REPLY_PATH
P_STATUS_REPORT_REQUEST
P_CANCEL_ENABLED
P_CANCEL_MODE
P_MC_TIMESTAMP
P_STATUS_CODE
P_STATUS_ERROR_CODE
P_DISCHARGE_TIME
P_TARIFF_CLASS
P_SERVICE_DESCRIPTION
P_MESSAGE_COUNT
P_PRIORITY
P_DELIVERY_REQUEST_MODE
P_SERVICE_CENTER_ADDRESS
P_GET_PARAMETER
P_MC_TIME
P_ERROR_CODE
P_ERROR_TEXT

Definition at line 160 of file smsc_cimd2.c.

     {
    P_USER_IDENTITY = 10,
    P_PASSWORD = 11,
    P_DESTINATION_ADDRESS = 21,
    P_ORIGINATING_ADDRESS = 23,
    P_ORIGINATING_IMSI = 26,
    P_ALPHANUMERIC_ORIGINATING_ADDRESS = 27,
    P_ORIGINATED_VISITED_MSC = 28,
    P_DATA_CODING_SCHEME = 30,
    P_USER_DATA_HEADER = 32,
    P_USER_DATA = 33,
    P_USER_DATA_BINARY = 34,
    P_MORE_MESSAGES_TO_SEND = 44,
    P_VALIDITY_PERIOD_RELATIVE = 50,
    P_VALIDITY_PERIOD_ABSOLUTE = 51,
    P_PROTOCOL_IDENTIFIER = 52,
    P_FIRST_DELIVERY_TIME_RELATIVE = 53,
    P_FIRST_DELIVERY_TIME_ABSOLUTE = 54,
    P_REPLY_PATH = 55,
    P_STATUS_REPORT_REQUEST = 56,
    P_CANCEL_ENABLED = 58,
    P_CANCEL_MODE = 59,
    P_MC_TIMESTAMP = 60,
    P_STATUS_CODE = 61,
    P_STATUS_ERROR_CODE = 62,
    P_DISCHARGE_TIME = 63,
    P_TARIFF_CLASS = 64,
    P_SERVICE_DESCRIPTION = 65,
    P_MESSAGE_COUNT = 66,
    P_PRIORITY = 67,
    P_DELIVERY_REQUEST_MODE = 68,
    P_SERVICE_CENTER_ADDRESS = 69,
    P_GET_PARAMETER = 500,
    P_MC_TIME = 501,
    P_ERROR_CODE = 900,
    P_ERROR_TEXT = 901
};

anonymous enum

anonymous enum

Enumerator
P_INT
P_STRING
P_ADDRESS
P_TIME
P_HEX
P_SMS

Definition at line 205 of file smsc_cimd2.c.

{ P_INT, P_STRING, P_ADDRESS, P_TIME, P_HEX, P_SMS };

Function Documentation

cimd2_accept_delivery_report_message()

static Msg * cimd2_accept_delivery_report_message ( struct packet *  request, SMSCConn *  conn  )

static

Definition at line 2084 of file smsc_cimd2.c.

References code, DLR_EXPIRED, DLR_FAIL, dlr_find(), DLR_SUCCESS, smscconn::id, msg, octstr_destroy(), octstr_get_cstr, P_DESTINATION_ADDRESS, P_MC_TIMESTAMP, P_STATUS_CODE, P_USER_DATA, and packet_get_parm().

Referenced by cimd2_handle_request().

{
    Msg *msg = NULL;
    Octstr *destination = NULL;
    Octstr *timestamp = NULL;
    Octstr *statuscode = NULL;
    int st_code;
    int code;

    destination = packet_get_parm(request, P_DESTINATION_ADDRESS);
    timestamp = packet_get_parm(request, P_MC_TIMESTAMP);
    statuscode = packet_get_parm(request, P_STATUS_CODE);

    st_code = atoi(octstr_get_cstr(statuscode));

    switch(st_code)
    {
    case 2:  /* validity period expired */
    code = DLR_EXPIRED;
    break;
    case 3:  /* delivery failed */
    case 6: /* last no response */
    case 7: /* message cancelled */
    case 8: /* message deleted */
    case 9: /* message deleted by cancel */
    code = DLR_FAIL;
        break;
    case 4: /* delivery successful */
        code = DLR_SUCCESS;
        break;
    default:
        code = 0;
    }
    if(code)
        msg = dlr_find(conn->id, timestamp, destination, code, 1);
    else
        msg = NULL;

    /* recode the body into msgdata */
    if (msg) {
        msg->sms.msgdata = packet_get_parm(request, P_USER_DATA);
        if (!msg->sms.msgdata) {
            msg->sms.msgdata = statuscode;
            statuscode = NULL;
        }
    }

    octstr_destroy(statuscode);
    octstr_destroy(destination);
    octstr_destroy(timestamp);

    return msg;
 }

cimd2_accept_message()

static Msg* cimd2_accept_message ( struct packet *  request, SMSCConn *  conn  )

static

Definition at line 1588 of file smsc_cimd2.c.

References charset_gsm_to_utf8(), convert_cimd2_to_gsm(), dcs_to_fields(), debug(), error(), smscconn::id, info(), msg_create, msg_destroy(), octstr_destroy(), octstr_get_cstr, octstr_len(), P_DATA_CODING_SCHEME, P_DESTINATION_ADDRESS, P_ORIGINATING_ADDRESS, P_USER_DATA, P_USER_DATA_BINARY, P_USER_DATA_HEADER, packet_get_address_parm(), packet_get_hex_parm(), packet_get_int_parm(), packet_get_sms_parm(), and text.

Referenced by cimd2_handle_request().

{
    Msg *message = NULL;
    Octstr *destination = NULL;
    Octstr *origin = NULL;
    Octstr *UDH = NULL;
    Octstr *text = NULL;
    int DCS;

    /* See GSM 03.38.  The bit patterns we can handle are:
     *   000xyyxx  Uncompressed text, yy indicates alphabet.
     *                   yy = 00, default alphabet
     *                   yy = 01, 8-bit data
     *                   yy = 10, UCS-2
     *                   yy = 11, reserved
     *   1111xyxx  Data, y indicates alphabet.
     *                   y = 0, default alphabet
     *                   y = 1, 8-bit data
     */
    DCS = packet_get_int_parm(request, P_DATA_CODING_SCHEME);

    destination = packet_get_address_parm(request, P_DESTINATION_ADDRESS);
    origin = packet_get_address_parm(request, P_ORIGINATING_ADDRESS);
    UDH = packet_get_hex_parm(request, P_USER_DATA_HEADER);
    /* Text is either in User Data or User Data Binary field. */
    text = packet_get_sms_parm(request, P_USER_DATA);
    if (text != NULL) {
        convert_cimd2_to_gsm(text,conn);
        charset_gsm_to_utf8(text);
    } else {
        /*
         * FIXME: If DCS indicates GSM charset, and we get it in binary,
         * then it's probably bit-packed.  We'll have to undo it because
         * our "charset_gsm" means one gsm character per octet.  This is
         * not currently supported. -- RB
         */
        text = packet_get_hex_parm(request, P_USER_DATA_BINARY);
    }

    /* Code elsewhere in the gateway always expects the sender and
     * receiver fields to be filled, so we discard messages that
     * lack them.  If they should not be discarded, then the code
     * handling sms messages should be reviewed.  -- RB */
    if (!destination || octstr_len(destination) == 0) {
        info(0, "CIMD2[%s]: Got SMS without receiver, discarding.",
              octstr_get_cstr(conn->id));
        goto error;
    }
    if (!origin || octstr_len(origin) == 0) {
        info(0, "CIMD2[%s]: Got SMS without sender, discarding.",
              octstr_get_cstr(conn->id));
        goto error;
    }

    if (!text && (!UDH || octstr_len(UDH) == 0)) {
        info(0, "CIMD2[%s]: Got empty SMS, ignoring.",
              octstr_get_cstr(conn->id));
        goto error;
    }
    
    message = msg_create(sms);
    if (! dcs_to_fields(&message, DCS)) {
    /* XXX Should reject this message ? */
        debug("bb.sms.cimd2", 0, "CIMD2[%s]: Invalid DCS",
              octstr_get_cstr(conn->id));
    dcs_to_fields(&message, 0);
    }
    time(&message->sms.time);
    message->sms.sender = origin;
    message->sms.receiver = destination;
    if (UDH) {
        message->sms.udhdata = UDH;
    }
    message->sms.msgdata = text;
    return message;

error:
    msg_destroy(message);
    octstr_destroy(destination);
    octstr_destroy(origin);
    octstr_destroy(UDH);
    octstr_destroy(text);
    return NULL;
}

cimd2_add_msg_cb()

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

static

Definition at line 2239 of file smsc_cimd2.c.

References smscconn::data, gwlist_produce(), gwthread_wakeup(), privdata::io_thread, msg_duplicate(), and privdata::outgoing_queue.

Referenced by smsc_cimd2_create().

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

    copy = msg_duplicate(sms);
    gwlist_produce(pdata->outgoing_queue, copy);
    gwthread_wakeup(pdata->io_thread);

    return 0;
}

cimd2_close_socket()

static void cimd2_close_socket ( PrivData *  pdata )

static

Definition at line 1837 of file smsc_cimd2.c.

References privdata::conn, gw_assert(), smscconn::id, octstr_get_cstr, privdata::socket, and warning().

Referenced by cimd2_login(), cimd2_shutdown_cb(), cimd2_submit_msg(), and sms_receive().

{
    gw_assert(pdata != NULL);

    if (pdata->socket < 0)
        return;

    if (close(pdata->socket) < 0)
        warning(errno, "CIMD2[%s]: error closing socket",
                octstr_get_cstr(pdata->conn->id));
    pdata->socket = -1;
}

cimd2_destroy()

static void cimd2_destroy ( PrivData *  pdata )

static

Definition at line 1929 of file smsc_cimd2.c.

References privdata::conn, gwlist_destroy(), gwlist_len(), privdata::host, smscconn::id, privdata::inbuffer, msg_destroy_item(), privdata::my_number, octstr_destroy(), octstr_get_cstr, privdata::outgoing_queue, privdata::password, privdata::received, privdata::stopped, privdata::username, and warning().

Referenced by cimd2_shutdown_cb(), and smsc_cimd2_create().

{
    int discarded;

    if (pdata == NULL) 
        return;
        
    octstr_destroy(pdata->host);
    octstr_destroy(pdata->username);
    octstr_destroy(pdata->password);
    octstr_destroy(pdata->inbuffer);
    octstr_destroy(pdata->my_number);

    discarded = gwlist_len(pdata->received);
    if (discarded > 0)
        warning(0, "CIMD2[%s]: discarded %d received messages",
                octstr_get_cstr(pdata->conn->id), 
                discarded);

    gwlist_destroy(pdata->received, msg_destroy_item);
    gwlist_destroy(pdata->outgoing_queue, NULL);
    gwlist_destroy(pdata->stopped, NULL);

    gw_free(pdata);
}

cimd2_get_packet()

static struct packet* cimd2_get_packet ( PrivData *  pdata, Octstr **  ts  )

static

Definition at line 1526 of file smsc_cimd2.c.

References privdata::conn, packet::data, debug(), error(), gw_assert(), smscconn::id, privdata::inbuffer, privdata::keepalive, privdata::next_ping, octstr_append_from_socket(), octstr_get_cstr, P_MC_TIMESTAMP, packet_check(), packet_check_can_receive(), packet_extract(), packet_get_parm(), read_available(), RESPONSE_TIMEOUT, privdata::socket, and warning().

Referenced by cimd2_request().

{
    struct packet *packet = NULL;

    gw_assert(pdata != NULL);

    /* If packet is already available, don't try to read anything */
    packet = packet_extract(pdata->inbuffer, pdata->conn);

    while (packet == NULL) {
        if (read_available(pdata->socket, RESPONSE_TIMEOUT) != 1) {
            warning(0, "CIMD2[%s]: SMSC is not responding",
                    octstr_get_cstr(pdata->conn->id));
            return NULL;
        }

        if (octstr_append_from_socket(pdata->inbuffer, pdata->socket) <= 0) {
            error(0, "CIMD2[%s]: cimd2_get_packet: read failed",
                  octstr_get_cstr(pdata->conn->id));
            return NULL;
        }

        packet = packet_extract(pdata->inbuffer, pdata->conn);
    }

    packet_check(packet,pdata->conn);
    packet_check_can_receive(packet,pdata->conn);
    debug("bb.sms.cimd2", 0, "CIMD2[%s]: received: <%s>",
          octstr_get_cstr(pdata->conn->id), 
          octstr_get_cstr(packet->data));
    if (ts)
        *ts = packet_get_parm(packet,P_MC_TIMESTAMP);

    if (pdata->keepalive > 0)
        pdata->next_ping = time(NULL) + pdata->keepalive;

    return packet;
}

cimd2_handle_request()

static void cimd2_handle_request ( struct packet *  request, SMSCConn *  conn  )

static

Definition at line 1674 of file smsc_cimd2.c.

References cimd2_accept_delivery_report_message(), cimd2_accept_message(), cimd2_send_response(), smscconn::data, DELIVER_MESSAGE, DELIVER_STATUS_REPORT, gwlist_append(), smscconn::id, octstr_get_cstr, packet::operation, privdata::receive_seq, privdata::received, packet::seq, and warning().

Referenced by cimd2_receive_msg(), and cimd2_request().

{
    PrivData *pdata = conn->data;
    Msg *message = NULL;

    if ((request->seq == 254 && pdata->receive_seq == 0) ||
            request->seq == pdata->receive_seq - 2) {
        warning(0, "CIMD2[%s]: request had same sequence number as previous.",
                octstr_get_cstr(conn->id));
    }
    else {
        pdata->receive_seq = request->seq + 2;
        if (pdata->receive_seq > 254)
            pdata->receive_seq = 0;

        if (request->operation == DELIVER_STATUS_REPORT) {
            message = cimd2_accept_delivery_report_message(request, conn);
            if (message)
                gwlist_append(pdata->received, message);
        }
        else if (request->operation == DELIVER_MESSAGE) {
            message = cimd2_accept_message(request,conn);
            if (message)
                gwlist_append(pdata->received, message);
        }
    }

    cimd2_send_response(request, pdata);
}

cimd2_login()

static int cimd2_login ( SMSCConn *  conn )

static

Definition at line 1854 of file smsc_cimd2.c.

References BOGUS_SEQUENCE, cimd2_close_socket(), cimd2_request(), smscconn::data, error(), gw_assert(), privdata::host, smscconn::id, info(), LOGIN, octstr_get_cstr, smscconn::our_host, privdata::our_port, P_PASSWORD, P_USER_IDENTITY, packet_add_string_parm(), packet_create(), packet_destroy(), privdata::password, privdata::port, privdata::socket, tcpip_connect_to_server_with_port(), privdata::username, and warning().

Referenced by io_thread().

{
    PrivData *pdata = conn->data;
    int ret;
    struct packet *packet = NULL;

    gw_assert(pdata != NULL);

    if (pdata->socket >= 0) {
        warning(0, "CIMD2[%s]: login: socket was already open; closing",
                octstr_get_cstr(conn->id));
        cimd2_close_socket(pdata);
    }
    
    pdata->socket = tcpip_connect_to_server_with_port(
                                            octstr_get_cstr(pdata->host),
                                            pdata->port,
                                            pdata->our_port,
                                            (conn->our_host ? octstr_get_cstr(conn->our_host) : NULL)); 
    if (pdata->socket != -1) {
    
        packet = packet_create(LOGIN, BOGUS_SEQUENCE);
        packet_add_string_parm(packet, P_USER_IDENTITY, pdata->username, conn);
        packet_add_string_parm(packet, P_PASSWORD, pdata->password, conn);
        
        ret = cimd2_request(packet, conn, NULL);
        
        if (ret >= 0) {
            packet_destroy(packet);
            info(0, "CIMD2[%s] logged in.",
                 octstr_get_cstr(conn->id));
            return 0;
        }
    }
    error(0, "CIMD2[%s] login failed.",
          octstr_get_cstr(conn->id));
    cimd2_close_socket(pdata);
    packet_destroy(packet);
    return -1;
}

cimd2_logout()

static void cimd2_logout ( SMSCConn *  conn )

static

Definition at line 1895 of file smsc_cimd2.c.

References BOGUS_SEQUENCE, cimd2_request(), smscconn::id, info(), LOGOUT, octstr_get_cstr, packet_create(), and packet_destroy().

Referenced by cimd2_shutdown_cb().

{
    struct packet *packet = NULL;
    int ret;

    packet = packet_create(LOGOUT, BOGUS_SEQUENCE);

    /* TODO: Don't wait very long for a response in this case. */
    ret = cimd2_request(packet, conn, NULL);

    if (ret == 0) {
        info(0, "CIMD2[%s] logged out.",
             octstr_get_cstr(conn->id));
    }
    packet_destroy(packet);
}

cimd2_queued_cb()

static long cimd2_queued_cb ( SMSCConn *  conn )

static

Definition at line 2313 of file smsc_cimd2.c.

References smscconn::data, gwlist_len(), smscconn::load, privdata::outgoing_queue, SMSCCONN_DEAD, and smscconn::status.

Referenced by smsc_cimd2_create().

{
    PrivData *pdata = conn->data;
    conn->load = (pdata ? (conn->status != SMSCCONN_DEAD ? 
                  gwlist_len(pdata->outgoing_queue) : 0) : 0);
    return conn->load; 
}

cimd2_receive_msg()

static int cimd2_receive_msg ( SMSCConn *  conn, Msg **  msg  )

static

Definition at line 2002 of file smsc_cimd2.c.

References cimd2_handle_request(), cimd2_send_alive(), privdata::conn, smscconn::data, packet::data, debug(), error(), gw_assert(), gwlist_consume(), gwlist_len(), smscconn::id, privdata::inbuffer, privdata::keepalive, msg, privdata::next_ping, octstr_append_from_socket(), octstr_dump, octstr_get_cstr, packet::operation, packet_check(), packet_check_can_receive(), packet_destroy(), packet_extract(), read_available(), privdata::received, RESPONSE, privdata::socket, and warning().

Referenced by sms_receive().

{
    PrivData *pdata = conn->data;
    long ret;
    struct packet *packet;

    gw_assert(pdata != NULL);

    if (gwlist_len(pdata->received) > 0) {
        *msg = gwlist_consume(pdata->received);
        return 1;
    }

    if (pdata->socket < 0) {
        /* XXX We have to assume that smsc_send_message is
         * currently trying to reopen, so we have to make
         * this thread wait.  It should be done in a nicer
         * way. */
        return 0;
    }
    
    ret = read_available(pdata->socket, 0);
    if (ret == 0) {
        if (pdata->keepalive > 0 && pdata->next_ping < time(NULL)) {
            if (cimd2_send_alive(conn) < 0)
        return -1;
        }
        return 0;
    }

    if (ret < 0) {
        warning(errno, "CIMD2[%s]: cimd2_receive_msg: read_available failed",
                octstr_get_cstr(conn->id));
        return -1;
    }

    /* We have some data waiting... see if it is an sms delivery. */
    ret = octstr_append_from_socket(pdata->inbuffer, pdata->socket);

    if (ret == 0) {
        warning(0, "CIMD2[%s]: cimd2_receive_msg: service center closed connection.",
                octstr_get_cstr(conn->id));
        return -1;
    }
    if (ret < 0) {
        warning(0, "CIMD2[%s]: cimd2_receive_msg: read failed",
                octstr_get_cstr(conn->id));
        return -1;
    }


    for (;;) {
        packet = packet_extract(pdata->inbuffer,conn);
        if (!packet)
            break;

        packet_check(packet,conn);
        packet_check_can_receive(packet,conn);
        debug("bb.sms.cimd2", 0, "CIMD2[%s]: received: <%s>",
              octstr_get_cstr(pdata->conn->id), 
              octstr_get_cstr(packet->data));

        if (packet->operation < RESPONSE)
            cimd2_handle_request(packet, conn);
        else {
            error(0, "CIMD2[%s]: cimd2_receive_msg: unexpected response packet",
                octstr_get_cstr(conn->id));
            octstr_dump(packet->data, 0);
        }

        packet_destroy(packet);
    }

    if (gwlist_len(pdata->received) > 0) {
    *msg = gwlist_consume(pdata->received);
        return 1;
    }
    return 0;
}

cimd2_request()

static int cimd2_request ( struct packet *  request, SMSCConn *  conn, Octstr **  ts  )

static

Definition at line 1718 of file smsc_cimd2.c.

References cimd2_get_packet(), cimd2_handle_request(), smscconn::data, packet::data, debug(), error(), GENERAL_ERROR_RESPONSE, gw_assert(), smscconn::id, NACK, octstr_destroy(), octstr_dump, octstr_get_cstr, octstr_write_to_socket(), packet::operation, operation_can_send(), operation_name(), packet_destroy(), packet_display_error(), packet_set_checksum(), packet_set_send_sequence(), reply(), RESPONSE, privdata::send_seq, packet::seq, privdata::socket, and warning().

Referenced by cimd2_login(), cimd2_logout(), cimd2_send_alive(), and cimd2_submit_msg().

{
    PrivData *pdata = conn->data;
    int ret;
    struct packet *reply = NULL;
    int errorcode;
    int tries = 0;

    gw_assert(pdata != NULL);
    gw_assert(request != NULL);
    gw_assert(operation_can_send(request->operation));

    if (pdata->socket < 0) {
        warning(0, "CIMD2[%s]: cimd2_request: socket not open.",
                octstr_get_cstr(conn->id));
        return -2;        
    }
    
retransmit:
    packet_set_send_sequence(request, pdata);
    packet_set_checksum(request);

    debug("bb.sms.cimd2", 0, "CIMD2[%s]: sending <%s>",
          octstr_get_cstr(conn->id),
          octstr_get_cstr(request->data));

    ret = octstr_write_to_socket(pdata->socket, request->data);
    if (ret < 0)
        goto io_error;

next_reply:
    packet_destroy(reply);  /* destroy old, if any */
    reply = cimd2_get_packet(pdata, ts);
    if (!reply)
        goto io_error;

    errorcode = packet_display_error(reply,conn);

    if (reply->operation == NACK) {
        warning(0, "CIMD2[%s]: received NACK",
                octstr_get_cstr(conn->id));
        octstr_dump(reply->data, 0);
        /* Correct sequence number if server says it was wrong,
         * but only if server's number is sane. */
        if (reply->seq != request->seq && (reply->seq % 2) == 1) {
            warning(0, "CIMD2[%s]: correcting sequence number from %ld to %ld.",
                    octstr_get_cstr(conn->id),
                    (long) pdata->send_seq, 
                    (long) reply->seq);
            pdata->send_seq = reply->seq;
        }
        goto retry;
    }

    if (reply->operation == GENERAL_ERROR_RESPONSE) {
        error(0, "CIMD2[%s]: received general error response",
              octstr_get_cstr(conn->id));
        goto io_error;
    }

    /* The server sent us a request.  Handle it, then wait for
     * a new reply. */
    if (reply->operation < RESPONSE) {
        cimd2_handle_request(reply, conn);
        goto next_reply;
    }

    if (reply->seq != request->seq) {
        /* We got a response to a different request number than
         * what we send.  Strange. */
        warning(0, "CIMD2[%s]: response had unexpected sequence number; ignoring.",
                octstr_get_cstr(conn->id));
        goto next_reply;
    }

    if (reply->operation != request->operation + RESPONSE) {
        /* We got a response that didn't match our request */
        Octstr *request_name = operation_name(request->operation);
        Octstr *reply_name = operation_name(reply->operation);
        warning(0, "CIMD2[%s]: %s request got a %s",
                octstr_get_cstr(conn->id),
                octstr_get_cstr(request_name),
                octstr_get_cstr(reply_name));

        octstr_destroy(request_name);
        octstr_destroy(reply_name);
        octstr_dump(reply->data, 0);
        goto retry;
    }

    if (errorcode > 0)
        goto error;

    /* The reply passed all the checks... looks like the SMSC accepted
     * our request! */
    packet_destroy(reply);
    return 0;

io_error:
    packet_destroy(reply);
    return -2;

error:
    packet_destroy(reply);
    return -1;

retry:
    if (++tries < 3) {
        warning(0, "CIMD2[%s]: Retransmitting (take %d)", 
                octstr_get_cstr(conn->id),
                tries);
        goto retransmit;
    }
    warning(0, "CIMD2[%s]: Giving up.",
            octstr_get_cstr(conn->id));
    goto io_error;
}

cimd2_send_alive()

static int cimd2_send_alive ( SMSCConn *  conn )

static

Definition at line 1912 of file smsc_cimd2.c.

References ALIVE, BOGUS_SEQUENCE, cimd2_request(), smscconn::id, octstr_get_cstr, packet_create(), packet_destroy(), and warning().

Referenced by cimd2_receive_msg().

{
    struct packet *packet = NULL;
    int ret;

    packet = packet_create(ALIVE, BOGUS_SEQUENCE);
    ret = cimd2_request(packet, conn, NULL);
    packet_destroy(packet);

    if (ret < 0)
        warning(0, "CIMD2[%s]: SMSC not alive.",
                octstr_get_cstr(conn->id));

    return ret;
}

cimd2_send_response()

static void cimd2_send_response ( struct packet *  request, PrivData *  pdata  )

static

Definition at line 1567 of file smsc_cimd2.c.

References privdata::conn, debug(), gw_assert(), smscconn::id, octstr_get_cstr, octstr_write_to_socket(), packet::operation, packet_create(), packet_destroy(), packet_set_checksum(), response(), RESPONSE, packet::seq, and privdata::socket.

Referenced by cimd2_handle_request().

{
    struct packet *response;

    gw_assert(request != NULL);
    gw_assert(request->operation < RESPONSE);

    response = packet_create(request->operation + RESPONSE, request->seq);
    packet_set_checksum(response);

    debug("bb.sms.cimd2", 0, "CIMD2[%s]: sending <%s>",
          octstr_get_cstr(pdata->conn->id),
          octstr_get_cstr(response->data));

    /* Don't check errors here because if there is something
     * wrong with the socket, the main loop will detect it. */
    octstr_write_to_socket(pdata->socket, response->data);

    packet_destroy(response);
}

cimd2_shutdown_cb()

static int cimd2_shutdown_cb ( SMSCConn *  conn, int  finish_sending  )

static

Definition at line 2252 of file smsc_cimd2.c.

References bb_smscconn_killed(), bb_smscconn_send_failed(), cimd2_close_socket(), cimd2_destroy(), cimd2_logout(), smscconn::data, debug(), gwlist_extract_first(), gwlist_remove_producer(), gwthread_join(), gwthread_wakeup(), smscconn::id, privdata::io_thread, smscconn::is_stopped, msg, octstr_get_cstr, privdata::outgoing_queue, privdata::quitting, SMSCCONN_DEAD, SMSCCONN_FAILED_SHUTDOWN, SMSCCONN_KILLED_SHUTDOWN, smscconn::status, privdata::stopped, and smscconn::why_killed.

Referenced by smsc_cimd2_create().

{
    PrivData *pdata = conn->data;
    
    debug("bb.sms", 0, "Shutting down SMSCConn CIMD2 %s (%s)",
          octstr_get_cstr(conn->id), 
          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;
    pdata->quitting = 1;     /* Separate from why_killed to avoid locking, as
                              * why_killed may be changed from outside? */

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

    cimd2_logout(conn);
    if (conn->is_stopped) {
        gwlist_remove_producer(pdata->stopped);
        conn->is_stopped = 0;
    }

    if (pdata->io_thread != -1) {
        gwthread_wakeup(pdata->io_thread);
        gwthread_join(pdata->io_thread);
    }

    cimd2_close_socket(pdata);
    cimd2_destroy(pdata); 
     
    debug("bb.sms", 0, "SMSCConn CIMD2 %s shut down.",  
          octstr_get_cstr(conn->id)); 
    conn->status = SMSCCONN_DEAD; 
    bb_smscconn_killed(); 
    return 0;
}    

cimd2_start_cb()

static void cimd2_start_cb ( SMSCConn *  conn )

static

Definition at line 2294 of file smsc_cimd2.c.

References smscconn::data, debug(), gwlist_remove_producer(), gwthread_wakeup(), smscconn::id, privdata::io_thread, octstr_get_cstr, and privdata::stopped.

Referenced by smsc_cimd2_create().

{
    PrivData *pdata = conn->data;

    gwlist_remove_producer(pdata->stopped);
    /* in case there are messages in the buffer already */
    gwthread_wakeup(pdata->io_thread);
    debug("bb.sms", 0, "SMSCConn CIMD2 %s, start called",
          octstr_get_cstr(conn->id));
}

cimd2_stop_cb()

static void cimd2_stop_cb ( SMSCConn *  conn )

static

Definition at line 2305 of file smsc_cimd2.c.

References smscconn::data, debug(), gwlist_add_producer(), smscconn::id, octstr_get_cstr, and privdata::stopped.

Referenced by smsc_cimd2_create().

{
    PrivData *pdata = conn->data;
    gwlist_add_producer(pdata->stopped);
    debug("bb.sms", 0, "SMSCConn CIMD2 %s, stop called",
          octstr_get_cstr(conn->id));
}

cimd2_submit_msg()

static int cimd2_submit_msg ( SMSCConn *  conn, Msg *  msg  )

static

Definition at line 1956 of file smsc_cimd2.c.

References bb_smscconn_send_failed(), bb_smscconn_sent(), cimd2_close_socket(), cimd2_request(), smscconn::data, debug(), dlr_add(), DLR_IS_SUCCESS_OR_FAIL, smscconn::flow_mutex, gw_assert(), smscconn::id, msg, mutex_lock, mutex_unlock, privdata::my_number, privdata::no_dlr, octstr_create, octstr_destroy(), octstr_get_cstr, packet_destroy(), packet_encode_message(), SMSCCONN_DISCONNECTED, SMSCCONN_FAILED_MALFORMED, SMSCCONN_FAILED_REJECTED, SMSCCONN_FAILED_TEMPORARILY, and smscconn::status.

Referenced by io_thread().

{
    PrivData *pdata = conn->data;
    struct packet *packet;
    Octstr *ts = NULL;
    int ret;

    gw_assert(pdata != NULL);
    debug("bb.sms.cimd2", 0, "CIMD2[%s]: sending message",
        octstr_get_cstr(conn->id));

    packet = packet_encode_message(msg, pdata->my_number,conn);
    if (!packet) {
        /* This is a protocol error. Does this help? I doubt..
         * But nevermind that.
         */
        bb_smscconn_send_failed(conn, msg,
                SMSCCONN_FAILED_MALFORMED, octstr_create("MALFORMED"));
        return -1;
    }

    ret = cimd2_request(packet, conn, &ts);
    if ((ret == 0) && (ts) && DLR_IS_SUCCESS_OR_FAIL(msg->sms.dlr_mask) && !pdata->no_dlr) {
        dlr_add(conn->id, ts, msg, 1);
    }
    octstr_destroy(ts);
    packet_destroy(packet);
    
    if (ret == -1) {
        bb_smscconn_send_failed(conn, msg,
                SMSCCONN_FAILED_REJECTED, octstr_create("REJECTED"));
    }
    else if (ret == -2) {
        cimd2_close_socket(pdata);
        bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_TEMPORARILY, NULL);
        mutex_lock(conn->flow_mutex);
        conn->status = SMSCCONN_DISCONNECTED;
        mutex_unlock(conn->flow_mutex);
    }
    else {
        bb_smscconn_sent(conn,msg, NULL);
    }

    return ret;
}

convert_cimd2_to_gsm()

static void convert_cimd2_to_gsm ( Octstr *  text, SMSCConn *  conn  )

static

Definition at line 1081 of file smsc_cimd2.c.

References cimd1, cimd2, cimd_combinations, gsm, smscconn::id, octstr_delete(), octstr_get_char(), octstr_get_cstr, octstr_len(), octstr_set_char(), text, and warning().

Referenced by cimd2_accept_message().

{
    long pos, len;
    int cimd1, cimd2;
    int c;
    int i;

    /* CIMD2 uses four single-character mappings that do not map
     * to themselves:
     * '@' from 64 to 0, '$' from 36 to 2, ']' from 93 to 14 (A-ring),
     * and '}' from 125 to 15 (a-ring).
     * Other than those, we only have to worry about the escape
     * sequences introduced by _ (underscore).
     */

    len = octstr_len(text);
    for (pos = 0; pos < len; pos++) {
        c = octstr_get_char(text, pos);
        if (c == '@')
            octstr_set_char(text, pos, 0);
        else if (c == '$')
            octstr_set_char(text, pos, 2);
        else if (c == ']')
            octstr_set_char(text, pos, 14);
        else if (c == '}')
            octstr_set_char(text, pos, 15);
        else if (c == '_' && pos + 2 < len) {
            cimd1 = octstr_get_char(text, pos + 1);
            cimd2 = octstr_get_char(text, pos + 2);
            for (i = 0; cimd_combinations[i].cimd1 != 0; i++) {
                if (cimd_combinations[i].cimd1 == cimd1 &&
                    cimd_combinations[i].cimd2 == cimd2)
                    break;
            }
            if (cimd_combinations[i].cimd1 == 0)
                warning(0, "CIMD2[%s]: Encountered unknown "
                        "escape code _%c%c, ignoring.",
                        octstr_get_cstr(conn->id),
                        cimd1, cimd2);
            else {
                octstr_delete(text, pos, 2);
                octstr_set_char(text, pos, cimd_combinations[i].gsm);
                len = octstr_len(text);
            }
        }
    }
}

convert_gsm_to_cimd2()

static void convert_gsm_to_cimd2 ( Octstr *  text )

static

Definition at line 1134 of file smsc_cimd2.c.

References cimd1, cimd2, cimd_combinations, gsm, gw_assert(), octstr_get_char(), octstr_insert_data(), octstr_len(), octstr_set_char(), and text.

Referenced by packet_encode_message().

{
    long pos, len;

    len = octstr_len(text);
    for (pos = 0; pos < len; pos++) {
        int c, i;

        c = octstr_get_char(text, pos);
        /* If c is not in the GSM alphabet at this point,
         * the caller did something badly wrong. */
        gw_assert(c >= 0);
        gw_assert(c < 128);

        for (i = 0; cimd_combinations[i].cimd1 != 0; i++) {
            if (cimd_combinations[i].gsm == c)
                break;
        }

        if (cimd_combinations[i].gsm == c) {
            /* Escape sequence */
            octstr_insert_data(text, pos, "_ ", 2);
            pos += 2;
            len += 2;
            octstr_set_char(text, pos - 1, cimd_combinations[i].cimd1);
            octstr_set_char(text, pos, cimd_combinations[i].cimd2);
        } else if (c == 2) {
            /* The dollar sign is the only GSM character that
                 * does not have a CIMD escape sequence and does not
             * map to itself. */
            octstr_set_char(text, pos, '$');
        }
    }
}

io_thread()

static void io_thread ( void *  arg )

static

Definition at line 2164 of file smsc_cimd2.c.

References bb_smscconn_connected(), bb_smscconn_receive(), cimd2_login(), cimd2_submit_msg(), smscconn::connect_time, smscconn::data, debug(), error(), smscconn::flow_mutex, gwlist_consume(), gwlist_extract_first(), gwthread_sleep(), smscconn::id, smscconn::log_idx, log_thread_to(), msg, mutex_lock, mutex_unlock, octstr_get_cstr, privdata::outgoing_queue, privdata::quitting, smscconn::reconnect_delay, sms_receive(), SMSCCONN_ACTIVE, SMSCCONN_RECONNECTING, smscconn::status, and privdata::stopped.

Referenced by smsc_cimd2_create().

{
    Msg       *msg;
    SMSCConn  *conn = arg;
    PrivData *pdata = conn->data;
    double    sleep = 0.0001;

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

    /* remove messages from SMSC until we are killed */
    while (!pdata->quitting) {
    
        gwlist_consume(pdata->stopped); /* block here if suspended/isolated */
      
        /* check that connection is active */
        if (conn->status != SMSCCONN_ACTIVE) {
            if (cimd2_login(conn) != 0) { 
                error(0, "CIMD2[%s]: Couldn't connect to SMSC (retrying in %ld seconds).",
                      octstr_get_cstr(conn->id), 
                      conn->reconnect_delay);
                gwthread_sleep(conn->reconnect_delay);
                mutex_lock(conn->flow_mutex);
                conn->status = SMSCCONN_RECONNECTING; 
                mutex_unlock(conn->flow_mutex);
                continue; 
            } 
            mutex_lock(conn->flow_mutex);
            conn->status = SMSCCONN_ACTIVE;
            conn->connect_time = time(NULL);
            bb_smscconn_connected(conn);
            mutex_unlock(conn->flow_mutex);
        }

        /* receive messages */
        do { 
            msg = sms_receive(conn);
            if (msg) {
                sleep = 0;
                debug("bb.sms.cimd2", 0, "CIMD2[%s]: new message received",
                      octstr_get_cstr(conn->id));
                bb_smscconn_receive(conn, msg);
            }
        } while (msg);
 
        /* send messages */
        do {
            msg = gwlist_extract_first(pdata->outgoing_queue);
            if (msg) {
                sleep = 0;
                if (cimd2_submit_msg(conn,msg) != 0) break;
            }
        } while (msg);
 
        if (sleep > 0) {

            /* note that this implementations means that we sleep even
             * when we fail connection.. but time is very short, anyway
             */
            gwthread_sleep(sleep);
            /* gradually sleep longer and longer times until something starts to
             * happen - this of course reduces response time, but that's better than
             * extensive CPU usage when it is not used
             */
            sleep *= 2;
            if (sleep >= 2.0)
                sleep = 1.999999;
        }
        else {
            sleep = 0.0001;
        }
    }
}

isphonedigit()

static int isphonedigit ( int  c )

static

Definition at line 324 of file smsc_cimd2.c.

Referenced by packet_add_address_parm(), packet_check_parameter(), and parm_valid_address().

{
    return isdigit(c) || c == '+' || c == '-';
}

operation_can_receive()

static int operation_can_receive ( int  operation )

static

Definition at line 422 of file smsc_cimd2.c.

References operation_can_send(), operation_find(), operations, and RESPONSE.

Referenced by operation_can_send(), and packet_check_can_receive().

{
    int i = operation_find(operation);

    if (i >= 0)
        return operations[i].can_receive;

    /* If we can send the request, then we can receive the response. */
    if (operation >= RESPONSE)
        return operation_can_send(operation - RESPONSE);

    return 0;
}

operation_can_send()

static int operation_can_send ( int  operation )

static

Definition at line 406 of file smsc_cimd2.c.

References operation_can_receive(), operation_find(), operations, and RESPONSE.

Referenced by cimd2_request(), and operation_can_receive().

{
    int i = operation_find(operation);

    if (i >= 0)
        return operations[i].can_send;

    /* If we can receive the request, then we can send the response. */
    if (operation >= RESPONSE)
        return operation_can_receive(operation - RESPONSE);

    return 0;
}

operation_find()

static int operation_find ( int  operation )

static

Definition at line 371 of file smsc_cimd2.c.

References code, and operations.

Referenced by operation_can_receive(), operation_can_send(), and operation_name().

{
    int i;

    for (i = 0; operations[i].name != NULL; i++) {
        if (operations[i].code == operation)
            return i;
    }

    return -1;
}

operation_name()

static Octstr * operation_name ( int  operation )

static

Definition at line 384 of file smsc_cimd2.c.

References name, octstr_append_cstr(), octstr_create, operation_find(), operations, and RESPONSE.

Referenced by cimd2_request(), packet_check_can_receive(), and packet_display_error().

{
    int i;

    i = operation_find(operation);
    if (i >= 0)
        return octstr_create(operations[i].name);

    if (operation >= RESPONSE) {
        i = operation_find(operation - RESPONSE);
        if (i >= 0) {
            Octstr *name = octstr_create(operations[i].name);
            octstr_append_cstr(name, " response");
            return name;
        }
    }

    /* Put the operation number here when we have octstr_format */
    return octstr_create("(unknown)");
}

packet_add_address_parm()

static void packet_add_address_parm ( struct packet *  packet, int  parmno, Octstr *  value, SMSCConn *  conn  )

static

Definition at line 1233 of file smsc_cimd2.c.

References gw_assert(), isphonedigit(), octstr_check_range(), octstr_len(), P_ADDRESS, and packet_add_parm().

Referenced by packet_encode_message().

{
    gw_assert(octstr_check_range(value, 0, octstr_len(value), isphonedigit));
    packet_add_parm(packet, P_ADDRESS, parmno, value, conn);
}

packet_add_hex_parm()

static void packet_add_hex_parm ( struct packet *  packet, int  parmno, Octstr *  value, SMSCConn *  conn  )

static

Definition at line 1252 of file smsc_cimd2.c.

References octstr_binary_to_hex(), octstr_destroy(), octstr_duplicate, P_HEX, and packet_add_parm().

Referenced by packet_encode_message().

{
    value = octstr_duplicate(value);
    octstr_binary_to_hex(value, 1);   /* 1 for uppercase hex, i.e. A .. F */
    packet_add_parm(packet, P_HEX, parmno, value, conn);
    octstr_destroy(value);
}

packet_add_int_parm()

static void packet_add_int_parm ( struct packet *  packet, int  parmno, long  value, SMSCConn *  conn  )

static

Definition at line 1261 of file smsc_cimd2.c.

References gw_assert(), octstr_create, octstr_destroy(), P_INT, packet_add_parm(), and parm_in_range().

Referenced by packet_encode_message().

{
    char buf[128];
    Octstr *valuestr;

    gw_assert(parm_in_range(parmno, value));

    sprintf(buf, "%ld", value);
    valuestr = octstr_create(buf);
    packet_add_parm(packet, P_INT, parmno, valuestr, conn);
    octstr_destroy(valuestr);
}

packet_add_parm()

static void packet_add_parm ( struct packet *  packet, int  parmtype, int  parmno, Octstr *  value, SMSCConn *  conn  )

static

Definition at line 1191 of file smsc_cimd2.c.

References packet::data, gw_assert(), smscconn::id, octstr_copy, octstr_destroy(), octstr_get_cstr, octstr_insert(), octstr_insert_data(), octstr_len(), parm_maxlen(), parm_name(), parm_type(), TAB_str, and warning().

Referenced by packet_add_address_parm(), packet_add_hex_parm(), packet_add_int_parm(), packet_add_sms_parm(), packet_add_string_parm(), and packet_encode_message().

{
    char parmh[sizeof("tPPP:")];
    long position;
    long len;
    int copied = 0;

    len = octstr_len(value);

    gw_assert(packet != NULL);
    gw_assert(parm_type(parmno) == parmtype);

    if (len > parm_maxlen(parmno)) {
        warning(0, "CIMD2[%s]: %s parameter too long, truncating from "
                "%ld to %ld characters",
                octstr_get_cstr(conn->id), 
                parm_name(parmno),
                len, 
                (long) parm_maxlen(parmno));
        value = octstr_copy(value, 0, parm_maxlen(parmno));
        copied = 1;
    }

    /* There's a TAB and ETX at the end; insert it before those.
     * The new parameter will come with a new starting TAB. */
    position = octstr_len(packet->data) - 2;

    sprintf(parmh, TAB_str "%03d:", parmno);
    octstr_insert_data(packet->data, position, parmh, strlen(parmh));
    octstr_insert(packet->data, value, position + strlen(parmh));
    if (copied)
        octstr_destroy(value);
}

packet_add_sms_parm()

static void packet_add_sms_parm ( struct packet *  packet, int  parmno, Octstr *  value, SMSCConn *  conn  )

static

Definition at line 1241 of file smsc_cimd2.c.

References P_SMS, and packet_add_parm().

Referenced by packet_encode_message().

{
    packet_add_parm(packet, P_SMS, parmno, value, conn);
}

packet_add_string_parm()

static void packet_add_string_parm ( struct packet *  packet, int  parmno, Octstr *  value, SMSCConn *  conn  )

static

Definition at line 1227 of file smsc_cimd2.c.

References P_STRING, and packet_add_parm().

Referenced by cimd2_login(), and packet_encode_message().

{
    packet_add_parm(packet, P_STRING, parmno, value, conn);
}

packet_check()

static int packet_check ( struct packet *  packet, SMSCConn *  conn  )

static

Definition at line 846 of file smsc_cimd2.c.

References packet::data, gw_assert(), gw_isxdigit(), smscconn::id, octstr_check_range(), octstr_dump, octstr_get_cstr, octstr_len(), octstr_search_char(), packet_check_header(), packet_check_parameter(), TAB, and warning().

Referenced by cimd2_get_packet(), and cimd2_receive_msg().

{
    int errors = 0;
    long pos, next;
    Octstr *data;

    gw_assert(packet != NULL);
    data = packet->data;

    if (octstr_search_char(data, 0, 0) >= 0) {
        /* CIMD2 spec does not allow NUL bytes in a packet */
        warning(0, "CIMD2[%s]: packet contains NULs",
                octstr_get_cstr(conn->id));
        errors++;
    }

    /* Assume the packet starts with STX and ends with ETX,
     * because we parsed it that way in the first place. */

    errors += (packet_check_header(packet,conn) < 0);

    /* Parameters are separated by tabs.  After the last parameter
     * there is a tab, an optional two-digit checksum, and the ETX.
     * Check each parameter in turn, by skipping from tab to tab.
     */
    /* Start at the first tab, wherever it is, so that we can still
     * check parameters if the header was weird. */
    pos = octstr_search_char(data, TAB, 0);
    for ( ; pos >= 0; pos = next) {
        next = octstr_search_char(data, TAB, pos + 1);
        if (next >= 0) {
            errors += (packet_check_parameter(packet, pos, next - pos, conn) < 0);
        } else {
            /* Check if the checksum has the right format.  Don't
             * check the sum itself here, that will be done in a
             * separate call later. */
            /* There are two valid formats: TAB ETX (no checksum)
             * and TAB digit digit ETX.  We already know the TAB
             * and the ETX are there. */
            if (!(octstr_len(data) - pos == 2 ||
                  (octstr_len(data) - pos == 4 &&
                   octstr_check_range(data, pos + 1, 2, gw_isxdigit)))) {
                warning(0, "CIMD2[%s]: packet checksum in wrong format",
                        octstr_get_cstr(conn->id));
                errors++;
            }
        }
    }


    if (errors > 0) {
        octstr_dump(packet->data, 0);
        return -1;
    }

    return 0;
}

packet_check_can_receive()

static void packet_check_can_receive ( struct packet *  packet, SMSCConn *  conn  )

static

Definition at line 904 of file smsc_cimd2.c.

References gw_assert(), smscconn::id, name, octstr_destroy(), octstr_get_cstr, packet::operation, operation_can_receive(), operation_name(), and warning().

Referenced by cimd2_get_packet(), and cimd2_receive_msg().

{
    gw_assert(packet != NULL);

    if (!operation_can_receive(packet->operation)) {
        Octstr *name = operation_name(packet->operation);
        warning(0, "CIMD2[%s]: SMSC sent us %s request",
                octstr_get_cstr(conn->id),
                octstr_get_cstr(name));
        octstr_destroy(name);
    }
}

packet_check_header()

static int packet_check_header ( struct packet *  packet, SMSCConn *  conn  )

static

Definition at line 705 of file smsc_cimd2.c.

References packet::data, gw_assert(), gw_isdigit(), smscconn::id, octstr_check_range(), octstr_get_char(), octstr_get_cstr, octstr_len(), TAB, and warning().

Referenced by packet_check().

{
    Octstr *data;

    gw_assert(packet != NULL);
    data = packet->data;

    /* The header must have a two-digit operation code, a colon,
     * and a three-digit sequence number, followed by a tab.
     * (CIMD2, 3.1) */
    if (octstr_len(data) < 8 ||
        !octstr_check_range(data, 1, 2, gw_isdigit) ||
        octstr_get_char(data, 3) != ':' ||
        !octstr_check_range(data, 4, 3, gw_isdigit) ||
        octstr_get_char(data, 7) != TAB) {
        warning(0, "CIMD2[%s]: packet header in wrong format",
                octstr_get_cstr(conn->id));
        return -1;
    }

    return 0;
}

packet_check_parameter()

static int packet_check_parameter ( struct packet *  packet, long  pos, long  len, SMSCConn *  conn  )

static

Definition at line 728 of file smsc_cimd2.c.

References packet::data, gw_assert(), gw_isdigit(), gw_isxdigit(), smscconn::id, isphonedigit(), maxlen, maxval, minval, octstr_check_range(), octstr_get_char(), octstr_get_cstr, octstr_parse_long(), P_ADDRESS, P_HEX, P_INT, P_SMS, P_STRING, P_TIME, parameters, parm_index(), type, and warning().

Referenced by packet_check().

{
    Octstr *data;
    long parm;
    long dpos, dlen;
    int negative;
    long value;
    int i;
    int errors = 0;

    gw_assert(packet != NULL);
    data = packet->data;

    /* The parameter header should be TAB, followed by a three-digit
     * parameter number, a colon, and the data.  We already know about
     * the tab. */

    if (len < 5 ||
        !octstr_check_range(data, pos + 1, 3, gw_isdigit) ||
        octstr_get_char(data, pos + 4) != ':') {
        warning(0, "CIMD2[%s]: parameter at offset %ld in wrong format",
                octstr_get_cstr(conn->id),
                pos);
        errors++;
    }

    /* If we can't parse a parameter number, there's nothing more
     * that we can check. */
    dpos = octstr_parse_long(&parm, data, pos + 1, 10);
    if (dpos < 0)
        return -1;
    if (octstr_get_char(data, dpos) == ':')
        dpos++;
    dlen = len - (dpos - pos);
    /* dlen can not go negative because octstr_parse_long must have
     * been stopped by the TAB at the end of the parameter data. */
    gw_assert(dlen >= 0);

    i = parm_index(parm);

    if (i < 0) {
        warning(0, "CIMD2[%s]: packet contains unknown parameter %ld", 
                octstr_get_cstr(conn->id),
                parm);
        return -1;
    }

    if (dlen > parameters[i].maxlen) {
        warning(0, "CIMD2[%s]: packet has '%s' parameter with length %ld, spec says max %d",
                octstr_get_cstr(conn->id),
                parameters[i].name, len, parameters[i].maxlen);
        errors++;
    }

    switch (parameters[i].type) {
    case P_INT:
        /* Allow a leading - */
        negative = (octstr_get_char(data, dpos) == '-');
        if (!octstr_check_range(data, dpos + negative,
                                dlen - negative, gw_isdigit)) {
            warning(0, "CIMD2[%s]: packet has '%s' parameter with non-integer contents", 
                    octstr_get_cstr(conn->id),
                    parameters[i].name);
            errors++;
        }
        if (octstr_parse_long(&value, data, dpos, 10) >= 0 &&
            (value < parameters[i].minval || value > parameters[i].maxval)) {
            warning(0, "CIMD2[%s]: packet has '%s' parameter out of range (value %ld, min %d, max %d)",
                    octstr_get_cstr(conn->id),
                    parameters[i].name, value,
                    parameters[i].minval, parameters[i].maxval);
            errors++;
        }
        break;
    case P_TIME:
        if (!octstr_check_range(data, dpos, dlen, gw_isdigit)) {
            warning(0, "CIMD2[%s]: packet has '%s' parameter with non-digit contents", 
                    octstr_get_cstr(conn->id),
                    parameters[i].name);
            errors++;
        }
        break;
    case P_ADDRESS:
        if (!octstr_check_range(data, dpos, dlen, isphonedigit)) {
            warning(0, "CIMD2[%s]: packet has '%s' parameter with non phone number contents", 
                    octstr_get_cstr(conn->id),
                    parameters[i].name);
            errors++;
        }
        break;
    case P_HEX:
        if (!octstr_check_range(data, dpos, dlen, gw_isxdigit)) {
            warning(0, "CIMD2[%s]: packet has '%s' parameter with non-hex contents", 
                    octstr_get_cstr(conn->id),
                    parameters[i].name);
            errors++;
        }
        if (dlen % 2 != 0) {
            warning(0, "CIMD2[%s]: packet has odd-length '%s' parameter", 
                    octstr_get_cstr(conn->id),
                    parameters[i].name);
            errors++;
        }
        break;
    case P_SMS:
    case P_STRING:  /* nothing to check */
        break;
    }

    if (errors > 0)
        return -1;
    return 0;
}

packet_create()

static struct packet* packet_create ( int  operation, int  seq  )

static

Definition at line 1176 of file smsc_cimd2.c.

References packet::data, ETX_str, octstr_create, packet::operation, packet::seq, STX_str, and TAB_str.

Referenced by cimd2_login(), cimd2_logout(), cimd2_send_alive(), cimd2_send_response(), and packet_encode_message().

{
    struct packet *packet;
    char minpacket[sizeof("sOO:SSSte")];

    packet = gw_malloc(sizeof(*packet));
    packet->operation = operation;
    packet->seq = seq;
    sprintf(minpacket, STX_str "%02d:%03d" TAB_str ETX_str, operation, seq);
    packet->data = octstr_create(minpacket);

    return packet;
}

packet_destroy()

static void packet_destroy ( struct packet *  packet )

static

Definition at line 521 of file smsc_cimd2.c.

References packet::data, and octstr_destroy().

Referenced by cimd2_login(), cimd2_logout(), cimd2_receive_msg(), cimd2_request(), cimd2_send_alive(), cimd2_send_response(), and cimd2_submit_msg().

{
    if (packet != NULL) {
        octstr_destroy(packet->data);
        gw_free(packet);
    }
}

packet_display_error()

static int packet_display_error ( struct packet *  packet, SMSCConn *  conn  )

static

Definition at line 979 of file smsc_cimd2.c.

References cimd2_errors, code, error(), smscconn::id, octstr_create, octstr_destroy(), octstr_get_cstr, packet::operation, operation_name(), P_ERROR_CODE, P_ERROR_TEXT, packet_get_int_parm(), packet_get_string_parm(), and text.

Referenced by cimd2_request().

{
    int code;
    Octstr *text = NULL;
    Octstr *opname = NULL;

    code = packet_get_int_parm(packet, P_ERROR_CODE);
    text = packet_get_string_parm(packet, P_ERROR_TEXT);

    if (code <= 0) {
        octstr_destroy(text);
        return 0;
    }

    if (text == NULL) {
        /* No error text.  Try to find it in the table. */
        int i;
        for (i = 0; cimd2_errors[i].text != NULL; i++) {
            if (cimd2_errors[i].code == code) {
                text = octstr_create(cimd2_errors[i].text);
                break;
            }
        }
    }

    if (text == NULL) {
        /* Still no error text.  Make one up. */
        text = octstr_create("Unknown error");
    }

    opname = operation_name(packet->operation);
    error(0, "CIMD2[%s]: %s contained error message:",
          octstr_get_cstr(conn->id),
          octstr_get_cstr(opname));
    error(0, "code %03d: %s", code, octstr_get_cstr(text));
    octstr_destroy(opname);
    octstr_destroy(text);
    return code;
}

packet_encode_message()

static struct packet* packet_encode_message ( Msg *  msg, Octstr *  sender_prefix, SMSCConn *  conn  )

static

Definition at line 1319 of file smsc_cimd2.c.

References smscconn::alt_dcs, BOGUS_SEQUENCE, charset_gsm_truncate(), charset_utf8_to_gsm(), convert_gsm_to_cimd2(), smscconn::data, DC_7BIT, DC_8BIT, DC_UCS2, DC_UNDEF, DLR_IS_SUCCESS_OR_FAIL, fields_to_dcs(), gw_assert(), smscconn::id, msg, MSG_PARAM_UNDEFINED, privdata::no_dlr, octstr_compare(), octstr_copy, octstr_create, octstr_destroy(), octstr_duplicate, octstr_get_cstr, octstr_imm(), octstr_len(), octstr_ncompare(), octstr_truncate(), P_ALPHANUMERIC_ORIGINATING_ADDRESS, P_DATA_CODING_SCHEME, P_DESTINATION_ADDRESS, P_INT, P_MORE_MESSAGES_TO_SEND, P_ORIGINATING_ADDRESS, P_PROTOCOL_IDENTIFIER, P_REPLY_PATH, P_STATUS_REPORT_REQUEST, P_TARIFF_CLASS, P_USER_DATA, P_USER_DATA_BINARY, P_USER_DATA_HEADER, P_VALIDITY_PERIOD_RELATIVE, packet_add_address_parm(), packet_add_hex_parm(), packet_add_int_parm(), packet_add_parm(), packet_add_sms_parm(), packet_add_string_parm(), packet_create(), parm_valid_address(), SUBMIT_MESSAGE, text, and warning().

Referenced by cimd2_submit_msg().

{
    struct packet *packet;
    PrivData *pdata = conn->data;
    Octstr *text;
    int spaceleft;
    long truncated;
    int dcs = 0;
    int setvalidity = 0;

    gw_assert(msg != NULL);
    gw_assert(msg->type == sms);
    gw_assert(msg->sms.receiver != NULL);

    dcs = fields_to_dcs(msg, (msg->sms.alt_dcs != -1 ? 
        msg->sms.alt_dcs : conn->alt_dcs));
    if (msg->sms.sender == NULL)
        msg->sms.sender = octstr_create("");

    if (!parm_valid_address(msg->sms.receiver)) {
        warning(0, "CIMD2[%s]: non-digits in destination phone number '%s', discarded",
                octstr_get_cstr(conn->id),
                octstr_get_cstr(msg->sms.receiver));
        return NULL;
    }

    packet = packet_create(SUBMIT_MESSAGE, BOGUS_SEQUENCE);

    packet_add_address_parm(packet, P_DESTINATION_ADDRESS, msg->sms.receiver, conn);

    /* CIMD2 interprets the originating address as a sub-address to
     * our connection number (so if the connection is "400" and we
     * fill in "600" as the sender number, the user sees "400600").
     * Since we have no way to ask what this number is, it has to
     * be configured. */

    /* Quick and dirty check to see if we are using alphanumeric sender */
    if (parm_valid_address(msg->sms.sender)) {
        /* We are not, so send in the usual way */
        /* Speed up the default case */
        if (octstr_len(sender_prefix) == 0) {
            packet_add_address_parm(packet, P_ORIGINATING_ADDRESS,msg->sms.sender, conn);
        }
        else if (octstr_compare(sender_prefix, octstr_imm("never")) != 0) {
            if (octstr_ncompare(sender_prefix, msg->sms.sender,
                                octstr_len(sender_prefix)) == 0) {
                Octstr *sender;
                sender = octstr_copy(msg->sms.sender,
                                     octstr_len(sender_prefix), octstr_len(msg->sms.sender));
                packet_add_address_parm(packet, P_ORIGINATING_ADDRESS, sender, conn);
                octstr_destroy(sender);
            } else {
                warning(0, "CIMD2[%s]: Sending message with originating address <%s>, "
                        "which does not start with the sender-prefix.",
                        octstr_get_cstr(conn->id),
                        octstr_get_cstr(msg->sms.sender));
            }
        }
    }
    else {
        /* The test above to check if sender was all digits failed, so assume we want alphanumeric sender */
        packet_add_string_parm(packet, P_ALPHANUMERIC_ORIGINATING_ADDRESS,msg->sms.sender, conn);
    }

    /* Add the validity period if necessary.  This sets the relative validity
     * period as this is the description of the "validity" parameter of the
     * sendsms interface.
     *
     * Convert from minutes to GSM 03.40 specification (section 9.2.3.12).
     * 0-143   = 0 to 12 hours in 5 minute increments.
     * 144-167 = 12hrs30min to 24hrs in 30 minute increments.
     * 168-196 = 2days to 30days in 1 day increments.
     * 197-255 = 5weeks to 63weeks in 1 week increments.
     *
     * This code was copied from smsc_at2.c.
     */
    if (msg->sms.validity != MSG_PARAM_UNDEFINED) {
        long val = (msg->sms.validity - time(NULL)) / 60;
        if (val > 635040)
            setvalidity = 255;
        if (val >= 50400 && val <= 635040)
            setvalidity = (val - 1) / 7 / 24 / 60 + 192 + 1;
        if (val > 43200 && val < 50400)
            setvalidity = 197;
        if (val >= 2880 && val <= 43200)
            setvalidity = (val - 1) / 24 / 60 + 166 + 1;
        if (val > 1440 && val < 2880)
            setvalidity = 168;
        if (val >= 750 && val <= 1440)
            setvalidity = (val - 720 - 1) / 30 + 143 + 1;
        if (val > 720 && val < 750)
            setvalidity = 144;
        if (val >= 5 && val <= 720)
            setvalidity = (val - 1) / 5 - 1 + 1;
        if (val < 5)
            setvalidity = 0;

        packet_add_int_parm(packet, P_VALIDITY_PERIOD_RELATIVE, setvalidity, conn);
    }

    /* Explicitly ask not to get status reports.
     * If we do not do this, the server's default might be to
     * send status reports in some cases, and we don't do anything
     * with those reports anyway. */
    /* ask for the delivery reports if needed*/

    if (!pdata->no_dlr)
        if (DLR_IS_SUCCESS_OR_FAIL(msg->sms.dlr_mask))
            packet_add_int_parm(packet, P_STATUS_REPORT_REQUEST, 14, conn);
        else
            packet_add_int_parm(packet, P_STATUS_REPORT_REQUEST, 0, conn);
    else if( pdata->no_dlr && DLR_IS_SUCCESS_OR_FAIL(msg->sms.dlr_mask)) 
        warning(0, "CIMD2[%s]: dlr request make no sense while no-dlr set to true",
             octstr_get_cstr(conn->id));

    /* Turn off reply path as default.
     * This avoids phones automatically asking for a reply
     */
    if (msg->sms.rpi > 0)
    packet_add_int_parm(packet, P_REPLY_PATH, 1, conn);
    else
        packet_add_int_parm(packet, P_REPLY_PATH, 0, conn);

    /* Use binfo to set the tariff class */
    if (octstr_len(msg->sms.binfo))
    packet_add_parm(packet, P_INT, P_TARIFF_CLASS, msg->sms.binfo, conn);

    /* Set the protocol identifier if requested */
    if (msg->sms.pid > 0)
        packet_add_int_parm(packet, P_PROTOCOL_IDENTIFIER, msg->sms.pid, conn);
 
    /* If there are more messages to the same destination, then set the
    * More Messages to Send flag. This allow faster delivery of many messages 
    * to the same destination
    */
    if (msg->sms.msg_left > 0)
        packet_add_int_parm(packet, P_MORE_MESSAGES_TO_SEND, 1, conn);
    else
        packet_add_int_parm(packet, P_MORE_MESSAGES_TO_SEND, 0, conn);
    
    truncated = 0;

    spaceleft = 140;
    if (octstr_len(msg->sms.udhdata)) {
        /* udhdata will be truncated and warned about if
         * it does not fit. */
        packet_add_hex_parm(packet, P_USER_DATA_HEADER, msg->sms.udhdata, conn);
    }
    if (msg->sms.coding == DC_7BIT || msg->sms.coding == DC_UNDEF)
        spaceleft = spaceleft * 8 / 7;
    if (spaceleft < 0)
        spaceleft = 0;

    text = octstr_duplicate(msg->sms.msgdata);

    if (octstr_len(text) > 0 && spaceleft == 0) {
        warning(0, "CIMD2[%s]: message filled up with UDH, no room for message text",
                octstr_get_cstr(conn->id));
    } else if (msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2) {
        if (octstr_len(text) > spaceleft) {
            truncated = octstr_len(text) - spaceleft;
            octstr_truncate(text, spaceleft);
        }
        packet_add_hex_parm(packet, P_USER_DATA_BINARY, text, conn);
    } else {
        /* Going from latin1 to GSM to CIMD2 may seem like a
         * detour, but it's the only way to get all the escape
         * codes right. */
        charset_utf8_to_gsm(text);
        truncated = charset_gsm_truncate(text, spaceleft);
        convert_gsm_to_cimd2(text);
        packet_add_sms_parm(packet, P_USER_DATA, text, conn);
    }

    if (dcs != 0)
        packet_add_int_parm(packet, P_DATA_CODING_SCHEME, dcs, conn);

    if (truncated > 0) {
        warning(0, "CIMD2[%s]: truncating message text to fit in %d characters.", 
                octstr_get_cstr(conn->id),
                spaceleft);
    }

    octstr_destroy(text);
    return packet;
}

packet_extract()

static struct packet* packet_extract ( Octstr *  in, SMSCConn *  conn  )

static

Definition at line 533 of file smsc_cimd2.c.

References ETX, ETX_str, smscconn::id, octstr_append_cstr(), octstr_copy, octstr_delete(), octstr_get_cstr, octstr_len(), octstr_search_char(), packet_parse(), STX, and warning().

Referenced by cimd2_get_packet(), and cimd2_receive_msg().

{
    int stx, etx;
    Octstr *packet;

    /* Find STX, and delete everything up to it */
    stx = octstr_search_char(in, STX, 0);
    if (stx < 0) {
        octstr_delete(in, 0, octstr_len(in));
        return NULL;
    } else {
        octstr_delete(in, 0, stx);
    }

    /* STX is now in position 0.  Find ETX. */
    etx = octstr_search_char(in, ETX, 1);
    if (etx < 0)
        return NULL;

    /* What shall we do with STX data... STX data... ETX?
     * Either skip to the second STX, or assume an ETX marker before
     * the STX.  Doing the latter has a chance of succeeding, and
     * will at least allow good logging of the error. */
    stx = octstr_search_char(in, STX, 1);
    if (stx >= 0 && stx < etx) {
        warning(0, "CIMD2[%s]: packet without end marker",
                octstr_get_cstr(conn->id));
        packet = octstr_copy(in, 0, stx);
        octstr_delete(in, 0, stx);
        octstr_append_cstr(packet, ETX_str);
    } else {
        /* Normal case. Copy packet, and cut it from the source. */
        packet = octstr_copy(in, 0, etx + 1);
        octstr_delete(in, 0, etx + 1);
    }

    return packet_parse(packet);
}

packet_get_address_parm()

static Octstr* packet_get_address_parm ( struct packet *  packet, int  parmno  )

static

Definition at line 653 of file smsc_cimd2.c.

References gw_assert(), P_ADDRESS, packet_get_parm(), and parm_type().

Referenced by cimd2_accept_message().

{
    /* Our code should never even try a bad parameter access. */
    gw_assert(parm_type(parmno) == P_ADDRESS);

    return packet_get_parm(packet, parmno);
}

packet_get_hex_parm()

static Octstr* packet_get_hex_parm ( struct packet *  packet, int  parmno  )

static

Definition at line 681 of file smsc_cimd2.c.

References error(), gw_assert(), octstr_destroy(), octstr_hex_to_binary(), P_HEX, packet_get_parm(), and parm_type().

Referenced by cimd2_accept_message().

{
    Octstr *value = NULL;

    /* Our code should never even try a bad parameter access. */
    gw_assert(parm_type(parmno) == P_HEX);

    value = packet_get_parm(packet, parmno);
    if (!value)
        goto error;

    if (octstr_hex_to_binary(value) < 0)
        goto error;

    return value;

error:
    octstr_destroy(value);
    return NULL;
}

packet_get_int_parm()

static long packet_get_int_parm ( struct packet *  packet, int  parmno  )

static

Definition at line 616 of file smsc_cimd2.c.

References error(), gw_assert(), octstr_destroy(), octstr_parse_long(), P_INT, packet_get_parm(), and parm_type().

Referenced by cimd2_accept_message(), and packet_display_error().

{
    Octstr *valuestr = NULL;
    long value;

    /* Our code should never even try a bad parameter access. */
    gw_assert(parm_type(parmno) == P_INT);

    valuestr = packet_get_parm(packet, parmno);
    if (!valuestr)
        goto error;

    if (octstr_parse_long(&value, valuestr, 0, 10) < 0)
        goto error;

    octstr_destroy(valuestr);
    return value;

error:
    octstr_destroy(valuestr);
    return INT_MIN;
}

packet_get_parm()

static Octstr* packet_get_parm ( struct packet *  packet, int  parmno  )

static

Definition at line 579 of file smsc_cimd2.c.

References packet::data, gw_assert(), number, octstr_copy, octstr_parse_long(), octstr_search_char(), and TAB.

Referenced by cimd2_accept_delivery_report_message(), cimd2_get_packet(), packet_get_address_parm(), packet_get_hex_parm(), packet_get_int_parm(), packet_get_sms_parm(), and packet_get_string_parm().

{
    long pos, next;
    long valuepos;
    long number;

    gw_assert(packet != NULL);
    pos = octstr_search_char(packet->data, TAB, 0);
    if (pos < 0)
        return NULL;  /* Bad packet, nothing we can do */

    /* Parameters have a tab on each end.  If we don't find the
     * closing tab, we're at the checksum, so we stop. */
    for ( ;
          (next = octstr_search_char(packet->data, TAB, pos + 1)) >= 0;
          pos = next) {
        if (octstr_parse_long(&number, packet->data, pos + 1, 10) < 0)
            continue;
        if (number != parmno)
            continue;
        valuepos = octstr_search_char(packet->data, ':', pos + 1);
        if (valuepos < 0)
            continue;  /* badly formatted parm */
        valuepos++;  /* skip the ':' */

        /* Found the right parameter */
        return octstr_copy(packet->data, valuepos, next - valuepos);
    }

    return NULL;
}

packet_get_sms_parm()

static Octstr* packet_get_sms_parm ( struct packet *  packet, int  parmno  )

static

Definition at line 665 of file smsc_cimd2.c.

References gw_assert(), P_SMS, packet_get_parm(), and parm_type().

Referenced by cimd2_accept_message().

{
    /* Our code should never even try a bad parameter access. */
    gw_assert(parm_type(parmno) == P_SMS);

    return packet_get_parm(packet, parmno);
}

packet_get_string_parm()

static Octstr* packet_get_string_parm ( struct packet *  packet, int  parmno  )

static

Definition at line 642 of file smsc_cimd2.c.

References gw_assert(), P_STRING, packet_get_parm(), and parm_type().

Referenced by packet_display_error().

{
    /* Our code should never even try a bad parameter access. */
    gw_assert(parm_type(parmno) == P_STRING);

    return packet_get_parm(packet, parmno);
}

packet_parse()

static struct packet* packet_parse ( Octstr *  packet_data )

static

Definition at line 507 of file smsc_cimd2.c.

References packet::data, and packet_parse_header().

Referenced by packet_extract().

{
    struct packet *packet;

    packet = gw_malloc(sizeof(*packet));
    packet->data = packet_data;

    /* Fill in packet->operation and packet->seq */
    packet_parse_header(packet);

    return packet;
}

packet_parse_header()

static void packet_parse_header ( struct packet *  packet )

static

Definition at line 480 of file smsc_cimd2.c.

References packet::data, number, octstr_get_char(), octstr_parse_long(), packet::operation, and packet::seq.

Referenced by packet_parse().

{
    int pos;
    long number;

    /* Set default values, in case we can't parse the fields */
    packet->operation = -1;
    packet->seq = -1;

    pos = octstr_parse_long(&number, packet->data, 1, 10);
    if (pos < 0)
        return;
    packet->operation = number;

    if (octstr_get_char(packet->data, pos++) != ':')
        return;

    pos = octstr_parse_long(&number, packet->data, pos, 10);
    if (pos < 0)
        return;
    packet->seq = number;
}

packet_set_checksum()

static void packet_set_checksum ( struct packet *  packet )

static

Definition at line 1274 of file smsc_cimd2.c.

References packet::data, gw_assert(), octstr_delete(), octstr_get_char(), octstr_insert_data(), octstr_len(), and TAB.

Referenced by cimd2_request(), and cimd2_send_response().

{
    Octstr *data;
    int checksum;
    long pos, len;
    char buf[16];

    gw_assert(packet != NULL);

    data = packet->data;
    if (octstr_get_char(data, octstr_len(data) - 2) != TAB) {
        /* Packet already has checksum; kill it. */
        octstr_delete(data, octstr_len(data) - 3, 2);
    }

    gw_assert(octstr_get_char(data, octstr_len(data) - 2) == TAB);

    /* Sum all the way up to the last TAB */
    checksum = 0;
    for (pos = 0, len = octstr_len(data); pos < len - 1; pos++) {
        checksum += octstr_get_char(data, pos);
        checksum &= 0xff;
    }

    sprintf(buf, "%02X", checksum);
    octstr_insert_data(data, len - 1, buf, 2);
}

packet_set_send_sequence()

static void packet_set_send_sequence ( struct packet *  packet, PrivData *  pdata  )

static

Definition at line 1511 of file smsc_cimd2.c.

References gw_assert(), LOGIN, packet::operation, packet_set_sequence(), and privdata::send_seq.

Referenced by cimd2_request().

{
    gw_assert(pdata != NULL);
    /* LOGIN packets always have sequence number 001 */
    if (packet->operation == LOGIN)
        pdata->send_seq = 1;
    /* Send sequence numbers are always odd, receiving are always even */
    gw_assert(pdata->send_seq % 2 == 1);

    packet_set_sequence(packet, pdata->send_seq);
    pdata->send_seq += 2;
    if (pdata->send_seq > 256)
        pdata->send_seq = 1;
}

packet_set_sequence()

static void packet_set_sequence ( struct packet *  packet, int  seq  )

static

Definition at line 1302 of file smsc_cimd2.c.

References packet::data, gw_assert(), octstr_set_char(), and packet::seq.

Referenced by packet_set_send_sequence().

{
    char buf[16];

    gw_assert(packet != NULL);
    gw_assert(seq >= 0);
    gw_assert(seq < 256);

    sprintf(buf, "%03d", seq);

    /* Start at 4 to skip the <STX> ZZ: part of the header. */
    octstr_set_char(packet->data, 4, buf[0]);
    octstr_set_char(packet->data, 5, buf[1]);
    octstr_set_char(packet->data, 6, buf[2]);
    packet->seq = seq;
}

parm_in_range()

static int parm_in_range ( int  parmno, long  value  )

static

Definition at line 310 of file smsc_cimd2.c.

References maxval, minval, parameters, and parm_index().

Referenced by packet_add_int_parm().

{
    int i;

    i = parm_index(parmno);

    if (i < 0)
        return -1;

    return (value >= parameters[i].minval && value <= parameters[i].maxval);
}

parm_index()

static int parm_index ( int  parmno )

static

Definition at line 260 of file smsc_cimd2.c.

References number, and parameters.

Referenced by packet_check_parameter(), parm_in_range(), parm_maxlen(), parm_name(), and parm_type().

{
    int i;

    for (i = 0; parameters[i].name != NULL; i++) {
        if (parameters[i].number == parmno)
            return i;
    }

    return -1;
}

parm_maxlen()

static int parm_maxlen ( int  parmno )

static

Definition at line 287 of file smsc_cimd2.c.

References parameters, and parm_index().

Referenced by packet_add_parm(), and smsc_cimd2_create().

{
    int i = parm_index(parmno);

    if (i < 0)
        return -1;

    return parameters[i].maxlen;
}

parm_name()

static const char* parm_name ( int  parmno )

static

Definition at line 297 of file smsc_cimd2.c.

References parameters, and parm_index().

Referenced by packet_add_parm().

{
    int i = parm_index(parmno);

    if (i < 0)
        return NULL;

    return parameters[i].name;
}

parm_type()

static int parm_type ( int  parmno )

static

Definition at line 274 of file smsc_cimd2.c.

References parameters, and parm_index().

Referenced by packet_add_parm(), packet_get_address_parm(), packet_get_hex_parm(), packet_get_int_parm(), packet_get_sms_parm(), and packet_get_string_parm().

{
    int i = parm_index(parmno);

    if (i < 0)
        return -1;

    return parameters[i].type;
}

parm_valid_address()

static int parm_valid_address ( Octstr *  value )

static

Definition at line 329 of file smsc_cimd2.c.

References isphonedigit(), octstr_check_range(), and octstr_len().

Referenced by packet_encode_message().

{
    return octstr_check_range(value, 0, octstr_len(value), isphonedigit);
}

sms_receive()

static Msg* sms_receive ( SMSCConn *  conn )

static

Definition at line 2139 of file smsc_cimd2.c.

References cimd2_close_socket(), cimd2_receive_msg(), smscconn::data, smscconn::flow_mutex, smscconn::id, msg_destroy(), mutex_lock, mutex_unlock, octstr_duplicate, SMSCCONN_DISCONNECTED, and smscconn::status.

Referenced by io_thread().

{
    PrivData *pdata = conn->data;
    int ret;
    Msg *newmsg = NULL;

    ret = cimd2_receive_msg(conn, &newmsg);
    if (ret == 1) {
        /* if any smsc_id available, use it */
        newmsg->sms.smsc_id = octstr_duplicate(conn->id);
        return newmsg;
    } 
    else if (ret == 0) { /* no message, just retry... */
        return NULL;
    } 
    /* error. reconnect. */
    msg_destroy(newmsg);
    mutex_lock(conn->flow_mutex);
    cimd2_close_socket(pdata);
    conn->status = SMSCCONN_DISCONNECTED;
    mutex_unlock(conn->flow_mutex);
    return NULL;
}

smsc_cimd2_create()

int smsc_cimd2_create	(	SMSCConn *	conn,
		CfgGroup *	grp
	)

Definition at line 2321 of file smsc_cimd2.c.

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

Referenced by smscconn_create().

{
    PrivData *pdata;
    int ok;
    int maxlen;

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

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

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

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

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

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


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

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

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

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

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

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

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

    return 0;
}

Variable Documentation

can_receive

int can_receive

Definition at line 348 of file smsc_cimd2.c.

can_send

int can_send

Definition at line 347 of file smsc_cimd2.c.

cimd1

unsigned char cimd1

Definition at line 1024 of file smsc_cimd2.c.

Referenced by convert_cimd2_to_gsm(), and convert_gsm_to_cimd2().

cimd2

unsigned char cimd2

Definition at line 1024 of file smsc_cimd2.c.

Referenced by convert_cimd2_to_gsm(), and convert_gsm_to_cimd2().

cimd2_errors

struct { ... } cimd2_errors[]

Referenced by packet_display_error().

cimd_combinations

const { ... } cimd_combinations[]

Referenced by convert_cimd2_to_gsm(), and convert_gsm_to_cimd2().

code

int code

Definition at line 346 of file smsc_cimd2.c.

Referenced by abort_delivery(), cimd2_accept_delivery_report_message(), convert_html_entity(), describe_code(), http_status_class(), octstr_url_decode(), ois_decode_submit_sm_result(), operation_find(), packet_display_error(), remove_session_data(), response_push_message(), send_bad_message_response(), tell_fatal_error(), ws_asm_dasm(), ws_bc_add_function(), and xidris_parse_reply().

gsm

unsigned char gsm

Definition at line 1025 of file smsc_cimd2.c.

Referenced by charset_gsm_truncate(), convert_cimd2_to_gsm(), and convert_gsm_to_cimd2().

maxlen

int maxlen

Definition at line 214 of file smsc_cimd2.c.

Referenced by eat_int_parm(), octstr_set_bits(), packet_check_parameter(), and smsc_cimd2_create().

maxval

int maxval

Definition at line 216 of file smsc_cimd2.c.

Referenced by packet_check_parameter(), and parm_in_range().

minval

int minval

Definition at line 216 of file smsc_cimd2.c.

Referenced by packet_check_parameter(), and parm_in_range().

name

static Octstr * name

Definition at line 212 of file smsc_cimd2.c.

Referenced by add_group(), cfg_dump(), cfg_get_multi_group(), cfg_get_single_group(), cfg_read(), cgw_read_op(), cgwop_add(), cgwop_get(), change_header_value(), check_do_elements(), check_variable_name(), config_reload(), decode_bearer_indication(), do_pidfile(), drop_optional_header(), emi2_emimsg_send(), fill_threadinfo(), get_cookies(), get_do_element_name(), get_x_kannel_from_headers(), grp_dump(), gw_dlopen_get_symbol(), gw_gethostbyname(), gwthread_create_real(), gwthread_shutdown(), header_is_called(), http_cgi_variable(), http_header_add(), http_header_combine(), http_header_find_all(), http_header_find_first_real(), http_header_get(), http_header_pack(), http_header_remove_all(), http_header_value(), main(), new_extparm(), octstr_dump_short(), open_file(), operation_name(), ota_tokenize_bookmarks(), packet_check_can_receive(), parse_array_element(), parse_attribute(), parse_data_element(), parse_document(), parse_element(), parse_fault_element(), parse_headers(), parse_member_element(), parse_methodcall_element(), parse_methodresponse_element(), parse_ota_syncsettings(), parse_param_element(), parse_params_element(), parse_signal(), parse_struct_element(), parse_url_value(), parse_value_element(), pass_field_name(), pass_optional_header(), read_test_ppg_config(), set_group_name(), smpp_tlv_get_by_name(), smsbox_sendota_post(), soap_convert_token(), spawn_thread(), split_header_list(), type_is(), urltrans_find_username(), wap_map_add_url(), wap_map_add_user(), ws_bc_add_function(), ws_bc_add_pragma_user_agent_property(), ws_bc_add_pragma_user_agent_property_and_scheme(), ws_expr_call(), ws_formal_parameter(), ws_function(), ws_function_hash(), ws_hash_get(), ws_hash_put(), ws_stdlib_function(), ws_variable_declaration(), ws_variable_define(), ws_variable_lookup(), wsp_cap_count(), wsp_cap_create(), wsp_cap_get_data(), wsp_cap_unpack_list(), xmlrpc_add_member(), xmlrpc_add_member_scalar(), xmlrpc_call_create(), xmlrpc_doc_create_call(), xmlrpc_get_member(), xmlrpc_get_member_content(), xmlrpc_get_member_type(), and yyparse().

number

int number

Definition at line 213 of file smsc_cimd2.c.

Referenced by blacklisted(), check_startmark(), does_prefix_match(), gwthread_shutdown(), normalize_number(), number_to_cstr(), number_to_string(), octstr_parse_double(), octstr_parse_long(), packet_get_parm(), packet_parse_header(), parm_index(), parse_charset(), prefix_allowed(), startmark(), wap_push_ppg_pushuser_client_phone_number_acceptable(), and whitelisted().

operations

const { ... } operations[]

Initial value:

= {
    { "Login", LOGIN, 1, 0 },
    { "Logout", LOGOUT, 1, 0 },
    { "Submit message", SUBMIT_MESSAGE, 1, 0 },
    { "Enquire message status", ENQUIRE_MESSAGE_STATUS, 1, 0 },
    { "Delivery request", DELIVERY_REQUEST, 1, 0 },
    { "Cancel message", CANCEL_MESSAGE, 1, 0 },
    { "Set parameter", SET_REQ, 1, 0 },
    { "Get parameter", GET_REQ, 1, 0 },

    { "Deliver message", DELIVER_MESSAGE, 0, 1 },
    { "Deliver status report", DELIVER_STATUS_REPORT, 0, 1 },

    { "Alive", ALIVE, 1, 1 },

    { "NACK", NACK, 1, 1 },
    { "General error response", GENERAL_ERROR_RESPONSE, 0, 1 },

    { NULL, 0, 0, 0 }
}

Referenced by operation_can_receive(), operation_can_send(), operation_find(), and operation_name().

parameters

const { ... } parameters[]

Referenced by packet_check_parameter(), parm_in_range(), parm_index(), parm_maxlen(), parm_name(), and parm_type().

text

char* text

Definition at line 921 of file smsc_cimd2.c.

Referenced by at2_pdu_decode_deliver_sm(), bb_alog_sms(), bearerbox_to_smpp(), brunet_receive_sms(), cimd2_accept_message(), cimd_receive_msg(), clickatell_receive_sms(), convert_cimd2_to_gsm(), convert_gsm_to_cimd2(), create_onetrans(), generic_receive_sms(), get_pattern(), get_variable(), get_x_kannel_from_xml(), handle_submit(), hash_create(), kannel_receive_sms(), msg_to_pdu(), obey_request_thread(), octstr_shrink_blanks(), octstr_strip_blanks(), octstr_strip_char(), octstr_strip_crlfs(), octstr_strip_nonalphanums(), only_blanks(), pack_quoted_string(), packet_display_error(), packet_encode_message(), parse_variable(), set_charset(), smsbox_req_handle(), smsbox_req_sendsms(), smsbox_sendsms_post(), wml_init(), wml_table_len(), wsp_pack_constrained_value(), wsp_pack_quoted_text(), wsp_pack_text(), and xidris_receive_sms().

type

int type

Definition at line 215 of file smsc_cimd2.c.

Referenced by action_create(), add_pragma(), asm_alloc(), at2_pdu_decode(), at2_pdu_decode_report_sm(), eq_create_event(), error_converting(), error_from_network_error_code(), expr_alloc(), generic_receive_sms(), get_x_kannel_from_xml(), handle_operation(), handle_reply(), http_header_get_content_type(), http_type_accepted(), is_defined_field(), IsCodepageTag(), main(), memorybuffer_has_rawmessage(), meta_data_unpack(), mime_entity_dump_real(), msg_create_real(), msg_to_bb(), NewNode(), numhash_create(), obey_request(), packet_check_parameter(), parse_ext_qualifiers(), qualifiers(), radius_pdu_create(), radius_pdu_unpack(), radius_type_convert(), ReadCodepageTag(), receive_reply(), send_abort(), smasi_pdu_create(), smasi_pdu_unpack(), smpp_pdu_create(), smpp_pdu_unpack(), smsbox_sendota_post(), smsbox_sendsms_post(), smsbox_xmlrpc_post(), smsc_http_create(), smsc_open(), stmt_alloc(), store_init(), unpack_parameter(), unpack_tpis(), update_table(), update_tables(), url_result_thread(), wap_event_create_real(), wap_event_name(), wbmp_create(), ws_expr_binary(), ws_expr_call(), ws_expr_logical(), ws_expr_unary(), ws_yy_lex(), wsp_pdu_create(), wtp_pdu_append_tpi(), wtp_pdu_create(), xmlrpc_add_element_scalar(), xmlrpc_add_member_scalar(), xmlrpc_create_scalar_value(), xmlrpc_doc_add_scalar(), xmlrpc_scalar_create(), and xmlrpc_value_get_type_smart().