smpp_pdu.h File Reference

#include "gwlib/gwlib.h"
#include "gwlib/dict.h"
#include "smpp_pdu.def"

Go to the source code of this file.

Data Structures
struct	SMPP_PDU

Macros
#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)
#define	NULTERMINATED(name, max_octets)
#define	OCTETS(name, field_giving_octets)
#define	PDU(name, id, fields)   name = id,
#define	OPTIONAL_BEGIN
#define	TLV_INTEGER(name, octets)   long name;
#define	TLV_NULTERMINATED(name, max_len)   Octstr *name;
#define	TLV_OCTETS(name, min_len, max_len)   Octstr *name;
#define	OPTIONAL_END   Dict *tlv;
#define	INTEGER(name, octets)   unsigned long name;
#define	NULTERMINATED(name, max_octets)   Octstr *name;
#define	OCTETS(name, field_giving_octets)   Octstr *name;
#define	PDU(name, id, fields)   struct name { fields } name;
#define	GSM_ADDR_TON_UNKNOWN   0x00000000
#define	GSM_ADDR_TON_INTERNATIONAL   0x00000001
#define	GSM_ADDR_TON_NATIONAL   0x00000002
#define	GSM_ADDR_TON_NETWORKSPECIFIC   0x00000003
#define	GSM_ADDR_TON_SUBSCRIBER   0x00000004
#define	GSM_ADDR_TON_ALPHANUMERIC   0x00000005 /* GSM TS 03.38 */
#define	GSM_ADDR_TON_ABBREVIATED   0x00000006
#define	GSM_ADDR_TON_EXTENSION   0x00000007 /* Reserved */
#define	GSM_ADDR_NPI_UNKNOWN   0x00000000
#define	GSM_ADDR_NPI_E164   0x00000001
#define	GSM_ADDR_NPI_X121   0x00000003
#define	GSM_ADDR_NPI_TELEX   0x00000004
#define	GSM_ADDR_NPI_NATIONAL   0x00000008
#define	GSM_ADDR_NPI_PRIVATE   0x00000009
#define	GSM_ADDR_NPI_ERMES   0x0000000A /* ETSI DE/PS 3 01-3 */
#define	GSM_ADDR_NPI_INTERNET   0x0000000E /* SMPP v5.0, sec. 4.7.2, page 113 */
#define	GSM_ADDR_NPI_EXTENSION   0x0000000F /* Reserved */
#define	GSM_ADDR_NPI_WAP_CLIENT_ID   0x00000012 /* SMPP v5.0, sec. 4.7.2, page 113 */
#define	ESM_CLASS_SUBMIT_DEFAULT_SMSC_MODE   0x00000000
#define	ESM_CLASS_SUBMIT_DATAGRAM_MODE   0x00000001
#define	ESM_CLASS_SUBMIT_FORWARD_MODE   0x00000002
#define	ESM_CLASS_SUBMIT_STORE_AND_FORWARD_MODE   0x00000003
#define	ESM_CLASS_SUBMIT_DELIVERY_ACK   0x00000008
#define	ESM_CLASS_SUBMIT_USER_ACK   0x00000010
#define	ESM_CLASS_SUBMIT_UDH_INDICATOR   0x00000040
#define	ESM_CLASS_SUBMIT_RPI   0x00000080
#define	ESM_CLASS_SUBMIT_UDH_AND_RPI   0x000000C0
#define	ESM_CLASS_DELIVER_DEFAULT_TYPE   0x00000000
#define	ESM_CLASS_DELIVER_SMSC_DELIVER_ACK   0x00000004
#define	ESM_CLASS_DELIVER_SME_DELIVER_ACK   0x00000008
#define	ESM_CLASS_DELIVER_SME_MANULAL_ACK   0x00000010
#define	ESM_CLASS_DELIVER_INTERM_DEL_NOTIFICATION   0x00000020
#define	ESM_CLASS_DELIVER_UDH_INDICATOR   0x00000040
#define	ESM_CLASS_DELIVER_RPI   0x00000080
#define	ESM_CLASS_DELIVER_UDH_AND_RPI   0x000000C0

Typedefs
typedef struct SMPP_PDU	SMPP_PDU

