smpp_pdu.c File Reference

#include <string.h>
#include "smpp_pdu.h"
#include "smpp_pdu.def"

Go to the source code of this file.

Data Structures
struct	smpp_tlv

Macros
#define	MIN_SMPP_PDU_LEN   (4*4)
#define	MAX_SMPP_PDU_LEN   (7424)
#define	DEFAULT_SMSC_ID   "def;ault"
#define	OPTIONAL_BEGIN
#define	TLV_INTEGER(name, octets)   OCTETS(name, octets)
#define	TLV_NULTERMINATED(name, max_len)   OCTETS(name, max_len)
#define	TLV_OCTETS(name, min_len, max_len)   OCTETS(name, min_len)
#define	OPTIONAL_END
#define	INTEGER(name, octets)   OCTETS(name, octets)
#define	NULTERMINATED(name, max_octets)   OCTETS(name, max_octets)
#define	OCTETS(name, field_giving_octetst)
#define	PDU(name, id, fields)
#define	OPTIONAL_BEGIN
#define	TLV_INTEGER(name, octets)   p->name = -1;
#define	TLV_NULTERMINATED(name, max_len)   p->name = NULL;
#define	TLV_OCTETS(name, min_len, max_len)   p->name = NULL;
#define	OPTIONAL_END   p->tlv = dict_create(1024, octstr_destroy_item);
#define	INTEGER(name, octets)   p->name = 0;
#define	NULTERMINATED(name, max_octets)   p->name = NULL;
#define	OCTETS(name, field_giving_octetst)   p->name = NULL;
#define	PDU(name, id, fields)
#define	OPTIONAL_BEGIN
#define	TLV_INTEGER(name, octets)   p->name = -1;
#define	TLV_NULTERMINATED(name, max_octets)   octstr_destroy(p->name);
#define	TLV_OCTETS(name, min_len, max_len)   octstr_destroy(p->name);
#define	OPTIONAL_END   dict_destroy(p->tlv);
#define	INTEGER(name, octets)   p->name = 0; /* Make sure "p" is used */
#define	NULTERMINATED(name, max_octets)   octstr_destroy(p->name);
#define	OCTETS(name, field_giving_octets)   octstr_destroy(p->name);
#define	PDU(name, id, fields)   case id: { struct name *p = &pdu->u.name; fields } break;
#define	OPTIONAL_BEGIN
#define	TLV_INTEGER(name, octets)
#define	TLV_NULTERMINATED(name, max_len)
#define	TLV_OCTETS(name, min_len, max_len)
#define	OPTIONAL_END
#define	INTEGER(name, octets)   p = *(&p);
#define	NULTERMINATED(name, max_octets)   p = *(&p);
#define	OCTETS(name, field_giving_octets)   p->field_giving_octets = octstr_len(p->name);
#define	PDU(name, id, fields)   case id: { struct name *p = &pdu->u.name; fields } break;
#define	TL(name, octets)
#define	OPTIONAL_BEGIN
#define	TLV_INTEGER(name, octets)
#define	TLV_NULTERMINATED(name, max_len)
#define	TLV_OCTETS(name, min_len, max_len)
#define	OPTIONAL_END
#define	INTEGER(name, octets)   append_encoded_integer(os, p->name, octets);
#define	NULTERMINATED(name, max_octets)
#define	OCTETS(name, field_giving_octets)   if (p->name) octstr_append(os, p->name);
#define	PDU(name, id, fields)   case id: { struct name *p = &pdu->u.name; fields } break;
#define	OPTIONAL_BEGIN
#define	TLV_INTEGER(mname, octets)
#define	TLV_NULTERMINATED(mname, max_len)
#define	TLV_OCTETS(mname, min_len, max_len)
#define	OPTIONAL_END
#define	INTEGER(name, octets)
#define	NULTERMINATED(name, max_octets)
#define	OCTETS(name, field_giving_octets)
#define	PDU(name, id, fields)   case id: { struct name *p = &pdu->u.name; fields } break;
#define	OPTIONAL_BEGIN
#define	TLV_INTEGER(name, max_len)
#define	TLV_NULTERMINATED(name, max_len)
#define	TLV_OCTETS(name, min_len, max_len)
#define	OPTIONAL_END
#define	INTEGER(name, octets)   debug("sms.smpp", 0, " %s: %lu = 0x%08lx", #name, p->name, p->name);
#define	NULTERMINATED(name, max_octets)   octstr_dump_short(p->name, 2, #name);
#define	OCTETS(name, field_giving_octets)   octstr_dump_short(p->name, 2, #name);
#define	PDU(name, id, fields)   case id: { struct name *p = &pdu->u.name; fields } break;
#define	OPTIONAL_BEGIN
#define	TLV_INTEGER(name, max_len)
#define	TLV_NULTERMINATED(name, max_len)
#define	TLV_OCTETS(name, min_len, max_len)
#define	OPTIONAL_END
#define	INTEGER(name, octets)   octstr_format_append(str, " [%s:0:0x%08lx]", #name, p->name);
#define	NULTERMINATED(name, max_octets)   octstr_format_append(str, " [%s:%d:%E]", #name, octstr_len(p->name), (p->name != NULL ? p->name : octstr_imm("NULL")));
#define	OCTETS(name, field_giving_octets)   octstr_format_append(str, " [%s:%d:%E]", #name, octstr_len(p->name), (p->name != NULL ? p->name : octstr_imm("NULL")));
#define	PDU(name, id, fields)   case id: { struct name *p = &pdu->u.name; fields } break;

Functions
static void	smpp_tlv_destroy (struct smpp_tlv *tlv)
void	smpp_tlv_add_constant (Octstr *smsc_id, Dict **tlvs)
static struct smpp_tlv *	smpp_tlv_get_by_name (Octstr *smsc_id, Octstr *name)
static struct smpp_tlv *	smpp_tlv_get_by_tag (Octstr *smsc_id, long tag)
int	smpp_pdu_init (Cfg *cfg)
int	smpp_pdu_shutdown (void)
static long	decode_integer (Octstr *os, long pos, int octets)
static void	append_encoded_integer (Octstr *os, unsigned long u, long octets)
static int	copy_until_nul (const char *field_name, Octstr *os, long *pos, long max_octets, Octstr **data)
static int	is_defined_field (long type, const char *field_name)
SMPP_PDU *	smpp_pdu_create (unsigned long type, unsigned long seq_no)
void	smpp_pdu_destroy (SMPP_PDU *pdu)
Octstr *	smpp_pdu_pack (Octstr *smsc_id, SMPP_PDU *pdu)
SMPP_PDU *	smpp_pdu_unpack (Octstr *smsc_id, Octstr *data_without_len)
void	smpp_pdu_dump (Octstr *smsc_id, SMPP_PDU *pdu)
void	smpp_pdu_dump_line (Octstr *smsc_id, SMPP_PDU *pdu)
long	smpp_pdu_read_len (Connection *conn)
Octstr *	smpp_pdu_read_data (Connection *conn, long len)
const char *	smpp_error_to_string (enum SMPP_ERROR_MESSAGES error)

Variables
static Dict *	tlvs_by_tag
static Dict *	tlvs_by_name
static Dict *	tlvs_by_const
static List *	tlvs
static int	initialized

Macro Definition Documentation

DEFAULT_SMSC_ID

#define DEFAULT_SMSC_ID   "def;ault"

Definition at line 73 of file smpp_pdu.c.

Referenced by smpp_pdu_init(), smpp_tlv_get_by_name(), and smpp_tlv_get_by_tag().

INTEGER [1/8]

#define INTEGER	(		name,
			octets
	)		OCTETS(name, octets)

INTEGER [2/8]

#define INTEGER	(		name,
			octets
	)		p->name = 0;

INTEGER [3/8]

#define INTEGER	(		name,
			octets
	)		p->name = 0; /* Make sure "p" is used */

INTEGER [4/8]

#define INTEGER	(		name,
			octets
	)		p = *(&p);

INTEGER [5/8]

#define INTEGER	(		name,
			octets
	)		append_encoded_integer(os, p->name, octets);

INTEGER [6/8]

#define INTEGER	(		name,
			octets
	)

Value:

if ((p->name = decode_integer(data_without_len, pos, octets)) == -1) \
            goto err; \
        pos += octets;

INTEGER [7/8]

#define INTEGER	(		name,
			octets
	)		debug("sms.smpp", 0, " %s: %lu = 0x%08lx", #name, p->name, p->name);

INTEGER [8/8]

#define INTEGER	(		name,
			octets
	)		octstr_format_append(str, " [%s:0:0x%08lx]", #name, p->name);

MAX_SMPP_PDU_LEN

#define MAX_SMPP_PDU_LEN   (7424)

Definition at line 71 of file smpp_pdu.c.

Referenced by smpp_pdu_read_len().

MIN_SMPP_PDU_LEN

#define MIN_SMPP_PDU_LEN   (4*4)

Definition at line 69 of file smpp_pdu.c.

Referenced by smpp_pdu_read_len().

NULTERMINATED [1/8]

#define NULTERMINATED	(		name,
			max_octets
	)		OCTETS(name, max_octets)

