smsc_smpp.c

gnu的专业网关smpp协议支持源代码。

/* 
 * smsc_smpp.c - SMPP v3.3 and v3.4 implementation 
 * 
 * Lars Wirzenius 
 */ 
  
/* XXX check SMSCConn conformance */ 
/* XXX UDH reception */ 
/* XXX check UDH sending fields esm_class and data_coding from GSM specs */ 
/* XXX charset conversions on incoming messages (didn't work earlier,  
       either) */ 
/* XXX numbering plans and type of number: check spec */ 
  
#include "gwlib/gwlib.h" 
#include "msg.h" 
#include "smsc_p.h" 
#include "smpp_pdu.h" 
#include "smscconn_p.h" 
#include "bb_smscconn_cb.h" 
#include "sms.h" 
#include "dlr.h" 
 
/* 
 * Select these based on whether you want to dump SMPP PDUs as they are  
 * sent and received or not. Not dumping should be the default in at least 
 * stable releases. 
 */ 

#define DEBUG 1

#ifndef DEBUG 
/* This version doesn't dump. */ 
static void dump_pdu(const char *msg, Octstr *id, SMPP_PDU *pdu) 
{ 
} 
#else 
/* This version does dump. */ 
static void dump_pdu(const char *msg, Octstr *id, SMPP_PDU *pdu) 
{ 
    debug("bb.sms.smpp", 0, "SMPP[%s]: %s", 
          octstr_get_cstr(id), msg); 
    smpp_pdu_dump(pdu); 
} 
#endif 
 
 
/*  
 * Some defaults.
 */ 
 
#define SMPP_ENQUIRE_LINK_INTERVAL  30.0 
#define SMPP_MAX_PENDING_SUBMITS    10 
#define SMPP_RECONNECT_DELAY	    10.0 
#define SMPP_DEFAULT_VERSION        0x34
#define SMPP_DEFAULT_PRIORITY       0
#define SMPP_THROTTLING_SLEEP_TIME  15


/*
 * Some SMPP error messages we come across
 */

enum {
    SMPP_ESME_RMSGQFUL   = 0x00000014,
    SMPP_ESME_RTHROTTLED = 0x00000058
} SMPP_ERROR_MESSAGES;
 
 
/*********************************************************************** 
 * Implementation of the actual SMPP protocol: reading and writing 
 * PDUs in the correct order. 
 */ 
 
 