Enumerations
enum	{ PDU, PDU }
enum	SMPP_ERROR_MESSAGES {   SMPP_ESME_ROK = 0x00000000, SMPP_ESME_RINVMSGLEN = 0x00000001, SMPP_ESME_RINVCMDLEN = 0x00000002, SMPP_ESME_RINVCMDID = 0x00000003,   SMPP_ESME_RINVBNDSTS = 0x00000004, SMPP_ESME_RALYBND = 0x00000005, SMPP_ESME_RINVPRTFLG = 0x00000006, SMPP_ESME_RINVREGDLVFLG = 0x00000007,   SMPP_ESME_RSYSERR = 0x00000008, SMPP_ESME_RINVSRCADR = 0x0000000A, SMPP_ESME_RINVDSTADR = 0x0000000B, SMPP_ESME_RINVMSGID = 0x0000000C,   SMPP_ESME_RBINDFAIL = 0x0000000D, SMPP_ESME_RINVPASWD = 0x0000000E, SMPP_ESME_RINVSYSID = 0x0000000F, SMPP_ESME_RCANCELFAIL = 0x00000011,   SMPP_ESME_RREPLACEFAIL = 0x00000013, SMPP_ESME_RMSGQFUL = 0x00000014, SMPP_ESME_RINVSERTYP = 0x00000015, SMPP_ESME_RINVNUMDESTS = 0x00000033,   SMPP_ESME_RINVDLNAME = 0x00000034, SMPP_ESME_RINVDESTFLAG = 0x00000040, SMPP_ESME_RINVSUBREP = 0x00000042, SMPP_ESME_RINVESMCLASS = 0x00000043,   SMPP_ESME_RCNTSUBDL = 0x00000044, SMPP_ESME_RSUBMITFAIL = 0x00000045, SMPP_ESME_RINVSRCTON = 0x00000048, SMPP_ESME_RINVSRCNPI = 0x00000049,   SMPP_ESME_RINVDSTTON = 0x00000050, SMPP_ESME_RINVDSTNPI = 0x00000051, SMPP_ESME_RINVSYSTYP = 0x00000053, SMPP_ESME_RINVREPFLAG = 0x00000054,   SMPP_ESME_RINVNUMMSGS = 0x00000055, SMPP_ESME_RTHROTTLED = 0x00000058, SMPP_ESME_RINVSCHED = 0x00000061, SMPP_ESME_RINVEXPIRY = 0x00000062,   SMPP_ESME_RINVDFTMSGID = 0x00000063, SMPP_ESME_RX_T_APPN = 0x00000064, SMPP_ESME_RX_P_APPN = 0x00000065, SMPP_ESME_RX_R_APPN = 0x00000066,   SMPP_ESME_RQUERYFAIL = 0x00000067, SMPP_ESME_RINVTLVSTREAM = 0x000000C0, SMPP_ESME_RTLVNOTALLWD = 0x000000C1, SMPP_ESME_RINVTLVLEN = 0x000000C2,   SMPP_ESME_RMISSINGTLV = 0x000000C3, SMPP_ESME_RINVTLVVAL = 0x000000C4, SMPP_ESME_RDELIVERYFAILURE = 0x000000FE, SMPP_ESME_RUNKNOWNERR = 0x000000FF,   SMPP_ESME_RSERTYPUNAUTH = 0x00000100, SMPP_ESME_RPROHIBITED = 0x00000101, SMPP_ESME_RSERTYPUNAVAIL = 0x00000102, SMPP_ESME_RSERTYPDENIED = 0x00000103,   SMPP_ESME_RINVDCS = 0x00000104, SMPP_ESME_RINVSRCADDRSUBUNIT = 0x00000105, SMPP_ESME_RINVDSTADDRSUBUNIT = 0x00000106, SMPP_ESME_RINVBCASTFREQINT = 0x00000107,   SMPP_ESME_RINVBCASTALIAS_NAME = 0x00000108, SMPP_ESME_RINVBCASTAREAFMT = 0x00000109, SMPP_ESME_RINVNUMBCAST_AREAS = 0x0000010A, SMPP_ESME_RINVBCASTCNTTYPE = 0x0000010B,   SMPP_ESME_RINVBCASTMSGCLASS = 0x0000010C, SMPP_ESME_RBCASTFAIL = 0x0000010D, SMPP_ESME_RBCASTQUERYFAIL = 0x0000010E, SMPP_ESME_RBCASTCANCELFAIL = 0x0000010F,   SMPP_ESME_RINVBCAST_REP = 0x00000110, SMPP_ESME_RINVBCASTSRVGRP = 0x00000111, SMPP_ESME_RINVBCASTCHANIND = 0x00000112 }