NULTERMINATED [2/8]

#define NULTERMINATED	(		name,
			max_octets
	)		p->name = NULL;

NULTERMINATED [3/8]

#define NULTERMINATED	(		name,
			max_octets
	)		octstr_destroy(p->name);

NULTERMINATED [4/8]

#define NULTERMINATED	(		name,
			max_octets
	)		p = *(&p);

NULTERMINATED [5/8]

#define NULTERMINATED	(		name,
			max_octets
	)

Value:

if (p->name != NULL) { \
            if (octstr_len(p->name) >= max_octets) { \
                warning(0, "SMPP: PDU element <%s> too long " \
                        "(length is %ld, should be %d)", \
                        #name, octstr_len(p->name), max_octets-1); \
                temp = octstr_copy(p->name, 0, max_octets-1); \
            } else \
                temp = octstr_duplicate(p->name); \
            octstr_append(os, temp); \
            octstr_destroy(temp); \
        } \
        octstr_append_char(os, '\0');

NULTERMINATED [6/8]

#define NULTERMINATED	(		name,
			max_octets
	)

Value:

/* just warn about errors but not fail */ \
        copy_until_nul(#name, data_without_len, &pos, max_octets, &p->name);

NULTERMINATED [7/8]

#define NULTERMINATED	(		name,
			max_octets
	)		octstr_dump_short(p->name, 2, #name);

NULTERMINATED [8/8]

#define NULTERMINATED	(		name,
			max_octets
	)		octstr_format_append(str, " [%s:%d:%E]", #name, octstr_len(p->name), (p->name != NULL ? p->name : octstr_imm("NULL")));

OCTETS [1/8]

#define OCTETS	(		name,
			field_giving_octetst
	)

Value:

if (strncmp(#name, field_name, sizeof(#name) - 1) == 0) \
                return 1;

OCTETS [2/8]

#define OCTETS	(		name,
			field_giving_octetst
	)		p->name = NULL;

OCTETS [3/8]

#define OCTETS	(		name,
			field_giving_octets
	)		octstr_destroy(p->name);

OCTETS [4/8]

#define OCTETS	(		name,
			field_giving_octets
	)		p->field_giving_octets = octstr_len(p->name);

OCTETS [5/8]

#define OCTETS	(		name,
			field_giving_octets
	)		if (p->name) octstr_append(os, p->name);

OCTETS [6/8]

#define OCTETS	(		name,
			field_giving_octets
	)

Value:

p->name = octstr_copy(data_without_len, pos, \
                          p->field_giving_octets); \
        if (p->field_giving_octets != (unsigned long) octstr_len(p->name)) { \
            error(0, "smpp_pdu: error while unpacking '" #name "', " \
                     "len is %ld but should have been %ld, dropping.", \
                     octstr_len(p->name), p->field_giving_octets); \
            goto err; \
        } else { \
            pos += p->field_giving_octets; \
        }

OCTETS [7/8]

#define OCTETS	(		name,
			field_giving_octets
	)		octstr_dump_short(p->name, 2, #name);

OCTETS [8/8]

#define OCTETS	(		name,
			field_giving_octets
	)		octstr_format_append(str, " [%s:%d:%E]", #name, octstr_len(p->name), (p->name != NULL ? p->name : octstr_imm("NULL")));

OPTIONAL_BEGIN [1/8]

#define OPTIONAL_BEGIN

OPTIONAL_BEGIN [2/8]

#define OPTIONAL_BEGIN

OPTIONAL_BEGIN [3/8]

#define OPTIONAL_BEGIN

OPTIONAL_BEGIN [4/8]

#define OPTIONAL_BEGIN

OPTIONAL_BEGIN [5/8]

#define OPTIONAL_BEGIN

OPTIONAL_BEGIN [6/8]

#define OPTIONAL_BEGIN

Value:

{   /* Read optional parameters */  \
            while (pos + 4 <= len) { \
                struct smpp_tlv *tlv; \
                unsigned long opt_tag, opt_len; \
                opt_tag = decode_integer(data_without_len, pos, 2); pos += 2; \
                debug("sms.smpp", 0, "Optional parameter tag (0x%04lx)", opt_tag);  \
                opt_len = decode_integer(data_without_len, pos, 2); pos += 2;  \
                debug("sms.smpp", 0, "Optional parameter length read as %ld", opt_len); \
                /* check configured TLVs */ \
                tlv = smpp_tlv_get_by_tag(smsc_id, opt_tag); \
                if (tlv != NULL) debug("sms.smpp", 0, "Found configured optional parameter `%s'", octstr_get_cstr(tlv->name));

OPTIONAL_BEGIN [7/8]

#define OPTIONAL_BEGIN

OPTIONAL_BEGIN [8/8]

#define OPTIONAL_BEGIN

OPTIONAL_END [1/8]

#define OPTIONAL_END

OPTIONAL_END [2/8]

#define OPTIONAL_END   p->tlv = dict_create(1024, octstr_destroy_item);

OPTIONAL_END [3/8]

#define OPTIONAL_END   dict_destroy(p->tlv);

OPTIONAL_END [4/8]

#define OPTIONAL_END

OPTIONAL_END [5/8]

#define OPTIONAL_END

OPTIONAL_END [6/8]

#define OPTIONAL_END

OPTIONAL_END [7/8]

#define OPTIONAL_END

Value:

if (p->tlv != NULL) { \
            List *keys; \
            Octstr *key; \
            struct smpp_tlv *tlv; \
            keys = dict_keys(p->tlv); \
            while(keys != NULL && (key = gwlist_extract_first(keys)) != NULL) { \
                tlv = smpp_tlv_get_by_name(smsc_id, key); \
                if (tlv != NULL) { \
                    octstr_dump_short(dict_get(p->tlv, key), 2, octstr_get_cstr(key)); \
                } \
                octstr_destroy(key); \
            } \
            gwlist_destroy(keys, octstr_destroy_item); \
        }

OPTIONAL_END [8/8]

#define OPTIONAL_END

Value:

if (p->tlv != NULL) { \
            List *keys; \
            Octstr *key; \
            struct smpp_tlv *tlv; \
            keys = dict_keys(p->tlv); \
            while(keys != NULL && (key = gwlist_extract_first(keys)) != NULL) { \
                tlv = smpp_tlv_get_by_name(smsc_id, key); \
                if (tlv != NULL) { \
                    Octstr *val = dict_get(p->tlv, key); \
                    octstr_format_append(str, " [%E:%d:%E]", key, octstr_len(val), val); \
                } \
                octstr_destroy(key); \
            } \
            gwlist_destroy(keys, octstr_destroy_item); \
        }

PDU [1/8]

#define PDU	(		name,
			id,
			fields
	)

Value:

case id: { \
            fields \
        } break;

PDU [2/8]

#define PDU	(		name,
			id,
			fields
	)

Value:

case id: { \
            struct name *p = &pdu->u.name; \
            pdu->type_name = #name; \
            fields \
            p->command_id = type; \
            p->sequence_number = seq_no; \
        } break;

PDU [3/8]

#define PDU	(		name,
			id,
			fields
	)		case id: { struct name *p = &pdu->u.name; fields } break;

PDU [4/8]

#define PDU	(		name,
			id,
			fields
	)		case id: { struct name *p = &pdu->u.name; fields } break;

PDU [5/8]

#define PDU	(		name,
			id,
			fields
	)		case id: { struct name *p = &pdu->u.name; fields } break;

PDU [6/8]

#define PDU	(		name,
			id,
			fields
	)		case id: { struct name *p = &pdu->u.name; fields } break;

PDU [7/8]

#define PDU	(		name,
			id,
			fields
	)		case id: { struct name *p = &pdu->u.name; fields } break;

PDU [8/8]

#define PDU	(		name,
			id,
			fields
	)		case id: { struct name *p = &pdu->u.name; fields } break;

TL

#define TL	(		name,
			octets
	)

Value:

append_encoded_integer(os, SMPP_##name, 2); \
        append_encoded_integer(os, octets, 2);

TLV_INTEGER [1/8]

#define TLV_INTEGER	(		name,
			octets
	)		OCTETS(name, octets)

TLV_INTEGER [2/8]

#define TLV_INTEGER	(		name,
			octets
	)		p->name = -1;

TLV_INTEGER [3/8]

#define TLV_INTEGER	(		name,
			octets
	)		p->name = -1;

TLV_INTEGER [4/8]

#define TLV_INTEGER	(		name,
			octets
	)

TLV_INTEGER [5/8]

#define TLV_INTEGER	(		name,
			octets
	)

Value:

if (p->name >= 0) { \
            TL(name, octets); \
            INTEGER(name, octets) \
        }

TLV_INTEGER [6/8]

