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

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

手机WAP编程

开发平台：

WINDOWS

smsc_emi2.c：源码内容
  1. /*
  2.  * smsc_emi2.c - interface to EMI SMS centers
  3.  *
  4.  * Uoti Urpala 2001
  5.  */
  7. /* Doesn't warn about unrecognized configuration variables */
  8. /* The EMI specification doesn't document how connections should be
  9.  * opened/used. The way they currently work might need to be changed. */
  12. #include <sys/types.h>
  13. #include <sys/socket.h>
  14. #include <unistd.h>
  15. #include <errno.h>
  16. #include <time.h>
  17. #include <limits.h>
  18. #include <float.h>
  20. #include "gwlib/gwlib.h"
  21. #include "smscconn.h"
  22. #include "smscconn_p.h"
  23. #include "bb_smscconn_cb.h"
  24. #include "msg.h"
  25. #include "sms.h"
  26. #include "emimsg.h"
  27. #include "dlr.h"
  29. #define EMI2_MAX_TRN 100
  31. typedef struct privdata {
  32.     Octstr *name;
  33.     List *outgoing_queue;
  34.     long receiver_thread;
  35.     long sender_thread;
  36.     int retry;    /* Retry always to connect to smsc */
  37.     int shutdown;   /* Internal signal to shut down */
  38.     int listening_socket; /* File descriptor */
  39.     int send_socket;
  40.     int port, alt_port;   /* SMSC port */
  41.     int our_port;   /* Optional local port number in which to
  42.    * bind our end of send connection */
  43.     int rport;   /* Receive-port to listen */
  44.     Octstr *allow_ip, *deny_ip;
  45.     Octstr *host, *alt_host, *username, *password, *our_host;
  46.     Octstr *my_number; /* My number if we want to force one */
  47.     int unacked; /* Sent messages not acked */
  48.     struct {
  49. time_t sendtime; /* When we sent out a message with a given
  50.  * TRN. Is 0 if the TRN slot is currently free. */
  51. int     sendtype; /* OT of message, undefined if time == 0 */
  52. int dlr;            /* dlr = DLR_SMSC_SUCCESS || DLR_SMSC_FAIL */
  53. Msg     *sendmsg;  /* Corresponding message for OT == 51 */
  54.     } slots[EMI2_MAX_TRN];
  55.     int keepalive;  /* Seconds to send a Keepalive Command (OT=31) */
  56.     int flowcontrol; /* 0=Windowing, 1=Stop-and-Wait */
  57.     int waitack; /* Seconds to wait to ack */
  58.     int throughput; /* Messages per second */
  59.     int window; /* In windowed flow-control, the window size */
  60.     int         can_write;      /* write = 1, read = 0, for stop-and-wait flow control */
  61.     int         priv_nexttrn;   /* next TRN, this should never be accessed directly.
  62.  * use int emi2_next_trn (SMSCConn *conn) instead.
  63.  */
  64.     time_t last_activity_time; /* the last time something was sent over the main
  65.      * SMSC connection
  66.      */
  67.     time_t      check_time;
  68.     int         idle_timeout;   /* Seconds a Main connection to the SMSC is allowed to be idle.
  69.    If 0, no idle timeout is in effect */
  70.     Octstr   *npid; /* Notification PID value */
  71.     Octstr   *nadc; /* Notification Address */
  72. } PrivData;
  74. typedef enum {
  75.     EMI2_SENDREQ,  /* somebody asked this driver to send a SMS message */
  76.     EMI2_SMSCREQ,  /* the SMSC wants something from us */
  77.     EMI2_CONNERR,  /* an error condition in the SMSC main connection */
  78.     EMI2_TIMEOUT,  /* timeout on the SMSC main connection */
  79. } EMI2Event;
  81. #define PRIVDATA(conn) ((PrivData *)((conn)->data))
  83. #define SLOTBUSY(conn,i) (PRIVDATA(conn)->slots[(i)].sendtime != 0)
  85. #define CONNECTIONIDLE(conn)
  86. ((PRIVDATA(conn)->unacked == 0) &&
  87.  (PRIVDATA(conn)->idle_timeout ?
  88.   (PRIVDATA(conn)->last_activity_time + PRIVDATA(conn)->idle_timeout) <= time(0):0))
  90. #define emi2_can_send(conn)
  91. ((PRIVDATA(conn)->can_write || !PRIVDATA(conn)->flowcontrol) &&
  92.  (PRIVDATA(conn)->unacked < PRIVDATA(conn)->window) &&
  93.  (!PRIVDATA(conn)->shutdown))
  95. #define emi2_needs_keepalive(conn)
  96. (emi2_can_send(conn) &&
  97.  (PRIVDATA(conn)->keepalive > 0) &&
  98.  (time(NULL) > (PRIVDATA(conn)->last_activity_time + PRIVDATA(conn)->keepalive)))
  100. /*
  101.  * Send an EMI message and update the last_activity_time field.
  102.  */
  103. static int emi2_emimsg_send(SMSCConn *conn, Connection *server, struct emimsg *emimsg)
  104. {
  105.     int result = emimsg_send(server, emimsg, PRIVDATA(conn)->name);
  107.     if (result >= 0 && emimsg->or == 'O' && ( emimsg->ot == 31 || emimsg->ot == 51)) {
  108. PRIVDATA(conn)->last_activity_time = time (NULL);
  109.     }
  111.     return result;
  112. }
  114. /* Wait for a message of type 'ot', sent with TRN 0, to be acked.
  115.  * Timeout after 't' seconds. Any other packets received are ignored.
  116.  * This function is meant for initial login packet(s) and testing.
  117.  * Return 1 for positive ACK, 0 for timeout, -1 for broken/closed connection,
  118.  * -2 for negative NACK. */
  119. static int wait_for_ack(PrivData *privdata, Connection *server, int ot, int t)
  120. {
  121.     time_t timeout_time;
  122.     int time_left;
  123.     Octstr *str;
  124.     struct emimsg *emimsg;
  126.     timeout_time = time(NULL) + t;
  127.     while (1) {
  128. str = conn_read_packet(server, 2, 3);
  129. if (conn_eof(server)) {
  130.     error(0, "EMI2[%s]: connection closed in wait_for_ack",
  131.   octstr_get_cstr(privdata->name));
  132.     return -1;
  133. }
  134. if (conn_read_error(server)) {
  135.     error(0, "EMI2[%s]: connection error in wait_for_ack",
  136.   octstr_get_cstr(privdata->name));
  137.     return -1;
  138. }
  139. if (str) {
  140.     emimsg = get_fields(str, privdata->name);
  141.     if (emimsg == NULL) {
  142. octstr_destroy(str);
  143. continue;
  144.     }
  145.     if (emimsg->ot == ot && emimsg->trn == 0 && emimsg->or == 'R') {
  146. octstr_destroy(str);
  147. break;
  148.     }
  149.     warning(0, "EMI2[%s]: ignoring message %s while waiting for ack to"
  150. "ot:%d trn:%d", octstr_get_cstr(privdata->name),
  151. octstr_get_cstr(str), ot, 0);
  152.     emimsg_destroy(emimsg);
  153.     octstr_destroy(str);
  154. }
  155. time_left = timeout_time - time(NULL);
  156. if (time_left < 0 || privdata->shutdown)
  157.     return 0;
  158. conn_wait(server, time_left);
  159.     }
  160.     if (octstr_get_char(emimsg->fields[0], 0) == 'N') {
  161. emimsg_destroy(emimsg);
  162. return -2;
  163.     }
  164.     emimsg_destroy(emimsg);
  165.     return 1;
  166. }
  169. static struct emimsg *make_emi31(PrivData *privdata, int trn)
  170. {
  171.     struct emimsg *emimsg;
  173.     if(octstr_len(privdata->username) || octstr_len(privdata->my_number)) {
  174.         emimsg = emimsg_create_op(31, trn, privdata->name);
  175.         if(octstr_len(privdata->username)) {
  176.             emimsg->fields[0] = octstr_duplicate(privdata->username);
  177. } else {
  178.             emimsg->fields[0] = octstr_duplicate(privdata->my_number);
  179. }
  180.         emimsg->fields[1] = octstr_create("0539");
  181.         return emimsg;
  182.     } else {
  183.         return NULL;
  184.     }
  185. }
  188. static struct emimsg *make_emi60(PrivData *privdata)
  189. {
  190.     struct emimsg *emimsg;
  192.     emimsg = emimsg_create_op(60, 0, privdata->name);
  193.     emimsg->fields[E60_OADC] = octstr_duplicate(privdata->username);
  194.     emimsg->fields[E60_OTON] = octstr_create("6");
  195.     emimsg->fields[E60_ONPI] = octstr_create("5");
  196.     emimsg->fields[E60_STYP] = octstr_create("1");
  197.     emimsg->fields[E60_PWD] = octstr_duplicate(privdata->password);
  198.     octstr_binary_to_hex(emimsg->fields[E60_PWD], 1);
  199.     emimsg->fields[E60_VERS] = octstr_create("0100");
  200.     return emimsg;
  201. }
  204. static Connection *open_send_connection(SMSCConn *conn)
  205. {
  206.     PrivData *privdata = conn->data;
  207.     int result, wait, alt_host, do_alt_host;
  208.     struct emimsg *emimsg;
  209.     Connection *server;
  210.     Msg *msg;
  212.     do_alt_host = octstr_len(privdata->alt_host) != 0 || 
  213.     privdata->alt_port != 0;
  215.     wait = 0;
  216.     alt_host = -1; /* to avoid waiting in first cicle */
  218.     mutex_lock(conn->flow_mutex);
  219.     conn->status = SMSCCONN_RECONNECTING;
  220.     mutex_unlock(conn->flow_mutex);
  221.     while (!privdata->shutdown) {
  222. /* Change status only if the first attempt to form a
  223.  * connection fails, as it's possible that the SMSC closed the
  224.  * connection because of idle timeout and a new one will be
  225.  * created quickly. */
  226. if (wait) {
  227.     while ((msg = list_extract_first(privdata->outgoing_queue))) {
  228. bb_smscconn_send_failed(conn, msg,
  229. SMSCCONN_FAILED_TEMPORARILY);
  230.     }
  231.     if(alt_host == 0) {
  232. info(0, "EMI2[%s]: waiting for %d %s before trying to "
  233.     "connect again", octstr_get_cstr(privdata->name), 
  234.     (wait < 60 ? wait : wait/60), 
  235.     (wait < 60 ? "seconds" : "minutes"));
  236. gwthread_sleep(wait);
  237. wait = wait > (privdata->retry ? 3600 : 600) ?
  238.     (privdata->retry ? 3600 : 600) : wait * 2;
  239.     }
  240. }
  241. else
  242.     wait = 15; 
  244. if(alt_host != 1) {
  245.     info(0, "EMI2[%s]: connecting to Primary SMSC", 
  246.     octstr_get_cstr(privdata->name));
  247.     server = conn_open_tcp_with_port(privdata->host, privdata->port,
  248.      privdata->our_port, 
  249.      privdata->our_host);
  250.     if(do_alt_host)
  251. alt_host=1;
  252.     else
  253. alt_host=0;
  254. } else {
  255.     info(0, "EMI2[%s]: connecting to Alternate SMSC",
  256.     octstr_get_cstr(privdata->name));
  257.     /* use alt_host or/and alt_port if defined */
  258.     server = conn_open_tcp_with_port(
  259. (octstr_len(privdata->alt_host) ? privdata->alt_host : privdata->host),
  260. (privdata->alt_port ? privdata->alt_port : privdata->port),
  261. privdata->our_port, privdata->our_host);
  262.     alt_host=0;
  263. }
  264. if (privdata->shutdown) {
  265.     conn_destroy(server);
  266.     return NULL;
  267. }
  268. if (server == NULL) {
  269.     error(0, "EMI2[%s]: opening TCP connection to %s failed",
  270.   octstr_get_cstr(privdata->name),
  271.   octstr_get_cstr(privdata->host));
  272.     continue;
  273. }
  275. if (privdata->username && privdata->password) {
  276.     emimsg = make_emi60(privdata);
  277.     emi2_emimsg_send(conn, server, emimsg);
  278.     emimsg_destroy(emimsg);
  279.     result = wait_for_ack(privdata, server, 60, 30);
  280.     if (result == -2) {
  281. /* Are SMSCs going to return any temporary errors? If so,
  282.  * testing for those error codes should be added here. */
  283. error(0, "EMI2[%s]: Server rejected our login, giving up",
  284.       octstr_get_cstr(privdata->name));
  285. conn_destroy(server);
  286. if(! privdata->retry)  {
  287.     conn->why_killed = SMSCCONN_KILLED_WRONG_PASSWORD;
  288.     return NULL;
  289. } else
  290.     continue;
  291.     }
  292.     else if (result == 0) {
  293. error(0, "EMI2[%s]: Got no reply to login attempt "
  294.       "within 30 s", octstr_get_cstr(privdata->name));
  295. conn_destroy(server);
  296. continue;
  297.     }
  298.     else if (result == -1) { /* Broken connection, already logged */
  299. conn_destroy(server);
  300. continue;
  301.     }
  302.     privdata->last_activity_time = 0; /* to force keepalive after login */
  303.     privdata->can_write = 1;
  305. }
  307. mutex_lock(conn->flow_mutex);
  308. conn->status = SMSCCONN_ACTIVE;
  309. conn->connect_time = time(NULL);
  310. mutex_unlock(conn->flow_mutex);
  311. bb_smscconn_connected(conn);
  312. return server;
  313.     }
  314.     return NULL;
  315. }
  318. static void pack_7bit(Octstr *str)
  319. {
  320.     Octstr *result;
  321.     int len, i;
  322.     int numbits, value;
  324.     result = octstr_create("0");
  325.     len = octstr_len(str);
  326.     value = 0;
  327.     numbits = 0;
  328.     for (i = 0; i < len; i++) {
  329. value += octstr_get_char(str, i) << numbits;
  330. numbits += 7;
  331. if (numbits >= 8) {
  332.     octstr_append_char(result, value & 0xff);
  333.     value >>= 8;
  334.     numbits -= 8;
  335. }
  336.     }
  337.     if (numbits > 0)
  338. octstr_append_char(result, value);
  339.     octstr_set_char(result, 0, (len * 7 + 3) / 4);
  340.     octstr_delete(str, 0, LONG_MAX);
  341.     octstr_append(str, result);
  342.     octstr_binary_to_hex(str, 1);
  343.     octstr_destroy(result);
  344. }
  347. static struct emimsg *msg_to_emimsg(Msg *msg, int trn, PrivData *privdata)
  348. {
  349.     Octstr *str;
  350.     struct emimsg *emimsg;
  351.     int dcs;
  352.     struct tm tm;
  353.     char p[20];
  355.     emimsg = emimsg_create_op(51, trn, privdata->name);
  356.     str = octstr_duplicate(msg->sms.sender);
  357.     if(octstr_get_char(str,0) == '+') {
  358.      /* either alphanum or international */
  359.      if (!octstr_check_range(str, 1, 256, gw_isdigit)) {
  360.     /* alphanumeric sender address with + in front*/
  361.     charset_latin1_to_gsm(str);
  362.     octstr_truncate(str, 11); /* max length of alphanumeric OaDC */
  363.     emimsg->fields[E50_OTOA] = octstr_create("5039");
  364.     pack_7bit(str);
  365. }
  366. else {
  367.     /* international number. Set format and remove + */
  368.     emimsg->fields[E50_OTOA] = octstr_create("1139");
  369.     octstr_delete(str, 0, 1);
  370.     octstr_truncate(str, 22);  /* max length of numeric OaDC */
  371. }
  372.     }
  373.     else {
  374. if (!octstr_check_range(str, 0, 256, gw_isdigit)) {
  375.     /* alphanumeric sender address */
  376.             charset_latin1_to_gsm(str);
  377.     octstr_truncate(str, 11); /* max length of alphanumeric OaDC */
  378.     emimsg->fields[E50_OTOA] = octstr_create("5039");
  379.     pack_7bit(str);
  380. }
  381.     }
  382.  
  383.     emimsg->fields[E50_OADC] = str;
  385.     /* set protocoll id */
  386.     if (msg->sms.pid != 0) {
  387.         emimsg->fields[E50_RPID] = octstr_format("%04d", msg->sms.pid);
  388.     }
  390.     /* set reply path indicator */
  391.     if (msg->sms.rpi != 0) {
  392.         emimsg->fields[E50_RPI] = octstr_create("1");
  393.     }
  395.     str = octstr_duplicate(msg->sms.receiver);
  396.     if(octstr_get_char(str,0) == '+') {
  397.       /* international number format */
  398.       /* EMI doesnt understand + so we have to replace it with something useful */
  399.       /* we try 00 here. Should really be done in the config instead so this */
  400.       /* is only a workaround to make wrong configs work  */
  401.  octstr_delete(str, 0, 1);
  402.  octstr_insert_data(str, 0, "00",2);
  403.     }
  404.     octstr_truncate(str, 16); /* max length of ADC */
  405.     emimsg->fields[E50_ADC] = str;
  406.    
  407.     emimsg->fields[E50_XSER] = octstr_create("");
  409.     /* XSer1: UDH */
  410.     if (octstr_len(msg->sms.udhdata)) {
  411. str = octstr_create("");
  412. octstr_append_char(str, 1);
  413. octstr_append_char(str, octstr_len(msg->sms.udhdata));
  414. octstr_append(str, msg->sms.udhdata);
  415. octstr_binary_to_hex(str, 1);
  416. octstr_append(emimsg->fields[E50_XSER],str);
  417.         octstr_destroy(str);
  418.     }
  420.     /* XSer2: DCS */
  421.     dcs = fields_to_dcs(msg, msg->sms.alt_dcs);
  422.     if (dcs != 0 && dcs != 4) {
  423.     str = octstr_create("");
  424. octstr_append_char(str, 2); 
  425. octstr_append_char(str, 1); /* len 01 */
  426. octstr_append_char(str, dcs);
  427. octstr_binary_to_hex(str, 1);
  428. octstr_append(emimsg->fields[E50_XSER],str);
  429. octstr_destroy(str);
  430.     }
  432.     if (msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2) {
  433. emimsg->fields[E50_MT] = octstr_create("4");
  434. emimsg->fields[E50_MCLS] = octstr_create("1");
  435. str = octstr_duplicate(msg->sms.msgdata);
  436. emimsg->fields[E50_NB] =
  437.     octstr_format("%04d", 8 * octstr_len(str));
  438. octstr_binary_to_hex(str, 1);
  439. emimsg->fields[E50_TMSG] = str;
  440.     }
  441.     else {
  442. emimsg->fields[E50_MT] = octstr_create("3");
  443. str = octstr_duplicate(msg->sms.msgdata);
  444. charset_latin1_to_gsm(str);
  445. /* Could still be too long after truncation if there's an UDH part,
  446.  * but this is only to notice errors elsewhere (should never happen).*/
  447. if (charset_gsm_truncate(str, 160))
  448.     error(0, "EMI2[%s]: Message to send is longer "
  449.   "than 160 gsm characters",
  450.   octstr_get_cstr(privdata->name));
  451. octstr_binary_to_hex(str, 1);
  452. emimsg->fields[E50_AMSG] = str;
  453.     }
  455.     if (msg->sms.validity) {
  456. tm = gw_localtime(time(NULL) + msg->sms.validity * 60);
  457. sprintf(p, "%02d%02d%02d%02d%02d",
  458.     tm.tm_mday, tm.tm_mon + 1, tm.tm_year % 100, 
  459.     tm.tm_hour, tm.tm_min);
  460. str = octstr_create(p);
  461. emimsg->fields[E50_VP] = str;
  462.     }
  463.     if (msg->sms.deferred) {
  464. str = octstr_create("1");
  465. emimsg->fields[E50_DD] = str;
  466. tm = gw_localtime(time(NULL) + msg->sms.deferred * 60);
  467. sprintf(p, "%02d%02d%02d%02d%02d",
  468.     tm.tm_mday, tm.tm_mon + 1, tm.tm_year % 100, 
  469.     tm.tm_hour, tm.tm_min);
  470. str = octstr_create(p);
  471. emimsg->fields[E50_DDT] = str;
  472.     }
  474.     /* if delivery reports are asked, lets ask for them too */
  475.     /* even the sender might not be interested in delivery or non delivery */
  476.     /* we still need them back to clear out the memory after the message */
  477.     /* has been delivered or non delivery has been confirmed */
  478.     if (msg->sms.dlr_mask & (DLR_SUCCESS | DLR_FAIL | DLR_BUFFERED)) {
  479.      emimsg->fields[E50_NRQ] = octstr_create("1");
  480.         emimsg->fields[E50_NT] = octstr_create("");
  481.     octstr_append_decimal(emimsg->fields[E50_NT], 3 + (msg->sms.dlr_mask & DLR_BUFFERED)); 
  482.     if (privdata->npid)
  483.             emimsg->fields[E50_NPID] = octstr_duplicate(privdata->npid);
  484.     if (privdata->nadc)
  485.             emimsg->fields[E50_NADC] = octstr_duplicate(privdata->nadc); 
  486.     }
  487.     return emimsg;
  488. }
  491. /* Return -1 if the connection broke, 0 if the request couldn't be handled
  492.  * (unknown type), or 1 if everything was successful */
  493. static int handle_operation(SMSCConn *conn, Connection *server,
  494.    struct emimsg *emimsg)
  495. {
  496.     struct emimsg *reply;
  497.     Octstr *tempstr, *xser;
  498.     int type, len;
  499.     Msg *msg = NULL;
  500.     struct universaltime unitime;
  501.     int st_code;
  502.     PrivData *privdata = conn->data;
  504.   
  505.     switch(emimsg->ot) {
  506.     case 01:
  507. msg = msg_create(sms);
  508. if (emimsg->fields[E01_AMSG] == NULL)
  509.     emimsg->fields[E01_AMSG] = octstr_create("");
  510. else if (octstr_hex_to_binary(emimsg->fields[E01_AMSG]) == -1)
  511.     warning(0, "EMI2[%s]: Couldn't decode message text",
  512.     octstr_get_cstr(privdata->name));
  514. if (emimsg->fields[E01_MT] == NULL) {
  515.     warning(0, "EMI2[%s]: required field MT missing",
  516.     octstr_get_cstr(privdata->name));
  517.     /* This guess could be incorrect, maybe the message should just
  518.        be dropped */
  519.     emimsg->fields[E01_MT] = octstr_create("3");
  520. }
  522. if (octstr_get_char(emimsg->fields[E01_MT], 0) == '3') {
  523.     msg->sms.msgdata = emimsg->fields[E01_AMSG];
  524.     emimsg->fields[E01_AMSG] = NULL; /* So it's not freed */
  525.     charset_gsm_to_latin1(msg->sms.msgdata);
  526. }
  527. else {
  528.     error(0, "EMI2[%s]: MT == %s isn't supported for operation type 01",
  529.   octstr_get_cstr(privdata->name),
  530.   octstr_get_cstr(emimsg->fields[E01_MT]));
  531.     msg->sms.msgdata = octstr_create("");
  532. }
  534. msg->sms.sender = octstr_duplicate(emimsg->fields[E01_OADC]);
  535. if (msg->sms.sender == NULL) {
  536.     warning(0, "EMI2[%s]: Empty sender field in received message",
  537.     octstr_get_cstr(privdata->name));
  538.     msg->sms.sender = octstr_create("");
  539. }
  541. if(octstr_len(PRIVDATA(conn)->my_number)) {
  542.     msg->sms.receiver = octstr_duplicate(PRIVDATA(conn)->my_number);
  543. }
  544. else {
  545.     msg->sms.receiver = octstr_duplicate(emimsg->fields[E01_ADC]);
  546. }
  547. if (msg->sms.sender == NULL) {
  548.     warning(0, "EMI2[%s]: Empty receiver field in received message",
  549.     octstr_get_cstr(privdata->name));
  550.     msg->sms.receiver = octstr_create("");
  551. }
  553. /* Operation type 01 doesn't have a time stamp field */
  554. time(&msg->sms.time);
  556. msg->sms.smsc_id = octstr_duplicate(conn->id);
  557. bb_smscconn_receive(conn, msg);
  558. reply = emimsg_create_reply(01, emimsg->trn, 1, privdata->name);
  559. if (emi2_emimsg_send(conn, server, reply) < 0) {
  560.     emimsg_destroy(reply);
  561.     return -1;
  562. }
  563. emimsg_destroy(reply);
  564. return 1;
  566.     case 52:
  567. msg = msg_create(sms);
  568. /* AMSG is the same field as TMSG */
  569. if (emimsg->fields[E50_AMSG] == NULL)
  570.     emimsg->fields[E50_AMSG] = octstr_create("");
  571. else if (octstr_hex_to_binary(emimsg->fields[E50_AMSG]) == -1)
  572.     warning(0, "EMI2[%s]: Couldn't decode message text",
  573.       octstr_get_cstr(privdata->name));
  575. xser = emimsg->fields[E50_XSER];
  576. while (octstr_len(xser) > 0) {
  577.     tempstr = octstr_copy(xser, 0, 4);
  578.     if (octstr_hex_to_binary(tempstr) == -1)
  579. error(0, "EMI2[%s]: Invalid XSer", 
  580.       octstr_get_cstr(privdata->name));
  581.     type = octstr_get_char(tempstr, 0);
  582.     len = octstr_get_char(tempstr, 1);
  583.     octstr_destroy(tempstr);
  584.     if (len < 0) {
  585. error(0, "EMI2[%s]: Malformed emi XSer field",
  586.       octstr_get_cstr(privdata->name));
  587. break;
  588.     }
  589.     if (type != 1 && type != 2)
  590. warning(0, "EMI2[%s]: Unsupported EMI XSer field %d", 
  591. octstr_get_cstr(privdata->name), type);
  592.     else {
  593. if (type == 1) {
  594.     tempstr = octstr_copy(xser, 4, len * 2);
  595.     if (octstr_hex_to_binary(tempstr) == -1)
  596. error(0, "EMI2[%s]: Invalid UDH contents",
  597.       octstr_get_cstr(privdata->name));
  598.     msg->sms.udhdata = tempstr;
  599. }
  600. if (type == 2) {
  601.     int dcs;
  602.     tempstr = octstr_copy(xser, 4, 2);
  603.     octstr_hex_to_binary(tempstr);
  604.     dcs = octstr_get_char(tempstr, 0);
  605.     octstr_destroy(tempstr);
  606.     if (! dcs_to_fields(&msg, dcs)) {
  607. error(0, "EMI2[%s]: invalid dcs received",
  608.       octstr_get_cstr(privdata->name));
  609. /* XXX Should we discard message ? */
  610. dcs_to_fields(&msg, 0);
  611.     }
  612. }
  613.     }
  614.     octstr_delete(xser, 0, 2 * len + 4);
  615. }
  617. if (emimsg->fields[E50_MT] == NULL) {
  618.     warning(0, "EMI2[%s]: required field MT missing",
  619.     octstr_get_cstr(privdata->name));
  620.     /* This guess could be incorrect, maybe the message should just
  621.        be dropped */
  622.     emimsg->fields[E50_MT] = octstr_create("3");
  623. }
  624. if (octstr_get_char(emimsg->fields[E50_MT], 0) == '3') {
  625.     msg->sms.msgdata = emimsg->fields[E50_AMSG];
  626.     emimsg->fields[E50_AMSG] = NULL; /* So it's not freed */
  627.     charset_gsm_to_latin1(msg->sms.msgdata);
  628. }
  629. else if (octstr_get_char(emimsg->fields[E50_MT], 0) == '4') {
  630.     msg->sms.msgdata = emimsg->fields[E50_TMSG];
  631.     emimsg->fields[E50_TMSG] = NULL;
  632. }
  633. else {
  634.     error(0, "EMI2[%s]: MT == %s isn't supported yet",
  635.   octstr_get_cstr(privdata->name),
  636.   octstr_get_cstr(emimsg->fields[E50_MT]));
  637.     msg->sms.msgdata = octstr_create("");
  638. }
  640. msg->sms.sender = octstr_duplicate(emimsg->fields[E50_OADC]);
  641. if (msg->sms.sender == NULL) {
  642.     warning(0, "EMI2[%s]: Empty sender field in received message",
  643.     octstr_get_cstr(privdata->name));
  644.     msg->sms.sender = octstr_create("");
  645. }
  647. if(octstr_len(PRIVDATA(conn)->my_number)) {
  648.     msg->sms.receiver = octstr_duplicate(PRIVDATA(conn)->my_number);
  649. }
  650. else {
  651.     msg->sms.receiver = octstr_duplicate(emimsg->fields[E50_ADC]);
  652. }
  653. if (msg->sms.sender == NULL) {
  654.     warning(0, "EMI2[%s]: Empty receiver field in received message",
  655.     octstr_get_cstr(privdata->name));
  656.     msg->sms.receiver = octstr_create("");
  657. }
  659. tempstr = emimsg->fields[E50_SCTS]; /* Just a shorter name */
  660. if (tempstr == NULL) {
  661.     warning(0, "EMI2[%s]: Received EMI message doesn't have required timestamp",
  662.     octstr_get_cstr(privdata->name));
  663.     goto notime;
  664. }
  665. if (octstr_len(tempstr) != 12) {
  666.     warning(0, "EMI2[%s]: EMI SCTS field must have length 12, now %ld",
  667.     octstr_get_cstr(privdata->name), octstr_len(tempstr));
  668.     goto notime;
  669. }
  670. if (octstr_parse_long(&unitime.second, tempstr, 10, 10) != 12 ||
  671.     (octstr_delete(tempstr, 10, 2),
  672.      octstr_parse_long(&unitime.minute, tempstr, 8, 10) != 10) ||
  673.     (octstr_delete(tempstr, 8, 2),
  674.      octstr_parse_long(&unitime.hour, tempstr, 6, 10) != 8) ||
  675.     (octstr_delete(tempstr, 6, 2),
  676.      octstr_parse_long(&unitime.year, tempstr, 4, 10) != 6) ||
  677.     (octstr_delete(tempstr, 4, 2),
  678.      octstr_parse_long(&unitime.month, tempstr, 2, 10) != 4) ||
  679.     (octstr_delete(tempstr, 2, 2),
  680.      octstr_parse_long(&unitime.day, tempstr, 0, 10) != 2)) {
  681.     error(0, "EMI2[%s]: EMI delivery time stamp looks malformed",
  682.   octstr_get_cstr(privdata->name));
  683. notime:
  684.     time(&msg->sms.time);
  685. }
  686. else {
  687.     unitime.year += 2000; /* Conversion function expects full year */
  688.         unitime.month -= 1; /* conversion function expects 0-based months */
  689.     msg->sms.time = date_convert_universal(&unitime);
  690. }
  692. msg->sms.smsc_id = octstr_duplicate(conn->id);
  693. counter_increase(conn->received);
  694. bb_smscconn_receive(conn, msg);
  695. reply = emimsg_create_reply(52, emimsg->trn, 1, privdata->name);
  696. if (emi2_emimsg_send(conn, server, reply) < 0) {
  697.     emimsg_destroy(reply);
  698.     return -1;
  699. }
  700. emimsg_destroy(reply);
  701. return 1;
  702.     case 53: /* delivery notification */     
  703. st_code = atoi(octstr_get_cstr(emimsg->fields[E50_DST]));
  704. switch(st_code)
  705. {
  706. case 0: /* delivered */
  707. msg = dlr_find(octstr_get_cstr((conn->id ? conn->id : privdata->name)), 
  708. octstr_get_cstr(emimsg->fields[E50_SCTS]), /* timestamp */
  709. octstr_get_cstr(emimsg->fields[E50_OADC]), /* destination */
  710. DLR_SUCCESS);
  711. break;
  712. case 1: /* buffered */
  713. msg = dlr_find(octstr_get_cstr((conn->id ? conn->id : privdata->name)), 
  714. octstr_get_cstr(emimsg->fields[E50_SCTS]), /* timestamp */
  715. octstr_get_cstr(emimsg->fields[E50_OADC]), /* destination */
  716. DLR_BUFFERED);
  717. break;
  718. case 2: /* not delivered */
  719. msg = dlr_find(octstr_get_cstr((conn->id ? conn->id : privdata->name)), 
  720. octstr_get_cstr(emimsg->fields[E50_SCTS]), /* timestamp */
  721. octstr_get_cstr(emimsg->fields[E50_OADC]), /* destination */
  722. DLR_FAIL);
  723. break;
  724. }
  725. if (msg != NULL) {     
  726.     
  727.         /*
  728.          * Recode the msg structure with the given msgdata.
  729.          * Note: the DLR URL is delivered in msg->sms.dlr_url already.
  730.          */
  731.         msg->sms.msgdata = octstr_duplicate(emimsg->fields[E50_AMSG]);
  732.         octstr_hex_to_binary(msg->sms.msgdata);
  733.         msg->sms.sms_type = report;
  735.     bb_smscconn_receive(conn, msg);
  736. }
  737. reply = emimsg_create_reply(53, emimsg->trn, 1, privdata->name);
  738. if (emi2_emimsg_send(conn, server, reply) < 0) {
  739.     emimsg_destroy(reply);
  740.     return -1;
  741. }
  742. emimsg_destroy(reply);
  743. return 1;
  745.     default:
  746. error(0, "EMI2[%s]: I don't know how to handle operation type %d", 
  747.       octstr_get_cstr(privdata->name), emimsg->ot);
  748. return 0;
  749.     }
  750. }
  752. /*
  753.  * get all unacknowledged messages from the ringbuffer and queue them
  754.  * for retransmission.
  755.  */
  756. static void clear_sent(PrivData *privdata)
  757. {
  758.     int i;
  759.     debug("smsc.emi2", 0, "EMI2[%s]: clear_sent called", 
  760.   octstr_get_cstr(privdata->name));
  761.     for (i = 0; i < EMI2_MAX_TRN; i++) {
  762. if (privdata->slots[i].sendtime && privdata->slots[i].sendtype == 51)
  763.     list_produce(privdata->outgoing_queue, privdata->slots[i].sendmsg);
  764. privdata->slots[i].sendtime = 0;
  765.     }
  766.     privdata->unacked = 0;
  767. }
  769. /*
  770.  * wait seconds seconds for something to happen (a send SMS request, activity
  771.  * on the SMSC main connection, an error or timeout) and tell the caller
  772.  * what happened.
  773.  */
  774. static EMI2Event emi2_wait (SMSCConn *conn, Connection *server, double seconds)
  775. {
  776.     if (emi2_can_send(conn) && list_len(PRIVDATA(conn)->outgoing_queue)) {
  777. return EMI2_SENDREQ;
  778.     }
  779.     
  780.     if (server != NULL) {
  781. switch (conn_wait(server, seconds)) {
  782. case 1: return list_len(PRIVDATA(conn)->outgoing_queue) ? EMI2_SENDREQ : EMI2_TIMEOUT;
  783. case 0: return EMI2_SMSCREQ;
  784. default: return EMI2_CONNERR;
  785. }
  786.     } else {
  787. gwthread_sleep(seconds);
  788. return list_len(PRIVDATA(conn)->outgoing_queue) ? EMI2_SENDREQ : EMI2_TIMEOUT;
  789.     }
  790. }
  792. /*
  793.  * obtain the next free TRN.
  794.  */
  795. static int emi2_next_trn (SMSCConn *conn)
  796. {
  797. #define INC_TRN(x) ((x)=((x) + 1) % EMI2_MAX_TRN)
  798.     int result;
  799.     
  800.     while (SLOTBUSY(conn,PRIVDATA(conn)->priv_nexttrn))
  801. INC_TRN(PRIVDATA(conn)->priv_nexttrn); /* pick unused TRN */
  802.     
  803.     result = PRIVDATA(conn)->priv_nexttrn;
  804.     INC_TRN(PRIVDATA(conn)->priv_nexttrn);
  806.     return result;
  807. #undef INC_TRN
  808. }
  810. /*
  811.  * send an EMI type 31 message when required.
  812.  */
  813. static int emi2_keepalive_handling (SMSCConn *conn, Connection *server)
  814. {
  815.     struct emimsg *emimsg;
  816.     int nexttrn = emi2_next_trn (conn);
  817.     
  818.     emimsg = make_emi31(PRIVDATA(conn), nexttrn);
  819.     if(emimsg) {
  820.         PRIVDATA(conn)->slots[nexttrn].sendtype= 31;
  821.         PRIVDATA(conn)->slots[nexttrn].sendtime = time(NULL);
  822.         PRIVDATA(conn)->unacked++;
  824.         if (emi2_emimsg_send(conn, server, emimsg) == -1) {
  825.            emimsg_destroy(emimsg);
  826.            return -1;
  827.         }
  828.         emimsg_destroy(emimsg);
  829.     }
  831.     PRIVDATA(conn)->can_write = 0;
  833.     return 0;
  834. }
  837. /*
  838.  * the actual send logic: Send all queued messages in a burst.
  839.  */
  840. static int emi2_do_send (SMSCConn *conn, Connection *server)
  841. {
  842.     struct emimsg *emimsg;
  843.     Msg           *msg;
  844.     double         delay = 0;
  846.     if (PRIVDATA(conn)->throughput) {
  847. delay = 1.0 / PRIVDATA(conn)->throughput;
  848.     }
  849.     
  850.     /* Send messages if there's room in the sending window */
  851.     while (emi2_can_send (conn) &&
  852.    (msg = list_extract_first(PRIVDATA(conn)->outgoing_queue)) != NULL) {
  853. int nexttrn = emi2_next_trn (conn);
  855. if (PRIVDATA(conn)->throughput)
  856.     gwthread_sleep(delay);
  858. /* convert the generic Kannel message into an EMI type message */
  859. emimsg = msg_to_emimsg(msg, nexttrn, PRIVDATA(conn));
  861. /* remember the message for retransmission or DLR */
  862. PRIVDATA(conn)->slots[nexttrn].sendmsg = msg;
  863. PRIVDATA(conn)->slots[nexttrn].sendtype = 51;
  864. PRIVDATA(conn)->slots[nexttrn].sendtime = time(NULL);
  866. /* send the message */
  867. if (emi2_emimsg_send(conn, server, emimsg) == -1) {
  868.     emimsg_destroy(emimsg);
  869.     return -1;
  870. }
  872. /* report the submission to the DLR code */
  873. if (msg->sms.dlr_mask & 0x18) {
  874.     Octstr *ts;
  875.     ts = octstr_create("");
  876.     octstr_append(ts, (conn->id ? conn->id : PRIVDATA(conn)->name));
  877.     octstr_append_char(ts, '-');
  878.     octstr_append_decimal(ts, nexttrn);
  880.     dlr_add(octstr_get_cstr((conn->id ? conn->id : PRIVDATA(conn)->name)), 
  881.     octstr_get_cstr(ts),
  882.     octstr_get_cstr(msg->sms.sender),
  883.     octstr_get_cstr(emimsg->fields[E50_ADC]),
  884.     octstr_get_cstr(msg->sms.service),
  885.     octstr_get_cstr(msg->sms.dlr_url),
  886.     msg->sms.dlr_mask);
  887.     
  888.     octstr_destroy(ts);
  889.     PRIVDATA(conn)->slots[nexttrn].dlr = 1;
  890. } else {
  891.     PRIVDATA(conn)->slots[nexttrn].dlr = 0;
  892. }
  894. /* we just sent a message */
  895. PRIVDATA(conn)->unacked++;
  897. emimsg_destroy(emimsg);
  899. /*
  900.  * remember that there is an open request for stop-wait flow control
  901.  * FIXME: couldn't this be done with the unacked field as well? After
  902.  * all stop-wait is just a window of size 1.
  903.  */
  904. PRIVDATA(conn)->can_write = 0;
  905.     }
  907.     return 0;
  908. }
  910. static int emi2_handle_smscreq (SMSCConn *conn, Connection *server)
  911. {
  912.     Octstr   *str;
  913.     struct emimsg *emimsg;
  914.     PrivData *privdata = conn->data;
  915.     
  916.     /* Read acks/nacks/ops from the server */
  917.     while ((str = conn_read_packet(server, 2, 3))) {
  918. debug("smsc.emi2", 0, "EMI2[%s]: Got packet from the main socket",
  919.       octstr_get_cstr(privdata->name));
  921. /* parse the msg */
  922. emimsg = get_fields(str, privdata->name);
  923. octstr_destroy(str);
  925. if (emimsg == NULL) {
  926.     continue; /* The parse functions logged errors */
  927. }
  929. if (emimsg->or == 'O') {
  930.     /* If the SMSC wants to send operations through this
  931.      * socket, we'll have to read them because there
  932.      * might be ACKs too. We just drop them while stopped,
  933.      * hopefully the SMSC will resend them later. */
  934.     if (!conn->is_stopped) {
  935. if (handle_operation(conn, server, emimsg) < 0)
  936.     return -1; /* Connection broke */
  937.     } else {
  938. info(0, "EMI2[%s]: Ignoring operation from main socket "
  939.      "because the connection is stopped.",
  940.      octstr_get_cstr(privdata->name));
  941.     }
  942. } else {   /* Already checked to be 'O' or 'R' */
  943.     if (!SLOTBUSY(conn,emimsg->trn) ||
  944. emimsg->ot != PRIVDATA(conn)->slots[emimsg->trn].sendtype) {
  945. error(0, "EMI2[%s]: Got ack for TRN %d, don't remember sending O?", 
  946.       octstr_get_cstr(privdata->name), emimsg->trn);
  947.     } else {
  948. PRIVDATA(conn)->can_write = 1;
  949. PRIVDATA(conn)->slots[emimsg->trn].sendtime = 0;
  950. PRIVDATA(conn)->unacked--;
  952. if (emimsg->ot == 51) {
  953.     if (PRIVDATA(conn)->slots[emimsg->trn].dlr) {
  954. Msg *dlrmsg;
  955. Octstr *ts;
  956. Msg *origmsg;
  958. origmsg = PRIVDATA(conn)->slots[emimsg->trn].sendmsg;
  960. ts = octstr_create("");
  961. octstr_append(ts, (conn->id ? conn->id : privdata->name));
  962. octstr_append_char(ts, '-');
  963. octstr_append_decimal(ts, emimsg->trn);
  965. dlrmsg = dlr_find(octstr_get_cstr((conn->id ? conn->id : privdata->name)), 
  966.   octstr_get_cstr(ts), /* timestamp */
  967.   octstr_get_cstr(origmsg->sms.receiver), /* destination */
  968.   (octstr_get_char(emimsg->fields[0], 0) == 'A' ? 
  969.    DLR_SMSC_SUCCESS : DLR_SMSC_FAIL));
  971. octstr_destroy(ts);
  972. if (dlrmsg != NULL) {
  973.     Octstr *moretext;
  975.                 /*
  976.                  * Recode the msg structure with the given msgdata.
  977.                  * Note: the DLR URL is delivered in msg->sms.dlr_url already.
  978.                  */
  979.                 dlrmsg->sms.msgdata = octstr_duplicate(emimsg->fields[E50_AMSG]);
  980.                 octstr_hex_to_binary(dlrmsg->sms.msgdata);
  981.                 dlrmsg->sms.sms_type = report;
  983.     moretext = octstr_create("");
  984.     if (octstr_get_char(emimsg->fields[0], 0) == 'N') {
  985.                     octstr_append(moretext, emimsg->fields[1]);
  986.                     octstr_append_char(moretext, '-');
  987.                     octstr_append(moretext, emimsg->fields[2]);
  988.     }
  989.     octstr_append_char(moretext, '/');
  990.     octstr_insert(dlrmsg->sms.msgdata, moretext, 0);
  991.     octstr_destroy(moretext);
  993.     bb_smscconn_receive(conn, dlrmsg);
  994. }
  995.     }
  997.     if (octstr_get_char(emimsg->fields[0], 0) == 'A') {
  998. /* we got an ack back. We might have to store the */
  999. /* timestamp for delivery notifications now */
  1000. Octstr *ts, *adc;
  1001. int i;
  1002. Msg *m;
  1003.   
  1004. ts = octstr_duplicate(emimsg->fields[2]);
  1005. if (octstr_len(ts)) {
  1006.     i = octstr_search_char(ts,':',0);
  1007.     if (i>0) {
  1008. octstr_delete(ts,0,i+1);
  1009. adc = octstr_duplicate(emimsg->fields[2]);
  1010. octstr_truncate(adc,i);
  1011.         
  1012. m = PRIVDATA(conn)->slots[emimsg->trn].sendmsg;
  1013. if(m == NULL) {
  1014.     info(0,"EMI2[%s]: uhhh m is NULL, very bad",
  1015.  octstr_get_cstr(privdata->name));
  1016. } else if (m->sms.dlr_mask & 0x7) {
  1017.     dlr_add(octstr_get_cstr((conn->id ? conn->id : privdata->name)), 
  1018.     octstr_get_cstr(ts),
  1019.     octstr_get_cstr(m->sms.sender),
  1020.     octstr_get_cstr(adc),
  1021.     octstr_get_cstr(m->sms.service),
  1022.     octstr_get_cstr(m->sms.dlr_url),
  1023.     m->sms.dlr_mask);
  1024. }
  1025. octstr_destroy(ts);
  1026. octstr_destroy(adc);
  1027.     } else {
  1028. octstr_destroy(ts);
  1029.     }
  1031.     
  1032. }
  1033. /*
  1034.  * report the successful transmission to the generic bb code.
  1035.  */
  1036. bb_smscconn_sent(conn,
  1037.  PRIVDATA(conn)->slots[emimsg->trn].sendmsg);
  1038.     } else {
  1039. /* XXX Process error code here
  1040. long errorcode;
  1041. octstr_parse_long(&errorcode, emimsg->fields[1], 0, 10);
  1042. ... switch(errorcode) ...
  1043. } 
  1045. else { */
  1046.     bb_smscconn_send_failed(conn,
  1047. PRIVDATA(conn)->slots[emimsg->trn].sendmsg,
  1048. SMSCCONN_FAILED_REJECTED);
  1049. /* } */
  1050.     }
  1051. } else if (emimsg->ot == 31) {
  1052.     /* XXX Process error codes here
  1053.     if (octstr_get_char(emimsg->fields[0], 0) == 'N') {
  1054. long errorcode;
  1055. octstr_parse_long(&errorcode, emimsg->fields[1], 0, 10);
  1056. ... switch errorcode ...
  1057.     } 
  1058.     
  1059.     else { */
  1060. ;
  1061.     /* } */
  1062. } else {
  1063.     panic(0, "EMI2[%s]: Bug, ACK handler missing for sent packet",
  1064.   octstr_get_cstr(privdata->name));
  1065. }
  1066.     }
  1067. }
  1068. emimsg_destroy(emimsg);
  1069.     }
  1071.     if (conn_read_error(server)) {
  1072. error(0, "EMI2[%s]: Error trying to read ACKs from SMSC",
  1073.       octstr_get_cstr(privdata->name));
  1074. return -1;
  1075.     }
  1076.     
  1077.     if (conn_eof(server)) {
  1078. info(0, "EMI2[%s]: Main connection closed by SMSC",
  1079.      octstr_get_cstr(privdata->name));
  1080. return -1;
  1081.     }
  1083.     return 0;
  1084. }
  1086. static void emi2_idleprocessing(SMSCConn *conn)
  1087. {
  1088.     time_t current_time;
  1089.     int i;
  1090.     PrivData *privdata = conn->data;
  1091.     
  1092.     /*
  1093.      * Check whether there are messages the server hasn't acked in a
  1094.      * reasonable time
  1095.      */
  1096.     current_time = time(NULL);
  1097.     
  1098.     if (PRIVDATA(conn)->unacked && (current_time > (PRIVDATA(conn)->check_time + 30))) {
  1099. PRIVDATA(conn)->check_time = current_time;
  1100. for (i = 0; i < EMI2_MAX_TRN; i++) {
  1101.     if (SLOTBUSY(conn,i)
  1102. && PRIVDATA(conn)->slots[i].sendtime < (current_time - PRIVDATA(conn)->waitack)) {
  1103. PRIVDATA(conn)->slots[i].sendtime = 0;
  1104. PRIVDATA(conn)->unacked--;
  1105. if (PRIVDATA(conn)->slots[i].sendtype == 51) {
  1106.     warning(0, "EMI2[%s]: received neither ACK nor NACK for message %d " 
  1107.     "in %d seconds, resending message", octstr_get_cstr(privdata->name),
  1108.     i, PRIVDATA(conn)->waitack);
  1109.     list_produce(PRIVDATA(conn)->outgoing_queue,
  1110.  PRIVDATA(conn)->slots[i].sendmsg);
  1111.     if (PRIVDATA(conn)->flowcontrol) PRIVDATA(conn)->can_write=1;
  1112.     /* Wake up this same thread to send again
  1113.      * (simpler than avoiding sleep) */
  1114.     gwthread_wakeup(PRIVDATA(conn)->sender_thread);
  1115. } else if (PRIVDATA(conn)->slots[i].sendtype == 31) {
  1116.     warning(0, "EMI2[%s]: Alert (operation 31) was not "
  1117.     "ACKed within %d seconds", octstr_get_cstr(privdata->name),
  1118.     PRIVDATA(conn)->waitack);
  1119.     if (PRIVDATA(conn)->flowcontrol) PRIVDATA(conn)->can_write=1;
  1120. } else {
  1121.     panic(0, "EMI2[%s]: Bug, no timeout handler for sent packet",
  1122.   octstr_get_cstr(privdata->name));
  1123. }
  1124.     }
  1125. }
  1126.     }
  1127. }
  1129. static void emi2_idletimeout_handling (SMSCConn *conn, Connection **server)
  1130. {
  1131.     PrivData *privdata = conn->data;
  1133.     /*
  1134.      * close the connection if there was no activity.
  1135.      */
  1136.     if ((*server != NULL) && CONNECTIONIDLE(conn)) {
  1137. info(0, "EMI2[%s]: closing idle connection.",
  1138.      octstr_get_cstr(privdata->name));
  1139. conn_destroy(*server);
  1140. *server = NULL;
  1141.     }
  1142. }
  1144. /*
  1145.  * this function calculates the new timeouttime.
  1146.  */
  1147. static double emi2_get_timeouttime (SMSCConn *conn, Connection *server)
  1148. {
  1149.     double ka_timeouttime = PRIVDATA(conn)->keepalive ? PRIVDATA(conn)->keepalive + 1 : DBL_MAX;
  1150.     double idle_timeouttime = (PRIVDATA(conn)->idle_timeout && server) ? PRIVDATA(conn)->idle_timeout : DBL_MAX;
  1151.     double result = ka_timeouttime < idle_timeouttime ? ka_timeouttime : idle_timeouttime;
  1153.     if (result == DBL_MAX)
  1154. result = 30;
  1156.     return result;
  1157. }
  1159. /*
  1160.  * the main event processing loop.
  1161.  */
  1162. static void emi2_send_loop(SMSCConn *conn, Connection **server)
  1163. {
  1164.     PrivData *privdata = conn->data;
  1166.     for (;;) {
  1167. double timeouttime;
  1168. EMI2Event event;
  1170. if (emi2_needs_keepalive (conn)) {
  1171.     if (*server == NULL) {
  1172. return; /* reopen the connection */
  1173.     }
  1174.     
  1175.     emi2_keepalive_handling (conn, *server);
  1176. }
  1178. timeouttime = emi2_get_timeouttime (conn, *server);
  1180. event = emi2_wait (conn, *server, timeouttime);
  1182. switch (event) {
  1183. case EMI2_CONNERR:
  1184.     return;
  1185.     
  1186. case EMI2_SENDREQ:
  1187.     if (*server == NULL) {
  1188. return; /* reopen the connection */
  1189.     }
  1190.     
  1191.     if (emi2_do_send (conn, *server) < 0) {
  1192. return; /* reopen the connection */
  1193.     }
  1194.     break;
  1195.     
  1196. case EMI2_SMSCREQ:
  1197.     if (emi2_handle_smscreq (conn, *server) < 0) {
  1198. return; /* reopen the connection */
  1199.     }
  1200.     break;
  1201.     
  1202. case EMI2_TIMEOUT:
  1203.     break;
  1204. }
  1206.         if ((*server !=NULL) && (emi2_handle_smscreq (conn, *server) < 0)) {
  1207.             return; /* reopen the connection */
  1208.         }
  1210. emi2_idleprocessing (conn);
  1211. emi2_idletimeout_handling (conn, server);
  1213. if (PRIVDATA(conn)->shutdown && (PRIVDATA(conn)->unacked == 0)) {
  1214.     /* shutdown and no open messages */
  1215.     break;
  1216. }
  1218. if (*server != NULL) {
  1219.     if (conn_read_error(*server)) {
  1220. warning(0, "EMI2[%s]: Error reading from the main connection",
  1221. octstr_get_cstr(privdata->name));
  1222. break;
  1223.     }
  1225.     if (conn_eof(*server)) {
  1226. info(0, "EMI2[%s]: Main connection closed by SMSC",
  1227.      octstr_get_cstr(privdata->name));
  1228. break;
  1229.     }
  1230. }
  1231.     }
  1232. }
  1234. static void emi2_sender(void *arg)
  1235. {
  1236.     SMSCConn *conn = arg;
  1237.     PrivData *privdata = conn->data;
  1238.     Msg *msg;
  1239.     Connection *server;
  1241.     while (!privdata->shutdown) {
  1242. if ((server = open_send_connection(conn)) == NULL) {
  1243.     privdata->shutdown = 1;
  1244.     if (privdata->rport > 0)
  1245. gwthread_wakeup(privdata->receiver_thread);
  1246.     break;
  1247. }
  1248. emi2_send_loop(conn, &server);
  1249. clear_sent(privdata);
  1251. if (server != NULL) {
  1252.     conn_destroy(server);
  1253. }
  1254.     }
  1256.     while((msg = list_extract_first(privdata->outgoing_queue)) != NULL)
  1257. bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN);
  1258.     if (privdata->rport > 0)
  1259. gwthread_join(privdata->receiver_thread);
  1260.     mutex_lock(conn->flow_mutex);
  1262.     conn->status = SMSCCONN_DEAD;
  1264.     debug("bb.sms", 0, "EMI2[%s]: connection has completed shutdown.",
  1265.   octstr_get_cstr(privdata->name));
  1267.     list_destroy(privdata->outgoing_queue, NULL);
  1268.     octstr_destroy(privdata->name);
  1269.     octstr_destroy(privdata->allow_ip);
  1270.     octstr_destroy(privdata->deny_ip);
  1271.     octstr_destroy(privdata->host);
  1272.     octstr_destroy(privdata->alt_host);
  1273.     octstr_destroy(privdata->my_number);
  1274.     octstr_destroy(privdata->username);
  1275.     octstr_destroy(privdata->password);
  1276.     octstr_destroy(privdata->npid);
  1277.     octstr_destroy(privdata->nadc);
  1278.     gw_free(privdata);
  1279.     conn->data = NULL;
  1281.     mutex_unlock(conn->flow_mutex);
  1282.     bb_smscconn_killed();
  1283. }
  1286. static void emi2_receiver(SMSCConn *conn, Connection *server)
  1287. {
  1288.     PrivData *privdata = conn->data;
  1289.     Octstr *str;
  1290.     struct emimsg *emimsg;
  1292.     while (1) {
  1293. if (conn_eof(server)) {
  1294.     info(0, "EMI2[%s]: receive connection closed by SMSC",
  1295.  octstr_get_cstr(privdata->name));
  1296.     return;
  1297. }
  1298. if (conn_read_error(server)) {
  1299.     error(0, "EMI2[%s]: receive connection broken",
  1300.   octstr_get_cstr(privdata->name));
  1301.     return;
  1302. }
  1303. if (conn->is_stopped)
  1304.     str = NULL;
  1305. else
  1306.     str = conn_read_packet(server, 2, 3);
  1307. if (str) {
  1308.     debug("smsc.emi2", 0, "EMI2[%s]: Got packet from the receive connection.",
  1309.   octstr_get_cstr(privdata->name));
  1310.     if ( (emimsg = get_fields(str, privdata->name)) ) {
  1311. if (emimsg->or == 'O') {
  1312.     if (handle_operation(conn, server, emimsg) < 0) {
  1313. emimsg_destroy(emimsg);
  1314. return;
  1315.     }
  1316. }
  1317. else
  1318.     error(0, "EMI2[%s]: No ACKs expected on receive connection!",
  1319.   octstr_get_cstr(privdata->name));
  1320. emimsg_destroy(emimsg);
  1321.     }
  1322.     octstr_destroy(str);
  1323. }
  1324. else
  1325.     conn_wait(server, -1);
  1326. if (privdata->shutdown)
  1327.     break;
  1328.     }
  1329.     return;
  1330. }
  1333. static int emi2_open_listening_socket(PrivData *privdata)
  1334. {
  1335.     int s;
  1337.     if ( (s = make_server_socket(privdata->rport, NULL)) == -1) {
  1338.     /* XXX add interface_name if required */
  1339. error(0, "EMI2[%s]: could not create listening socket in port %d",
  1340.       octstr_get_cstr(privdata->name), privdata->rport);
  1341. return -1;
  1342.     }
  1343.     if (socket_set_blocking(s, 0) == -1) {
  1344. error(0, "EMI2[%s]: couldn't make listening socket port %d "
  1345.  "non-blocking", octstr_get_cstr(privdata->name), privdata->rport);
  1346. close(s);
  1347. return -1;
  1348.     }
  1349.     privdata->listening_socket = s;
  1350.     return 0;
  1351. }
  1354. static void emi2_listener(void *arg)
  1355. {
  1356.     SMSCConn *conn = arg;
  1357.     PrivData *privdata = conn->data;
  1358.     struct sockaddr_in server_addr;
  1359.     socklen_t server_addr_len;
  1360.     Octstr *ip;
  1361.     Connection *server;
  1362.     int  s, ret;
  1364.     while (!privdata->shutdown) {
  1365. server_addr_len = sizeof(server_addr);
  1366. ret = gwthread_pollfd(privdata->listening_socket, POLLIN, -1);
  1367. if (ret == -1) {
  1368.     if (errno == EINTR)
  1369. continue;
  1370.     error(0, "EMI2[%s]: Poll for emi2 smsc connections failed, shutting down",
  1371.   octstr_get_cstr(privdata->name));
  1372.     break;
  1373. }
  1374. if (privdata->shutdown)
  1375.     break;
  1376. if (ret == 0) /* This thread was woken up from elsewhere, but
  1377.  if we're not shutting down nothing to do here. */
  1378.     continue;
  1379. s = accept(privdata->listening_socket, (struct sockaddr *)&server_addr,
  1380.    &server_addr_len);
  1381. if (s == -1) {
  1382.     warning(errno, "EMI2[%s]: emi2_listener: accept() failed, retrying...",
  1383.     octstr_get_cstr(privdata->name));
  1384.     continue;
  1385. }
  1386. ip = host_ip(server_addr);
  1387. if (!is_allowed_ip(privdata->allow_ip, privdata->deny_ip, ip)) {
  1388.     info(0, "EMI2[%s]: smsc connection tried from denied host <%s>,"
  1389.  " disconnected", octstr_get_cstr(privdata->name), 
  1390.  octstr_get_cstr(ip));
  1391.     octstr_destroy(ip);
  1392.     close(s);
  1393.     continue;
  1394. }
  1395. server = conn_wrap_fd(s, 0);
  1396. if (server == NULL) {
  1397.     error(0, "EMI2[%s]: emi2_listener: conn_wrap_fd failed on accept()ed fd",
  1398.   octstr_get_cstr(privdata->name));
  1399.     octstr_destroy(ip);
  1400.     close(s);
  1401.     continue;
  1402. }
  1403. conn_claim(server);
  1404. info(0, "EMI2[%s]: smsc connected from %s", 
  1405.      octstr_get_cstr(privdata->name), octstr_get_cstr(ip));
  1406. octstr_destroy(ip);
  1408. emi2_receiver(conn, server);
  1409. conn_destroy(server);
  1410.     }
  1411.     if (close(privdata->listening_socket) == -1)
  1412. warning(errno, "EMI2[%s]: couldn't close listening socket "
  1413. "at shutdown", octstr_get_cstr(privdata->name));
  1414.     gwthread_wakeup(privdata->sender_thread);
  1415. }
  1418. static int add_msg_cb(SMSCConn *conn, Msg *sms)
  1419. {
  1420.     PrivData *privdata = conn->data;
  1421.     Msg *copy;
  1423.     copy = msg_duplicate(sms);
  1424.     list_produce(privdata->outgoing_queue, copy);
  1425.     gwthread_wakeup(privdata->sender_thread);
  1427.     return 0;
  1428. }
  1431. static int shutdown_cb(SMSCConn *conn, int finish_sending)
  1432. {
  1433.     PrivData *privdata = conn->data;
  1435.     debug("bb.sms", 0, "EMI2[%s]: Shutting down SMSCConn EMI2, %s",
  1436.   octstr_get_cstr(privdata->name), 
  1437.   finish_sending ? "slow" : "instant");
  1439.     /* Documentation claims this would have been done by smscconn.c,
  1440.        but isn't when this code is being written. */
  1441.     conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;
  1442.     privdata->shutdown = 1; /* Separate from why_killed to avoid locking, as
  1443.    why_killed may be changed from outside? */
  1445.     if (finish_sending == 0) {
  1446. Msg *msg;
  1447. while((msg = list_extract_first(privdata->outgoing_queue)) != NULL) {
  1448.     bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN);
  1449. }
  1450.     }
  1452.     if (privdata->rport > 0)
  1453. gwthread_wakeup(privdata->receiver_thread);
  1454.     return 0;
  1455. }
  1458. static void start_cb(SMSCConn *conn)
  1459. {
  1460.     PrivData *privdata = conn->data;
  1462.     /* in case there are messages in the buffer already */
  1463.     if (privdata->rport > 0)
  1464. gwthread_wakeup(privdata->receiver_thread);
  1465.     debug("smsc.emi2", 0, "EMI2[%s]: start called",
  1466.   octstr_get_cstr(privdata->name));
  1467. }
  1470. static long queued_cb(SMSCConn *conn)
  1471. {
  1472.     PrivData *privdata = conn->data;
  1473.     long ret;
  1475.     ret = (privdata ? list_len(privdata->outgoing_queue) : 0);
  1477.     /* use internal queue as load, maybe something else later */
  1479.     conn->load = ret;
  1480.     return ret;
  1481. }
  1484. int smsc_emi2_create(SMSCConn *conn, CfgGroup *cfg)
  1485. {
  1486.     PrivData *privdata;
  1487.     Octstr *allow_ip, *deny_ip, *host, *alt_host;
  1488.     long portno, our_port, keepalive, flowcontrol, waitack, throughput, 
  1489.          idle_timeout, alt_portno; 
  1490.     long window;
  1491.      /* has to be long because of cfg_get_integer */
  1492.     int i;
  1494.     allow_ip = deny_ip = host = alt_host = NULL; 
  1496.     privdata = gw_malloc(sizeof(PrivData));
  1497.     privdata->outgoing_queue = list_create();
  1498.     privdata->listening_socket = -1;
  1499.     privdata->can_write = 1;
  1500.     privdata->priv_nexttrn = 0;
  1501.     privdata->last_activity_time = 0;
  1503.     
  1504.     host = cfg_get(cfg, octstr_imm("host"));
  1505.     if (host == NULL) {
  1506. error(0, "EMI2[-]: 'host' missing in emi2 configuration.");
  1507. goto error;
  1508.     }
  1509.     privdata->host = host;
  1511.     if (cfg_get_integer(&portno, cfg, octstr_imm("port")) == -1)
  1512. portno = 0;
  1513.     privdata->port = portno;
  1514.     if (privdata->port <= 0 || privdata->port > 65535) {
  1515. error(0, "EMI2[%s]: 'port' missing/invalid in emi2 configuration.",
  1516.       octstr_get_cstr(host));
  1517. goto error;
  1518.     }
  1520.     privdata->our_host = cfg_get(cfg, octstr_imm("our-host"));
  1522.     if (cfg_get_integer(&our_port, cfg, octstr_imm("our-port")) == -1)
  1523. privdata->our_port = 0; /* 0 means use any port */
  1524.     else
  1525. privdata->our_port = our_port;
  1527.     privdata->name = cfg_get(cfg, octstr_imm("smsc-id"));
  1528.     if(privdata->name == NULL) {
  1529. privdata->name = octstr_create("");
  1531. /* Add our_host */
  1532. if(octstr_len(privdata->our_host)) {
  1533.     octstr_append(privdata->name, privdata->our_host);
  1534. }
  1536. /* Add our_port */
  1537. if(privdata->our_port != 0) {
  1538.     /* if we have our_port but not our_host, add kannel:our_port */
  1539.     if(octstr_len(privdata->name) == 0) {
  1540. octstr_append(privdata->name, octstr_imm("kannel"));
  1541.     }
  1542.     octstr_append_char(privdata->name, ':');
  1543.     octstr_append_decimal(privdata->name, privdata->our_port);
  1544. } else {
  1545.     if(octstr_len(privdata->name) != 0) {
  1546. octstr_append(privdata->name, octstr_imm(":*"));
  1547.     }
  1548. }
  1549.     
  1550. /* if we have our_host neither our_port */
  1551. if(octstr_len(privdata->name) != 0)
  1552.     octstr_append(privdata->name, octstr_imm("->"));
  1554. octstr_append(privdata->name, privdata->host);
  1555. octstr_append_char(privdata->name, ':');
  1556. octstr_append_decimal(privdata->name, privdata->port);
  1557.     }
  1560.     if (cfg_get_integer(&idle_timeout, cfg, octstr_imm("idle-timeout")) == -1)
  1561. idle_timeout = 0;
  1562.     
  1563.     privdata->idle_timeout = idle_timeout;
  1565.     alt_host = cfg_get(cfg, octstr_imm("alt-host"));
  1566.     privdata->alt_host = alt_host;
  1568.     if (cfg_get_integer(&portno, cfg, octstr_imm("receive-port")) < 0)
  1569. portno = 0;
  1570.     privdata->rport = portno;
  1572.     if (cfg_get_integer(&alt_portno, cfg, octstr_imm("alt-port")) < 0) 
  1573. alt_portno = 0;
  1574.     privdata->alt_port = alt_portno;
  1576.     allow_ip = cfg_get(cfg, octstr_imm("connect-allow-ip"));
  1577.     if (allow_ip)
  1578. deny_ip = octstr_create("*.*.*.*");
  1579.     else
  1580. deny_ip = NULL;
  1581.     privdata->username = cfg_get(cfg, octstr_imm("smsc-username"));
  1582.     privdata->password = cfg_get(cfg, octstr_imm("smsc-password"));
  1584.     privdata->my_number = cfg_get(cfg, octstr_imm("my-number"));
  1586.     privdata->npid = cfg_get(cfg, octstr_imm("notification-pid"));
  1587.     privdata->nadc = cfg_get(cfg, octstr_imm("notification-addr"));
  1588.     
  1589.     cfg_get_bool(&privdata->retry, cfg, octstr_imm("retry"));
  1590.     if(privdata->retry < 0) 
  1591. privdata->retry = 0;
  1593.     if ( (privdata->username == NULL && privdata->my_number == NULL)
  1594.          || cfg_get_integer(&keepalive, cfg, octstr_imm("keepalive")) < 0)
  1595. privdata->keepalive = 0;
  1596.     else
  1597. privdata->keepalive = keepalive;
  1599.     if (cfg_get_integer(&flowcontrol, cfg, octstr_imm("flow-control")) < 0)
  1600. privdata->flowcontrol = 0;
  1601.     else
  1602. privdata->flowcontrol = flowcontrol;
  1603.     if (privdata->flowcontrol < 0 || privdata->flowcontrol > 1) {
  1604. error(0, "EMI2[%s]: 'flow-control' invalid in emi2 configuration.",
  1605.       octstr_get_cstr(privdata->name));
  1606. goto error;
  1607.     }
  1609.     if (cfg_get_integer(&throughput, cfg, octstr_imm("throughput")) < 0)
  1610. privdata->throughput = 0;
  1611.     else
  1612. privdata->throughput = throughput;
  1614.     if (cfg_get_integer(&window, cfg, octstr_imm("window")) < 0)
  1615. privdata->window = EMI2_MAX_TRN;
  1616.     else
  1617. privdata->window = window;
  1618.     if (privdata->window > EMI2_MAX_TRN) {
  1619. warning(0, "EMI2[%s]: Value of 'window' should be lesser or equal to %d..", 
  1620. octstr_get_cstr(privdata->name), EMI2_MAX_TRN);
  1621. privdata->window = EMI2_MAX_TRN;
  1622.     }
  1624.     if (cfg_get_integer(&waitack, cfg, octstr_imm("wait-ack")) < 0)
  1625. privdata->waitack = 60;
  1626.     else
  1627. privdata->waitack = waitack;
  1628.     if (privdata->waitack < 30 ) {
  1629. error(0, "EMI2[%s]: 'wait-ack' invalid in emi2 configuration.",
  1630.       octstr_get_cstr(privdata->name));
  1631. goto error;
  1632.     }
  1634.     if (privdata->rport < 0 || privdata->rport > 65535) {
  1635. error(0, "EMI2[%s]: 'receive-port' missing/invalid in emi2 configuration.",
  1636.       octstr_get_cstr(privdata->name));
  1637. goto error;
  1638.     }
  1640.     privdata->allow_ip = allow_ip;
  1641.     privdata->deny_ip = deny_ip;
  1643.     if (privdata->rport > 0 && emi2_open_listening_socket(privdata) < 0) {
  1644. gw_free(privdata);
  1645. privdata = NULL;
  1646. goto error;
  1647.     }
  1649.     conn->data = privdata;
  1651.     conn->name = octstr_format("EMI2:%S:%d:%S", privdata->host, privdata->port,
  1652.                                privdata->username ? privdata->username : octstr_imm("null"));
  1654.     privdata->shutdown = 0;
  1656.     for (i = 0; i < EMI2_MAX_TRN; i++)
  1657. privdata->slots[i].sendtime = 0;
  1658.     privdata->unacked = 0;
  1660.     conn->status = SMSCCONN_CONNECTING;
  1661.     conn->connect_time = time(NULL);
  1663.     if ( privdata->rport > 0 && (privdata->receiver_thread =
  1664.   gwthread_create(emi2_listener, conn)) == -1)
  1665.   goto error;
  1667.     if ((privdata->sender_thread = gwthread_create(emi2_sender, conn)) == -1) {
  1668. privdata->shutdown = 1;
  1669. if (privdata->rport > 0) {
  1670.     gwthread_wakeup(privdata->receiver_thread);
  1671.     gwthread_join(privdata->receiver_thread);
  1672. }
  1673. goto error;
  1674.     }
  1676.     conn->shutdown = shutdown_cb;
  1677.     conn->queued = queued_cb;
  1678.     conn->start_conn = start_cb;
  1679.     conn->send_msg = add_msg_cb;
  1681.     return 0;
  1683. error:
  1684.     error(0, "EMI2[%s]: Failed to create emi2 smsc connection",
  1685.   octstr_get_cstr(privdata->name));
  1686.     if (privdata != NULL) {
  1687. list_destroy(privdata->outgoing_queue, NULL);
  1688.     }
  1689.     gw_free(privdata);
  1690.     octstr_destroy(allow_ip);
  1691.     octstr_destroy(deny_ip);
  1692.     octstr_destroy(host);
  1693.     conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
  1694.     conn->status = SMSCCONN_DEAD;
  1695.     info(0, "EMI2[%s]: exiting", octstr_get_cstr(privdata->name));
  1696.     return -1;
  1697. }