Functions
int	smpp_pdu_init (Cfg *cfg)
int	smpp_pdu_shutdown (void)
SMPP_PDU *	smpp_pdu_create (unsigned long type, unsigned long seq_no)
void	smpp_pdu_destroy (SMPP_PDU *pdu)
int	smpp_pdu_is_valid (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)
void	smpp_tlv_add_constant (Octstr *smsc_id, Dict **tlvs)

Macro Definition Documentation

ESM_CLASS_DELIVER_DEFAULT_TYPE

#define ESM_CLASS_DELIVER_DEFAULT_TYPE   0x00000000

Definition at line 146 of file smpp_pdu.h.

ESM_CLASS_DELIVER_INTERM_DEL_NOTIFICATION

#define ESM_CLASS_DELIVER_INTERM_DEL_NOTIFICATION   0x00000020

Definition at line 150 of file smpp_pdu.h.

ESM_CLASS_DELIVER_RPI

#define ESM_CLASS_DELIVER_RPI   0x00000080

Definition at line 152 of file smpp_pdu.h.

ESM_CLASS_DELIVER_SME_DELIVER_ACK

#define ESM_CLASS_DELIVER_SME_DELIVER_ACK   0x00000008

Definition at line 148 of file smpp_pdu.h.

ESM_CLASS_DELIVER_SME_MANULAL_ACK

#define ESM_CLASS_DELIVER_SME_MANULAL_ACK   0x00000010

Definition at line 149 of file smpp_pdu.h.

ESM_CLASS_DELIVER_SMSC_DELIVER_ACK

#define ESM_CLASS_DELIVER_SMSC_DELIVER_ACK   0x00000004

Definition at line 147 of file smpp_pdu.h.

Referenced by msg_to_pdu().

ESM_CLASS_DELIVER_UDH_AND_RPI

#define ESM_CLASS_DELIVER_UDH_AND_RPI   0x000000C0

Definition at line 153 of file smpp_pdu.h.

ESM_CLASS_DELIVER_UDH_INDICATOR

#define ESM_CLASS_DELIVER_UDH_INDICATOR   0x00000040

Definition at line 151 of file smpp_pdu.h.

Referenced by msg_to_pdu().

ESM_CLASS_SUBMIT_DATAGRAM_MODE

#define ESM_CLASS_SUBMIT_DATAGRAM_MODE   0x00000001

Definition at line 137 of file smpp_pdu.h.

ESM_CLASS_SUBMIT_DEFAULT_SMSC_MODE

#define ESM_CLASS_SUBMIT_DEFAULT_SMSC_MODE   0x00000000

Definition at line 136 of file smpp_pdu.h.

ESM_CLASS_SUBMIT_DELIVERY_ACK

#define ESM_CLASS_SUBMIT_DELIVERY_ACK   0x00000008

Definition at line 140 of file smpp_pdu.h.

ESM_CLASS_SUBMIT_FORWARD_MODE

#define ESM_CLASS_SUBMIT_FORWARD_MODE   0x00000002

Definition at line 138 of file smpp_pdu.h.

ESM_CLASS_SUBMIT_RPI

#define ESM_CLASS_SUBMIT_RPI   0x00000080

Definition at line 143 of file smpp_pdu.h.

Referenced by data_sm_to_msg(), msg_to_pdu(), and pdu_to_msg().

ESM_CLASS_SUBMIT_STORE_AND_FORWARD_MODE

#define ESM_CLASS_SUBMIT_STORE_AND_FORWARD_MODE   0x00000003

Definition at line 139 of file smpp_pdu.h.

Referenced by smsc_smpp_create().

ESM_CLASS_SUBMIT_UDH_AND_RPI

