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

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

手机WAP编程

开发平台：

WINDOWS

smsc_smasi.c：源码内容
  1. /*
  2.  * Implementation of a SM/ASI SMSC module.
  3.  *
  4.  * Stipe Tolj <tolj@wapme-systems.de>
  5.  *
  6.  * This module connects to a CriticalPath InVoke SMS Center which
  7.  * uses the SM/ASI protocoll. 
  8.  * The module is heavily based on the SMPP module design.
  9.  *
  10.  * TODO:
  11.  * 1. alt_dcs is not used. Instead, msg->sms.mclass is used as the SMASI
  12.  *    Class.
  13.  * 2. Numbers are not handled correctly, I guess. SMASI allows only(?)
  14.  *    international numbers without leading double zero. How to ensure
  15.  *    this?
  16.  * 3. Handling of npi and ton correct?
  17.  * 4. SubmitMulti PDUs not supported.
  18.  * 5. Replace PDUs not supported.
  19.  * 6. Status PDUs not supported.
  20.  * 7. Cancel PDUs not supported.
  21.  * 8. UserRes PDUs not supported.
  22.  * 9. Smsc PDUs not supported.
  23.  * 10. EnquireLink PDUs not supported.
  24.  */
  26. #include "gwlib/gwlib.h"
  27. #include "msg.h"
  28. #include "smsc_p.h"
  29. #include "smasi_pdu.h"
  30. #include "smscconn_p.h"
  31. #include "bb_smscconn_cb.h"
  32. #include "sms.h"
  33. #include "dlr.h"
  35. #define DEBUG 1
  37. #ifndef DEBUG
  38. static void dump_pdu(const char *msg, Octstr *id, SMASI_PDU *pdu) { }
  39. #else
  40. static void dump_pdu(const char *msg, Octstr *id, SMASI_PDU *pdu) 
  41. {
  42.     debug("bb.sms.smasi", 0, "SMASI[%s]: %s", octstr_get_cstr(id), msg);
  43.     smasi_pdu_dump(pdu);
  44. }
  45. #endif
  48. /************************************************************************/
  49. /* DEFAULT SETTINGS                                                     */
  50. /************************************************************************/
  52. #define SMASI_DEFAULT_PORT          21500
  53. #define SMASI_RECONNECT_DELAY       10.0
  54. #define SMASI_DEFAULT_PRIORITY      0
  55. #define MAX_PENDING_SUBMITS         10
  56. #define SMASI_THROTTLING_SLEEP_TIME 15
  57. #define SMASI_ENQUIRE_LINK_INTERVAL  30.0 
  60. /************************************************************************/
  61. /* OVERRIDE SETTINGS                                                    */
  62. /************************************************************************/
  64. /* Set these to -1 if no override desired. Values carried in message will
  65.  * be used then. Or the defaults - if message has no values.
  66.  * 
  67.  * Otherwise these values will be forced!
  68.  */
  70. #define SMASI_OVERRIDE_SOURCE_TON    1
  71. #define SMASI_OVERRIDE_SOURCE_NPI    -1
  72. #define SMASI_OVERRIDE_DEST_TON      -1
  73. #define SMASI_OVERRIDE_DEST_NPI      -1
  76. /************************************************************************/
  77. /* SMASI STRUCTURE AND RELATED FUNCTIONS                                */
  78. /************************************************************************/
  80. typedef struct {
  81.     SMSCConn * conn;                 /* connection to the bearerbox */
  82.     int thread_handle;               /* handle for the SMASI thread */
  83.     List *msgs_to_send;
  84.     Dict *sent_msgs;                 /* hash table for send, but yet not confirmed */
  85.     List *received_msgs;             /* list of received, but yet not processed */
  86.     Counter *message_id_counter;     /* sequence number */
  87.     Octstr *host;                    /* host or IP of the SMASI server */
  88.     long port;                       /* port to connect to */
  89.     Octstr *username;     
  90.     Octstr * password;
  91.     Octstr * my_number;
  92.     long source_addr_ton;
  93.     long source_addr_npi;
  94.     long dest_addr_ton;
  95.     long dest_addr_npi;
  96.     long reconnect_delay;
  97.     long priority;
  98.     time_t throttling_err_time;
  99.     int quitting;
  100.     long enquire_link_interval;
  101.     int logged_off;
  102. } SMASI;
  105. static SMASI *smasi_create(SMSCConn *conn) 
  106. {
  108.     SMASI *smasi = gw_malloc(sizeof(SMASI));
  110.     smasi->conn = conn;
  112.     smasi->thread_handle = -1;
  113.     smasi->msgs_to_send = list_create();
  114.     smasi->sent_msgs = dict_create(16, NULL);
  115.     smasi->received_msgs = list_create();
  116.     smasi->message_id_counter = counter_create();
  117.     smasi->host = NULL;
  118.     smasi->username = NULL;
  119.     smasi->password = NULL;
  120.     smasi->source_addr_ton = -1;
  121.     smasi->source_addr_npi = -1;
  122.     smasi->dest_addr_ton = -1;
  123.     smasi->dest_addr_npi = -1;
  124.     smasi->my_number = NULL;
  125.     smasi->port = 21500;
  126.     smasi->reconnect_delay = 10;
  127.     smasi->quitting = 0;
  128.     smasi->logged_off = 0;
  129.     smasi->priority = 0;
  130.     smasi->throttling_err_time = 0;
  131.     smasi->enquire_link_interval = 30;
  133.     list_add_producer(smasi->msgs_to_send);
  135.     return smasi;
  136. } 
  139. static void smasi_destroy(SMASI *smasi) 
  140. {
  141.     if (smasi == NULL) return;
  143.     list_destroy(smasi->msgs_to_send, msg_destroy_item);
  144.     dict_destroy(smasi->sent_msgs);
  145.     list_destroy(smasi->received_msgs, msg_destroy_item);
  146.     counter_destroy(smasi->message_id_counter);
  147.     octstr_destroy(smasi->host);
  148.     octstr_destroy(smasi->username);
  149.     octstr_destroy(smasi->password);
  150.     gw_free(smasi);
  151. } 
  155. /************************************************************************/
  156. /* DATA ENCODING                                                        */
  157. /************************************************************************/
  159. /* These values will be initialized on module startup. They contain the
  160.  * ASCII representation of the chars that need to be escaped in the message
  161.  * body before transmission. Example: "," (comma) will be represented by
  162.  * the octet string ":2c".
  163.  */
  165. static Octstr *colon = NULL;
  166. static Octstr *assign = NULL;
  167. static Octstr *comma = NULL;
  168. static Octstr *cr = NULL;
  169. static Octstr *lf = NULL;
  172. /*
  173.  * Escapes outgoing message body data by replacing occurrences of "special"
  174.  * chars inside the octet string.
  175.  */
  176. static void escape_data(Octstr *data) 
  177. {
  178.     long pos = 0;
  180.     /* This one uses a different approach than the encode and decode
  181.      * functions. Because it is assumed, that only a fraction of the
  182.      * contained chars have to be escaped.
  183.      */
  184.     while (pos < octstr_len(data)) {
  185.         Octstr * escaped = NULL;
  186.         int check = octstr_get_char(data, pos);
  188.         if (check == ':') escaped = colon;
  189.         else if (check == '=') escaped = assign;
  190.         else if (check == ',') escaped = comma;
  191.         else if (check == 'n') escaped = cr;
  192.         else if (check == 'r') escaped = lf;
  194.         if (escaped != NULL) {
  195.             /* If the current char has to be escaped, delete the char from
  196.              * the source string, replace it with the escape sequence, and
  197.              * advance position until after the inserted sequence.
  198.              */
  199.             octstr_delete(data, pos, 1);
  200.             octstr_insert(data, escaped, pos);
  201.             pos += octstr_len(escaped);
  202.         } else {
  203.             /* If not escaped, simply skip the current char. */
  204.             pos++;
  205.         } 
  206.     } 
  207. } 
  210. /*
  211.  * Unescapes incoming message body data by replacing occurrences of escaped
  212.  * chars with their original character representation.
  213.  */
  214. static void unescape_data(Octstr *data) 
  215. {
  216.     long pos = 0;
  218.     /* Again, an inplace transformation is used. Because, again, it is
  219.      * assumed that only a fraction of chars has to be unescaped.
  220.      */
  221.     while (pos < octstr_len(data)) {
  222.         int check = octstr_get_char(data, pos);
  224.         if (check == ':') {
  225.             char byte = 0;
  226.             int msb = octstr_get_char(data, pos + 1);
  227.             int lsb = octstr_get_char(data, pos + 2);
  229.             if (msb == '0') msb = 0;
  230.             else if (msb >= '1' && msb <= '9') msb -= '1' + 1;
  231.             else msb -= 'a' + 10;
  233.             if (lsb == '0') lsb = 0;
  234.             else if (lsb >= '1' && lsb <= '9') lsb -= '1' + 1;
  235.             else lsb -= 'a' + 10;
  237.             byte = msb << 4 | lsb;
  239.             /* Do inplace unescaping. */
  240.             octstr_delete(data, pos, 3);
  241.             octstr_insert_data(data, pos, &byte, 1);
  242.         } 
  243.         pos++;
  244.     } 
  245. }
  248. /*
  249.  * Will replace a binary data octet string (inplace) with a SMASI conform
  250.  * ASCII representation of the data.
  251.  */
  252. static void encode_binary_data(Octstr *data) 
  253. {
  254.     Octstr *result = octstr_create("");
  255.     long pos = 0;
  257.     while (pos < octstr_len(data)) {
  258.         int encode = octstr_get_char(data, pos);
  259.         int msb = (encode & 0xf0) >> 4;
  260.         int lsb = (encode & 0x0f) >> 0;
  262.         if (msb == 0) msb = '0';
  263.         else if (msb < 10) msb = '1' + msb - 1;
  264.         else msb = 'a' + msb - 10;
  266.         if (lsb == 0) lsb = '0';
  267.         else if (lsb < 10) lsb = '1' + lsb - 1;
  268.         else lsb = 'a' + lsb - 10;
  270.         octstr_append_char(result, ':');
  271.         octstr_append_char(result, msb);
  272.         octstr_append_char(result, lsb);
  274.         pos++;
  275.     } 
  276.     /* Replace binary data octet string with ASCII representation. */
  277.     octstr_delete(data, 0, octstr_len(data));
  278.     octstr_append(data, result);
  279.     octstr_destroy(result);
  280. }
  283. /*
  284.  * Replaces a SMASI conform ASCII representation of binary data with the
  285.  * original binary data octet string. Will abort data decoding if the ASCII
  286.  * representation is invalid.
  287.  */
  288. static void decode_binary_data(Octstr *data) 
  289. {
  290.     long pos = 0;
  291.     Octstr * result = octstr_create("");
  293.     for (pos = 0; pos < octstr_len(data); pos += 3) {
  294.         int check = octstr_get_char(data, pos);
  296.         if (check != ':') {
  297.             warning(0, "Malformed binary encoded data.");
  298.             return;
  299.         } else {
  300.             int byte = 0;
  301.             int msb = octstr_get_char(data, pos + 1);
  302.             int lsb = octstr_get_char(data, pos + 2);
  304.             if (msb == '0') msb = 0;
  305.             else if (msb >= '1' && msb <= '9') msb = msb - 48;
  306.             else msb = msb - 'a' + 10;
  308.             if (lsb == '0') lsb = 0;
  309.             else if (lsb >= '1' && lsb <= '9') lsb = lsb - 48;
  310.             else lsb = lsb - 'a' + 10;
  312.             byte = msb << 4 | lsb;
  314.             octstr_append_char(result, byte);
  315.         } 
  316.     } 
  318.     /* Replace ASCII representation with binary data octet string. */
  319.     octstr_delete(data, 0, octstr_len(data));
  320.     octstr_append(data, result);
  321.     octstr_destroy(result);
  322. }
  325. /************************************************************************/
  326. /* MESSAGE PROCESSING                                                   */
  327. /************************************************************************/
  329. static Octstr *get_ton_npi_value(int override, int message) 
  330. {
  331.     if(override != -1) {
  332.         debug("bb.sms.smasi", 0, "SMASI: Manually forced source addr ton = %d", 
  333.               override);
  334.         return(octstr_format("%ld", override));
  335.     } else {
  336.         return(octstr_format("%ld", message));
  337.     }
  338. }
  341. /*
  342.  * Gets the value to be used as source_addr_ton. Will use override values
  343.  * if configured. Will use values from message otherwise. Or fall back to
  344.  * defaults if nothing given.
  345.  */
  346. static Octstr *get_source_addr_ton(SMASI *smasi, Msg *msg) 
  347. {
  348.     return get_ton_npi_value(smasi->source_addr_ton, 
  349.                              GSM_ADDR_TON_INTERNATIONAL);
  350. }
  353. /*
  354.  * Gets the value to be used as source_addr_npi. Will use override values
  355.  * if configured. Will use values from message otherwise. Or fall back to
  356.  * defaults if nothing given.
  357.  */
  358. static Octstr *get_source_addr_npi(SMASI *smasi, Msg *msg) 
  359. {
  360.     return get_ton_npi_value(smasi->source_addr_npi, 
  361.                              GSM_ADDR_NPI_E164);
  362. }
  365. /*
  366.  * Gets the value to be used as dest_addr_ton. Will use override values
  367.  * if configured. Will use values from message otherwise. Or fall back to
  368.  * defaults if nothing given.
  369.  */
  370. static Octstr *get_dest_addr_ton(SMASI *smasi, Msg *msg) 
  371. {
  372.     return get_ton_npi_value(smasi->dest_addr_ton, 
  373.                              GSM_ADDR_TON_INTERNATIONAL);
  374. }
  377. /*
  378.  * Gets the value to be used as dest_addr_npi. Will use override values
  379.  * if configured. Will use values from message otherwise. Or fall back to
  380.  * defaults if nothing given.
  381.  */
  382. static Octstr *get_dest_addr_npi(SMASI *smasi, Msg *msg) 
  383. {
  384.     return get_ton_npi_value(smasi->dest_addr_npi, 
  385.                              GSM_ADDR_NPI_E164);
  386. }
  389. /*
  390.  * Determine the originator (sender number) type based on the number. Will
  391.  * change the originator number if necessary.
  392.  */
  393. static Octstr *get_originator_type(SMASI *smasi, Octstr *originator) 
  394. {
  395.     /* International or alphanumeric sender? */
  396.     if (octstr_get_char(originator, 0) == '+') {
  397.         if (!octstr_check_range(originator, 1, 256, gw_isdigit)) {
  398.             return octstr_format("%ld", GSM_ADDR_TON_ALPHANUMERIC);
  399.         } else {
  400.            /* Numeric sender address with + in front: The + has to be
  401.             * removed from this international number.
  402.             */
  403.            octstr_delete(originator, 0, 1);
  404.            return octstr_format("%ld", GSM_ADDR_TON_INTERNATIONAL);
  405.         }
  406.     } else if (!octstr_check_range(originator, 0, 256, gw_isdigit)) {
  407.        return octstr_format("%ld", GSM_ADDR_TON_ALPHANUMERIC);
  408.     }
  410.     /* Return the default value. */
  411.     return octstr_format("%ld", GSM_ADDR_TON_INTERNATIONAL);
  412. }
  415. /*
  416.  * Creates a SubmitReq PDU from an outgoing message.
  417.  */
  418. static SMASI_PDU *msg_to_pdu(SMASI *smasi, Msg *msg) 
  419. {
  420.     SMASI_PDU *pdu = smasi_pdu_create(SubmitReq);
  422.     pdu->u.SubmitReq.Destination = octstr_duplicate(msg->sms.receiver);
  423.     pdu->u.SubmitReq.Body = octstr_duplicate(msg->sms.msgdata);
  424.     pdu->u.SubmitReq.Originator = octstr_duplicate(msg->sms.sender);
  426.     pdu->u.SubmitReq.OriginatorType = 
  427.         get_originator_type(smasi, pdu->u.SubmitReq.Originator);
  429.     pdu->u.SubmitReq.Sequence = 
  430.         octstr_format("%ld", counter_increase(smasi->message_id_counter));
  433.     /* If its a international number starting with +, lets remove the +. */
  434.     if (octstr_get_char(pdu->u.SubmitReq.Destination, 0) == '+')
  435.         octstr_delete(pdu->u.SubmitReq.Destination, 0,1);
  437.     /* Do ton and npi override - if configured. Use values from message
  438.      * otherwise.
  439.      */
  440.     pdu->u.SubmitReq.OriginatorType = get_source_addr_ton(smasi, msg);
  441.     pdu->u.SubmitReq.OriginatorPlan = get_source_addr_npi(smasi, msg);
  442.     pdu->u.SubmitReq.DestinationType = get_dest_addr_ton(smasi, msg);
  443.     pdu->u.SubmitReq.DestinationPlan = get_dest_addr_npi(smasi, msg);
  444.        
  445.     /* Set priority. */
  446.     if (smasi->priority >= 0 && smasi->priority <= 3) {
  447.         pdu->u.SubmitReq.MqPriority = octstr_format("%ld", smasi->priority);
  448.     } else {
  449.         pdu->u.SubmitReq.MqPriority = octstr_format("%ld", 0);
  450.     }
  452.     /* Set encoding. */
  453.     if (msg->sms.coding != 0) {
  454.         if (msg->sms.coding == 1)
  455.             pdu->u.SubmitReq.MsEncoding = octstr_create("7bit");
  456.         else if (msg->sms.coding == 2)
  457.             pdu->u.SubmitReq.MsEncoding = octstr_create("8bit");
  458.         else if (msg->sms.coding == 2)
  459.             pdu->u.SubmitReq.MsEncoding = octstr_create("16bit");
  461.         /* Everything else will default to 7bit. */
  462.     }
  464.     /* Set messaging class - if within defined parameter range. */
  465.     if (msg->sms.mclass >= 0 && msg->sms.mclass <= 4)
  466.         pdu->u.SubmitReq.Class = octstr_format("%ld", (msg->sms.mclass - 1));
  468.     /* Set Protocol ID. */
  469.     pdu->u.SubmitReq.ProtocolID = octstr_format("%ld", msg->sms.pid);
  471.     /* Check if SMS is binary. */
  472.     if (msg->sms.udhdata && octstr_len(msg->sms.udhdata) > 0) {
  473.         
  474.         pdu->u.SubmitReq.UserDataHeader =
  475.           octstr_duplicate(msg->sms.udhdata);
  477.         pdu->u.SubmitReq.BodyEncoding =
  478.           octstr_create("Data");
  480.         if (pdu->u.SubmitReq.MsEncoding)
  481.           octstr_destroy(pdu->u.SubmitReq.MsEncoding);
  483.         pdu->u.SubmitReq.MsEncoding =
  484.           octstr_create("transparent");
  486.         /* Encode data. */
  487.         encode_binary_data(pdu->u.SubmitReq.UserDataHeader);
  488.         encode_binary_data(pdu->u.SubmitReq.Body);
  489.     } else {
  491.         /* Otherwise do data escaping. */
  492.         escape_data(pdu->u.SubmitReq.Body);
  493.     } 
  495.     return pdu;
  496. } 
  499. /*
  500.  * Create a message structure from an incoming DeliverReq PDU.
  501.  */
  502. static Msg *pdu_to_msg(SMASI_PDU *pdu) 
  503. {
  504.     Msg *msg = NULL;
  506.     gw_assert(pdu->type == DeliverReq);
  507.     gw_assert(pdu->u.DeliverReq.Originator);
  508.     gw_assert(pdu->u.DeliverReq.Destination);
  509.     gw_assert(pdu->u.DeliverReq.Body);
  511.     msg = msg_create(sms);;
  513.     msg->sms.sender = octstr_duplicate(pdu->u.DeliverReq.Originator);
  514.     msg->sms.receiver = octstr_duplicate(pdu->u.DeliverReq.Destination);
  515.     msg->sms.msgdata = octstr_duplicate(pdu->u.DeliverReq.Body);
  516.  
  517.     /* Unescape (non-binary) or decode (binary) data. */
  518.     if (pdu->u.DeliverReq.UserDataHeader &&
  519.         octstr_len(pdu->u.DeliverReq.UserDataHeader) > 0) {
  521.         msg->sms.udhdata = octstr_duplicate(pdu->u.DeliverReq.UserDataHeader);
  523.         decode_binary_data(msg->sms.msgdata);
  524.         decode_binary_data(msg->sms.udhdata);
  525.     } else {
  526.         unescape_data(msg->sms.msgdata);
  527.     } 
  529.     /* Read priority. */
  530.     if (pdu->u.DeliverReq.ProtocolId)
  531.         if (octstr_parse_long(&msg->sms.pid, 
  532.                               pdu->u.DeliverReq.ProtocolId, 0, 10) == -1)
  533.             msg->sms.pid = 0;
  535.     /* Read Coding. */
  536.     if (pdu->u.SubmitReq.MsEncoding) {
  538.         /* Use specified coding. */
  539.         if (octstr_str_compare(pdu->u.SubmitReq.MsEncoding, "7bit") == 0)
  540.             msg->sms.coding = 1;
  541.         else if (octstr_str_compare(pdu->u.SubmitReq.MsEncoding, "8bit") == 0)
  542.             msg->sms.coding = 2;
  543.         else if (octstr_str_compare(pdu->u.SubmitReq.MsEncoding, "UCS2") == 0)
  544.             msg->sms.coding = 3;
  545.         else if (octstr_str_compare(pdu->u.SubmitReq.MsEncoding, "transparent") == 0)
  546.             msg->sms.coding = 2;
  547.     } else {
  549.         /* Determine specified coding according to udhdata presence. */
  550.         if (pdu->u.SubmitReq.UserDataHeader)
  551.             msg->sms.coding = 2;
  552.         else
  553.             msg->sms.coding = 1;
  554.     }
  556.     /* Read message class. */
  557.     if (pdu->u.SubmitReq.Class) {
  558.         if (octstr_parse_long(&msg->sms.mclass, 
  559.                               pdu->u.SubmitReq.Class, 0, 10) == -1)
  560.             msg->sms.mclass = 0;    /* Set to unspecified. */
  561.         else
  562.             msg->sms.mclass++;      /* Correct value mapping. */
  563.     }
  565.     /* Read protocol ID. */
  566.     if (pdu->u.SubmitReq.ProtocolID)
  567.         if (octstr_parse_long(&msg->sms.pid, 
  568.                               pdu->u.SubmitReq.ProtocolID, 0, 10) == -1)
  569.             msg->sms.pid = 0;
  571.     return msg;
  572. }
  573.  
  575. /************************************************************************/
  576. /* PDU HANDLING                                                         */
  577. /************************************************************************/
  579. static void send_logoff(SMASI *smasi, Connection *conn) 
  580. {
  581.     SMASI_PDU *pdu = NULL;
  582.     Octstr *os = NULL;
  584.     counter_increase(smasi->message_id_counter);
  586.     pdu = smasi_pdu_create(LogoffReq);
  587.     pdu->u.LogoffReq.Reason = octstr_create("Client shutting down");
  588.     dump_pdu("Sending !LogoffReq:", smasi->conn->id, pdu); 
  590.     os = smasi_pdu_pack(pdu);
  591.     conn_write(conn, os);
  592.     octstr_destroy(os);
  593.     smasi_pdu_destroy(pdu);
  594. }
  596.  
  597. static void send_enquire_link(SMASI *smasi, Connection *conn, long *last_sent) 
  598. { 
  599.     SMASI_PDU *pdu = NULL; 
  600.     Octstr *os = NULL; 
  601.  
  602.     if (date_universal_now() - *last_sent < smasi->enquire_link_interval)
  603.         return; 
  604.     *last_sent = date_universal_now(); 
  605.  
  606.     pdu = smasi_pdu_create(EnquireLinkReq);
  607.     dump_pdu("Sending EnquireLinkReq:", smasi->conn->id, pdu); 
  608.     os = smasi_pdu_pack(pdu); 
  609.     if (os)
  610.    conn_write(conn, os); /* Write errors checked by caller. */ 
  611.     octstr_destroy(os); 
  612.     smasi_pdu_destroy(pdu); 
  613. } 
  616. static int send_pdu(Connection *conn, Octstr *id, SMASI_PDU *pdu)
  617. {
  618.     Octstr * os = NULL;
  619.     int ret = 0;
  621.     dump_pdu("Sending PDU:", id, pdu); 
  622.     os = smasi_pdu_pack(pdu);
  623.     if (os) ret = conn_write(conn, os);
  624.     else ret = -1;
  626.     octstr_destroy(os);
  627.     return ret;
  628. }
  629.  
  631. /*
  632.  * Try to read a SMASI PDU from a connection. Return -1 for error (caller
  633.  * should close the connection), 0 for no PDU ready yet, or 1 for PDU read
  634.  * and unpacked. Return a pointer to the PDU in `*pdu'.
  635.  */
  636. static int read_pdu(SMASI *smasi, Connection *conn, SMASI_PDU **pdu) 
  637. {
  638.     Octstr *os;
  639.     
  640.     os = smasi_pdu_read(conn);
  641.     if (os == NULL) {
  642.         if (conn_eof(conn) || conn_read_error(conn)) 
  643.             return -1;
  644.         return 0;
  645.     }
  647.     *pdu = smasi_pdu_unpack(os);
  648.     if (*pdu == NULL) {
  649.         error(0, "SMASI[%s]: PDU unpacking failed.",
  650.               octstr_get_cstr(smasi->conn->id));
  651.         debug("bb.sms.smasi", 0, "SMASI[%s]: Failed PDU follows.",
  652.               octstr_get_cstr(smasi->conn->id));
  653.         octstr_dump(os, 0);
  654.         octstr_destroy(os);
  655.         return -1;
  656.     }
  657.     octstr_destroy(os);
  658.     return 1;
  659. }
  662. static void handle_pdu(SMASI *smasi, Connection *conn, 
  663.                        SMASI_PDU *pdu, long *pending_submits) 
  664. {
  665.     SMASI_PDU *resp = NULL;
  666.     Msg *msg = NULL;
  667.     long reason;
  669.     switch (pdu->type) {
  671.         case DeliverReq:
  672.             msg = pdu_to_msg(pdu);
  674.             if (smasi->my_number && octstr_len(smasi->my_number)) {
  675.                 octstr_destroy(msg->sms.receiver);
  676.                 msg->sms.receiver = octstr_duplicate(smasi->my_number);
  677.             }
  679.             time(&msg->sms.time);
  680.             msg->sms.smsc_id = octstr_duplicate(smasi->conn->id);
  681.             bb_smscconn_receive(smasi->conn, msg);
  682.             resp = smasi_pdu_create(DeliverConf);
  684.             if (pdu->u.DeliverReq.Sequence)
  685.                 resp->u.DeliverConf.Sequence =
  686.                   octstr_duplicate(pdu->u.DeliverReq.Sequence);
  688.             if (pdu->u.DeliverReq.MsgReference)
  689.                 resp->u.DeliverConf.MsgReference =
  690.                   octstr_duplicate(pdu->u.DeliverReq.MsgReference);
  691.             break;
  693.         case SubmitConf:
  694.             if (pdu->u.SubmitConf.Sequence) {
  695.                 msg = dict_remove(smasi->sent_msgs, 
  696.                                   pdu->u.SubmitConf.Sequence);
  697.             } else {
  698.                 msg = NULL;
  699.             }
  701.             if (msg == NULL) {
  702.                 warning(0, "SMASI[%s]: SMSC sent SubmitConf for unknown message.",
  703.                         octstr_get_cstr(smasi->conn->id));
  704.             } else {
  705.                 debug("bb.sms.smasi",0,
  706.                       "SMSC[%s]: SMSC confirmed msg seq <%s> ref <%s>",
  707.                        octstr_get_cstr(smasi->conn->id),
  708.                        octstr_get_cstr(pdu->u.SubmitConf.Sequence),
  709.                        octstr_get_cstr(pdu->u.SubmitConf.MsgReference));
  711.                 bb_smscconn_sent(smasi->conn, msg);
  713.                 --(*pending_submits);
  714.             }
  715.             break;
  717.         case SubmitRej:
  718.             if (pdu->u.SubmitRej.Sequence) {
  719.                 msg = dict_remove(smasi->sent_msgs, 
  720.                                   pdu->u.SubmitRej.Sequence);
  721.             } else {
  722.                 msg = NULL;
  723.             }
  725.             error(0, "SMASI[%s]: SMSC returned error code %s for "
  726.                   "message ref <%s>", octstr_get_cstr(smasi->conn->id),
  727.                   octstr_get_cstr(pdu->u.SubmitRej.RejectCode),
  728.                   octstr_get_cstr(pdu->u.SubmitRej.MsgReference));
  730.             if (msg == NULL) {
  731.                warning(0, "SMASI[%s]: SMSC sent SubmitRej for unknown message.",
  732.                        octstr_get_cstr(smasi->conn->id));
  733.             } else {
  734.                 reason = SMSCCONN_FAILED_REJECTED;
  735.                 bb_smscconn_send_failed(smasi->conn, msg, reason);
  736.                 --(*pending_submits);
  737.             }
  738.             break;
  740.         case LogonConf:
  741.             *pending_submits = 0;
  743.             smasi->conn->status = SMSCCONN_ACTIVE;
  744.             smasi->conn->connect_time = time(NULL);
  746.             bb_smscconn_connected(smasi->conn);
  748.             info(0, "SMASI[%s]: connection to SMSC established.",
  749.                  octstr_get_cstr(smasi->conn->id));
  750.             break;
  752.         case LogonRej:
  753.             if (octstr_len(pdu->u.LogonRej.Reason) > 0) {
  754.                 error(0, "SMASI[%s]: SMSC rejected login with reason <%s>",
  755.                       octstr_get_cstr(smasi->conn->id),
  756.                       octstr_get_cstr(pdu->u.LogonRej.Reason));
  757.             } else {
  758.                 error(0, "SMASI[%s]: SMSC rejected login without reason",
  759.                       octstr_get_cstr(smasi->conn->id));
  760.             }
  761.             break;
  763.         case LogoffConf:
  764.             info(0, "SMASI[%s]: SMSC confirmed logoff.",
  765.                  octstr_get_cstr(smasi->conn->id));
  766.             smasi->logged_off = 1;
  767.             break;
  769.         default:
  770.             warning(0, "SMASI[%s]: Unknown PDU type <%s>, ignored.",
  771.                     octstr_get_cstr(smasi->conn->id), pdu->type_name);
  772.             break;
  773.     }
  775.     if (resp != NULL) {
  776.         send_pdu(conn, smasi->conn->id, resp);
  777.         smasi_pdu_destroy(resp);
  778.     }
  779. }
  782. /************************************************************************/
  783. /* SMASI CONNECTION HANDLING                                            */
  784. /************************************************************************/
  786. /*
  787.  * Open transmission connection to SMS center. Return NULL for error,
  788.  * open connection for OK. Caller must set smasi->conn->status correctly
  789.  * before calling this.
  790.  */
  791. static Connection *open_connection(SMASI *smasi) 
  792. {
  793.     Connection *conn = conn_open_tcp(smasi->host, smasi->port, NULL);
  795.     if (conn == NULL) {
  796.         error(0, "SMASI[%s]: Couldn't connect to server.",
  797.               octstr_get_cstr(smasi->conn->id));
  798.         return NULL;
  799.     } else {
  800.         SMASI_PDU *logon = smasi_pdu_create(LogonReq);
  802.         logon->u.LogonReq.Name = octstr_duplicate(smasi->username);
  803.         logon->u.LogonReq.Password = octstr_duplicate(smasi->password);
  805.         counter_increase(smasi->message_id_counter);
  807.         send_pdu(conn, smasi->conn->id, logon);
  809.         smasi_pdu_destroy(logon);
  810.     }
  812.     return conn;
  813. } 
  816. static void send_messages(SMASI *smasi, Connection *conn, 
  817.                           long *pending_submits) 
  818. {
  819.     if (*pending_submits == -1) return;
  821.     while (*pending_submits < MAX_PENDING_SUBMITS) {
  822.         SMASI_PDU *pdu = NULL;
  823.         /* Get next message, quit if none to be sent. */
  824.         Msg * msg = list_extract_first(smasi->msgs_to_send);
  826.         if (msg == NULL) break;
  828.         /* Send PDU, record it as waiting for ack from SMSC. */
  829.         pdu = msg_to_pdu(smasi, msg);
  831.         if (pdu->u.SubmitReq.Sequence)
  832.             dict_put(smasi->sent_msgs, pdu->u.SubmitReq.Sequence, msg);
  834.         send_pdu(conn, smasi->conn->id, pdu);
  836.         smasi_pdu_destroy(pdu);
  838.         ++(*pending_submits);
  839.     }
  840. }
  843. /*
  844.  * This is the main function for the background thread for doing I/O on
  845.  * one SMASI connection (the one for transmitting or receiving messages).
  846.  * It makes the initial connection to the SMASI server and re-connects
  847.  * if there are I/O errors or other errors that require it.
  848.  */
  849. static void smasi_thread(void *arg) 
  850. {
  851.     long pending_submits;
  852.     long len;
  853.     SMASI_PDU *pdu;
  854.     SMASI *smasi;
  855.     int logoff_already_sent = 0;
  856.     int ret;
  857.     Connection *conn;
  858.     long last_enquire_sent; 
  859.     double timeout; 
  861.     smasi = arg;
  863.     while (!smasi->quitting) {
  865.         conn = open_connection(smasi);
  866.         if (conn == NULL) {
  867.             error(0, "SMASI[%s]: Could not connect to SMSC center " 
  868.                   "(retrying in %ld seconds).",
  869.                   octstr_get_cstr(smasi->conn->id), smasi->reconnect_delay);
  871.             gwthread_sleep(smasi->reconnect_delay);
  872.             smasi->conn->status = SMSCCONN_RECONNECTING;
  873.             continue;
  874.         }
  876.         last_enquire_sent = date_universal_now(); 
  877.         pending_submits = -1;
  878.         len = 0;
  880.         for (;;) {
  881.             timeout = last_enquire_sent + smasi->enquire_link_interval
  882.                         - date_universal_now(); 
  884.             /* Send logoff request if module is shutting down. */
  885.             if (smasi->quitting && !logoff_already_sent) {
  886.                 send_logoff(smasi, conn);
  887.                 logoff_already_sent = 1;
  888.             } 
  890.             /* send an enquire link */
  891.             send_enquire_link(smasi, conn, &last_enquire_sent); 
  893.             /* Receive incoming PDUs. */
  894.             while ((ret = read_pdu(smasi, conn, &pdu)) == 1) {
  895.                 /* Deal with the PDU we just got */ 
  896.                 dump_pdu("Got PDU:", smasi->conn->id, pdu);
  898.                 /* Process the received PDU. */
  899.                 handle_pdu(smasi, conn, pdu, &pending_submits);
  901.                 smasi_pdu_destroy(pdu);
  903.                 /* Bail out if logoff confirmed. */
  904.                 if (smasi->logged_off) break;
  906.                 /* Make sure we send even if we read a lot. */
  907.                 if ((!smasi->throttling_err_time ||
  908.                     ((time(NULL) - smasi->throttling_err_time) >
  909.                      SMASI_THROTTLING_SLEEP_TIME
  910.                       && !(smasi->throttling_err_time = 0))))
  911.                     send_messages(smasi, conn, &pending_submits);
  912.             } 
  914.             /* Check if connection broken. */
  915.             if (ret == -1 || conn_wait(conn, -1) == -1) {
  916.                 error(0, "SMASI[%s]: I/O error or other error. Re-connecting.",
  917.                       octstr_get_cstr(smasi->conn->id));
  918.                 break;
  919.             } 
  921.             /* Bail out if logoff confirmed. */
  922.             if (smasi->logged_off) break;
  924.             if ((!smasi->throttling_err_time ||
  925.                 ((time(NULL) - smasi->throttling_err_time) >
  926.                  SMASI_THROTTLING_SLEEP_TIME
  927.                   && !(smasi->throttling_err_time = 0))))
  928.                 send_messages(smasi, conn, &pending_submits);
  930.         } 
  932.         conn_destroy(conn);
  933.         conn = NULL;
  934.     } 
  935. } 
  938. /************************************************************************/
  939. /* SMSCCONN INTERFACE                                                   */
  940. /************************************************************************/
  942. static long queued_cb(SMSCConn *conn) 
  943. {
  944.     SMASI *smasi = conn->data;
  946.     conn->load = (smasi ? (conn->status != SMSCCONN_DEAD ? 
  947.                     list_len(smasi->msgs_to_send) : 0) : 0);
  949.     return conn->load;
  950. } 
  953. static int send_msg_cb(SMSCConn *conn, Msg *msg) 
  954. {
  955.     SMASI *smasi = conn->data;
  957.     list_produce(smasi->msgs_to_send, msg_duplicate(msg));
  958.     gwthread_wakeup(smasi->thread_handle);
  960.     return 0;
  961. }
  964. static int shutdown_cb(SMSCConn *conn, int finish_sending) 
  965. {
  966.     SMASI *smasi = NULL;
  968.     debug("bb.sms.smasi", 0, "Shutting down SMSCConn %s (%s)",
  969.           octstr_get_cstr(conn->name), finish_sending ? "slow" : "instant");
  971.     conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;
  973.     smasi = conn->data;
  974.     smasi->quitting = 1;
  975.     gwthread_wakeup(smasi->thread_handle);
  976.     gwthread_join(smasi->thread_handle);
  977.     smasi_destroy(smasi);
  979.     debug("bb.sms.smasi", 0, "SMSCConn %s shut down.",
  980.           octstr_get_cstr(conn->name));
  981.     conn->status = SMSCCONN_DEAD;
  982.     bb_smscconn_killed();
  984.     /* Clean up. */
  985.     octstr_destroy(colon);
  986.     octstr_destroy(assign);
  987.     octstr_destroy(comma);
  988.     octstr_destroy(cr);
  989.     octstr_destroy(lf);
  991.     return 0;
  992. }
  995. /*
  996.  * Configures the SMASI structure according to the configuration.
  997.  *
  998.  * @return 0 on complete success. -1 if failed due to missing or invalid
  999.  * configuration entry.
  1000.  */
  1001. static int init_configuration(SMASI *smasi, CfgGroup *config) 
  1002. {
  1003.     /* Read mandatory entries. */
  1004.     smasi->host = cfg_get(config, octstr_imm("host"));
  1005.     smasi->username = cfg_get(config, octstr_imm("smsc-username"));
  1006.     smasi->password = cfg_get(config, octstr_imm("smsc-password"));
  1008.     /* Check configuration. */
  1009.     if (smasi->host == NULL) {
  1010.         error(0,"SMASI: Configuration file doesn't specify host");
  1011.         return -1;
  1012.     }
  1013.     if (smasi->username == NULL) {
  1014.         error(0, "SMASI: Configuration file doesn't specify username.");
  1015.         return -1;
  1016.     }
  1017.     if (smasi->password == NULL) {
  1018.         error(0, "SMASI: Configuration file doesn't specify password.");
  1019.         return -1;
  1020.     }
  1022.     /* Read optional entries. Set default values if not set. */
  1023.     smasi->my_number = cfg_get(config, octstr_imm("my-number"));
  1024.     if (cfg_get_integer(&smasi->port, config, octstr_imm("port")) == -1)
  1025.         smasi->port = SMASI_DEFAULT_PORT;
  1026.     if (cfg_get_integer(&smasi->reconnect_delay, config,
  1027.       octstr_imm("reconnect-delay")) == -1)
  1028.         smasi->reconnect_delay = SMASI_RECONNECT_DELAY;
  1029.     if (cfg_get_integer(&smasi->source_addr_ton, config,
  1030.       octstr_imm("source-addr-ton")) == -1)
  1031.         smasi->source_addr_ton = SMASI_OVERRIDE_SOURCE_TON;
  1032.     if (cfg_get_integer(&smasi->source_addr_npi, config,
  1033.       octstr_imm("source-addr-npi")) == -1)
  1034.         smasi->source_addr_npi = SMASI_OVERRIDE_SOURCE_NPI;
  1035.     if (cfg_get_integer(&smasi->dest_addr_ton, config,
  1036.       octstr_imm("dest-addr-ton")) == -1)
  1037.         smasi->source_addr_ton = SMASI_OVERRIDE_DEST_TON;
  1038.     if (cfg_get_integer(&smasi->dest_addr_npi, config,
  1039.       octstr_imm("dest-addr-npi")) == -1)
  1040.         smasi->source_addr_npi = SMASI_OVERRIDE_DEST_NPI;
  1041.     if (cfg_get_integer(&smasi->priority, config,
  1042.       octstr_imm("priority")) == -1)
  1043.         smasi->priority = SMASI_DEFAULT_PRIORITY;
  1044.     if (cfg_get_integer(&smasi->enquire_link_interval, config,
  1045.       octstr_imm("enquire-link-interval")) == -1)
  1046.         smasi->enquire_link_interval = SMASI_ENQUIRE_LINK_INTERVAL;
  1047.    
  1048.     /* Configure SMSC connection. */
  1049.     smasi->conn->data = smasi;
  1050.     smasi->conn->name = octstr_format("SMASI:%S:%d:%S",
  1051.         smasi->host, smasi->port, smasi->username);
  1053.     smasi->conn->id = cfg_get(config, octstr_imm("smsc-id"));
  1055.     if (smasi->conn->id == NULL)
  1056.       smasi->conn->id = octstr_duplicate(smasi->conn->name);
  1058.     return 0;
  1059. } 
  1062. int smsc_smasi_create(SMSCConn *conn, CfgGroup *config) 
  1063. {
  1064.     SMASI *smasi = NULL;
  1066.     /* Initialize data encoding subsystem. */
  1067.     colon = octstr_create(":3a");
  1068.     assign = octstr_create(":3d");
  1069.     comma = octstr_create(":2c");
  1070.     cr = octstr_create(":0a");
  1071.     lf = octstr_create(":0d");
  1073.     /* Create main SMASI structure and initialize it with configuration
  1074.      * settings.
  1075.      */
  1076.     smasi = smasi_create(conn);
  1078.     if (init_configuration(smasi, config) != 0)
  1079.         panic(0, "SMASI SMSC module configuration invalid.");
  1081.     conn->status = SMSCCONN_CONNECTING;
  1083.     /* Port is always set to a configured value or defaults to 21500.
  1084.      * Therefore, threads are always started.
  1085.      */
  1086.     smasi->thread_handle = gwthread_create(smasi_thread, smasi);
  1088.     if (smasi->thread_handle == -1) {
  1089.         error(0, "SMASI[%s]: Couldn't start SMASI thread.",
  1090.               octstr_get_cstr(smasi->conn->id));
  1091.         smasi_destroy(conn->data);
  1092.         return -1;
  1093.     } 
  1095.     /* Setup control function pointers. */
  1096.     conn->shutdown = shutdown_cb;
  1097.     conn->queued = queued_cb;
  1098.     conn->send_msg = send_msg_cb;
  1100.     return 0;
  1101. }