#define TLV_INTEGER	(		mname,
			octets
	)

Value:

if (SMPP_##mname == opt_tag) { \
                    /* check length */ \
                    if (opt_len > octets) { \
                        error(0, "SMPP: Optional field (%s) with invalid length (%ld) dropped.", #mname, opt_len); \
                        pos += opt_len; \
                        continue; \
                    } \
                    INTEGER(mname, opt_len); \
                    if (tlv != NULL) dict_put(p->tlv, tlv->name, octstr_format("%ld", p->mname)); \
                } else

TLV_INTEGER [7/8]

#define TLV_INTEGER	(		name,
			max_len
	)

Value:

if (p->name != -1)  { \
            INTEGER(name, max_len) \
        }

TLV_INTEGER [8/8]

#define TLV_INTEGER	(		name,
			max_len
	)

Value:

if (p->name != -1)  { \
            INTEGER(name, max_len) \
        }

TLV_NULTERMINATED [1/8]

#define TLV_NULTERMINATED	(		name,
			max_len
	)		OCTETS(name, max_len)

TLV_NULTERMINATED [2/8]

#define TLV_NULTERMINATED	(		name,
			max_len
	)		p->name = NULL;

TLV_NULTERMINATED [3/8]

#define TLV_NULTERMINATED	(		name,
			max_octets
	)		octstr_destroy(p->name);

TLV_NULTERMINATED [4/8]

#define TLV_NULTERMINATED	(		name,
			max_len
	)

TLV_NULTERMINATED [5/8]

#define TLV_NULTERMINATED	(		name,
			max_len
	)

Value:

if (p->name != NULL) { \
            TL(name, (octstr_len(p->name) > max_len ? max_len : octstr_len(p->name) + 1)); \
            NULTERMINATED(name, max_len) \
        }

TLV_NULTERMINATED [6/8]

#define TLV_NULTERMINATED	(		mname,
			max_len
	)

Value:

if (SMPP_##mname == opt_tag) { \
                    /* check length */ \
                    if (opt_len > max_len || pos+opt_len > len) { \
                        error(0, "SMPP: Optional field (%s) with invalid length (%ld) dropped.", #mname, opt_len);  \
                        pos += opt_len; \
                        continue; \
                    } \
                    if(p->mname != NULL) { \
                        warning(0, "SMPP: Optional field (%s) was sent more than once, overwriting", #mname); \
                        octstr_destroy(p->mname); \
                        p->mname = NULL; \
                    } \
                    copy_until_nul(#mname, data_without_len, &pos, opt_len, &p->mname); \
                    if (tlv != NULL) dict_put(p->tlv, tlv->name, octstr_duplicate(p->mname)); \
                } else

TLV_NULTERMINATED [7/8]

#define TLV_NULTERMINATED	(		name,
			max_len
	)

Value:

if (p->name != NULL) { \
            NULTERMINATED(name, max_len) \
        }

TLV_NULTERMINATED [8/8]

#define TLV_NULTERMINATED	(		name,
			max_len
	)

Value:

if (p->name != NULL) { \
            NULTERMINATED(name, max_len) \
        }

TLV_OCTETS [1/8]

#define TLV_OCTETS	(		name,
			min_len,
			max_len
	)		OCTETS(name, min_len)

TLV_OCTETS [2/8]

#define TLV_OCTETS	(		name,
			min_len,
			max_len
	)		p->name = NULL;

TLV_OCTETS [3/8]

#define TLV_OCTETS	(		name,
			min_len,
			max_len
	)		octstr_destroy(p->name);

TLV_OCTETS [4/8]

#define TLV_OCTETS	(		name,
			min_len,
			max_len
	)

TLV_OCTETS [5/8]

#define TLV_OCTETS	(		name,
			min_len,
			max_len
	)

Value:

if (p->name != NULL) { \
            unsigned long len = octstr_len(p->name); \
            if (len > max_len || len < min_len) { \
                error(0, "SMPP: Optional field (%s) with invalid length (%ld) (should be %d - %d) dropped.", \
                    #name, len, min_len, max_len);\
            } else { \
                TL(name, len); \
                octstr_append(os, p->name); \
            } \
        }

TLV_OCTETS [6/8]

#define TLV_OCTETS	(		mname,
			min_len,
			max_len
	)

Value:

if (SMPP_##mname == opt_tag) { \
                    /* check length */ \
                    if (opt_len < min_len || opt_len > max_len || pos + opt_len > len) { \
                        error(0, "SMPP: Optional field (%s) with invalid length (%ld) (should be %d - %d) dropped.", \
                            #mname, opt_len, min_len, max_len);  \
                        pos += opt_len; \
                        continue; \
                    } \
                    if(p->mname != NULL) { \
                        warning(0, "SMPP: Optional field (%s) was sent more than once, overwriting", #mname); \
                        octstr_destroy(p->mname); \
                        p->mname = NULL; \
                    } \
                    p->mname = octstr_copy(data_without_len, pos, opt_len); \
                    pos += opt_len; \
                    if (tlv != NULL) dict_put(p->tlv, tlv->name, octstr_duplicate(p->mname)); \
                } else

TLV_OCTETS [7/8]

#define TLV_OCTETS	(		name,
			min_len,
			max_len
	)

Value:

if (p->name != NULL) { \
            OCTETS(name, max_len) \
        }

TLV_OCTETS [8/8]

#define TLV_OCTETS	(		name,
			min_len,
			max_len
	)

Value:

if (p->name != NULL) { \
            OCTETS(name, max_len) \
        }

Function Documentation

append_encoded_integer()

static void append_encoded_integer ( Octstr *  os, unsigned long  u, long  octets  )

static

Definition at line 346 of file smpp_pdu.c.

References octstr_append_char().

Referenced by smpp_pdu_pack().

{
    long i;

    for (i = 0; i < octets; ++i)
        octstr_append_char(os, (u >> ((octets - i - 1) * 8)) & 0xFF);
}

copy_until_nul()

static int copy_until_nul ( const char *  field_name, Octstr *  os, long *  pos, long  max_octets, Octstr **  data  )

static

Definition at line 355 of file smpp_pdu.c.

References error(), octstr_copy, octstr_search_char(), and warning().

{
    long nul;

    *data = NULL;

    nul = octstr_search_char(os, '\0', *pos);
    if (nul == -1) {
        warning(0, "SMPP: PDU NULL terminated string (%s) has no NULL.", field_name);
        return -1;
    }
    if (*pos + max_octets < nul) {
        error(0, "SMPP: PDU NULL terminated string (%s) longer than allowed.", field_name);
        return -1;
    }
    *data = (nul - *pos > 0) ? octstr_copy(os, *pos, nul - *pos) : NULL;
    *pos = nul + 1;
    return 0;
}

decode_integer()

static long decode_integer ( Octstr *  os, long  pos, int  octets  )

static

Definition at line 330 of file smpp_pdu.c.

References octstr_get_char(), and octstr_len().

Referenced by smpp_pdu_unpack().

{
    unsigned long u;
    int i;

    if (octstr_len(os) < pos + octets) 
        return -1;

    u = 0;
    for (i = 0; i < octets; ++i)
        u = (u << 8) | octstr_get_char(os, pos + i);

    return u;
}

is_defined_field()

static int is_defined_field ( long  type, const char *  field_name  )

static

Definition at line 375 of file smpp_pdu.c.

References type.