#define ESM_CLASS_SUBMIT_UDH_AND_RPI   0x000000C0

Definition at line 144 of file smpp_pdu.h.

ESM_CLASS_SUBMIT_UDH_INDICATOR

#define ESM_CLASS_SUBMIT_UDH_INDICATOR   0x00000040

Definition at line 142 of file smpp_pdu.h.

Referenced by data_sm_to_msg(), handle_mo_dcs(), msg_to_pdu(), and pdu_to_msg().

ESM_CLASS_SUBMIT_USER_ACK

#define ESM_CLASS_SUBMIT_USER_ACK   0x00000010

Definition at line 141 of file smpp_pdu.h.

GSM_ADDR_NPI_E164

#define GSM_ADDR_NPI_E164   0x00000001

Definition at line 123 of file smpp_pdu.h.

GSM_ADDR_NPI_ERMES

#define GSM_ADDR_NPI_ERMES   0x0000000A /* ETSI DE/PS 3 01-3 */

Definition at line 128 of file smpp_pdu.h.

GSM_ADDR_NPI_EXTENSION

#define GSM_ADDR_NPI_EXTENSION   0x0000000F /* Reserved */

Definition at line 130 of file smpp_pdu.h.

GSM_ADDR_NPI_INTERNET

#define GSM_ADDR_NPI_INTERNET   0x0000000E /* SMPP v5.0, sec. 4.7.2, page 113 */

Definition at line 129 of file smpp_pdu.h.

GSM_ADDR_NPI_NATIONAL

#define GSM_ADDR_NPI_NATIONAL   0x00000008

Definition at line 126 of file smpp_pdu.h.

GSM_ADDR_NPI_PRIVATE

#define GSM_ADDR_NPI_PRIVATE   0x00000009

Definition at line 127 of file smpp_pdu.h.

GSM_ADDR_NPI_TELEX

#define GSM_ADDR_NPI_TELEX   0x00000004

Definition at line 125 of file smpp_pdu.h.

GSM_ADDR_NPI_UNKNOWN

#define GSM_ADDR_NPI_UNKNOWN   0x00000000

Definition at line 122 of file smpp_pdu.h.

GSM_ADDR_NPI_WAP_CLIENT_ID

#define GSM_ADDR_NPI_WAP_CLIENT_ID   0x00000012 /* SMPP v5.0, sec. 4.7.2, page 113 */

Definition at line 131 of file smpp_pdu.h.

GSM_ADDR_NPI_X121

#define GSM_ADDR_NPI_X121   0x00000003

Definition at line 124 of file smpp_pdu.h.

GSM_ADDR_TON_ABBREVIATED

#define GSM_ADDR_TON_ABBREVIATED   0x00000006

Definition at line 119 of file smpp_pdu.h.

GSM_ADDR_TON_ALPHANUMERIC

#define GSM_ADDR_TON_ALPHANUMERIC   0x00000005 /* GSM TS 03.38 */

Definition at line 118 of file smpp_pdu.h.

GSM_ADDR_TON_EXTENSION

#define GSM_ADDR_TON_EXTENSION   0x00000007 /* Reserved */

Definition at line 120 of file smpp_pdu.h.

GSM_ADDR_TON_INTERNATIONAL

#define GSM_ADDR_TON_INTERNATIONAL   0x00000001

Definition at line 114 of file smpp_pdu.h.

GSM_ADDR_TON_NATIONAL

#define GSM_ADDR_TON_NATIONAL   0x00000002

Definition at line 115 of file smpp_pdu.h.

GSM_ADDR_TON_NETWORKSPECIFIC

#define GSM_ADDR_TON_NETWORKSPECIFIC   0x00000003

Definition at line 116 of file smpp_pdu.h.

GSM_ADDR_TON_SUBSCRIBER

#define GSM_ADDR_TON_SUBSCRIBER   0x00000004

Definition at line 117 of file smpp_pdu.h.

GSM_ADDR_TON_UNKNOWN

#define GSM_ADDR_TON_UNKNOWN   0x00000000

Definition at line 113 of file smpp_pdu.h.

INTEGER [1/2]

#define INTEGER	(		name,
			octets
	)