typedef struct { 
    long transmitter; 
    long receiver; 
    List *msgs_to_send; 
    Dict *sent_msgs; 
    List *received_msgs; 
    Counter *message_id_counter; 
    Octstr *host; 
    Octstr *system_type; 
    Octstr *username; 
    Octstr *password; 
    Octstr *address_range; 
    Octstr *our_host; 
    Octstr *my_number; 
    int source_addr_ton; 
    int source_addr_npi; 
    int dest_addr_ton; 
    int dest_addr_npi;
    int alt_dcs;
    int transmit_port; 
    int receive_port; 
    int quitting; 
    long enquire_link_interval;
    long max_pending_submits;
    long reconnect_delay;
    int version;
    int priority;       /* set default priority for messages */    
    time_t throttling_err_time;
    int smpp_msg_id_type;  /* msg id in C string, hex or decimal */
    int autodetect_addr;
    SMSCConn *conn; 
} SMPP; 
 
 
static SMPP *smpp_create(SMSCConn *conn, Octstr *host, int transmit_port,  
    	    	    	 int receive_port, Octstr *system_type,  
                         Octstr *username, Octstr *password, 
    	    	    	 Octstr *address_range, Octstr *our_host,  
                         int source_addr_ton, int source_addr_npi,  
                         int dest_addr_ton, int dest_addr_npi, 
                         int alt_dcs, int enquire_link_interval, 
                         int max_pending_submits, int reconnect_delay,
                         int version, int priority, Octstr *my_number,
                         int smpp_msg_id_type, int autodetect_addr) 
{ 
    SMPP *smpp; 
     
    smpp = gw_malloc(sizeof(*smpp)); 
    smpp->transmitter = -1; 
    smpp->receiver = -1; 
    smpp->msgs_to_send = list_create(); 
    smpp->sent_msgs = dict_create(16, NULL); 
    list_add_producer(smpp->msgs_to_send); 
    smpp->received_msgs = list_create(); 
    smpp->message_id_counter = counter_create(); 
    smpp->host = octstr_duplicate(host); 
    smpp->system_type = octstr_duplicate(system_type); 
    smpp->username = octstr_duplicate(username); 
    smpp->password = octstr_duplicate(password); 
    smpp->address_range = octstr_duplicate(address_range); 
    smpp->source_addr_ton = source_addr_ton; 
    smpp->source_addr_npi = source_addr_npi; 
    smpp->dest_addr_ton = dest_addr_ton; 
    smpp->dest_addr_npi = dest_addr_npi; 
    smpp->alt_dcs = alt_dcs;
    smpp->our_host = octstr_duplicate(our_host); 
    smpp->my_number = octstr_duplicate(my_number); 
    smpp->transmit_port = transmit_port; 
    smpp->receive_port = receive_port; 
    smpp->enquire_link_interval = enquire_link_interval;
    smpp->max_pending_submits = max_pending_submits; 
    smpp->reconnect_delay = reconnect_delay;
    smpp->quitting = 0; 
    smpp->version = version;
    smpp->priority = priority;
    smpp->conn = conn; 
    smpp->throttling_err_time = 0; 
    smpp->smpp_msg_id_type = smpp_msg_id_type;    
    smpp->autodetect_addr = autodetect_addr;
 
    return smpp; 
} 
 
 
static void smpp_destroy(SMPP *smpp) 
{ 
    if (smpp != NULL) { 
	list_destroy(smpp->msgs_to_send, msg_destroy_item); 
	dict_destroy(smpp->sent_msgs); 
	list_destroy(smpp->received_msgs, msg_destroy_item); 
	counter_destroy(smpp->message_id_counter); 
	octstr_destroy(smpp->host); 
	octstr_destroy(smpp->username); 
	octstr_destroy(smpp->password); 
	octstr_destroy(smpp->system_type); 
	octstr_destroy(smpp->address_range); 
	octstr_destroy(smpp->our_host); 
	gw_free(smpp); 
    } 
} 
 
 
/* 
 * Try to read an SMPP PDU from a Connection. Return -1 for error (caller 
 * should close the connection), 0 for no PDU to ready yet, or 1 for PDU 
 * read and unpacked. Return a pointer to the PDU in `*pdu'. Use `*len' 
 * to store the length of the PDU to read (it may be possible to read the 
 * length, but not the rest of the PDU - we need to remember the lenght 
 * for the next call). `*len' should be zero at the first call. 
 */ 
