开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > 手机WAP编程 > 查看源码
smsc_smpp.c
资源名称：gateway-1.2.1　[点击查看]
上传用户：gzpyjq
上传日期：2013-01-31
资源大小：1852k
文件大小：45k
源码类别：

手机WAP编程

开发平台：

WINDOWS

smsc_smpp.c：源码内容
  1. /* 
  2.  * smsc_smpp.c - SMPP v3.3 and v3.4 implementation 
  3.  * 
  4.  * Lars Wirzenius 
  5.  */ 
  6.   
  7. /* XXX check SMSCConn conformance */ 
  8. /* XXX UDH reception */ 
  9. /* XXX check UDH sending fields esm_class and data_coding from GSM specs */ 
  10. /* XXX charset conversions on incoming messages (didn't work earlier,  
  11.        either) */ 
  12. /* XXX numbering plans and type of number: check spec */ 
  13.   
  14. #include "gwlib/gwlib.h" 
  15. #include "msg.h" 
  16. #include "smsc_p.h" 
  17. #include "smpp_pdu.h" 
  18. #include "smscconn_p.h" 
  19. #include "bb_smscconn_cb.h" 
  20. #include "sms.h" 
  21. #include "dlr.h" 
  22.  
  23. /* 
  24.  * Select these based on whether you want to dump SMPP PDUs as they are  
  25.  * sent and received or not. Not dumping should be the default in at least 
  26.  * stable releases. 
  27.  */ 
  29. #define DEBUG 1
  31. #ifndef DEBUG 
  32. /* This version doesn't dump. */ 
  33. static void dump_pdu(const char *msg, Octstr *id, SMPP_PDU *pdu) 
  34. { 
  35. } 
  36. #else 
  37. /* This version does dump. */ 
  38. static void dump_pdu(const char *msg, Octstr *id, SMPP_PDU *pdu) 
  39. { 
  40.     debug("bb.sms.smpp", 0, "SMPP[%s]: %s", 
  41.           octstr_get_cstr(id), msg); 
  42.     smpp_pdu_dump(pdu); 
  43. } 
  44. #endif 
  45.  
  46.  
  47. /*  
  48.  * Some defaults.
  49.  */ 
  50.  
  51. #define SMPP_ENQUIRE_LINK_INTERVAL  30.0 
  52. #define SMPP_MAX_PENDING_SUBMITS    10 
  53. #define SMPP_RECONNECT_DELAY     10.0 
  54. #define SMPP_DEFAULT_VERSION        0x34
  55. #define SMPP_DEFAULT_PRIORITY       0
  56. #define SMPP_THROTTLING_SLEEP_TIME  15
  59. /*
  60.  * Some SMPP error messages we come across
  61.  */
  63. enum {
  64.     SMPP_ESME_RMSGQFUL   = 0x00000014,
  65.     SMPP_ESME_RTHROTTLED = 0x00000058
  66. } SMPP_ERROR_MESSAGES;
  67.  
  68.  
  69. /*********************************************************************** 
  70.  * Implementation of the actual SMPP protocol: reading and writing 
  71.  * PDUs in the correct order. 
  72.  */ 
  73.  
  74.  
  75. typedef struct { 
  76.     long transmitter; 
  77.     long receiver; 
  78.     List *msgs_to_send; 
  79.     Dict *sent_msgs; 
  80.     List *received_msgs; 
  81.     Counter *message_id_counter; 
  82.     Octstr *host; 
  83.     Octstr *system_type; 
  84.     Octstr *username; 
  85.     Octstr *password; 
  86.     Octstr *address_range; 
  87.     Octstr *our_host; 
  88.     Octstr *my_number; 
  89.     int source_addr_ton; 
  90.     int source_addr_npi; 
  91.     int dest_addr_ton; 
  92.     int dest_addr_npi;
  93.     int alt_dcs;
  94.     int transmit_port; 
  95.     int receive_port; 
  96.     int quitting; 
  97.     long enquire_link_interval;
  98.     long max_pending_submits;
  99.     long reconnect_delay;
  100.     int version;
  101.     int priority;       /* set default priority for messages */    
  102.     time_t throttling_err_time;
  103.     int smpp_msg_id_type;  /* msg id in C string, hex or decimal */
  104.     int autodetect_addr;
  105.     SMSCConn *conn; 
  106. } SMPP; 
  107.  
  108.  
  109. static SMPP *smpp_create(SMSCConn *conn, Octstr *host, int transmit_port,  
  110.                 int receive_port, Octstr *system_type,  
  111.                          Octstr *username, Octstr *password, 
  112.                 Octstr *address_range, Octstr *our_host,  
  113.                          int source_addr_ton, int source_addr_npi,  
  114.                          int dest_addr_ton, int dest_addr_npi, 
  115.                          int alt_dcs, int enquire_link_interval, 
  116.                          int max_pending_submits, int reconnect_delay,
  117.                          int version, int priority, Octstr *my_number,
  118.                          int smpp_msg_id_type, int autodetect_addr) 
  119. { 
  120.     SMPP *smpp; 
  121.      
  122.     smpp = gw_malloc(sizeof(*smpp)); 
  123.     smpp->transmitter = -1; 
  124.     smpp->receiver = -1; 
  125.     smpp->msgs_to_send = list_create(); 
  126.     smpp->sent_msgs = dict_create(16, NULL); 
  127.     list_add_producer(smpp->msgs_to_send); 
  128.     smpp->received_msgs = list_create(); 
  129.     smpp->message_id_counter = counter_create(); 
  130.     smpp->host = octstr_duplicate(host); 
  131.     smpp->system_type = octstr_duplicate(system_type); 
  132.     smpp->username = octstr_duplicate(username); 
  133.     smpp->password = octstr_duplicate(password); 
  134.     smpp->address_range = octstr_duplicate(address_range); 
  135.     smpp->source_addr_ton = source_addr_ton; 
  136.     smpp->source_addr_npi = source_addr_npi; 
  137.     smpp->dest_addr_ton = dest_addr_ton; 
  138.     smpp->dest_addr_npi = dest_addr_npi; 
  139.     smpp->alt_dcs = alt_dcs;
  140.     smpp->our_host = octstr_duplicate(our_host); 
  141.     smpp->my_number = octstr_duplicate(my_number); 
  142.     smpp->transmit_port = transmit_port; 
  143.     smpp->receive_port = receive_port; 
  144.     smpp->enquire_link_interval = enquire_link_interval;
  145.     smpp->max_pending_submits = max_pending_submits; 
  146.     smpp->reconnect_delay = reconnect_delay;
  147.     smpp->quitting = 0; 
  148.     smpp->version = version;
  149.     smpp->priority = priority;
  150.     smpp->conn = conn; 
  151.     smpp->throttling_err_time = 0; 
  152.     smpp->smpp_msg_id_type = smpp_msg_id_type;    
  153.     smpp->autodetect_addr = autodetect_addr;
  154.  
  155.     return smpp; 
  156. } 
  157.  
  158.  
  159. static void smpp_destroy(SMPP *smpp) 
  160. { 
  161.     if (smpp != NULL) { 
  162. list_destroy(smpp->msgs_to_send, msg_destroy_item); 
  163. dict_destroy(smpp->sent_msgs); 
  164. list_destroy(smpp->received_msgs, msg_destroy_item); 
  165. counter_destroy(smpp->message_id_counter); 
  166. octstr_destroy(smpp->host); 
  167. octstr_destroy(smpp->username); 
  168. octstr_destroy(smpp->password); 
  169. octstr_destroy(smpp->system_type); 
  170. octstr_destroy(smpp->address_range); 
  171. octstr_destroy(smpp->our_host); 
  172. gw_free(smpp); 
  173.     } 
  174. } 
  175.  
  176.  
  177. /* 
  178.  * Try to read an SMPP PDU from a Connection. Return -1 for error (caller 
  179.  * should close the connection), 0 for no PDU to ready yet, or 1 for PDU 
  180.  * read and unpacked. Return a pointer to the PDU in `*pdu'. Use `*len' 
  181.  * to store the length of the PDU to read (it may be possible to read the 
  182.  * length, but not the rest of the PDU - we need to remember the lenght 
  183.  * for the next call). `*len' should be zero at the first call. 
  184.  */ 
  185. static int read_pdu(SMPP *smpp, Connection *conn, long *len, SMPP_PDU **pdu) 
  186. { 
  187.     Octstr *os; 
  188.  
  189.     if (*len == 0) { 
  190.         *len = smpp_pdu_read_len(conn); 
  191.         if (*len == -1) { 
  192.             error(0, "SMPP[%s]: Server sent garbage, ignored.",
  193.                   octstr_get_cstr(smpp->conn->id)); 
  194.             return -1; 
  195.         } else if (*len == 0) { 
  196.             if (conn_eof(conn) || conn_read_error(conn)) 
  197.                 return -1; 
  198.             return 0; 
  199.         } 
  200.     } 
  201.      
  202.     os = smpp_pdu_read_data(conn, *len); 
  203.     if (os == NULL) { 
  204.         if (conn_eof(conn) || conn_read_error(conn)) 
  205.             return -1; 
  206.         return 0; 
  207.     } 
  208.     *len = 0; 
  209.      
  210.     *pdu = smpp_pdu_unpack(os); 
  211.     if (*pdu == NULL) { 
  212.         error(0, "SMPP[%s]: PDU unpacking failed.",
  213.               octstr_get_cstr(smpp->conn->id)); 
  214.         debug("bb.sms.smpp", 0, "SMPP[%s]: Failed PDU follows.",
  215.               octstr_get_cstr(smpp->conn->id)); 
  216.         octstr_dump(os, 0); 
  217.         octstr_destroy(os); 
  218.         return -1; 
  219.     } 
  220.      
  221.     octstr_destroy(os); 
  222.     return 1; 
  223. } 
  224.  
  225.  
  226. static Msg *pdu_to_msg(SMPP_PDU *pdu) 
  227. { 
  228.     Msg *msg; 
  229.  
  230.     gw_assert(pdu->type == deliver_sm); 
  231.      
  232.     msg = msg_create(sms); 
  233.     msg->sms.sender = pdu->u.deliver_sm.source_addr; 
  234.     pdu->u.deliver_sm.source_addr = NULL; 
  235.     msg->sms.receiver = pdu->u.deliver_sm.destination_addr; 
  236.     pdu->u.deliver_sm.destination_addr = NULL; 
  237.     msg->sms.msgdata = pdu->u.deliver_sm.short_message; 
  238.     pdu->u.deliver_sm.short_message = NULL; 
  239.     charset_gsm_to_latin1(msg->sms.msgdata); 
  240.     msg->sms.pid = pdu->u.deliver_sm.protocol_id; 
  241.     dcs_to_fields(&msg, pdu->u.deliver_sm.data_coding); 
  242.  
  243.     return msg; 
  244. } 
  245.  
  246.  
  247. static long smpp_status_to_smscconn_failure_reason(long status) 
  248. { 
  249.     switch(status) {
  250.         case SMPP_ESME_RMSGQFUL:
  251.             return SMSCCONN_FAILED_TEMPORARILY;
  252.             break;
  254.         case SMPP_ESME_RTHROTTLED:
  255.             return SMSCCONN_FAILED_TEMPORARILY; 
  256.             break;
  258.         default:
  259.             return SMSCCONN_FAILED_REJECTED; 
  260.     }
  261. } 
  262.  
  263.  
  264. static SMPP_PDU *msg_to_pdu(SMPP *smpp, Msg *msg) 
  265. { 
  266.     SMPP_PDU *pdu; 
  267.     Octstr *buffer;
  268.     Octstr *relation_UTC_time = NULL;
  269.     struct tm gmtime, localtime, tm;
  270.     int gwqdiff;
  272.     pdu = smpp_pdu_create(submit_sm,  
  273.                  counter_increase(smpp->message_id_counter)); 
  274.               
  275.     pdu->u.submit_sm.source_addr = octstr_duplicate(msg->sms.sender); 
  276.     pdu->u.submit_sm.destination_addr = octstr_duplicate(msg->sms.receiver); 
  277.   
  278.     /* Check for manual override of source ton and npi values */ 
  279.     if(smpp->source_addr_ton > -1 && smpp->source_addr_npi > -1) { 
  280.         pdu->u.submit_sm.source_addr_ton = smpp->source_addr_ton; 
  281.         pdu->u.submit_sm.source_addr_npi = smpp->source_addr_npi; 
  282.         debug("bb.sms.smpp", 0, "SMPP[%s]: Manually forced source addr ton = %d, source add npi = %d", 
  283.               octstr_get_cstr(smpp->conn->id), smpp->source_addr_ton, 
  284.               smpp->source_addr_npi); 
  285.     } else { 
  286.         /* setup default values */ 
  287.         pdu->u.submit_sm.source_addr_ton = GSM_ADDR_TON_NATIONAL; /* national */ 
  288.         pdu->u.submit_sm.source_addr_npi = GSM_ADDR_NPI_E164; /* ISDN number plan */ 
  289.     }
  291.     if (smpp->autodetect_addr) {
  292.         /* lets see if its international or alphanumeric sender */ 
  293.         if (octstr_get_char(pdu->u.submit_sm.source_addr,0) == '+') { 
  294.             if (!octstr_check_range(pdu->u.submit_sm.source_addr, 1, 256, gw_isdigit)) { 
  295.                 pdu->u.submit_sm.source_addr_ton = GSM_ADDR_TON_ALPHANUMERIC; /* alphanum */ 
  296.                 pdu->u.submit_sm.source_addr_npi = GSM_ADDR_NPI_UNKNOWN;    /* short code */ 
  297.             } else { 
  298.                /* numeric sender address with + in front -> international (remove the +) */ 
  299.                octstr_delete(pdu->u.submit_sm.source_addr, 0, 1); 
  300.                pdu->u.submit_sm.source_addr_ton = GSM_ADDR_TON_INTERNATIONAL; 
  301.          } 
  302.         } else { 
  303.             if (!octstr_check_range(pdu->u.submit_sm.source_addr,0, 256, gw_isdigit)) { 
  304.                 pdu->u.submit_sm.source_addr_ton = GSM_ADDR_TON_ALPHANUMERIC; 
  305.                 pdu->u.submit_sm.source_addr_npi = GSM_ADDR_NPI_UNKNOWN; 
  306.             } 
  307.         } 
  308.     } 
  309.  
  310.     /* Check for manual override of destination ton and npi values */ 
  311.     if (smpp->dest_addr_ton > -1 && smpp->dest_addr_npi > -1) { 
  312.         pdu->u.submit_sm.dest_addr_ton = smpp->dest_addr_ton; 
  313.         pdu->u.submit_sm.dest_addr_npi = smpp->dest_addr_npi; 
  314.         debug("bb.sms.smpp", 0, "SMPP[%s]: Manually forced dest addr ton = %d, source add npi = %d", 
  315.               octstr_get_cstr(smpp->conn->id), smpp->dest_addr_ton, 
  316.               smpp->dest_addr_npi); 
  317.     } else { 
  318.         pdu->u.submit_sm.dest_addr_ton = GSM_ADDR_TON_NATIONAL; /* national */ 
  319.         pdu->u.submit_sm.dest_addr_npi = GSM_ADDR_NPI_E164; /* ISDN number plan */ 
  320.     } 
  321.  
  322.     /* 
  323.      * if its a international number starting with +, lets remove the 
  324.      * '+' and set number type to international instead  
  325.      */ 
  326.     if (octstr_get_char(pdu->u.submit_sm.destination_addr,0) == '+') { 
  327.         octstr_delete(pdu->u.submit_sm.destination_addr, 0,1); 
  328.         pdu->u.submit_sm.dest_addr_ton = GSM_ADDR_TON_INTERNATIONAL; 
  329.     } 
  330.  
  331.     /* 
  332.      * set the data coding scheme (DCS) field 
  333.      * check if we have a forced value for this from the smsc-group.
  334.      */
  335.     pdu->u.submit_sm.data_coding = fields_to_dcs(msg, (msg->sms.alt_dcs ? 
  336.         2 - msg->sms.alt_dcs : smpp->alt_dcs));
  338.     /* set protocoll id */
  339.     if(msg->sms.pid) 
  340.         pdu->u.submit_sm.protocol_id = msg->sms.pid; 
  342.     /*
  343.      * set the esm_class field
  344.      * default is store and forward, plus udh and rpi if requested
  345.      */
  346.     pdu->u.submit_sm.esm_class = ESM_CLASS_SUBMIT_STORE_AND_FORWARD_MODE;
  347.     if (octstr_len(msg->sms.udhdata)) 
  348.         pdu->u.submit_sm.esm_class = pdu->u.submit_sm.esm_class |
  349.             ESM_CLASS_SUBMIT_UDH_INDICATOR;
  350.     if (msg->sms.rpi) 
  351.         pdu->u.submit_sm.esm_class = pdu->u.submit_sm.esm_class |
  352.             ESM_CLASS_SUBMIT_RPI;
  354.     /*
  355.      * set data segments
  356.      */
  357.     if (octstr_len(msg->sms.udhdata)) { 
  358.         pdu->u.submit_sm.short_message = 
  359.        octstr_format("%S%S", msg->sms.udhdata, msg->sms.msgdata); 
  360.     } else { 
  361.         pdu->u.submit_sm.short_message = octstr_duplicate(msg->sms.msgdata); 
  362.         if (pdu->u.submit_sm.data_coding == 0 ) /* no reencoding for unicode! */ 
  363.             charset_latin1_to_gsm(pdu->u.submit_sm.short_message);  
  364.     } 
  366.     /*
  367.      * check for validity and defered settings
  368.      */
  369.     if (msg->sms.validity || msg->sms.deferred) {
  371.         /* work out 1/4 hour difference between local time and UTC/GMT */
  372.         gmtime = gw_gmtime(time(NULL));
  373.         localtime = gw_localtime(time(NULL));
  374.         gwqdiff = ((localtime.tm_hour - gmtime.tm_hour) * 4)
  375.                   + ((localtime.tm_min - gmtime.tm_min) / 15);
  376.         
  377.         if (gwqdiff >= 0) {
  378.             relation_UTC_time = octstr_create("+");
  379.         } else {
  380.             relation_UTC_time = octstr_create("-");
  381.             gwqdiff *= -1;  /* make absolute */
  382.         }
  384.         if (msg->sms.validity) {
  385.             tm = gw_localtime(time(NULL) + msg->sms.validity * 60);
  386.             buffer = octstr_format("%02d%02d%02d%02d%02d%02d0%02d%1s",
  387.                     tm.tm_year % 100, tm.tm_mon + 1, tm.tm_mday,
  388.                     tm.tm_hour, tm.tm_min, tm.tm_sec,
  389.                     gwqdiff, octstr_get_cstr(relation_UTC_time));
  390.             pdu->u.submit_sm.validity_period = octstr_copy(buffer,0,16);
  391.             octstr_destroy(buffer);
  392.         }
  394.         if (msg->sms.deferred) {
  395.             tm = gw_localtime(time(NULL) + msg->sms.deferred * 60);
  396.             buffer = octstr_format("%02d%02d%02d%02d%02d%02d0%02d%1s",
  397.                     tm.tm_year % 100, tm.tm_mon + 1, tm.tm_mday,
  398.                     tm.tm_hour, tm.tm_min, tm.tm_sec,
  399.                     gwqdiff, octstr_get_cstr(relation_UTC_time));
  400.             pdu->u.submit_sm.schedule_delivery_time = octstr_copy(buffer,0,16);
  401.             octstr_destroy(buffer);
  402.         }
  403.     }
  405.     /* ask for the delivery reports if needed */ 
  406.     if (msg->sms.dlr_mask & (DLR_SUCCESS|DLR_FAIL)) 
  407.         pdu->u.submit_sm.registered_delivery = 1;  
  409.     octstr_destroy(relation_UTC_time);
  411.     /* set priority */
  412.     if (smpp->priority >= 0 && smpp->priority <= 5) {
  413.         pdu->u.submit_sm.priority_flag = smpp->priority;       
  414.     } else {      
  415.         /* default priority is 0 */         
  416.         pdu->u.submit_sm.priority_flag = 0;         
  417.     }              
  419.     return pdu; 
  420. } 
  421.  
  422.  
  423. static void send_enquire_link(SMPP *smpp, Connection *conn, long *last_sent) 
  424. { 
  425.     SMPP_PDU *pdu; 
  426.     Octstr *os; 
  427.  
  428.     if (date_universal_now() - *last_sent < smpp->enquire_link_interval)
  429.         return; 
  430.     *last_sent = date_universal_now(); 
  431.  
  432.     pdu = smpp_pdu_create(enquire_link, counter_increase(smpp->message_id_counter)); 
  433.     dump_pdu("Sending enquire link:", smpp->conn->id, pdu); 
  434.     os = smpp_pdu_pack(pdu); 
  435.     if (os)
  436. conn_write(conn, os); /* Write errors checked by caller. */ 
  437.     octstr_destroy(os); 
  438.     smpp_pdu_destroy(pdu); 
  439. } 
  440.  
  441.  
  442. static void send_unbind(SMPP *smpp, Connection *conn)
  443. {
  444.     SMPP_PDU *pdu;
  445.     Octstr *os;
  446.     pdu = smpp_pdu_create(unbind, counter_increase(smpp->message_id_counter));
  447.     dump_pdu("Sending unbind:", smpp->conn->id, pdu);
  448.     os = smpp_pdu_pack(pdu);
  449.     conn_write(conn, os);
  450.     octstr_destroy(os);
  451.     smpp_pdu_destroy(pdu);
  452. }
  455. static int send_pdu(Connection *conn, Octstr *id, SMPP_PDU *pdu) 
  456. { 
  457.     Octstr *os; 
  458.     int ret; 
  459.      
  460.     dump_pdu("Sending PDU:", id, pdu); 
  461.     os = smpp_pdu_pack(pdu); 
  462.     if (os)
  463.         ret = conn_write(conn, os);   /* Caller checks for write errors later */ 
  464.     else
  465. ret = -1;
  466.     octstr_destroy(os); 
  467.     return ret; 
  468. } 
  469.  
  470.  
  471. static void send_messages(SMPP *smpp, Connection *conn, long *pending_submits) 
  472. { 
  473.     Msg *msg; 
  474.     SMPP_PDU *pdu; 
  475.     Octstr *os; 
  476.  
  477.     if (*pending_submits == -1) 
  478.         return; 
  479.  
  480.     while (*pending_submits < smpp->max_pending_submits) {
  481.      /* Get next message, quit if none to be sent */ 
  482.      msg = list_extract_first(smpp->msgs_to_send); 
  483.         if (msg == NULL) 
  484.             break; 
  485.      
  486.         /* Send PDU, record it as waiting for ack from SMS center */ 
  487.         pdu = msg_to_pdu(smpp, msg); 
  488.         os = octstr_format("%ld", pdu->u.submit_sm.sequence_number); 
  489.         dict_put(smpp->sent_msgs, os, msg); 
  490.         octstr_destroy(os); 
  491.         send_pdu(conn, smpp->conn->id, pdu); 
  492.         smpp_pdu_destroy(pdu); 
  493.  
  494.         ++(*pending_submits); 
  495.     } 
  496. } 
  497.  
  498.  
  499. /* 
  500.  * Open transmission connection to SMS center. Return NULL for error,  
  501.  * open Connection for OK. Caller must set smpp->conn->status correctly  
  502.  * before calling this. 
  503.  */ 
  504. static Connection *open_transmitter(SMPP *smpp) 
  505. { 
  506.     SMPP_PDU *bind; 
  507.     Connection *conn; 
  508.  
  509.     conn = conn_open_tcp(smpp->host, smpp->transmit_port, smpp->our_host ); 
  510.     if (conn == NULL) { 
  511.         error(0, "SMPP[%s]: Couldn't connect to server.",
  512.               octstr_get_cstr(smpp->conn->id)); 
  513.         return NULL; 
  514.     } 
  515.      
  516.     bind = smpp_pdu_create(bind_transmitter, 
  517.                 counter_increase(smpp->message_id_counter)); 
  518.     bind->u.bind_transmitter.system_id = octstr_duplicate(smpp->username); 
  519.     bind->u.bind_transmitter.password = octstr_duplicate(smpp->password); 
  520.     if (smpp->system_type == NULL) 
  521.         bind->u.bind_transmitter.system_type = octstr_create("VMA"); 
  522.     else 
  523.         bind->u.bind_transmitter.system_type =  
  524.        octstr_duplicate(smpp->system_type); 
  525.     bind->u.bind_transmitter.interface_version = smpp->version;
  526.     bind->u.bind_transmitter.address_range =  
  527.      octstr_duplicate(smpp->address_range); 
  528.     send_pdu(conn, smpp->conn->id, bind); 
  529.     smpp_pdu_destroy(bind); 
  530.  
  531.     return conn; 
  532. } 
  533.  
  534.  
  535. /* 
  536.  * Open transceiver connection to SMS center. Return NULL for error, 
  537.  * open Connection for OK. Caller must set smpp->conn->status correctly 
  538.  * before calling this. 
  539.  */ 
  540. static Connection *open_transceiver(SMPP *smpp) 
  541. { 
  542.     SMPP_PDU *bind; 
  543.     Connection *conn; 
  544.      
  545.     conn = conn_open_tcp(smpp->host, smpp->transmit_port, smpp->our_host ); 
  546.     if (conn == NULL) {  
  547.        error(0, "SMPP[%s]: Couldn't connect to server.",
  548.              octstr_get_cstr(smpp->conn->id)); 
  549.        return NULL; 
  550.     } 
  551.  
  552.     bind = smpp_pdu_create(bind_transceiver, 
  553.                            counter_increase(smpp->message_id_counter)); 
  554.     bind->u.bind_transmitter.system_id = octstr_duplicate(smpp->username); 
  555.     bind->u.bind_transmitter.password = octstr_duplicate(smpp->password); 
  556.     if (smpp->system_type == NULL) 
  557.         bind->u.bind_transmitter.system_type = octstr_create("VMA"); 
  558.     else    
  559.         bind->u.bind_transmitter.system_type = octstr_duplicate(smpp->system_type); 
  560.     bind->u.bind_transmitter.interface_version = smpp->version;
  561.     bind->u.bind_transmitter.address_range = octstr_duplicate(smpp->address_range); 
  562.     send_pdu(conn, smpp->conn->id, bind); 
  563.     smpp_pdu_destroy(bind); 
  564.  
  565.     return conn; 
  566. } 
  567.  
  568.  
  569. /* 
  570.  * Open reception connection to SMS center. Return NULL for error,  
  571.  * open Connection for OK. Caller must set smpp->conn->status correctly  
  572.  * before calling this. 
  573.  */ 
  574. static Connection *open_receiver(SMPP *smpp) 
  575. { 
  576.     SMPP_PDU *bind; 
  577.     Connection *conn; 
  578.  
  579.     conn = conn_open_tcp(smpp->host, smpp->receive_port, smpp->our_host ); 
  580.     if (conn == NULL) { 
  581.         error(0, "SMPP[%s]: Couldn't connect to server.",
  582.               octstr_get_cstr(smpp->conn->id)); 
  583.         return NULL; 
  584.     } 
  585.      
  586.     bind = smpp_pdu_create(bind_receiver, 
  587.                 counter_increase(smpp->message_id_counter)); 
  588.     bind->u.bind_receiver.system_id = octstr_duplicate(smpp->username); 
  589.     bind->u.bind_receiver.password = octstr_duplicate(smpp->password); 
  590.     if (smpp->system_type == NULL) 
  591.         bind->u.bind_receiver.system_type = octstr_create("VMA"); 
  592.     else 
  593.         bind->u.bind_receiver.system_type =  
  594.             octstr_duplicate(smpp->system_type); 
  595.     bind->u.bind_receiver.interface_version = smpp->version;
  596.     bind->u.bind_receiver.address_range =  
  597.         octstr_duplicate(smpp->address_range); 
  598.     send_pdu(conn, smpp->conn->id, bind); 
  599.     smpp_pdu_destroy(bind); 
  600.  
  601.     return conn; 
  602. } 
  603.  
  604.  
  605. static void handle_pdu(SMPP *smpp, Connection *conn, SMPP_PDU *pdu,  
  606.                  long *pending_submits) 
  607. { 
  608.     SMPP_PDU *resp; 
  609.     Octstr *os; 
  610.     Msg *msg, *dlrmsg=NULL; 
  611.     long reason; 
  612.     resp = NULL; 
  613.  
  614.     switch (pdu->type) { 
  615.         case deliver_sm: 
  616.         /* XXX UDH */ 
  617.             /* 
  618.              * bb_smscconn_receive can fail, but we ignore that since we 
  619.              * have no way to usefull tell the SMS center about this 
  620.              * (no suitable error code for the deliver_sm_resp is defined) 
  621.              */ 
  623.             /* got a deliver ack (DLR)? */ 
  624.             if ((pdu->u.deliver_sm.esm_class == 0x02 || 
  625.                  pdu->u.deliver_sm.esm_class == 0x04)) { 
  626.                 Octstr *respstr;      
  627.                 Octstr *msgid = NULL; 
  628.                 Octstr *stat = NULL; 
  629.                 int dlrstat; 
  630.                 long curr = 0, vpos = 0; 
  631.        
  632.                 debug("bb.sms.smpp",0,"SMPP[%s] handle_pdu, got DLR",
  633.                       octstr_get_cstr(smpp->conn->id)); 
  634.        
  635.                 respstr = pdu->u.deliver_sm.short_message; 
  636.    
  637.                 /* get server message id */ 
  638.                 if ((curr = octstr_search(respstr, octstr_imm("id:"), 0)) != -1) {    
  639.                     vpos = octstr_search_char(respstr, ' ', curr); 
  640.                     if ((vpos-curr >0) && (vpos != -1)) 
  641.                         msgid = octstr_copy(respstr, curr+3, vpos-curr-3); 
  642.                 } else { 
  643.                     msgid = NULL; 
  644.                 }
  645.     
  646.                 /* get err & status code */ 
  647.                 if ((curr = octstr_search(respstr, octstr_imm("stat:"), 0)) != -1) {   
  648.                     vpos = octstr_search_char(respstr, ' ', curr); 
  649.                     if ((vpos-curr >0) && (vpos != -1)) 
  650.                         stat = octstr_copy(respstr, curr+5, vpos-curr-5); 
  651.                 } else { 
  652.                     stat = NULL; 
  653.                 }
  654.  
  655.                 /* 
  656.                  * we get the following status: 
  657.                  * DELIVRD, ACCEPTD, EXPIRED, DELETED, UNDELIV, UNKNOWN, REJECTD 
  658.                  */ 
  659.    
  660.                 if ((stat != NULL) && ((octstr_compare(stat, octstr_imm("DELIVRD")) == 0) || 
  661.                     (octstr_compare(stat, octstr_imm("ACCEPTD")) == 0))) 
  662.                     dlrstat = DLR_SUCCESS; 
  663.                 else 
  664.                     dlrstat = DLR_FAIL; 
  665.    
  666.                 if (msgid != NULL) { 
  667.                     Octstr *tmp;
  668.                     
  669.                     /* 
  670.                      * Obey which SMPP msg_id type this SMSC is using, where we 
  671.                      * have the following semantics for the variable smpp_msg_id:
  672.                      *
  673.                      * bit 1: type for submit_sm_resp, bit 2: type for deliver_sm 
  674.                      *
  675.                      * if bit is set value is hex otherwise dec
  676.                      *
  677.                      * 0x00 deliver_sm dec, submit_sm_resp dec
  678.                      * 0x01 deliver_sm dec, submit_sm_resp hex
  679.                      * 0x02 deliver_sm hex, submit_sm_resp dec
  680.                      * 0x03 deliver_sm hex, submit_sm_resp hex 
  681.                      *
  682.                      * Default behaviour is SMPP spec compliant, which means
  683.                      * msg_ids should be C strings and hence non modified.
  684.                      */
  685.                     if (smpp->smpp_msg_id_type == -1) {
  686.                         /* the default, C string */
  687.                         tmp = octstr_duplicate(msgid);
  688.                     } else {
  689.                         if (smpp->smpp_msg_id_type & 0x02) {                         
  690.                             tmp = octstr_format("%ld", strtol(octstr_get_cstr(msgid), NULL, 16));
  691.                         } else {
  692.                             tmp = octstr_format("%ld", strtol(octstr_get_cstr(msgid), NULL, 10));
  693.                         }
  694.                     }
  695.  
  696.                     dlrmsg = dlr_find(octstr_get_cstr(smpp->conn->id),  
  697.                                       octstr_get_cstr(tmp), /* smsc message id */ 
  698.                                       octstr_get_cstr(pdu->u.deliver_sm.destination_addr), /* destination */ 
  699.                                       dlrstat);
  700.                     octstr_destroy(tmp); 
  701.                 } 
  702.                 if (dlrmsg != NULL) {
  703.                     /* 
  704.                      * we found the delivery report in our storage, so recode the 
  705.                      * message structure. 
  706.                      * The DLR trigger URL is indicated by msg->sms.dlr_url. 
  707.                      */
  708.                     dlrmsg->sms.msgdata = octstr_duplicate(respstr);
  709.                     dlrmsg->sms.sms_type = report;
  711.                     bb_smscconn_receive(smpp->conn, dlrmsg);
  712.                 } else { 
  713.                     error(0,"SMPP[%s]: got DLR but could not find message or was not interested in it",
  714.                           octstr_get_cstr(smpp->conn->id));      
  715.                 }  
  716.                 resp = smpp_pdu_create(deliver_sm_resp,  
  717.                 pdu->u.deliver_sm.sequence_number); 
  718.           
  719.                 if (msgid != NULL) 
  720.                     octstr_destroy(msgid);      
  721.                 if (stat != NULL) 
  722.                     octstr_destroy(stat); 
  723.        
  724.             } else /* MO-SMS */
  725.             {
  726.                 /* ensure the smsc-id is set */ 
  727.                 msg = pdu_to_msg(pdu); 
  728.  
  729.                 /* Replace MO destination number with my-number */ 
  730.                 if (octstr_len(smpp->my_number)) { 
  731.                     octstr_destroy(msg->sms.receiver); 
  732.                     msg->sms.receiver = octstr_duplicate(smpp->my_number); 
  733.                 } 
  734.                 time(&msg->sms.time); 
  735.                 msg->sms.smsc_id = octstr_duplicate(smpp->conn->id); 
  736.                 (void) bb_smscconn_receive(smpp->conn, msg); 
  737.                 resp = smpp_pdu_create(deliver_sm_resp,  
  738.                             pdu->u.deliver_sm.sequence_number); 
  739.             } 
  740.             break; 
  741.  
  742.         case enquire_link: 
  743.             resp = smpp_pdu_create(enquire_link_resp,  
  744.                         pdu->u.enquire_link.sequence_number); 
  745.             break; 
  746.  
  747.         case enquire_link_resp: 
  748.             break; 
  749.  
  750.         case submit_sm_resp: 
  751.             os = octstr_format("%ld", pdu->u.submit_sm.sequence_number); 
  752.             msg = dict_remove(smpp->sent_msgs, os); 
  753.             octstr_destroy(os); 
  754.             if (msg == NULL) { 
  755.                 warning(0, "SMPP[%s]: SMSC sent submit_sm_resp " 
  756.                         "with wrong sequence number 0x%08lx",
  757.                         octstr_get_cstr(smpp->conn->id),
  758.                         pdu->u.submit_sm.sequence_number); 
  759.             } else if (pdu->u.submit_sm_resp.command_status != 0) { 
  760.                 error(0, "SMPP[%s]: SMSC returned error code 0x%08lx " 
  761.                       "in response to submit_sm.",
  762.                       octstr_get_cstr(smpp->conn->id),
  763.                       pdu->u.submit_sm_resp.command_status); 
  764.                 reason = smpp_status_to_smscconn_failure_reason( 
  765.                             pdu->u.submit_sm.command_status); 
  767.                 /* 
  768.                  * check to see if we got a "throttling error", in which case we'll just
  769.                  * sleep for a while 
  770.                  */
  771.                 if (pdu->u.submit_sm.command_status == SMPP_ESME_RTHROTTLED)
  772.                     time(&(smpp->throttling_err_time));
  773.                 else
  774.                     smpp->throttling_err_time = 0;
  775.  
  776.                 /* gen DLR_SMSC_FAIL */  
  777.                 if (reason == SMSCCONN_FAILED_REJECTED &&
  778.                     (msg->sms.dlr_mask & (DLR_SMSC_FAIL|DLR_FAIL))) { 
  779.                     Octstr *reply; 
  780.    
  781.                     reply = octstr_format("0x%08lx", 
  782.                                 pdu->u.submit_sm_resp.command_status); 
  783.                     /* generate DLR */ 
  784.                     info(0,"SMPP[%s]: creating DLR message",
  785.                          octstr_get_cstr(smpp->conn->id)); 
  786.                     dlrmsg = msg_create(sms); 
  787.                     dlrmsg->sms.service = octstr_duplicate(msg->sms.service); 
  788.                     dlrmsg->sms.dlr_mask = DLR_SMSC_FAIL; 
  789.                     dlrmsg->sms.sms_type = report; 
  790.                     dlrmsg->sms.smsc_id = octstr_duplicate(smpp->conn->id); 
  791.                     dlrmsg->sms.sender = octstr_duplicate(msg->sms.receiver); 
  792.                     dlrmsg->sms.receiver = octstr_create("000"); 
  793.                     dlrmsg->sms.dlr_url = octstr_duplicate(msg->sms.dlr_url);
  795.                     dlrmsg->sms.msgdata = reply;
  797.                     time(&dlrmsg->sms.time); 
  798.    
  799.                     info(0,"SMPP[%s]: DLR = %s", octstr_get_cstr(smpp->conn->id),
  800.                          octstr_get_cstr(dlrmsg->sms.dlr_url)); 
  801.                     bb_smscconn_receive(smpp->conn, dlrmsg); 
  802.                 } 
  804.                 bb_smscconn_send_failed(smpp->conn, msg, reason);
  805.                 --(*pending_submits); 
  806.             } else {  
  807.                 Octstr *tmp; 
  808.  
  809.                 /* check if msg_id is C string, decimal or hex for this SMSC */
  810.                 if (smpp->smpp_msg_id_type == -1) {
  811.                     /* the default, C string */
  812.                     tmp = octstr_duplicate(pdu->u.submit_sm_resp.message_id);
  813.                 } else {
  814.                     if (smpp->smpp_msg_id_type & 0x01) {   
  815.                         tmp = octstr_format("%ld", strtol(  /* hex */
  816.                             octstr_get_cstr(pdu->u.submit_sm_resp.message_id), NULL, 16));
  817.                     } else {
  818.                         tmp = octstr_format("%ld", strtol(  /* decimal */
  819.                             octstr_get_cstr(pdu->u.submit_sm_resp.message_id), NULL, 10));
  820.                     }
  821.                 }
  822.  
  823.                 /* SMSC ACK.. now we have the message id. */ 
  824.    
  825.                 if (msg->sms.dlr_mask & (DLR_SMSC_SUCCESS|DLR_SUCCESS|DLR_FAIL|DLR_BUFFERED)) 
  826.                     dlr_add(octstr_get_cstr(smpp->conn->id), 
  827.                             octstr_get_cstr(tmp), 
  828.                             octstr_get_cstr(msg->sms.sender), 
  829.                             octstr_get_cstr(msg->sms.receiver), 
  830.                             octstr_get_cstr(msg->sms.service), 
  831.                             octstr_get_cstr(msg->sms.dlr_url), 
  832.                             msg->sms.dlr_mask); 
  833.   
  834.                 /* gen DLR_SMSC_SUCCESS */ 
  835.                 if (msg->sms.dlr_mask & DLR_SMSC_SUCCESS) { 
  836.                     Octstr *reply; 
  837.    
  838.                     reply = octstr_format("0x%08lx", pdu->u.submit_sm_resp.command_status); 
  839.   
  840.                     dlrmsg = dlr_find(octstr_get_cstr(smpp->conn->id),  
  841.                                       octstr_get_cstr(tmp), /* smsc message id */ 
  842.                                       octstr_get_cstr(msg->sms.receiver), /* destination */ 
  843.                                       (DLR_SMSC_SUCCESS|((msg->sms.dlr_mask & (DLR_SUCCESS|DLR_FAIL)) ? DLR_BUFFERED : 0))); 
  844.    
  845.                     if (dlrmsg != NULL) { 
  846.                         octstr_append_char(reply, '/'); 
  847.                         dlrmsg->sms.msgdata = octstr_duplicate(reply);
  848.                         octstr_destroy(reply); 
  849.                         bb_smscconn_receive(smpp->conn, dlrmsg); 
  850.                     } else 
  851.                         error(0,"SMPP[%s]: Got SMSC_ACK but could not find message",
  852.                               octstr_get_cstr(smpp->conn->id)); 
  853.                 } 
  854.                 octstr_destroy(tmp); 
  855.                 bb_smscconn_sent(smpp->conn, msg); 
  856.                 --(*pending_submits); 
  857.             } /* end if for SMSC ACK */ 
  858.             break; 
  859.  
  860.         case bind_transmitter_resp: 
  861.             if (pdu->u.bind_transmitter_resp.command_status != 0) { 
  862.                 error(0, "SMPP[%s]: SMSC rejected login to transmit, " 
  863.               "code 0x%08lx.",
  864.                       octstr_get_cstr(smpp->conn->id),
  865.                       pdu->u.bind_transmitter_resp.command_status); 
  866.             } else { 
  867.                 *pending_submits = 0; 
  868.                 smpp->conn->status = SMSCCONN_ACTIVE; 
  869.                 smpp->conn->connect_time = time(NULL); 
  870.                 bb_smscconn_connected(smpp->conn); 
  871.             } 
  872.             break; 
  873.  
  874.         case bind_transceiver_resp: 
  875.             if (pdu->u.bind_transceiver_resp.command_status != 0) { 
  876.                 error(0, "SMPP[%s]: SMSC rejected login to transmit, " 
  877.                       "code 0x%08lx.",
  878.                       octstr_get_cstr(smpp->conn->id),
  879.                       pdu->u.bind_transceiver_resp.command_status); 
  880.             } else { 
  881.                 *pending_submits = 0; 
  882.                 smpp->conn->status = SMSCCONN_ACTIVE; 
  883.                 smpp->conn->connect_time = time(NULL); 
  884.                 bb_smscconn_connected(smpp->conn); 
  885.             } 
  886.             break; 
  887.  
  888.         case bind_receiver_resp: 
  889.             if (pdu->u.bind_receiver_resp.command_status != 0) { 
  890.                 error(0, "SMPP[%s]: SMSC rejected login to receive, " 
  891.                       "code 0x%08lx.", 
  892.                       octstr_get_cstr(smpp->conn->id),
  893.                       pdu->u.bind_receiver_resp.command_status); 
  894.             } else { 
  895.                 /* set only resceive status if no transmitt is bind */
  896.                 if (smpp->conn->status != SMSCCONN_ACTIVE) {
  897.                     smpp->conn->status = SMSCCONN_ACTIVE_RECV; 
  898.                     smpp->conn->connect_time = time(NULL);
  899.                 }
  900.             } 
  901.             break; 
  902.  
  903.         case unbind:
  904.             break;          
  905.  
  906.         case unbind_resp:       
  907.             break;
  909.         default: 
  910.             error(0, "SMPP[%s]: Unknown PDU type 0x%08lx, ignored.",
  911.                   octstr_get_cstr(smpp->conn->id), pdu->type); 
  912.             break; 
  913.     } 
  914.      
  915.     if (resp != NULL) { 
  916.      send_pdu(conn, smpp->conn->id, resp); 
  917.         smpp_pdu_destroy(resp); 
  918.     } 
  919. } 
  920.  
  921.  
  922. struct io_arg { 
  923.     SMPP *smpp; 
  924.     int transmitter; 
  925. }; 
  926.  
  927.  
  928. static struct io_arg *io_arg_create(SMPP *smpp, int transmitter) 
  929. { 
  930.     struct io_arg *io_arg; 
  931.      
  932.     io_arg = gw_malloc(sizeof(*io_arg)); 
  933.     io_arg->smpp = smpp; 
  934.     io_arg->transmitter = transmitter; 
  935.     return io_arg; 
  936. } 
  937.  
  938.  
  939.  
  940. /* 
  941.  * This is the main function for the background thread for doing I/O on 
  942.  * one SMPP connection (the one for transmitting or receiving messages). 
  943.  * It makes the initial connection to the SMPP server and re-connects 
  944.  * if there are I/O errors or other errors that require it. 
  945.  */ 
  946. static void io_thread(void *arg) 
  947. { 
  948.     SMPP *smpp; 
  949.     struct io_arg *io_arg; 
  950.     int transmitter; 
  951.     Connection *conn; 
  952.     int ret; 
  953.     long last_enquire_sent; 
  954.     long pending_submits; 
  955.     long len; 
  956.     SMPP_PDU *pdu; 
  957.     double timeout; 
  958.  
  959.     io_arg = arg; 
  960.     smpp = io_arg->smpp; 
  961.     transmitter = io_arg->transmitter; 
  962.     gw_free(io_arg); 
  963.  
  964.     conn = NULL; 
  965.     while (!smpp->quitting) { 
  966.         if (transmitter == 1) 
  967.             conn = open_transmitter(smpp); 
  968.         else if (transmitter == 2) 
  969.             conn = open_transceiver(smpp); 
  970.         else 
  971.             conn = open_receiver(smpp); 
  972.         if (conn == NULL) { 
  973.             error(0, "SMPP[%s]: Couldn't connect to SMS center (retrying in %ld seconds).",
  974.                   octstr_get_cstr(smpp->conn->id), smpp->reconnect_delay);
  975.             gwthread_sleep(smpp->reconnect_delay);
  976.             smpp->conn->status = SMSCCONN_RECONNECTING; 
  977.             continue; 
  978.         } 
  979.  
  980.         last_enquire_sent = date_universal_now(); 
  981.         pending_submits = -1; 
  982.         len = 0; 
  983.         for (;;) { 
  984.             timeout = last_enquire_sent + smpp->enquire_link_interval
  985.                         - date_universal_now(); 
  987.             /* unbind */
  988.             if (smpp->quitting) {
  989.                 send_unbind(smpp, conn);
  990.                 while ((ret = read_pdu(smpp, conn, &len, &pdu)) == 1) {
  991.                     dump_pdu("Got PDU:", smpp->conn->id, pdu);
  992.                     handle_pdu(smpp, conn, pdu, &pending_submits);
  993.                     smpp_pdu_destroy(pdu);
  994.                 }
  995.                 debug("bb.sms.smpp", 0, "SMPP[%s]: %s: break and shutting down",
  996.                       octstr_get_cstr(smpp->conn->id), __PRETTY_FUNCTION__);
  997.             }
  999.             if (smpp->quitting || conn_wait(conn, timeout) == -1) 
  1000.                 break; 
  1001.  
  1002.             send_enquire_link(smpp, conn, &last_enquire_sent); 
  1003.      
  1004.             while ((ret = read_pdu(smpp, conn, &len, &pdu)) == 1) { 
  1005.                 /* Deal with the PDU we just got */ 
  1006.                 dump_pdu("Got PDU:", smpp->conn->id, pdu); 
  1007.                 handle_pdu(smpp, conn, pdu, &pending_submits); 
  1008.                 smpp_pdu_destroy(pdu); 
  1009.  
  1010.                 /* Make sure we send enquire_link even if we read a lot */ 
  1011.                 send_enquire_link(smpp, conn, &last_enquire_sent); 
  1012.  
  1013.                 /* Make sure we send even if we read a lot */ 
  1014.                 if (transmitter &&
  1015.                     (!smpp->throttling_err_time || 
  1016.                     ((time(NULL) - smpp->throttling_err_time) > SMPP_THROTTLING_SLEEP_TIME 
  1017.                         && !(smpp->throttling_err_time = 0)))
  1018.                     )
  1019.                     send_messages(smpp, conn, &pending_submits); 
  1020.             } 
  1021.      
  1022.             if (ret == -1) { 
  1023.                 error(0, "SMPP[%s]: I/O error or other error. Re-connecting.",
  1024.                       octstr_get_cstr(smpp->conn->id)); 
  1025.                 break; 
  1026.             } 
  1027.      
  1028.             if (transmitter &&
  1029.                 (!smpp->throttling_err_time || 
  1030.                 ((time(NULL) - smpp->throttling_err_time) > SMPP_THROTTLING_SLEEP_TIME 
  1031.                     && !(smpp->throttling_err_time = 0)))
  1032.                 )
  1033.                 send_messages(smpp, conn, &pending_submits); 
  1034.         } 
  1035.  
  1036.         conn_destroy(conn); 
  1037.         conn = NULL; 
  1038.     } 
  1039.     conn_destroy(conn); 
  1040. } 
  1041.      
  1042.  
  1043. /*********************************************************************** 
  1044.  * Functions called by smscconn.c via the SMSCConn function pointers. 
  1045.  */ 
  1046.   
  1047.  
  1048. static long queued_cb(SMSCConn *conn) 
  1049. { 
  1050.     SMPP *smpp; 
  1051.  
  1052.     smpp = conn->data;
  1053.     conn->load = (smpp ? (conn->status != SMSCCONN_DEAD ? 
  1054.                   list_len(smpp->msgs_to_send) : 0) : 0);
  1055.     return conn->load; 
  1056. } 
  1057.  
  1058.  
  1059. static int send_msg_cb(SMSCConn *conn, Msg *msg) 
  1060. { 
  1061.     SMPP *smpp; 
  1062.      
  1063.     smpp = conn->data; 
  1064.     list_produce(smpp->msgs_to_send, msg_duplicate(msg)); 
  1065.     gwthread_wakeup(smpp->transmitter); 
  1066.     return 0; 
  1067. } 
  1068.  
  1069.  
  1070. static int shutdown_cb(SMSCConn *conn, int finish_sending) 
  1071. { 
  1072.     SMPP *smpp; 
  1073.  
  1074.     debug("bb.smpp", 0, "Shutting down SMSCConn %s (%s)", 
  1075.           octstr_get_cstr(conn->name), 
  1076.           finish_sending ? "slow" : "instant"); 
  1077.  
  1078.     conn->why_killed = SMSCCONN_KILLED_SHUTDOWN; 
  1079.  
  1080.     /* XXX implement finish_sending */ 
  1081.  
  1082.     smpp = conn->data; 
  1083.     smpp->quitting = 1; 
  1084.     gwthread_wakeup(smpp->transmitter); 
  1085.     gwthread_wakeup(smpp->receiver); 
  1086.     gwthread_join(smpp->transmitter); 
  1087.     gwthread_join(smpp->receiver); 
  1088.     smpp_destroy(smpp); 
  1089.      
  1090.     debug("bb.smpp", 0, "SMSCConn %s shut down.",  
  1091.           octstr_get_cstr(conn->name)); 
  1092.     conn->status = SMSCCONN_DEAD; 
  1093.     bb_smscconn_killed(); 
  1094.     return 0; 
  1095. } 
  1096.  
  1097.  
  1098. /*********************************************************************** 
  1099.  * Public interface. This version is suitable for the Kannel bearerbox 
  1100.  * SMSCConn interface. 
  1101.  */ 
  1102.  
  1103.  
  1104. int smsc_smpp_create(SMSCConn *conn, CfgGroup *grp) 
  1105. { 
  1106.     Octstr *host; 
  1107.     long port; 
  1108.     long receive_port; 
  1109.     Octstr *username; 
  1110.     Octstr *password; 
  1111.     Octstr *system_id; 
  1112.     Octstr *system_type; 
  1113.     Octstr *address_range; 
  1114.     long source_addr_ton; 
  1115.     long source_addr_npi; 
  1116.     long dest_addr_ton; 
  1117.     long dest_addr_npi; 
  1118.     Octstr *our_host; 
  1119.     Octstr *my_number; 
  1120.     SMPP *smpp; 
  1121.     int ok; 
  1122.     int transceiver_mode; 
  1123.     Octstr *smsc_id; 
  1124.     int alt_dcs;
  1125.     long enquire_link_interval;
  1126.     long max_pending_submits;
  1127.     long reconnect_delay;
  1128.     long version;
  1129.     long priority;
  1130.     long smpp_msg_id_type;
  1131.     int autodetect_addr;
  1132.  
  1133.     my_number = NULL; 
  1134.     transceiver_mode = 0;
  1135.     alt_dcs = 0;
  1136.     autodetect_addr = 0;
  1137.  
  1138.     host = cfg_get(grp, octstr_imm("host")); 
  1139.     if (cfg_get_integer(&port, grp, octstr_imm("port")) == -1) 
  1140.         port = 0; 
  1141.     if (cfg_get_integer(&receive_port, grp, octstr_imm("receive-port")) == -1) 
  1142.         receive_port = 0; 
  1143.     cfg_get_bool(&transceiver_mode, grp, octstr_imm("transceiver-mode")); 
  1144.     cfg_get_bool(&alt_dcs, grp, octstr_imm("alt-dcs")); 
  1145.     username = cfg_get(grp, octstr_imm("smsc-username")); 
  1146.     password = cfg_get(grp, octstr_imm("smsc-password")); 
  1147.     system_type = cfg_get(grp, octstr_imm("system-type")); 
  1148.     address_range = cfg_get(grp, octstr_imm("address-range")); 
  1149.     our_host = cfg_get(grp, octstr_imm("our-host")); 
  1150.     my_number = cfg_get(grp, octstr_imm("my-number")); 
  1151.      
  1152.     system_id = cfg_get(grp, octstr_imm("system-id")); 
  1153.     if (system_id != NULL) { 
  1154.         warning(0, "SMPP: obsolete system-id variable is set, " 
  1155.         "use smsc-username instead."); 
  1156.         if (username == NULL) { 
  1157.             warning(0, "SMPP: smsc-username not set, using system-id instead"); 
  1158.             username = system_id; 
  1159.         } else 
  1160.             octstr_destroy(system_id); 
  1161.     } 
  1163.     /* 
  1164.      * check if timing values have been configured, otherwise
  1165.      * use the predefined default values.
  1166.      */
  1167.     if (cfg_get_integer(&enquire_link_interval, grp, 
  1168.                         octstr_imm("enquire-link-interval")) == -1)
  1169.         enquire_link_interval = SMPP_ENQUIRE_LINK_INTERVAL;
  1170.     if (cfg_get_integer(&max_pending_submits, grp, 
  1171.                         octstr_imm("max-pending-submits")) == -1)
  1172.         max_pending_submits = SMPP_MAX_PENDING_SUBMITS;
  1173.     if (cfg_get_integer(&reconnect_delay, grp, 
  1174.                         octstr_imm("reconnect-delay")) == -1)
  1175.         reconnect_delay = SMPP_RECONNECT_DELAY;
  1176.  
  1177.     /* Check that config is OK */ 
  1178.     ok = 1; 
  1179.     if (host == NULL) { 
  1180.         error(0,"SMPP: Configuration file doesn't specify host"); 
  1181.         ok = 0; 
  1182.     }     
  1183.     if (username == NULL) { 
  1184.     error(0, "SMPP: Configuration file doesn't specify username."); 
  1185.     ok = 0; 
  1186.     } 
  1187.     if (password == NULL) { 
  1188.     error(0, "SMPP: Configuration file doesn't specify password."); 
  1189.     ok = 0; 
  1190.     } 
  1191.     if (system_type == NULL) { 
  1192.     error(0, "SMPP: Configuration file doesn't specify system-type."); 
  1193.     ok = 0; 
  1194.     } 
  1195.     if (!ok) 
  1196.         return -1; 
  1197.  
  1198.     /* if the ton and npi values are forced, set them, else set them to -1 */ 
  1199.     if (cfg_get_integer(&source_addr_ton, grp, 
  1200.                         octstr_imm("source-addr-ton")) == -1) 
  1201.         source_addr_ton = -1; 
  1202.     if (cfg_get_integer(&source_addr_npi, grp, 
  1203.                         octstr_imm("source-addr-npi")) == -1) 
  1204.         source_addr_npi = -1; 
  1205.     if (cfg_get_integer(&dest_addr_ton, grp, 
  1206.                         octstr_imm("dest-addr-ton")) == -1) 
  1207.         dest_addr_ton = -1; 
  1208.     if (cfg_get_integer(&dest_addr_npi, grp, 
  1209.                         octstr_imm("dest-addr-npi")) == -1) 
  1210.         dest_addr_npi = -1; 
  1212.     /* if source addr autodetection should be used set this to 1 */
  1213.     cfg_get_bool(&autodetect_addr, grp, octstr_imm("source-addr-autodetect")); 
  1215.     /* check for any specified interface version */
  1216.     if (cfg_get_integer(&version, grp, octstr_imm("interface-version")) == -1)
  1217.         version = SMPP_DEFAULT_VERSION;
  1218.     else
  1219.         /* convert decimal to BCD */
  1220.         version = ((version / 10) << 4) + (version % 10);
  1222.     /* check for any specified priority value in range [0-5] */
  1223.     if (cfg_get_integer(&priority, grp, octstr_imm("priority")) == -1)
  1224.         priority = SMPP_DEFAULT_PRIORITY;
  1226.     /* set the msg_id type variable for this SMSC */
  1227.     if (cfg_get_integer(&smpp_msg_id_type, grp, octstr_imm("msg-id-type")) == -1) {
  1228.         /* 
  1229.          * defaults to C string "as-is" style 
  1230.          */
  1231.         smpp_msg_id_type = -1; 
  1232.     } else {
  1233.         if (smpp_msg_id_type < 0 || smpp_msg_id_type > 3)
  1234.             panic(0,"SMPP: Invlid value for msg-id-type directive in configuraton"); 
  1235.     }
  1237.     smpp = smpp_create(conn, host, port, receive_port, system_type,  
  1238.                  username, password, address_range, our_host, 
  1239.                        source_addr_ton, source_addr_npi, dest_addr_ton,  
  1240.                        dest_addr_npi, alt_dcs, enquire_link_interval, 
  1241.                        max_pending_submits, reconnect_delay, 
  1242.                        version, priority, my_number, smpp_msg_id_type,
  1243.                        autodetect_addr); 
  1244.  
  1245.     conn->data = smpp; 
  1246.     conn->name = octstr_format("SMPP:%S:%d/%d:%S:%S",  
  1247.                       host, port, 
  1248.                                (receive_port ? receive_port : port),  
  1249.                                username, system_type); 
  1250.  
  1251.     smsc_id = cfg_get(grp, octstr_imm("smsc-id")); 
  1252.     if (smsc_id == NULL) { 
  1253.         conn->id = octstr_duplicate(conn->name); 
  1254.     } 
  1256.     octstr_destroy(host); 
  1257.     octstr_destroy(username); 
  1258.     octstr_destroy(password); 
  1259.     octstr_destroy(system_type); 
  1260.     octstr_destroy(address_range); 
  1261.     octstr_destroy(our_host); 
  1262.     octstr_destroy(my_number); 
  1263.     octstr_destroy(smsc_id);
  1264.  
  1265.     conn->status = SMSCCONN_CONNECTING; 
  1266.        
  1267.     /* 
  1268.      * I/O threads are only started if the corresponding ports 
  1269.      * have been configured with positive numbers. Use 0 to  
  1270.      * disable the creation of the corresponding thread. 
  1271.      */ 
  1272.     if (port != 0) 
  1273.         smpp->transmitter = gwthread_create(io_thread, io_arg_create(smpp,  
  1274.                                            (transceiver_mode ? 2 : 1))); 
  1275.     if (receive_port != 0) 
  1276.         smpp->receiver = gwthread_create(io_thread, io_arg_create(smpp, 0)); 
  1277.      
  1278.     if ((port != 0 && smpp->transmitter == -1) ||  
  1279.         (receive_port != 0 && smpp->receiver == -1)) { 
  1280.         error(0, "SMPP[%s]: Couldn't start I/O threads.",
  1281.               octstr_get_cstr(smpp->conn->id)); 
  1282.         smpp->quitting = 1; 
  1283.         if (smpp->transmitter != -1) { 
  1284.             gwthread_wakeup(smpp->transmitter); 
  1285.             gwthread_join(smpp->transmitter); 
  1286.         } 
  1287.         if (smpp->receiver != -1) { 
  1288.             gwthread_wakeup(smpp->receiver); 
  1289.             gwthread_join(smpp->receiver); 
  1290.         } 
  1291.      smpp_destroy(conn->data); 
  1292.         return -1; 
  1293.     } 
  1294.  
  1295.     conn->shutdown = shutdown_cb; 
  1296.     conn->queued = queued_cb; 
  1297.     conn->send_msg = send_msg_cb; 
  1298.  
  1299.     return 0; 
  1300. }
  1301.