Definition at line 99 of file smpp_pdu.h.

INTEGER [2/2]

#define INTEGER	(		name,
			octets
	)		unsigned long name;

Definition at line 99 of file smpp_pdu.h.

NULTERMINATED [1/2]

#define NULTERMINATED	(		name,
			max_octets
	)

Definition at line 100 of file smpp_pdu.h.

NULTERMINATED [2/2]

#define NULTERMINATED	(		name,
			max_octets
	)		Octstr *name;

Definition at line 100 of file smpp_pdu.h.

OCTETS [1/2]

#define OCTETS	(		name,
			field_giving_octets
	)

Definition at line 101 of file smpp_pdu.h.

OCTETS [2/2]

#define OCTETS	(		name,
			field_giving_octets
	)		Octstr *name;

Definition at line 101 of file smpp_pdu.h.

OPTIONAL_BEGIN [1/2]

#define OPTIONAL_BEGIN

Definition at line 94 of file smpp_pdu.h.

OPTIONAL_BEGIN [2/2]

#define OPTIONAL_BEGIN

Definition at line 94 of file smpp_pdu.h.

OPTIONAL_END [1/2]

#define OPTIONAL_END

Definition at line 98 of file smpp_pdu.h.

OPTIONAL_END [2/2]

#define OPTIONAL_END   Dict *tlv;

Definition at line 98 of file smpp_pdu.h.

PDU [1/2]

#define PDU	(		name,
			id,
			fields
	)		name = id,

Definition at line 102 of file smpp_pdu.h.

PDU [2/2]

#define PDU	(		name,
			id,
			fields
	)		struct name { fields } name;

Definition at line 102 of file smpp_pdu.h.

TLV_INTEGER [1/2]

#define TLV_INTEGER	(		name,
			max_len
	)

Definition at line 95 of file smpp_pdu.h.

TLV_INTEGER [2/2]

#define TLV_INTEGER	(		name,
			octets
	)		long name;

Definition at line 95 of file smpp_pdu.h.

TLV_NULTERMINATED [1/2]

#define TLV_NULTERMINATED	(		name,
			max_len
	)

Definition at line 96 of file smpp_pdu.h.

TLV_NULTERMINATED [2/2]

#define TLV_NULTERMINATED	(		name,
			max_len
	)		Octstr *name;

Definition at line 96 of file smpp_pdu.h.

TLV_OCTETS [1/2]

#define TLV_OCTETS	(		name,
			min_len,
			max_len
	)

Definition at line 97 of file smpp_pdu.h.

TLV_OCTETS [2/2]

#define TLV_OCTETS	(		name,
			min_len,
			max_len
	)		Octstr *name;

Definition at line 97 of file smpp_pdu.h.

Typedef Documentation

SMPP_PDU

typedef struct SMPP_PDU SMPP_PDU

Definition at line 89 of file smpp_pdu.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
PDU
PDU

Definition at line 74 of file smpp_pdu.h.

     {
    #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)
    #define NULTERMINATED(name, max_octets)
    #define OCTETS(name, field_giving_octets)
    #define PDU(name, id, fields) name = id,
    #include "smpp_pdu.def"
    SMPP_PDU_DUMMY_TYPE
};

SMPP_ERROR_MESSAGES

enum SMPP_ERROR_MESSAGES

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