{
    switch (type) {
    #define OPTIONAL_BEGIN
    #define TLV_INTEGER(name, octets) OCTETS(name, octets)
    #define TLV_NULTERMINATED(name, max_len) OCTETS(name, max_len)
    #define TLV_OCTETS(name, min_len, max_len) OCTETS(name, min_len)
    #define OPTIONAL_END
    #define INTEGER(name, octets) OCTETS(name, octets)
    #define NULTERMINATED(name, max_octets) OCTETS(name, max_octets)
    #define OCTETS(name, field_giving_octetst) \
            if (strncmp(#name, field_name, sizeof(#name) - 1) == 0) \
                return 1;
    #define PDU(name, id, fields) \
        case id: { \
            fields \
        } break;
    #include "smpp_pdu.def"
    default:
        break;
    }

    return 0;
}

smpp_error_to_string()

const char* smpp_error_to_string

(

enum SMPP_ERROR_MESSAGES

error

)

Definition at line 911 of file smpp_pdu.c.

References error(), SMPP_ESME_RALYBND, SMPP_ESME_RBCASTCANCELFAIL, SMPP_ESME_RBCASTFAIL, SMPP_ESME_RBCASTQUERYFAIL, SMPP_ESME_RBINDFAIL, SMPP_ESME_RCANCELFAIL, SMPP_ESME_RCNTSUBDL, SMPP_ESME_RDELIVERYFAILURE, SMPP_ESME_RINVBCAST_REP, SMPP_ESME_RINVBCASTALIAS_NAME, SMPP_ESME_RINVBCASTAREAFMT, SMPP_ESME_RINVBCASTCHANIND, SMPP_ESME_RINVBCASTCNTTYPE, SMPP_ESME_RINVBCASTFREQINT, SMPP_ESME_RINVBCASTMSGCLASS, SMPP_ESME_RINVBCASTSRVGRP, SMPP_ESME_RINVBNDSTS, SMPP_ESME_RINVCMDID, SMPP_ESME_RINVCMDLEN, SMPP_ESME_RINVDCS, SMPP_ESME_RINVDESTFLAG, SMPP_ESME_RINVDFTMSGID, SMPP_ESME_RINVDLNAME, SMPP_ESME_RINVDSTADDRSUBUNIT, SMPP_ESME_RINVDSTADR, SMPP_ESME_RINVDSTNPI, SMPP_ESME_RINVDSTTON, SMPP_ESME_RINVESMCLASS, SMPP_ESME_RINVEXPIRY, SMPP_ESME_RINVMSGLEN, SMPP_ESME_RINVNUMBCAST_AREAS, SMPP_ESME_RINVNUMDESTS, SMPP_ESME_RINVNUMMSGS, SMPP_ESME_RINVPASWD, SMPP_ESME_RINVPRTFLG, SMPP_ESME_RINVREGDLVFLG, SMPP_ESME_RINVREPFLAG, SMPP_ESME_RINVSCHED, SMPP_ESME_RINVSERTYP, SMPP_ESME_RINVSRCADDRSUBUNIT, SMPP_ESME_RINVSRCADR, SMPP_ESME_RINVSRCNPI, SMPP_ESME_RINVSRCTON, SMPP_ESME_RINVSUBREP, SMPP_ESME_RINVSYSID, SMPP_ESME_RINVSYSTYP, SMPP_ESME_RINVTLVLEN, SMPP_ESME_RINVTLVSTREAM, SMPP_ESME_RINVTLVVAL, SMPP_ESME_RMISSINGTLV, SMPP_ESME_RMSGQFUL, SMPP_ESME_ROK, SMPP_ESME_RPROHIBITED, SMPP_ESME_RQUERYFAIL, SMPP_ESME_RREPLACEFAIL, SMPP_ESME_RSERTYPDENIED, SMPP_ESME_RSERTYPUNAUTH, SMPP_ESME_RSERTYPUNAVAIL, SMPP_ESME_RSUBMITFAIL, SMPP_ESME_RSYSERR, SMPP_ESME_RTHROTTLED, SMPP_ESME_RTLVNOTALLWD, SMPP_ESME_RUNKNOWNERR, SMPP_ESME_RX_P_APPN, SMPP_ESME_RX_R_APPN, and SMPP_ESME_RX_T_APPN.

Referenced by handle_pdu().

{
    switch (error) {
        case SMPP_ESME_ROK:
            return "OK";
        case SMPP_ESME_RINVMSGLEN:
            return "Message Length is invalid";
        case SMPP_ESME_RINVCMDLEN:
            return "Command Length is invalid";
        case SMPP_ESME_RINVCMDID:
            return "Invalid Command ID";
        case SMPP_ESME_RINVBNDSTS:
            return "Incorrect BIND Status for given command";
        case SMPP_ESME_RALYBND:
            return "ESME Already in Bound State";
        case SMPP_ESME_RINVPRTFLG:
            return "Invalid Priority Flag";
        case SMPP_ESME_RINVREGDLVFLG:
            return "Invalid Registered Delivery Flag";
        case SMPP_ESME_RSYSERR:
            return "System Error";
        case SMPP_ESME_RINVSRCADR:
            return "Invalid Source Address";
        case SMPP_ESME_RINVDSTADR:
            return "Invalid Destination Address";
        case SMPP_ESME_RBINDFAIL:
            return "Bind Failed";
        case SMPP_ESME_RINVPASWD:
            return "Invalid Password";
        case SMPP_ESME_RINVSYSID:
            return "Invalid System ID";
        case SMPP_ESME_RCANCELFAIL:
            return "Cancel SM Failed";
        case SMPP_ESME_RREPLACEFAIL:
            return "Replace SM Failed";
        case SMPP_ESME_RMSGQFUL:
            return "Message Queue Full";
        case SMPP_ESME_RINVSERTYP:
            return "Invalid Service Type";
        case SMPP_ESME_RINVNUMDESTS:
            return "Invalid number of destinations";
        case SMPP_ESME_RINVDLNAME:
            return "Invalid Distribution List Name";
        case SMPP_ESME_RINVDESTFLAG:
            return "Destination flag is invalid";
        case SMPP_ESME_RINVSUBREP:
            return "Submit w/replace not supported/allowed";
        case SMPP_ESME_RINVESMCLASS:
            return "Invalid esm_class field data";
        case SMPP_ESME_RCNTSUBDL:
            return "Cannot Submit to Distribution List";
        case SMPP_ESME_RSUBMITFAIL:
            return "Submit failed";
        case SMPP_ESME_RINVSRCTON:
            return "Invalid Source address TON"; 
        case SMPP_ESME_RINVSRCNPI:
            return "Invalid Source address NPI";
        case SMPP_ESME_RINVDSTTON:
            return "Invalid Destination address TON";
        case SMPP_ESME_RINVDSTNPI:
            return "Invalid Destination address NPI";
        case SMPP_ESME_RINVSYSTYP:
            return "Invalid system_type field";
        case SMPP_ESME_RINVREPFLAG:
            return "Invalid replace_if_present flag";
        case SMPP_ESME_RINVNUMMSGS:
            return "Invalid number of messages";
        case SMPP_ESME_RTHROTTLED:
            return "Throttling error";
        case SMPP_ESME_RINVSCHED:
            return "Invalid Scheduled Delivery Time";
        case SMPP_ESME_RINVEXPIRY:
            return "Invalid message validity period";
        case SMPP_ESME_RINVDFTMSGID:
            return "Predefined Message ID is Invalid or specific predefined message was not found";
        case SMPP_ESME_RX_T_APPN:
            return "ESME Receiver Temporary App Error Code";
        case SMPP_ESME_RX_P_APPN:
            return "ESME Receiver Permanent App Error Code";
        case SMPP_ESME_RX_R_APPN:
            return "ESME Receiver Reject Message Error Code";
        case SMPP_ESME_RQUERYFAIL:
            return "query_sm request failed";
        case SMPP_ESME_RINVTLVSTREAM:
            return "Error in optional part of the PDU Body";
        case SMPP_ESME_RTLVNOTALLWD:
            return "TLV not allowed";
        case SMPP_ESME_RINVTLVLEN:
            return "Invalid Parameter Length";
        case SMPP_ESME_RMISSINGTLV:
            return "Expected TLV missing";
        case SMPP_ESME_RINVTLVVAL:
            return "Invalid TLV value";
        case SMPP_ESME_RDELIVERYFAILURE:
            return "Transaction Delivery Failure";
        case SMPP_ESME_RUNKNOWNERR:
            return "Unknown Error";
        case SMPP_ESME_RSERTYPUNAUTH:
            return "ESME Not authorized to use specified service_type";
        case SMPP_ESME_RPROHIBITED:
            return "ESME Prohibited from using specified operation";
        case SMPP_ESME_RSERTYPUNAVAIL:
            return "Specified service_type is unavailable";
        case SMPP_ESME_RSERTYPDENIED:
            return "Specified service_type is denied";
        case SMPP_ESME_RINVDCS:
            return "Invalid Data Coding Scheme";
        case SMPP_ESME_RINVSRCADDRSUBUNIT:
            return "Source Address Sub unit is invalid";
        case SMPP_ESME_RINVDSTADDRSUBUNIT:
            return "Destination Address Sub unit is invalid";
        case SMPP_ESME_RINVBCASTFREQINT:
            return "Broadcast Frequency Interval is invalid";
        case SMPP_ESME_RINVBCASTALIAS_NAME:
            return "Broadcast Alias Name is invalid";
        case SMPP_ESME_RINVBCASTAREAFMT:
            return "Broadcast Area Format is invalid";
        case SMPP_ESME_RINVNUMBCAST_AREAS:
            return "Number of Broadcast Areas is invalid";
        case SMPP_ESME_RINVBCASTCNTTYPE:
            return "Broadcast Content Type is invalid";
        case SMPP_ESME_RINVBCASTMSGCLASS:
            return "Broadcast Message Class is invalid";
        case SMPP_ESME_RBCASTFAIL:
            return "broadcast_sm operation failed";
        case SMPP_ESME_RBCASTQUERYFAIL:
            return "broadcast_query_sm operation failed";
        case SMPP_ESME_RBCASTCANCELFAIL:
            return "broadcast_cancel_sm operation failed";
        case SMPP_ESME_RINVBCAST_REP:
            return "Number of Repeated Broadcasts is invalid";
        case SMPP_ESME_RINVBCASTSRVGRP:
            return "Broadcast Service Group is invalid";
        case SMPP_ESME_RINVBCASTCHANIND:
            return "Broadcast Channel Indicator is invalid";

        default:
            /* tell the user that we have a vendor-specific beast here */
            if (error >= 0x0400 && error <= 0x04FF)
                return "Vendor-specific error, please refer to your SMPP provider";
            else
                return "Unknown/Reserved";
    }
}

smpp_pdu_create()

SMPP_PDU* smpp_pdu_create	(	unsigned long	type,
		unsigned long	seq_no
	)

Definition at line 400 of file smpp_pdu.c.

References error(), SMPP_PDU::type, and type.

Referenced by handle_bind_receiver(), handle_bind_transmitter(), handle_enquire_link(), handle_pdu(), handle_submit_sm(), handle_unbind(), msg_to_pdu(), open_receiver(), open_transceiver(), open_transmitter(), send_enquire_link(), send_gnack(), send_smpp_thread(), send_unbind(), smpp_emu_handle_pdu(), smpp_emu_writer(), smpp_pdu_unpack(), and smsc_emu_submit_ack().

{
    SMPP_PDU *pdu;

    pdu = gw_malloc(sizeof(*pdu));
    pdu->type = type;

    switch (type) {
    #define OPTIONAL_BEGIN
    #define TLV_INTEGER(name, octets) p->name = -1;
    #define TLV_NULTERMINATED(name, max_len) p->name = NULL;
    #define TLV_OCTETS(name, min_len, max_len) p->name = NULL;
    #define OPTIONAL_END p->tlv = dict_create(1024, octstr_destroy_item);
    #define INTEGER(name, octets) p->name = 0;
    #define NULTERMINATED(name, max_octets) p->name = NULL;
    #define OCTETS(name, field_giving_octetst) p->name = NULL;
    #define PDU(name, id, fields) \
        case id: { \
            struct name *p = &pdu->u.name; \
            pdu->type_name = #name; \
            fields \
            p->command_id = type; \
            p->sequence_number = seq_no; \
        } break;
    #include "smpp_pdu.def"
    default:
        error(0, "Unknown SMPP_PDU type, internal error.");
        gw_free(pdu);
        return NULL;
    }

    return pdu;
}

smpp_pdu_destroy()

void smpp_pdu_destroy

(

SMPP_PDU *

pdu

)

Definition at line 434 of file smpp_pdu.c.

References error(), and SMPP_PDU::type.

Referenced by bearerbox_to_smpp(), handle_pdu(), io_thread(), msg_to_pdu(), open_receiver(), open_transceiver(), open_transmitter(), receive_smpp_thread(), send_enquire_link(), send_gnack(), send_messages(), send_smpp_thread(), send_unbind(), smpp_emu_handle_pdu(), smpp_emu_reader(), smpp_emu_writer(), smpp_pdu_destroy_item(), smpp_pdu_unpack(), and smsc_emu_submit_ack().

{
    if (pdu == NULL)
        return;

    switch (pdu->type) {
    #define OPTIONAL_BEGIN
    #define TLV_INTEGER(name, octets) p->name = -1;
    #define TLV_NULTERMINATED(name, max_octets) octstr_destroy(p->name);
    #define TLV_OCTETS(name, min_len, max_len) octstr_destroy(p->name);
    #define OPTIONAL_END dict_destroy(p->tlv);
    #define INTEGER(name, octets) p->name = 0; /* Make sure "p" is used */
    #define NULTERMINATED(name, max_octets) octstr_destroy(p->name);
    #define OCTETS(name, field_giving_octets) octstr_destroy(p->name);
    #define PDU(name, id, fields) \
        case id: { struct name *p = &pdu->u.name; fields } break;
    #include "smpp_pdu.def"
    default:
        error(0, "Unknown SMPP_PDU type, internal error while destroying.");
    }
    gw_free(pdu);
}

smpp_pdu_dump()

void smpp_pdu_dump	(	Octstr *	smsc_id,
		SMPP_PDU *	pdu
	)

Definition at line 766 of file smpp_pdu.c.

References debug(), and error().

Referenced by handle_pdu().

{
    debug("sms.smpp", 0, "SMPP PDU %p dump:", (void *) pdu);
    debug("sms.smpp", 0, "  type_name: %s", pdu->type_name);
    switch (pdu->type) {
    #define OPTIONAL_BEGIN
    #define TLV_INTEGER(name, max_len) \
        if (p->name != -1)  { \
            INTEGER(name, max_len) \
        }
    #define TLV_NULTERMINATED(name, max_len) \
        if (p->name != NULL) { \
            NULTERMINATED(name, max_len) \
        }
    #define TLV_OCTETS(name, min_len, max_len) \
        if (p->name != NULL) { \
            OCTETS(name, max_len) \
        }
    #define OPTIONAL_END \
        if (p->tlv != NULL) { \
            List *keys; \
            Octstr *key; \
            struct smpp_tlv *tlv; \
            keys = dict_keys(p->tlv); \
            while(keys != NULL && (key = gwlist_extract_first(keys)) != NULL) { \
                tlv = smpp_tlv_get_by_name(smsc_id, key); \
                if (tlv != NULL) { \
                    octstr_dump_short(dict_get(p->tlv, key), 2, octstr_get_cstr(key)); \
                } \
                octstr_destroy(key); \
            } \
            gwlist_destroy(keys, octstr_destroy_item); \
        }
    #define INTEGER(name, octets) \
        debug("sms.smpp", 0, "  %s: %lu = 0x%08lx", #name, p->name, p->name);
    #define NULTERMINATED(name, max_octets) \
        octstr_dump_short(p->name, 2, #name);
    #define OCTETS(name, field_giving_octets) \
        octstr_dump_short(p->name, 2, #name);
    #define PDU(name, id, fields) \
        case id: { struct name *p = &pdu->u.name; fields } break;
    #include "smpp_pdu.def"
    default:
        error(0, "Unknown SMPP_PDU type, internal error.");
        break;
    }
    debug("sms.smpp", 0, "SMPP PDU dump ends.");
}

smpp_pdu_dump_line()

void smpp_pdu_dump_line	(	Octstr *	smsc_id,
		SMPP_PDU *	pdu
	)

Definition at line 816 of file smpp_pdu.c.

References debug(), error(), octstr_create, octstr_destroy(), octstr_format_append(), octstr_get_cstr, and SMPP_PDU::type_name.

{
    Octstr *str = octstr_create("");

    octstr_format_append(str, "SMPP PDU %p dump: [type_name:%d:%s]", (void *) pdu, strlen(pdu->type_name), pdu->type_name);
    switch (pdu->type) {
    #define OPTIONAL_BEGIN
    #define TLV_INTEGER(name, max_len) \
        if (p->name != -1)  { \
            INTEGER(name, max_len) \
        }
    #define TLV_NULTERMINATED(name, max_len) \
        if (p->name != NULL) { \
            NULTERMINATED(name, max_len) \
        }
    #define TLV_OCTETS(name, min_len, max_len) \
        if (p->name != NULL) { \
            OCTETS(name, max_len) \
        }
    #define OPTIONAL_END \
        if (p->tlv != NULL) { \
            List *keys; \
            Octstr *key; \
            struct smpp_tlv *tlv; \
            keys = dict_keys(p->tlv); \
            while(keys != NULL && (key = gwlist_extract_first(keys)) != NULL) { \
                tlv = smpp_tlv_get_by_name(smsc_id, key); \
                if (tlv != NULL) { \
                    Octstr *val = dict_get(p->tlv, key); \
                    octstr_format_append(str, " [%E:%d:%E]", key, octstr_len(val), val); \
                } \
                octstr_destroy(key); \
            } \
            gwlist_destroy(keys, octstr_destroy_item); \
        }
    #define INTEGER(name, octets) \
        octstr_format_append(str, " [%s:0:0x%08lx]", #name, p->name);
    #define NULTERMINATED(name, max_octets) \
        octstr_format_append(str, " [%s:%d:%E]", #name, octstr_len(p->name), (p->name != NULL ? p->name : octstr_imm("NULL")));
    #define OCTETS(name, field_giving_octets) \
        octstr_format_append(str, " [%s:%d:%E]", #name, octstr_len(p->name), (p->name != NULL ? p->name : octstr_imm("NULL")));
    #define PDU(name, id, fields) \
        case id: { struct name *p = &pdu->u.name; fields } break;
    #include "smpp_pdu.def"
    default:
        error(0, "Unknown SMPP_PDU type, internal error.");
        break;
    }
    debug("sms.smpp", 0, "%s", octstr_get_cstr(str));
    octstr_destroy(str);
}

smpp_pdu_init()

int smpp_pdu_init

(

Cfg *

cfg

)

Definition at line 184 of file smpp_pdu.c.

References cfg, cfg_get, cfg_get_integer(), cfg_get_multi_group(), smpp_tlv::constant, debug(), DEFAULT_SMSC_ID, dict_create(), dict_destroy(), dict_get(), dict_put(), dict_put_once(), error(), gwlist_create, gwlist_destroy(), gwlist_extract_first(), gwlist_produce(), initialized, smpp_tlv::length, smpp_tlv::name, octstr_create, octstr_destroy(), octstr_destroy_item(), octstr_format(), octstr_get_cstr, octstr_imm(), octstr_split(), octstr_str_case_compare(), smpp_tlv_destroy(), smpp_tlv::SMPP_TLV_INTEGER, smpp_tlv::SMPP_TLV_NULTERMINATED, smpp_tlv::SMPP_TLV_OCTETS, smsc_id, smpp_tlv::tag, tlvs, tlvs_by_const, tlvs_by_name, tlvs_by_tag, and smpp_tlv::type.

Referenced by init_smppbox(), main(), and smsc2_start().

{
    CfgGroup *grp;
    List *l;

    if (initialized)
        return 0;

    l = cfg_get_multi_group(cfg, octstr_imm("smpp-tlv"));
    tlvs = gwlist_create();
    tlvs_by_tag = dict_create(1024, (void(*)(void*))dict_destroy);
    tlvs_by_name = dict_create(1024, (void(*)(void*))dict_destroy);
    tlvs_by_const = dict_create(1024, (void(*)(void*))dict_destroy);
    while (l != NULL && (grp = gwlist_extract_first(l)) != NULL) {
        struct smpp_tlv *tlv;
        Octstr *tmp, *smsc_id;
        List *l2;

        tlv = gw_malloc(sizeof(*tlv));
        if ((tlv->name = cfg_get(grp, octstr_imm("name"))) == NULL) {
            error(0, "SMPP: Unable to get name for smpp-tlv.");
            smpp_tlv_destroy(tlv);
            goto failed;
        }
        tlv->constant = cfg_get(grp, octstr_imm("const"));
        if (cfg_get_integer(&tlv->tag, grp, octstr_imm("tag")) == -1) {
            error(0, "SMPP: Unable to get tag for smpp-tlv.");
            smpp_tlv_destroy(tlv);
            goto failed;
        }
        if (cfg_get_integer(&tlv->length, grp, octstr_imm("length")) == -1) {
            error(0, "SMPP: Unable to get length for smpp-tlv.");
            smpp_tlv_destroy(tlv);
            goto failed;
        }
        if ((tmp = cfg_get(grp, octstr_imm("type"))) == NULL) {
            error(0, "SMPP: Unable to get type for smpp-tlv.");
            smpp_tlv_destroy(tlv);
            goto failed;
        }
        if (octstr_str_case_compare(tmp, "octetstring") == 0)
            tlv->type = SMPP_TLV_OCTETS;
        else if (octstr_str_case_compare(tmp, "nulterminated") == 0)
            tlv->type = SMPP_TLV_NULTERMINATED;
        else if (octstr_str_case_compare(tmp, "integer") == 0)
            tlv->type = SMPP_TLV_INTEGER;
        else {
            error(0, "SMPP: Unknown type for smpp-tlv: `%s'", octstr_get_cstr(tmp));
            octstr_destroy(tmp);
            smpp_tlv_destroy(tlv);
            goto failed;
        }
        octstr_destroy(tmp);

        /* put to all TLVs */
        gwlist_produce(tlvs, tlv);

        smsc_id = cfg_get(grp, octstr_imm("smsc-id"));
        if (smsc_id != NULL) {
            l2 = octstr_split(smsc_id, octstr_imm(";"));
            octstr_destroy(smsc_id);
        } else {
            l2 = gwlist_create();
            gwlist_produce(l2, octstr_create(DEFAULT_SMSC_ID));
        }
        while(l2 != NULL && (smsc_id = gwlist_extract_first(l2)) != NULL) {
            Dict *tmp_dict;

            debug("sms.smpp", 0, "adding smpp-tlv for smsc-id=%s", octstr_get_cstr(smsc_id));

            /* name */
            tmp_dict = dict_get(tlvs_by_name, smsc_id);
            if (tmp_dict == NULL) {
                tmp_dict = dict_create(1024, NULL);
                dict_put(tlvs_by_name, smsc_id, tmp_dict);
            }
            /* put into dict */
            if (!dict_put_once(tmp_dict, tlv->name, tlv)) {
                error(0, "SMPP: Double TLV name %s found.", octstr_get_cstr(tlv->name));
                octstr_destroy(smsc_id);
                goto failed;
            }

            /* tag */
            tmp_dict = dict_get(tlvs_by_tag, smsc_id);
            if (tmp_dict == NULL) {
                tmp_dict = dict_create(1024, NULL);
                dict_put(tlvs_by_tag, smsc_id, tmp_dict);
            }
            tmp = octstr_format("%ld", tlv->tag);
            if (!dict_put_once(tmp_dict, tmp, tlv)) {
                error(0, "SMPP: Double TLV tag %s found.", octstr_get_cstr(tmp));
                gwlist_destroy(l2, octstr_destroy_item);
                octstr_destroy(tmp);
                octstr_destroy(smsc_id);
                goto failed;
            }

            /* const */
            if (tlv->constant != NULL) {
                tmp_dict = dict_get(tlvs_by_const, smsc_id);
                if (tmp_dict == NULL) {
                    tmp_dict = dict_create(1024, NULL);
                    dict_put(tlvs_by_const, smsc_id, tmp_dict);
                }
                if (!dict_put_once(tmp_dict, tlv->name, tlv)) {
                    error(0, "SMPP: Double TLV name %s found.", octstr_get_cstr(tlv->name));
                    octstr_destroy(smsc_id);
                    goto failed;
                }
            }

            octstr_destroy(tmp);
            octstr_destroy(smsc_id);
        }
        gwlist_destroy(l2, octstr_destroy_item);
    }
    gwlist_destroy(l, NULL);

    initialized = 1;
    return 0;

failed:
    gwlist_destroy(tlvs, (void(*)(void*))smpp_tlv_destroy);
    dict_destroy(tlvs_by_tag);
    dict_destroy(tlvs_by_name);
    return -1;
}

smpp_pdu_pack()

Octstr* smpp_pdu_pack	(	Octstr *	smsc_id,
		SMPP_PDU *	pdu
	)

Definition at line 458 of file smpp_pdu.c.

References append_encoded_integer(), error(), gw_assert(), octstr_create, octstr_destroy(), octstr_insert(), octstr_len(), and SMPP_PDU::type.

Referenced by handle_pdu(), send_enquire_link(), send_gnack(), send_pdu(), send_smpp_thread(), send_unbind(), smpp_emu_handle_pdu(), smpp_emu_writer(), and smsc_emu_submit_ack().

{
    Octstr *os;
    Octstr *temp;

    os = octstr_create("");

    gw_assert(pdu != NULL);

    /*
     * Fix lengths of octet string fields.
     */
    switch (pdu->type) {
    #define OPTIONAL_BEGIN
    #define TLV_INTEGER(name, octets)
    #define TLV_NULTERMINATED(name, max_len)
    #define TLV_OCTETS(name, min_len, max_len)
    #define OPTIONAL_END
    #define INTEGER(name, octets) p = *(&p);
    #define NULTERMINATED(name, max_octets) p = *(&p);
    #define OCTETS(name, field_giving_octets) \
        p->field_giving_octets = octstr_len(p->name);
    #define PDU(name, id, fields) \
        case id: { struct name *p = &pdu->u.name; fields } break;
    #include "smpp_pdu.def"
    default:
        error(0, "Unknown SMPP_PDU type, internal error while packing.");
    }

    switch (pdu->type) {
    #define TL(name, octets) \
        append_encoded_integer(os, SMPP_##name, 2); \
        append_encoded_integer(os, octets, 2);
    #define OPTIONAL_BEGIN
    #define TLV_INTEGER(name, octets) \
        if (p->name >= 0) { \
            TL(name, octets); \
            INTEGER(name, octets) \
        }
    #define TLV_NULTERMINATED(name, max_len) \
        if (p->name != NULL) { \
            TL(name, (octstr_len(p->name) > max_len ? max_len : octstr_len(p->name) + 1)); \
            NULTERMINATED(name, max_len) \
        }
    #define TLV_OCTETS(name, min_len, max_len) \
        if (p->name != NULL) { \
            unsigned long len = octstr_len(p->name); \
            if (len > max_len || len < min_len) { \
                error(0, "SMPP: Optional field (%s) with invalid length (%ld) (should be %d - %d) dropped.", \
                    #name, len, min_len, max_len);\
            } else { \
                TL(name, len); \
                octstr_append(os, p->name); \
            } \
        }
    #define OPTIONAL_END \
        if (p->tlv != NULL) { \
            Octstr *key; \
            List *keys; \
            struct smpp_tlv *tlv; \
            keys = dict_keys(p->tlv); \
            while(keys != NULL && (key = gwlist_extract_first(keys)) != NULL) { \
                tlv = smpp_tlv_get_by_name(smsc_id, key); \
                if (tlv == NULL) { \
                    if (!is_defined_field(pdu->type, octstr_get_cstr(key))) \
                        error(0, "SMPP: Unknown TLV `%s', don't send.", octstr_get_cstr(key)); \
                    octstr_destroy(key); \
                    continue; \
                } \
                switch(tlv->type) { \
                case SMPP_TLV_INTEGER: { \
                    long val = atol(octstr_get_cstr(dict_get(p->tlv, key))); \
                    append_encoded_integer(os, tlv->tag, 2); \
                    append_encoded_integer(os, tlv->length, 2); \
                    append_encoded_integer(os, val, tlv->length); \
                    break; \
                } \
                case SMPP_TLV_OCTETS: \
                case SMPP_TLV_NULTERMINATED: { \
                    Octstr *val = dict_get(p->tlv, key); \
                    unsigned long len = octstr_len(val); \
                    if (len > tlv->length) { \
                        error(0, "SMPP: Optional field (%s) with invalid length (%ld) (should be %ld) dropped.", \
                              octstr_get_cstr(key), len, tlv->length);\
                        octstr_destroy(key); \
                        continue; \
                    } \
                    append_encoded_integer(os, tlv->tag, 2); \
                    if (tlv->type == SMPP_TLV_NULTERMINATED) \
                        append_encoded_integer(os, len + 1, 2); \
                    else \
                        append_encoded_integer(os, len, 2); \
                    octstr_append(os, val); \
                    if (tlv->type == SMPP_TLV_NULTERMINATED) \
                        octstr_append_char(os, '\0'); \
                    break; \
                } \
                default: \
                    panic(0, "SMPP: Internal error, unknown configured TLV type %d.", tlv->type); \
                    break; \
                } \
                octstr_destroy(key); \
            } \
            gwlist_destroy(keys, octstr_destroy_item); \
        }
    #define INTEGER(name, octets) \
        append_encoded_integer(os, p->name, octets);
    #define NULTERMINATED(name, max_octets) \
        if (p->name != NULL) { \
            if (octstr_len(p->name) >= max_octets) { \
                warning(0, "SMPP: PDU element <%s> too long " \
                        "(length is %ld, should be %d)", \
                        #name, octstr_len(p->name), max_octets-1); \
                temp = octstr_copy(p->name, 0, max_octets-1); \
            } else \
                temp = octstr_duplicate(p->name); \
            octstr_append(os, temp); \
            octstr_destroy(temp); \
        } \
        octstr_append_char(os, '\0');
    #define OCTETS(name, field_giving_octets) \
        if (p->name) octstr_append(os, p->name);
    #define PDU(name, id, fields) \
        case id: { struct name *p = &pdu->u.name; fields } break;
    #include "smpp_pdu.def"
    default:
        error(0, "Unknown SMPP_PDU type 0x%08lx, internal error while packing.", pdu->type);
        break;
    }

    temp = octstr_create("");
    append_encoded_integer(temp, octstr_len(os) + 4, 4);
    octstr_insert(os, temp, 0);
    octstr_destroy(temp);

    return os;
}

smpp_pdu_read_data()

Octstr* smpp_pdu_read_data	(	Connection *	conn,
		long	len
	)

Definition at line 895 of file smpp_pdu.c.

References conn_read_fixed().

Referenced by read_pdu(), receive_smpp_thread(), and smpp_emu_reader().

{
    Octstr *os;

    os = conn_read_fixed(conn, len - 4);    /* `len' includes itself. */
    return os;
}

smpp_pdu_read_len()

long smpp_pdu_read_len

(

Connection *

conn

)

Definition at line 869 of file smpp_pdu.c.

References conn_read_fixed(), decode_network_long(), error(), MAX_SMPP_PDU_LEN, MIN_SMPP_PDU_LEN, octstr_destroy(), and octstr_get_many_chars().

Referenced by read_pdu(), receive_smpp_thread(), and smpp_emu_reader().

{
    Octstr *os;
    unsigned char buf[4];    /* The length is 4 octets. */
    long len;

    os = conn_read_fixed(conn, sizeof(buf));
    if (os == NULL)
        return 0;
    octstr_get_many_chars((char*) buf, os, 0, sizeof(buf));
    octstr_destroy(os);
    len = decode_network_long(buf);
    if (len < MIN_SMPP_PDU_LEN) {
    error(0, "SMPP: PDU length was too small (%ld, minimum is %ld).",
          len, (long) MIN_SMPP_PDU_LEN);
        return -1;
    }
    if (len > MAX_SMPP_PDU_LEN) {
    error(0, "SMPP: PDU length was too large (%ld, maximum is %ld).",
          len, (long) MAX_SMPP_PDU_LEN);
        return -1;
    }
    return len;
}

smpp_pdu_shutdown()

int smpp_pdu_shutdown

(

void

)

Definition at line 314 of file smpp_pdu.c.

References dict_destroy(), gwlist_destroy(), initialized, smpp_tlv_destroy(), tlvs, tlvs_by_name, and tlvs_by_tag.

Referenced by smsc2_shutdown().

{
    if (initialized == 0)
        return 0;

    initialized = 0;
    gwlist_destroy(tlvs, (void(*)(void*))smpp_tlv_destroy);
    tlvs = NULL;
    dict_destroy(tlvs_by_tag);
    dict_destroy(tlvs_by_name);
    tlvs_by_tag = tlvs_by_name = NULL;

    return 0;
}

smpp_pdu_unpack()

SMPP_PDU* smpp_pdu_unpack	(	Octstr *	smsc_id,
		Octstr *	data_without_len
	)

Definition at line 597 of file smpp_pdu.c.

References decode_integer(), error(), octstr_dump, octstr_len(), smpp_pdu_create(), smpp_pdu_destroy(), and type.

Referenced by read_pdu(), receive_smpp_thread(), and smpp_emu_reader().

{
    SMPP_PDU *pdu;
    unsigned long type;
    long len, pos;

    len = octstr_len(data_without_len);

    if (len < 4) {
        error(0, "SMPP: PDU was too short (%ld bytes).",
              octstr_len(data_without_len));
        return NULL;
    }

    /* get the PDU type */
    if ((type = decode_integer(data_without_len, 0, 4)) == -1)
        return NULL;

    /* create a coresponding representation structure */
    pdu = smpp_pdu_create(type, 0);
    if (pdu == NULL)
        return NULL;

    pos = 0;

    switch (type) {
    #define OPTIONAL_BEGIN  \
        {   /* Read optional parameters */  \
            while (pos + 4 <= len) { \
                struct smpp_tlv *tlv; \
                unsigned long opt_tag, opt_len; \
                opt_tag = decode_integer(data_without_len, pos, 2); pos += 2; \
                debug("sms.smpp", 0, "Optional parameter tag (0x%04lx)", opt_tag);  \
                opt_len = decode_integer(data_without_len, pos, 2); pos += 2;  \
                debug("sms.smpp", 0, "Optional parameter length read as %ld", opt_len); \
                /* check configured TLVs */ \
                tlv = smpp_tlv_get_by_tag(smsc_id, opt_tag); \
                if (tlv != NULL) debug("sms.smpp", 0, "Found configured optional parameter `%s'", octstr_get_cstr(tlv->name));
    #define TLV_INTEGER(mname, octets) \
                if (SMPP_##mname == opt_tag) { \
                    /* check length */ \
                    if (opt_len > octets) { \
                        error(0, "SMPP: Optional field (%s) with invalid length (%ld) dropped.", #mname, opt_len); \
                        pos += opt_len; \
                        continue; \
                    } \
                    INTEGER(mname, opt_len); \
                    if (tlv != NULL) dict_put(p->tlv, tlv->name, octstr_format("%ld", p->mname)); \
                } else
    #define TLV_NULTERMINATED(mname, max_len) \
                if (SMPP_##mname == opt_tag) { \
                    /* check length */ \
                    if (opt_len > max_len || pos+opt_len > len) { \
                        error(0, "SMPP: Optional field (%s) with invalid length (%ld) dropped.", #mname, opt_len);  \
                        pos += opt_len; \
                        continue; \
                    } \
                    if(p->mname != NULL) { \
                        warning(0, "SMPP: Optional field (%s) was sent more than once, overwriting", #mname); \
                        octstr_destroy(p->mname); \
                        p->mname = NULL; \
                    } \
                    copy_until_nul(#mname, data_without_len, &pos, opt_len, &p->mname); \
                    if (tlv != NULL) dict_put(p->tlv, tlv->name, octstr_duplicate(p->mname)); \
                } else
    #define TLV_OCTETS(mname, min_len, max_len) \
                if (SMPP_##mname == opt_tag) { \
                    /* check length */ \
                    if (opt_len < min_len || opt_len > max_len || pos + opt_len > len) { \
                        error(0, "SMPP: Optional field (%s) with invalid length (%ld) (should be %d - %d) dropped.", \
                            #mname, opt_len, min_len, max_len);  \
                        pos += opt_len; \
                        continue; \
                    } \
                    if(p->mname != NULL) { \
                        warning(0, "SMPP: Optional field (%s) was sent more than once, overwriting", #mname); \
                        octstr_destroy(p->mname); \
                        p->mname = NULL; \
                    } \
                    p->mname = octstr_copy(data_without_len, pos, opt_len); \
                    pos += opt_len; \
                    if (tlv != NULL) dict_put(p->tlv, tlv->name, octstr_duplicate(p->mname)); \
                } else
    #define OPTIONAL_END \
                { \
                    Octstr *val = NULL; \
                    if (tlv != NULL) { \
                        /* found configured tlv */ \
                        /* check length */ \
                        if (opt_len > tlv->length) { \
                            error(0, "SMPP: Optional field (%s) with invalid length (%ld) (should be %ld) dropped.", \
                                  octstr_get_cstr(tlv->name), opt_len, tlv->length); \
                            pos += opt_len; \
                            continue; \
                        } \
                        switch (tlv->type) { \
                        case SMPP_TLV_INTEGER: { \
                            long val_i; \
                            if ((val_i = decode_integer(data_without_len, pos, opt_len)) == -1) \
                                goto err; \
                            val = octstr_format("%ld", val_i); \
                            dict_put(p->tlv, tlv->name, val); \
                            pos += opt_len; \
                            break; \
                        } \
                        case SMPP_TLV_OCTETS: { \
                            val = octstr_copy(data_without_len, pos, opt_len); \
                            dict_put(p->tlv, tlv->name, val); \
                            pos += opt_len; \
                            break; \
                        } \
                        case SMPP_TLV_NULTERMINATED: { \
                            if (copy_until_nul(octstr_get_cstr(tlv->name), data_without_len, &pos, opt_len, &val) == 0) \
                                dict_put(p->tlv, tlv->name, val); \
                            break; \
                        } \
                        default: \
                            panic(0, "SMPP: Internal error, unknown configured TLV type %d.", tlv->type); \
                            break; \
                        } \
                    }  else { \
                        val = octstr_copy(data_without_len, pos, opt_len); \
                        if (val) \
                            octstr_binary_to_hex(val, 0); \
                        else \
                            val = octstr_create(""); \
                        warning(0, "SMPP: Unknown TLV(0x%04lx,0x%04lx,%s) for PDU type (%s) received!", \
                            opt_tag, opt_len, octstr_get_cstr(val), pdu->type_name); \
                        octstr_destroy(val); \
                        pos += opt_len; \
                    } \
                } \
            } \
        }
    #define INTEGER(name, octets) \
        if ((p->name = decode_integer(data_without_len, pos, octets)) == -1) \
            goto err; \
        pos += octets;
    #define NULTERMINATED(name, max_octets) \
        /* just warn about errors but not fail */ \
        copy_until_nul(#name, data_without_len, &pos, max_octets, &p->name);
    #define OCTETS(name, field_giving_octets) \
        p->name = octstr_copy(data_without_len, pos, \
                          p->field_giving_octets); \
        if (p->field_giving_octets != (unsigned long) octstr_len(p->name)) { \
            error(0, "smpp_pdu: error while unpacking '" #name "', " \
                     "len is %ld but should have been %ld, dropping.", \
                     octstr_len(p->name), p->field_giving_octets); \
            goto err; \
        } else { \
            pos += p->field_giving_octets; \
        }
    #define PDU(name, id, fields) \
        case id: { struct name *p = &pdu->u.name; fields } break;
    #include "smpp_pdu.def"
    default:
        error(0, "Unknown SMPP_PDU type 0x%08lx, internal error while unpacking.", type);
        break;
    }

    return pdu;
    
err:
    smpp_pdu_destroy(pdu);
    octstr_dump(data_without_len, 0);
    return NULL;
}

smpp_tlv_add_constant()

void smpp_tlv_add_constant	(	Octstr *	smsc_id,
		Dict **	tlvs
	)

Definition at line 102 of file smpp_pdu.c.

References smpp_tlv::constant, dict_create(), dict_get(), dict_keys(), dict_put(), gwlist_destroy(), gwlist_extract_first(), octstr_destroy(), octstr_destroy_item(), octstr_duplicate, smsc_id, tlvs, and tlvs_by_const.

Referenced by msg_to_pdu().

{
    Dict *constant;
    List *keys;
    Octstr *key;
    struct smpp_tlv *tlv;

    constant = dict_get(tlvs_by_const, smsc_id);
    if (constant == NULL)
        return;

    keys = dict_keys(constant);
    while ((key = gwlist_extract_first(keys)) != NULL) {
        /* only add if not available already */
        tlv = dict_get(constant, key);
        if (tlv && tlv->constant) {
            if (*tlvs) {
                if (dict_get(*tlvs, key) == NULL)
                    dict_put(*tlvs, key, octstr_duplicate(tlv->constant));
            } else {
                *tlvs = dict_create(1024, octstr_destroy_item);
                dict_put(*tlvs, key, octstr_duplicate(tlv->constant));
            }
        }
        octstr_destroy(key);
    }
    gwlist_destroy(keys, NULL);
}

smpp_tlv_destroy()

static void smpp_tlv_destroy ( struct smpp_tlv *  tlv )

static

Definition at line 92 of file smpp_pdu.c.

References smpp_tlv::constant, smpp_tlv::name, and octstr_destroy().

Referenced by smpp_pdu_init(), and smpp_pdu_shutdown().

{
    if (tlv == NULL)
        return;
    octstr_destroy(tlv->name);
    octstr_destroy(tlv->constant);
    gw_free(tlv);
}

smpp_tlv_get_by_name()

static struct smpp_tlv* smpp_tlv_get_by_name ( Octstr *  smsc_id, Octstr *  name  )

static

Definition at line 132 of file smpp_pdu.c.

References DEFAULT_SMSC_ID, dict_get(), name, octstr_imm(), smsc_id, and tlvs_by_name.

{
    struct smpp_tlv *res = NULL;
    Dict *tmp_dict;

    if (tlvs_by_name == NULL || name == NULL)
        return NULL;

    if (smsc_id != NULL) {
        tmp_dict = dict_get(tlvs_by_name, smsc_id);
        if (tmp_dict != NULL)
            res = dict_get(tmp_dict, name);
    }
    if (res == NULL) {
        /* try default smsc_id */
        smsc_id = octstr_imm(DEFAULT_SMSC_ID);
        tmp_dict = dict_get(tlvs_by_name, smsc_id);
        if (tmp_dict != NULL)
            res = dict_get(tmp_dict, name);
    }
    return res;
}

smpp_tlv_get_by_tag()

static struct smpp_tlv* smpp_tlv_get_by_tag ( Octstr *  smsc_id, long  tag  )

static

Definition at line 155 of file smpp_pdu.c.

References DEFAULT_SMSC_ID, dict_get(), octstr_destroy(), octstr_format(), octstr_imm(), smsc_id, smpp_tlv::tag, and tlvs_by_tag.

{
    struct smpp_tlv *res = NULL;
    Dict *tmp_dict;
    Octstr *tmp;

    if (tlvs_by_tag == NULL)
        return NULL;

    tmp = octstr_format("%ld", tag);

    if (smsc_id != NULL) {
        tmp_dict = dict_get(tlvs_by_tag, smsc_id);
        if (tmp_dict != NULL)
            res = dict_get(tmp_dict, tmp);
    }
    if (res == NULL) {
        /* try default smsc_id */
        smsc_id = octstr_imm(DEFAULT_SMSC_ID);
        tmp_dict = dict_get(tlvs_by_tag, smsc_id);
        if (tmp_dict != NULL)
            res = dict_get(tmp_dict, tmp);
    }

    octstr_destroy(tmp);

    return res;
}

Variable Documentation

initialized

int initialized

static

Definition at line 89 of file smpp_pdu.c.

Referenced by smpp_pdu_init(), and smpp_pdu_shutdown().

tlvs

List* tlvs

static

Definition at line 88 of file smpp_pdu.c.

Referenced by smpp_pdu_init(), smpp_pdu_shutdown(), and smpp_tlv_add_constant().

tlvs_by_const

Dict* tlvs_by_const

static

Definition at line 87 of file smpp_pdu.c.

Referenced by smpp_pdu_init(), and smpp_tlv_add_constant().

tlvs_by_name

Dict* tlvs_by_name

static

Definition at line 86 of file smpp_pdu.c.

Referenced by smpp_pdu_init(), smpp_pdu_shutdown(), and smpp_tlv_get_by_name().

tlvs_by_tag

Dict* tlvs_by_tag

static

Definition at line 84 of file smpp_pdu.c.

Referenced by smpp_pdu_init(), smpp_pdu_shutdown(), and smpp_tlv_get_by_tag().