static int read_pdu(SMPP *smpp, Connection *conn, long *len, SMPP_PDU **pdu) 
{ 
    Octstr *os; 
 
    if (*len == 0) { 
        *len = smpp_pdu_read_len(conn); 
        if (*len == -1) { 
            error(0, "SMPP[%s]: Server sent garbage, ignored.",
                  octstr_get_cstr(smpp->conn->id)); 
            return -1; 
        } else if (*len == 0) { 
            if (conn_eof(conn) || conn_read_error(conn)) 
                return -1; 
            return 0; 
        } 
    } 
     
    os = smpp_pdu_read_data(conn, *len); 
    if (os == NULL) { 
        if (conn_eof(conn) || conn_read_error(conn)) 
            return -1; 
        return 0; 
    } 
    *len = 0; 
     
    *pdu = smpp_pdu_unpack(os); 
    if (*pdu == NULL) { 
        error(0, "SMPP[%s]: PDU unpacking failed.",
              octstr_get_cstr(smpp->conn->id)); 
        debug("bb.sms.smpp", 0, "SMPP[%s]: Failed PDU follows.",
              octstr_get_cstr(smpp->conn->id)); 
        octstr_dump(os, 0); 
        octstr_destroy(os); 
        return -1; 
    } 
     
    octstr_destroy(os); 
    return 1; 
} 
 
 
static Msg *pdu_to_msg(SMPP_PDU *pdu) 
{ 
    Msg *msg; 
 
    gw_assert(pdu->type == deliver_sm); 
     
    msg = msg_create(sms); 
    msg->sms.sender = pdu->u.deliver_sm.source_addr; 
    pdu->u.deliver_sm.source_addr = NULL; 
    msg->sms.receiver = pdu->u.deliver_sm.destination_addr; 
    pdu->u.deliver_sm.destination_addr = NULL; 
    msg->sms.msgdata = pdu->u.deliver_sm.short_message; 
    pdu->u.deliver_sm.short_message = NULL; 
    charset_gsm_to_latin1(msg->sms.msgdata); 
    msg->sms.pid = pdu->u.deliver_sm.protocol_id; 
    dcs_to_fields(&msg, pdu->u.deliver_sm.data_coding); 
 
    return msg; 
} 
 
 
static long smpp_status_to_smscconn_failure_reason(long status) 
{ 
    switch(status) {
        case SMPP_ESME_RMSGQFUL:
            return SMSCCONN_FAILED_TEMPORARILY;
            break;

        case SMPP_ESME_RTHROTTLED:
            return SMSCCONN_FAILED_TEMPORARILY; 
            break;

        default:
            return SMSCCONN_FAILED_REJECTED; 
    }
} 
 
 
static SMPP_PDU *msg_to_pdu(SMPP *smpp, Msg *msg) 
{ 
    SMPP_PDU *pdu; 
    Octstr *buffer;
    Octstr *relation_UTC_time = NULL;
    struct tm gmtime, localtime, tm;
    int gwqdiff;

    pdu = smpp_pdu_create(submit_sm,  
    	    	    	  counter_increase(smpp->message_id_counter)); 
    	    	    
    pdu->u.submit_sm.source_addr = octstr_duplicate(msg->sms.sender); 
    pdu->u.submit_sm.destination_addr = octstr_duplicate(msg->sms.receiver); 
  
    /* Check for manual override of source ton and npi values */ 
    if(smpp->source_addr_ton > -1 && smpp->source_addr_npi > -1) { 
        pdu->u.submit_sm.source_addr_ton = smpp->source_addr_ton; 
        pdu->u.submit_sm.source_addr_npi = smpp->source_addr_npi; 
        debug("bb.sms.smpp", 0, "SMPP[%s]: Manually forced source addr ton = %d, source add npi = %d", 
              octstr_get_cstr(smpp->conn->id), smpp->source_addr_ton, 
              smpp->source_addr_npi); 
    } else { 
        /* setup default values */ 
        pdu->u.submit_sm.source_addr_ton = GSM_ADDR_TON_NATIONAL; /* national */ 
        pdu->u.submit_sm.source_addr_npi = GSM_ADDR_NPI_E164; /* ISDN number plan */ 
    }

    if (smpp->autodetect_addr) {
        /* lets see if its international or alphanumeric sender */ 
        if (octstr_get_char(pdu->u.submit_sm.source_addr,0) == '+') { 
            if (!octstr_check_range(pdu->u.submit_sm.source_addr, 1, 256, gw_isdigit)) { 
                pdu->u.submit_sm.source_addr_ton = GSM_ADDR_TON_ALPHANUMERIC; /* alphanum */ 
                pdu->u.submit_sm.source_addr_npi = GSM_ADDR_NPI_UNKNOWN;    /* short code */ 
            } else { 
               /* numeric sender address with + in front -> international (remove the +) */ 
               octstr_delete(pdu->u.submit_sm.source_addr, 0, 1); 
               pdu->u.submit_sm.source_addr_ton = GSM_ADDR_TON_INTERNATIONAL; 
    	    } 
        } else { 
            if (!octstr_check_range(pdu->u.submit_sm.source_addr,0, 256, gw_isdigit)) { 
                pdu->u.submit_sm.source_addr_ton = GSM_ADDR_TON_ALPHANUMERIC; 
                pdu->u.submit_sm.source_addr_npi = GSM_ADDR_NPI_UNKNOWN; 
            } 
        } 
    } 
 
    /* Check for manual override of destination ton and npi values */ 
    if (smpp->dest_addr_ton > -1 && smpp->dest_addr_npi > -1) { 
        pdu->u.submit_sm.dest_addr_ton = smpp->dest_addr_ton; 
        pdu->u.submit_sm.dest_addr_npi = smpp->dest_addr_npi; 
        debug("bb.sms.smpp", 0, "SMPP[%s]: Manually forced dest addr ton = %d, source add npi = %d", 
              octstr_get_cstr(smpp->conn->id), smpp->dest_addr_ton, 
              smpp->dest_addr_npi); 
    } else { 
        pdu->u.submit_sm.dest_addr_ton = GSM_ADDR_TON_NATIONAL; /* national */ 
        pdu->u.submit_sm.dest_addr_npi = GSM_ADDR_NPI_E164; /* ISDN number plan */ 
    } 
 
    /* 
     * if its a international number starting with +, lets remove the 
     * '+' and set number type to international instead  
     */ 
    if (octstr_get_char(pdu->u.submit_sm.destination_addr,0) == '+') {