Definition at line 159 of file smpp_pdu.h.

                         {
    SMPP_ESME_ROK = 0x00000000,
    SMPP_ESME_RINVMSGLEN = 0x00000001,
    SMPP_ESME_RINVCMDLEN = 0x00000002,
    SMPP_ESME_RINVCMDID = 0x00000003,
    SMPP_ESME_RINVBNDSTS = 0x00000004,
    SMPP_ESME_RALYBND = 0x00000005,
    SMPP_ESME_RINVPRTFLG = 0x00000006,
    SMPP_ESME_RINVREGDLVFLG = 0x00000007,
    SMPP_ESME_RSYSERR = 0x00000008,
    SMPP_ESME_RINVSRCADR = 0x0000000A,
    SMPP_ESME_RINVDSTADR = 0x0000000B,
    SMPP_ESME_RINVMSGID = 0x0000000C,
    SMPP_ESME_RBINDFAIL = 0x0000000D,
    SMPP_ESME_RINVPASWD = 0x0000000E,
    SMPP_ESME_RINVSYSID = 0x0000000F,
    SMPP_ESME_RCANCELFAIL = 0x00000011,
    SMPP_ESME_RREPLACEFAIL = 0x00000013,
    SMPP_ESME_RMSGQFUL   = 0x00000014,
    SMPP_ESME_RINVSERTYP = 0x00000015,
    SMPP_ESME_RINVNUMDESTS = 0x00000033,
    SMPP_ESME_RINVDLNAME = 0x00000034,
    SMPP_ESME_RINVDESTFLAG = 0x00000040,
    SMPP_ESME_RINVSUBREP = 0x00000042,
    SMPP_ESME_RINVESMCLASS = 0x00000043,
    SMPP_ESME_RCNTSUBDL = 0x00000044,
    SMPP_ESME_RSUBMITFAIL = 0x00000045,
    SMPP_ESME_RINVSRCTON = 0x00000048,
    SMPP_ESME_RINVSRCNPI = 0x00000049,
    SMPP_ESME_RINVDSTTON = 0x00000050,
    SMPP_ESME_RINVDSTNPI = 0x00000051,
    SMPP_ESME_RINVSYSTYP = 0x00000053,
    SMPP_ESME_RINVREPFLAG = 0x00000054,
    SMPP_ESME_RINVNUMMSGS = 0x00000055,
    SMPP_ESME_RTHROTTLED = 0x00000058,
    SMPP_ESME_RINVSCHED = 0x00000061,
    SMPP_ESME_RINVEXPIRY = 0x00000062,
    SMPP_ESME_RINVDFTMSGID = 0x00000063,
    SMPP_ESME_RX_T_APPN = 0x00000064,
    SMPP_ESME_RX_P_APPN = 0x00000065,
    SMPP_ESME_RX_R_APPN = 0x00000066,
    SMPP_ESME_RQUERYFAIL = 0x00000067,
    SMPP_ESME_RINVTLVSTREAM = 0x000000C0,
    SMPP_ESME_RTLVNOTALLWD = 0x000000C1,
    SMPP_ESME_RINVTLVLEN = 0x000000C2,
    SMPP_ESME_RMISSINGTLV = 0x000000C3,
    SMPP_ESME_RINVTLVVAL = 0x000000C4,
    SMPP_ESME_RDELIVERYFAILURE = 0x000000FE,
    SMPP_ESME_RUNKNOWNERR = 0x000000FF,
    SMPP_ESME_RSERTYPUNAUTH = 0x00000100,
    SMPP_ESME_RPROHIBITED = 0x00000101,
    SMPP_ESME_RSERTYPUNAVAIL = 0x00000102,
    SMPP_ESME_RSERTYPDENIED = 0x00000103,
    SMPP_ESME_RINVDCS = 0x00000104,
    SMPP_ESME_RINVSRCADDRSUBUNIT = 0x00000105,
    SMPP_ESME_RINVDSTADDRSUBUNIT = 0x00000106,
    SMPP_ESME_RINVBCASTFREQINT = 0x00000107,
    SMPP_ESME_RINVBCASTALIAS_NAME = 0x00000108,
    SMPP_ESME_RINVBCASTAREAFMT = 0x00000109,
    SMPP_ESME_RINVNUMBCAST_AREAS = 0x0000010A,
    SMPP_ESME_RINVBCASTCNTTYPE = 0x0000010B,
    SMPP_ESME_RINVBCASTMSGCLASS = 0x0000010C,
    SMPP_ESME_RBCASTFAIL = 0x0000010D,
    SMPP_ESME_RBCASTQUERYFAIL = 0x0000010E,
    SMPP_ESME_RBCASTCANCELFAIL = 0x0000010F,
    SMPP_ESME_RINVBCAST_REP = 0x00000110,
    SMPP_ESME_RINVBCASTSRVGRP = 0x00000111,
    SMPP_ESME_RINVBCASTCHANIND = 0x00000112,
};

Function Documentation

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_is_valid()

int smpp_pdu_is_valid

(

SMPP_PDU *

pdu

)

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