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

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

手机WAP编程

开发平台：

WINDOWS

smsc_cgw.c：源码内容
  1. /*
  2.  * smsc_cgw.c - Implements an interface to the Sonera ContentGateway software
  3.  *
  4.  * Anders Lindh, FlyerOne Ltd <alindh@flyerone.com>
  5.  *
  6.  *
  7.  * Changelog:
  8.  *
  9.  * 22/02/2002: Preliminary support for the Euro character (req. ProviderServer 2.5.2)
  10.  * 25/01/2002: Caught a potentially nasty bug
  11.  * 16/01/2002: Some code cleanup
  12.  * 10/01/2002: Fixed a bug in trn handling
  13.  * 16/11/2001: Some minor fixes (Thanks to Tuomas Luttinen)
  14.  * 12/11/2001: Delivery reports, better acking and numerous other small fixes
  15.  * 05/11/2001: Initial release. Based heavily on smsc_emi2 and smsc_at2. 
  16.  *
  17.  *
  18.  * TO-DO: Do some real life testing
  19.  *        Squash bugs
  20.  *
  21.  * Usage: add the following to kannel.conf:
  22.  *
  23.  * group = smsc
  24.  * smsc = cgw
  25.  * host = x.x.x.x      <- CGW server host
  26.  * port = xxxx         <- CGW server otp port (if omitted, defaults to 21772)
  27.  * receive-port = xxxx <- our port for incoming messages
  28.  * appname = xxxx      <- Name of a "Send only" service. Defaults to "send".
  29.  *               All outgoing messages are routed through this service.
  30.  *
  31.  * Configure ContentGateway software to use the above port as text-port
  32.  * (in provider.cnf). This is documented in their "Guide for Service
  33.  * development 2.5", page 80.
  34.  *
  35.  * Add a new "Receive only" service (with the Remote Control tool), and set
  36.  * the "Application for Incoming Message" to "text://kannelhost:receive-port".
  37.  *
  38.  *
  39.  * Note:
  40.  *
  41.  * Do NOT define the service as a "Query/Reply" service, as it expects response
  42.  * messages to have a matching session-id tag. Kannel does not store the
  43.  * relation between a query and a reply, so the response message will not have
  44.  * the session-id tag. Even though the messages are delivered successfully,
  45.  * billing of premium priced services will fail.
  46.  *
  47.  *
  48.  */
  51. #include <sys/types.h>
  52. #include <sys/socket.h>
  53. #include <unistd.h>
  54. #include <errno.h>
  55. #include <time.h>
  56. #include <limits.h>
  58. #include "gwlib/gwlib.h"
  59. #include "smscconn.h"
  60. #include "smscconn_p.h"
  61. #include "bb_smscconn_cb.h"
  62. #include "msg.h"
  63. #include "sms.h"
  64. #include "dlr.h"
  67. #define CGW_DEFPORT  21772
  68. #define CGW_EOL      0x0A
  69. #define CGW_TRN_MAX  500 /* Size of our internal message buffer. */
  71. #define CGWOP_MAXARGS 10      /* max. number of name:value pairs in cgwop */
  73. /* Valid CGW operations */
  75. #define CGW_OP_NOP 0      /* this doesn't really exist.. */
  76. #define CGW_OP_MSG 1
  77. #define CGW_OP_OK 2
  78. #define CGW_OP_ERR 3
  79. #define CGW_OP_DELIVERY 4
  80. #define CGW_OP_HELLO 5
  81. #define CGW_OP_STATUS 6
  83. struct cgwop
  84. {
  85.     int op;     /* one of above */
  86.     int num_fields;
  87.     int trn;                    /* transaction number, used to ACK messages */
  88.     Octstr **name;     /* for storing name/value pairs */
  89.     Octstr **value;
  90. };
  92. static char *cgw_ops[6] = {"nop", "msg", "ok", "err", "delivery", "hello"};
  95. typedef struct privdata
  96. {
  97.     List *outgoing_queue;
  98.     long receiver_thread;
  99.     long sender_thread;
  100.     int shutdown;             /* Internal signal to shut down */
  101.     int listening_socket;      /* File descriptor */
  102.     int send_socket;
  103.     int port;             /* SMSC port */
  104.     int rport;     /* port for receiving messages*/
  105.     int our_port;        /* Optional local port number in which to
  106.                            * bind our end of send connection */
  107.     Octstr *host;
  108.     Octstr *allow_ip, *deny_ip;
  109.     Octstr *appname;     /* Application name as defined in Sonera Remote manager */
  111.     Msg *sendmsg[CGW_TRN_MAX];
  112.     time_t sendtime[CGW_TRN_MAX];
  113.     int dlr[CGW_TRN_MAX];     /* dlr = DLR_SMSC_SUCCESS || DLR_SMSC_FAIL */
  114.     int unacked;     /* Sent messages not acked */
  115.     int waitack;         /* Seconds to wait to ack */
  116.     int nexttrn;
  117.     long check_time;      /* last checked ack/nack status */
  118. }
  119. PrivData;
  122. static int cgw_add_msg_cb(SMSCConn *conn, Msg *sms);
  123. static int cgw_shutdown_cb(SMSCConn *conn, int finish_sending);
  124. static void cgw_start_cb(SMSCConn *conn);
  125. static long cgw_queued_cb(SMSCConn *conn);
  126. static void cgw_sender(void *arg);
  127. static Connection *cgw_open_send_connection(SMSCConn *conn);
  128. static int cgw_send_loop(SMSCConn *conn, Connection *server);
  129. void cgw_check_acks(PrivData *privdata);
  130. int cgw_wait_command(PrivData *privdata, SMSCConn *conn, Connection *server, int timeout);
  131. static int cgw_open_listening_socket(PrivData *privdata);
  132. static void cgw_listener(void *arg);
  133. static void cgw_receiver(SMSCConn *conn, Connection *server);
  134. static int cgw_handle_op(SMSCConn *conn, Connection *server, struct cgwop *cgwop);
  135. struct cgwop *cgw_read_op(PrivData *privdata, SMSCConn *conn, Connection *server, time_t timeout);
  139. /******************************************************************************
  140.  * Functions for handling cgwop -structures
  141.  */
  143. static void cgwop_add(struct cgwop *cgwop, Octstr *name, Octstr *value)
  144. {
  145.     if (cgwop->num_fields < CGWOP_MAXARGS)
  146.     {
  147.         cgwop->name[cgwop->num_fields] = octstr_duplicate(name);
  148.         cgwop->value[cgwop->num_fields] = octstr_duplicate(value);
  150.         cgwop->num_fields++;
  151.     } else
  152.     {
  153.         info(0, "cgw: CGWOP_MAXARGS exceeded.");
  154.     }
  155. }
  158. static struct cgwop *cgwop_create(int op, int trn)
  159. {
  160.     struct cgwop *ret;
  161.     Octstr *trnstr;
  163.     ret = gw_malloc(sizeof(struct cgwop));
  165.     ret->op = op;
  166.     ret->num_fields = 0;
  167.     ret->trn = trn;
  169.     ret->name = gw_malloc(CGWOP_MAXARGS * sizeof(Octstr *));
  170.     ret->value = gw_malloc(CGWOP_MAXARGS * sizeof(Octstr *));
  172.     if (trn != -1)
  173.     {
  174.         trnstr = octstr_create("");
  175.         octstr_append_decimal(trnstr, trn);
  176.         cgwop_add(ret, octstr_imm("client-id"), trnstr);
  177.         octstr_destroy(trnstr);
  178.     }
  180.     return ret;
  181. }
  183. static void cgwop_destroy(struct cgwop *cgwop)
  184. {
  185.     int len;
  187.     len = cgwop->num_fields;
  188.     while (--len >= 0)
  189.     {
  190.         octstr_destroy(cgwop->name[len]);      /* octstr_destroy(NULL) is ok */
  191.         octstr_destroy(cgwop->value[len]);
  192.     }
  194.     gw_free(cgwop->name);
  195.     gw_free(cgwop->value);
  196.     gw_free(cgwop);
  197. }
  199. static Octstr *cgwop_get(struct cgwop *cgwop, Octstr *name)
  200. {
  201.     int len = cgwop->num_fields;
  203.     while (--len >= 0)
  204.         if (octstr_compare(name, cgwop->name[len]) == 0)
  205.             return cgwop->value[len];
  206.     return NULL;
  207. }
  209. static Octstr *cgwop_tostr(struct cgwop *cgwop)
  210. {
  211.     int len = cgwop->num_fields;
  212.     Octstr *str;
  214.     if (cgw_ops[cgwop->op] == NULL) return NULL;     // invalid operation
  216.     str = octstr_create("");
  218.     octstr_append(str, octstr_imm("op:"));
  219.     octstr_append(str, octstr_imm(cgw_ops[cgwop->op]));
  220.     octstr_append_char(str, CGW_EOL);
  222.     while (--len >= 0)
  223.     {
  224.         octstr_append(str, cgwop->name[len]);
  225.         octstr_append_char(str, ':');
  226.         octstr_append(str, cgwop->value[len]);
  227.         octstr_append_char(str, CGW_EOL);
  228.     }
  229.     octstr_append(str, octstr_imm("end:"));
  230.     octstr_append(str, octstr_imm(cgw_ops[cgwop->op]));
  231.     octstr_append_char(str, CGW_EOL);
  233.     return str;
  234. }
  236. static int cgwop_send(Connection *conn, struct cgwop *cgwop)
  237. {
  238.     Octstr *dta = cgwop_tostr(cgwop);
  240.     if (dta == NULL) return -1;     /* couldn't convert to string */
  242.     if (conn_write(conn, dta) == -1)
  243.     {
  244.         octstr_destroy(dta);
  245.         return -1;
  246.     }
  248.     octstr_destroy(dta);
  249.     return 1;
  250. }
  252. /******************************************************************************
  253.  * cgw_encode_msg - Encode a msg according to specifications
  254.  */
  256. static Octstr *cgw_encode_msg(Octstr* str)
  257. {
  258.     int i;
  259.     char esc = 27;
  260.     char e = 'e';
  262.     /* Euro char (0x80) -> ESC + e. We do this conversion as long as the message 
  263.        length is under 160 chars (the checking could probably be done better) */
  265.     while ((i = octstr_search_char(str, 0x80, 0)) != -1) {    
  266.         octstr_delete(str, i, 1);     // delete Euro char
  267. if (octstr_len(str) < 160) {
  268.     octstr_insert_data(str, i, &esc, 1);  // replace with ESC + e
  269.     octstr_insert_data(str, i+1, &e, 1);  
  270. } else {
  271.     octstr_insert_data(str, i, &e, 1);  // no room for ESC + e, just replace with an e
  272.         }
  273.     }
  276.     /* Escape backslash characters */
  277.     while ((i = octstr_search_char(str, '\', 0)) != -1) {
  278.         octstr_insert(str, octstr_imm("\"), i);
  279.     }
  280.     /* Remove Line Feed characters */
  281.     while ((i = octstr_search_char(str, CGW_EOL, 0)) != -1) {
  282.         octstr_delete(str, i, 1);     // delete EOL char
  283.         octstr_insert(str, octstr_imm("\n"), i);
  284.     }
  285.     /* Remove Carriage return characters */
  286.     while ((i = octstr_search_char(str, 13, 0)) != -1) {
  287.         octstr_delete(str, i, 1);     // delete EOL char
  288.         octstr_insert(str, octstr_imm("\r"), i);
  289.     }
  291.     return str;
  292. }
  294. /******************************************************************************
  295.  * cgw_decode_msg - Decode an incoming msg
  296.  */
  298. static Octstr *cgw_decode_msg(Octstr* str)
  299. {
  300.     int i;
  302.     /* make n -> linefeed */
  303.     while ((i = octstr_search(str, octstr_imm("\n"), 0)) != -1) {
  304.         octstr_delete(str, i, 2);     // delete "n" str
  305.         octstr_insert(str, octstr_imm("n"), i);
  306.     }
  307.     /* make r -> carriage return */
  308.     while ((i = octstr_search(str, octstr_imm("\r"), 0)) != -1) {
  309.         octstr_delete(str, i, 2);     // delete EOL char
  310.         octstr_insert(str, octstr_imm("r"), i);
  311.     }
  312.     /* remove double backslashes */
  313.     while ((i = octstr_search(str, octstr_imm("\\"), 0)) != -1) {
  314.         octstr_delete(str, i, 1);
  315.     }
  317.     return str;
  318. }
  320. /******************************************************************************
  321.  * msg_to_cgwop - Create a send cgwop from a message
  322.  */
  324. static struct cgwop *msg_to_cgwop(PrivData *privdata, Msg *msg, int trn)
  325. {
  326.     struct cgwop *cgwop;
  327.     Octstr *sender, *udh, *dta;
  329.     cgwop = cgwop_create(CGW_OP_MSG, trn);
  331.     if (cgwop == NULL) return NULL;
  333.     if (!octstr_check_range(msg->sms.sender, 0, octstr_len(msg->sms.sender), gw_isdigit))
  334.     {
  335.         /* If alphanumeric, simply prefix sender with '$' char */
  336.         sender = octstr_create("$");
  337.         octstr_append(sender, msg->sms.sender);
  338.     } else sender = octstr_duplicate(msg->sms.sender);
  340.     cgwop_add(cgwop, octstr_imm("app"), privdata->appname);
  341.     cgwop_add(cgwop, octstr_imm("from"), sender);
  342.     cgwop_add(cgwop, octstr_imm("to"), msg->sms.receiver);
  344.     /* If delivery reports are asked, ask for them by adding a nrq:anything field */
  345.     if (msg->sms.dlr_mask & 0x07)
  346.         cgwop_add(cgwop, octstr_imm("nrq"), octstr_imm("true"));
  348.     octstr_destroy(sender);
  350.     if (octstr_len(msg->sms.udhdata))
  351.     {
  352.         udh = octstr_duplicate(msg->sms.udhdata);
  353.         octstr_binary_to_hex(udh, 1);
  354.         cgwop_add(cgwop, octstr_imm("udh"), udh);
  355.         octstr_destroy(udh);
  357.         dta = octstr_duplicate(msg->sms.msgdata);
  358.         octstr_binary_to_hex(dta, 1);
  359.         cgwop_add(cgwop, octstr_imm("msg"), dta);
  360.         cgwop_add(cgwop, octstr_imm("type"), octstr_imm("bin"));
  361.         octstr_destroy(dta);
  362.     } else
  363.     {
  364.         cgwop_add(cgwop, octstr_imm("msg"), cgw_encode_msg(msg->sms.msgdata));
  365.     }
  367.     return cgwop;
  368. }
  371. /******************************************************************************
  372.  * Called to create the SMSC. This is our entry point.
  373.  */
  375. int smsc_cgw_create(SMSCConn *conn, CfgGroup *cfg)
  376. {
  377.     PrivData *privdata;
  378.     Octstr *allow_ip, *deny_ip, *host, *appname;
  379.     long portno, our_port, waitack;
  380.     int i;
  382.     privdata = gw_malloc(sizeof(PrivData));
  383.     privdata->outgoing_queue = list_create();
  384.     privdata->listening_socket = -1;
  386.     if (cfg_get_integer(&portno, cfg, octstr_imm("port")) == -1)
  387.         portno = 0;
  388.     privdata->port = portno;
  390.     if (cfg_get_integer(&portno, cfg, octstr_imm("receive-port")) < 0)
  391.         portno = 0;
  392.     privdata->rport = portno;
  394.     host = cfg_get(cfg, octstr_imm("host"));
  395.     appname = cfg_get(cfg, octstr_imm("appname"));
  397.     if (cfg_get_integer(&our_port, cfg, octstr_imm("our-port")) == -1)
  398.         privdata->our_port = 0;     /* 0 means use any port */
  399.     else
  400.         privdata->our_port = our_port;
  402.     allow_ip = cfg_get(cfg, octstr_imm("connect-allow-ip"));
  403.     if (allow_ip)
  404.         deny_ip = octstr_create("*.*.*.*");
  405.     else
  406.         deny_ip = NULL;
  408.     if (cfg_get_integer(&waitack, cfg, octstr_imm("wait-ack")) < 0)
  409.         privdata->waitack = 60;
  410.     else
  411.         privdata->waitack = waitack;
  413.     if (privdata->port <= 0 || privdata->port > 65535) {
  414.         info(1, "No port defined for cgw -> using default (%d)", CGW_DEFPORT);
  415.         privdata->port = CGW_DEFPORT;
  416.     }
  419.     if (host == NULL) {
  420.         error(0, "'host' missing in cgw configuration.");
  421.         goto error;
  422.     }
  424.     if (appname == NULL)
  425.         appname = octstr_create("send");
  427.     privdata->allow_ip = allow_ip;
  428.     privdata->deny_ip = deny_ip;
  429.     privdata->host = host;
  430.     privdata->appname = appname;
  431.     privdata->nexttrn = 0;
  432.     privdata->check_time = 0;
  434.     for (i = 0; i < CGW_TRN_MAX; i++) {
  435.         privdata->sendtime[i] = 0;
  436.         privdata->dlr[i] = 0;
  437.     }
  439.     if (privdata->rport > 0 && cgw_open_listening_socket(privdata) < 0) {
  440.         gw_free(privdata);
  441.         privdata = NULL;
  442.         goto error;
  443.     }
  446.     conn->data = privdata;
  448.     conn->name = octstr_format("CGW:%d", privdata->port);
  450.     privdata->shutdown = 0;
  452.     conn->status = SMSCCONN_CONNECTING;
  453.     conn->connect_time = time(NULL);
  455.     if (privdata->rport > 0 && (privdata->receiver_thread = gwthread_create(cgw_listener, conn)) == -1)
  456.         goto error;
  458.     if ((privdata->sender_thread = gwthread_create(cgw_sender, conn)) == -1) {
  459.         privdata->shutdown = 1;
  460.         goto error;
  461.     }
  463.     conn->shutdown = cgw_shutdown_cb;
  464.     conn->queued = cgw_queued_cb;
  465.     conn->start_conn = cgw_start_cb;
  466.     conn->send_msg = cgw_add_msg_cb;
  468.     return 0;
  470. error:
  471.     error(0, "Failed to create CGW smsc connection");
  472.     if (privdata != NULL)
  473.         list_destroy(privdata->outgoing_queue, NULL);
  475.     gw_free(privdata);
  476.     octstr_destroy(host);
  477.     octstr_destroy(allow_ip);
  478.     octstr_destroy(deny_ip);
  479.     octstr_destroy(appname);
  481.     conn->why_killed = SMSCCONN_KILLED_CANNOT_CONNECT;
  482.     conn->status = SMSCCONN_DEAD;
  483.     info(0, "exiting");
  484.     return -1;
  485. }
  488. /******************************************************************************
  489.  * Callbacks for startup, shutdown, incoming and outgoing messages
  490.  */
  493. static int cgw_add_msg_cb(SMSCConn *conn, Msg *sms)
  494. {
  495.     PrivData *privdata = conn->data;
  496.     Msg *copy;
  498.     copy = msg_duplicate(sms);
  499.     list_produce(privdata->outgoing_queue, copy);
  500.     gwthread_wakeup(privdata->sender_thread);
  502.     return 0;
  503. }
  506. static int cgw_shutdown_cb(SMSCConn *conn, int finish_sending)
  507. {
  508.     PrivData *privdata = conn->data;
  510.     debug("bb.sms", 0, "Shutting down SMSCConn CGW, %s",
  511.           finish_sending ? "slow" : "instant");
  513.     /* Documentation claims this would have been done by smscconn.c,
  514.        but isn't when this code is being written. */
  515.     conn->why_killed = SMSCCONN_KILLED_SHUTDOWN;
  516.     privdata->shutdown = 1;     /* Separate from why_killed to avoid locking, as
  517.                   * why_killed may be changed from outside? */
  519.     if (finish_sending == 0) {
  520.         Msg *msg;
  521.         while ((msg = list_extract_first(privdata->outgoing_queue)) != NULL) {
  522.             bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN);
  523.         }
  524.     }
  526.     if (privdata->rport > 0)
  527.         gwthread_wakeup(privdata->receiver_thread);
  528.     return 0;
  529. }
  532. static void cgw_start_cb(SMSCConn *conn)
  533. {
  534.     PrivData *privdata = conn->data;
  536.     /* in case there are messages in the buffer already */
  537.     if (privdata->rport > 0)
  538.         gwthread_wakeup(privdata->receiver_thread);
  539.     debug("smsc.cgw", 0, "smsc_cgw: start called");
  540. }
  543. static long cgw_queued_cb(SMSCConn *conn)
  544. {
  545.     PrivData *privdata = conn->data;
  546.     long ret = list_len(privdata->outgoing_queue);
  548.     /* use internal queue as load, maybe something else later */
  550.     conn->load = ret;
  551.     return ret;
  552. }
  555. /******************************************************************************
  556.  * This is the entry point for out sender thread. This function is responsible
  557.  * for sending and acking messages in queue
  558.  */
  560. static void cgw_sender(void *arg)
  561. {
  562.     SMSCConn *conn = arg;
  563.     PrivData *privdata = conn->data;
  564.     Msg *msg = NULL;
  565.     Connection *server = NULL;
  566.     int l = 0;
  567.     int ret = 0;
  569.     conn->status = SMSCCONN_CONNECTING;
  571.     while (!privdata->shutdown) {
  573.         // check that connection is active
  574.         if (conn->status != SMSCCONN_ACTIVE) {
  575.             if ((server = cgw_open_send_connection(conn)) == NULL) {
  576.                 privdata->shutdown = 1;
  577.                 error(0, "Unable to connect to CGW server");
  578.                 return ;
  579.             }
  581.             conn->status = SMSCCONN_ACTIVE;
  582.             bb_smscconn_connected(conn);
  583.         } else {
  584.     ret = 0;
  585.             l = list_len(privdata->outgoing_queue);
  586.             if (l > 0)
  587.                ret = cgw_send_loop(conn, server);     /* send any messages in queue */
  589.             if (ret != -1) ret = cgw_wait_command(privdata, conn, server, 1);     /* read ack's and delivery reports */
  590.             if (ret != -1) cgw_check_acks(privdata);     /* check un-acked messages */
  591.  
  592.             if (ret == -1) {
  593.                 mutex_lock(conn->flow_mutex);
  594.                 conn->status = SMSCCONN_RECONNECTING;
  595.                 mutex_unlock(conn->flow_mutex);
  596.     }
  597.         }
  598.     }
  600.     conn_destroy(server);
  602.     while ((msg = list_extract_first(privdata->outgoing_queue)) != NULL)
  603.         bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_SHUTDOWN);
  604.     mutex_lock(conn->flow_mutex);
  606.     conn->status = SMSCCONN_DEAD;
  608.     list_destroy(privdata->outgoing_queue, NULL);
  609.     octstr_destroy(privdata->host);
  610.     octstr_destroy(privdata->allow_ip);
  611.     octstr_destroy(privdata->deny_ip);
  613.     gw_free(privdata);
  614.     conn->data = NULL;
  616.     mutex_unlock(conn->flow_mutex);
  617.     debug("bb.sms", 0, "smsc_cgw connection has completed shutdown.");
  618.     bb_smscconn_killed();
  619. }
  622. static Connection *cgw_open_send_connection(SMSCConn *conn)
  623. {
  624.     PrivData *privdata = conn->data;
  625.     int wait;
  626.     Connection *server;
  627.     Msg *msg;
  629.     wait = 0;
  630.     while (!privdata->shutdown) {
  632.         /* Change status only if the first attempt to form a
  633.  * connection fails, as it's possible that the SMSC closed the
  634.  * connection because of idle timeout and a new one will be
  635.  * created quickly. */
  636.         if (wait) {
  637.             if (conn->status == SMSCCONN_ACTIVE) {
  638.                 mutex_lock(conn->flow_mutex);
  639.                 conn->status = SMSCCONN_RECONNECTING;
  640.                 mutex_unlock(conn->flow_mutex);
  641.             }
  642.             while ((msg = list_extract_first(privdata->outgoing_queue)))
  643.                 bb_smscconn_send_failed(conn, msg, SMSCCONN_FAILED_TEMPORARILY);
  644.             info(0, "smsc_cgw: waiting for %d minutes before trying to connect again", wait);
  645.             gwthread_sleep(wait * 60);
  646.             wait = wait > 5 ? 10 : wait * 2;
  647.         } else
  648.             wait = 1;
  650.         server = conn_open_tcp_with_port(privdata->host, privdata->port,
  651.                                          privdata->our_port, NULL /* privdata->our_host */);
  653.         if (privdata->shutdown) {
  654.             conn_destroy(server);
  655.             return NULL;
  656.         }
  658.         if (server == NULL) {
  659.             error(0, "smsc_cgw: opening TCP connection to %s failed", octstr_get_cstr(privdata->host));
  660.             continue;
  661.         }
  663.         if (conn->status != SMSCCONN_ACTIVE) {
  664.             mutex_lock(conn->flow_mutex);
  665.             conn->status = SMSCCONN_ACTIVE;
  666.             conn->connect_time = time(NULL);
  667.             mutex_unlock(conn->flow_mutex);
  668.             bb_smscconn_connected(conn);
  669.         }
  670.         return server;
  671.     }
  672.     return NULL;
  673. }
  676. /******************************************************************************
  677.  * Send messages in queue.
  678.  */
  680. static int cgw_send_loop(SMSCConn *conn, Connection *server)
  681. {
  682.     PrivData *privdata = conn->data;
  683.     struct cgwop *cgwop;
  684.     Msg *msg;
  685.     int firsttrn;
  687.     /* Send messages in queue */
  688.     while ((msg = list_extract_first(privdata->outgoing_queue)) != NULL) {
  689.         firsttrn = privdata->nexttrn;
  690.         while (privdata->sendtime[privdata->nexttrn] != 0) { 
  691.             if (++privdata->nexttrn >= CGW_TRN_MAX) privdata->nexttrn = 0;    
  692.             if (privdata->nexttrn == firsttrn) { /* no available trn */
  693.         /* this happens too many messages are sent, and old messages
  694.  * haven't been acked. In this case, increase size of 
  695.                  * CGW_TRN_MAX */
  696.                 info(0, "cgw: Saturated, increase size of CGW_TRN_MAX!");
  697.                 list_produce(privdata->outgoing_queue, msg);
  698.                 return 1;     /* re-insert, and go check for acks */
  699.             }
  700.         }
  702.         cgwop = msg_to_cgwop(privdata, msg, privdata->nexttrn);
  704.         if (cgwop == NULL) {
  705.             info(0, "cgw: cgwop == NULL");
  706.             return 0;
  707.         }
  709.         privdata->sendmsg[privdata->nexttrn] = msg;
  710.         privdata->sendtime[privdata->nexttrn] = time(NULL);
  712.         if (cgwop_send(server, cgwop) == -1) {
  713.             cgwop_destroy(cgwop);
  714.             info(0, "cgw: Unable to send (cgwop_send() == -1)");
  715.             return -1;
  716.         }
  718.         privdata->unacked++;
  720.         cgwop_destroy(cgwop);
  721.     }
  722.     return 0;
  723. }
  725. /* Check whether there are messages the server hasn't acked in a
  726.  * reasonable time */
  728. void cgw_check_acks(PrivData *privdata)
  729. {
  730.     time_t current_time;
  731.     int i;
  733.     current_time = time(NULL);
  734.     if (privdata->unacked && (current_time > privdata->check_time + 30)) {
  735.         privdata->check_time = current_time;
  736.         for (i = 0; i < CGW_TRN_MAX; i++)
  737.             if (privdata->sendtime[i] && privdata->sendtime[i] < (current_time - privdata->waitack)) {
  738.                 privdata->sendtime[i] = 0;
  739.                 privdata->unacked--;
  740.                 warning(0, "smsc_cgw: received neither OK nor ERR for message %d "
  741.                         "in %d seconds, resending message", i, privdata->waitack);
  742.                 list_produce(privdata->outgoing_queue, privdata->sendmsg[i]);
  743.             }
  744.     }
  745. }
  748. /******************************************************************************
  749.  * cgw_wait_command - Used by cgw_sender thread to read delivery reports
  750.  */
  752. int cgw_wait_command(PrivData *privdata, SMSCConn *conn, Connection *server, int timeout)
  753. {
  754.     int ret;
  755.     struct cgwop *cgwop;
  757.     /* is there data to be read? */
  758.     ret = gwthread_pollfd(privdata->send_socket, POLLIN, 0.2); 
  759.     
  760.     if (ret != -1) {
  761.         /* read all waiting ops */
  762. cgwop = cgw_read_op(privdata, conn, server, timeout);
  763.         if (cgwop != NULL) {
  764.     do {
  765. if (conn_eof(server)) {
  766.     info(0, "cgw: Connection closed by SMSC");
  767.     conn->status = SMSCCONN_DISCONNECTED;
  768.     if (cgwop != NULL) cgwop_destroy(cgwop);
  769.     return -1;
  770. }
  771. if (conn_read_error(server)) {
  772.     error(0, "cgw: Error trying to read ACKs from SMSC");
  773.     if (cgwop != NULL) cgwop_destroy(cgwop);
  774.     return -1;
  775. }
  777. cgw_handle_op(conn, server, cgwop);
  778. cgwop_destroy(cgwop);
  779.     } while ((cgwop = cgw_read_op(privdata, conn, server, timeout)) != NULL);
  780. } else 
  781.     conn_wait(server, 1); /* added because gwthread_pollfd
  782.      seems to always return 1. This will keep
  783.      the load on a reasonable level */
  784.     }
  786.     return 0;
  787. }
  790. /******************************************************************************
  791.  * cgw_read_op - read an operation, and return it as a *cgwop structure
  792.  *
  793.  * This function will not lock and wait for data if none is available. It will
  794.  * however lock until a whole op has been read. Timeout not implemented yet.
  795.  */
  797. struct cgwop *cgw_read_op(PrivData *privdata, SMSCConn *conn, Connection *server, time_t timeout)
  798. {
  799.     Octstr *line, *name, *value;
  800.     int finished = 0;
  801.     int c = 0;
  802.     struct cgwop *cgwop = NULL;
  804.     int op = CGW_OP_NOP;
  806.     if ((line = conn_read_line(server)) == NULL) 
  807.         return NULL;     /* don't block */
  809.     do
  810.     {
  811.         while (line == NULL)
  812.             line = conn_read_line(server);     /* wait for more data */
  814.         c = octstr_search_char(line, ':', 0);
  815.         if (c != -1) {
  816.             name = octstr_copy(line, 0, c);
  817.             value = octstr_copy(line, c + 1, octstr_len(line) - (c + 1));
  819.             if (octstr_compare(name, octstr_imm("hello")) == 0) {
  820.                 /* A connection is started by CGW by sending a 
  821.  * "hello: Provider Server..." line. */
  823.                 cgwop = cgwop_create(CGW_OP_HELLO, 0);
  824.                 cgwop_add(cgwop, octstr_imm("hello"), value);
  826.                 octstr_destroy(name);
  827.                 octstr_destroy(value);
  828.                 octstr_destroy(line);
  830.                 return cgwop;
  831.             }
  833.             if (octstr_compare(name, octstr_imm("op")) == 0) {
  834.                 /* check different ops */
  835.                 if (octstr_compare(value, octstr_imm("msg")) == 0)
  836.                     op = CGW_OP_MSG;
  837.                 else
  838.                     if (octstr_compare(value, octstr_imm("ok")) == 0)
  839.                         op = CGW_OP_OK;
  840.                     else
  841.                         if (octstr_compare(value, octstr_imm("delivery")) == 0)
  842.                             op = CGW_OP_DELIVERY;
  843.                         else
  844.                             if (octstr_compare(value, octstr_imm("err")) == 0)
  845.                                 op = CGW_OP_ERR;
  846.                             else
  847.                                 if (octstr_compare(value, octstr_imm("status")) == 0)
  848.                                     op = CGW_OP_STATUS;
  849.                                 else
  850.                                     info(0, "CGW: Received unknown op: %s", octstr_get_cstr(value));
  852.                 if (cgwop == NULL)
  853.                     cgwop = cgwop_create(op, 0);
  854.                 else
  855.                     info(0, "cgw: cgwop != null");
  856.             }
  858.             if (op != CGW_OP_NOP) {
  859.                 /* All commands have to be inside an op:xx ... end:xx statement */
  861.                 if (octstr_compare(name, octstr_imm("end")) == 0) { // found end of op
  862.                     finished = 1;
  863.                 } else {
  864.                     // store in name/value fields in cgwop
  865.                     if (cgwop != NULL) {
  866.                         cgwop_add(cgwop, name, value);
  867.                     }
  868.                 }
  869.             }
  870.             octstr_destroy(name);
  871.             octstr_destroy(value);
  872.             octstr_destroy(line);
  874.             if (!finished) line = conn_read_line(server);
  875.         } else {
  876.             info(0, "cgw: Received invalid input: %s", octstr_get_cstr(line));
  877.             octstr_destroy(line);
  878.             finished = 1;
  879.         }
  881.     } while (!finished);
  883.     return cgwop;
  884. }
  886. static int cgw_open_listening_socket(PrivData *privdata)
  887. {
  888.     int s;
  890.     if ((s = make_server_socket(privdata->rport, NULL)) == -1) {
  891.         /* XXX add interface_name if required */
  892.         error(0, "smsc_cgw: could not create listening socket in port %d", privdata->rport);
  893.         return -1;
  894.     }
  895.     if (socket_set_blocking(s, 0) == -1) {
  896.         error(0, "smsc_cgw: couldn't make listening socket port %d non-blocking", privdata->rport);
  897.         close(s);
  898.         return -1;
  899.     }
  900.     privdata->listening_socket = s;
  901.     return 0;
  902. }
  904. /******************************************************************************
  905.  * This is the entry point for our receiver thread. Listens for incoming 
  906.  * connections and handles operations.
  907.  */
  909. static void cgw_listener(void *arg)
  910. {
  911.     SMSCConn *conn = arg;
  912.     PrivData *privdata = conn->data;
  913.     struct sockaddr_in server_addr;
  914.     socklen_t server_addr_len;
  915.     Octstr *ip;
  916.     Connection *server;
  917.     int s, ret;
  919.     while (!privdata->shutdown) {
  920.         server_addr_len = sizeof(server_addr);
  922.         ret = gwthread_pollfd(privdata->listening_socket, POLLIN, -1);
  923.         if (ret == -1) {
  924.             if (errno == EINTR)
  925.                 continue;
  926.             error(0, "Poll for cgw smsc connections failed, shutting down");
  927.             break;
  928.         }
  930.         if (privdata->shutdown)
  931.             break;
  932.         if (ret == 0) /* This thread was woken up from elsewhere, but
  933.                        * if we're not shutting down nothing to do here. */
  934.             continue;
  935.         s = accept(privdata->listening_socket, (struct sockaddr *) & server_addr,
  936.                    &server_addr_len);
  937.         if (s == -1) {
  938.             warning(errno, "cgw_listener: accept() failed, retrying...");
  939.             continue;
  940.         }
  942.         ip = host_ip(server_addr);
  943.         if (!is_allowed_ip(privdata->allow_ip, privdata->deny_ip, ip)) {
  944.             info(0, "CGW smsc connection tried from denied host <%s>, disconnected", octstr_get_cstr(ip));
  945.             octstr_destroy(ip);
  946.             close(s);
  947.             continue;
  948.         }
  949.         server = conn_wrap_fd(s, 0);
  950.         if (server == NULL) {
  951.             error(0, "cgw_listener: conn_wrap_fd failed on accept()ed fd");
  952.             octstr_destroy(ip);
  953.             close(s);
  954.             continue;
  955.         }
  956.         conn_claim(server);
  957.         info(0, "cgw: smsc connected from %s", octstr_get_cstr(ip));
  958.         octstr_destroy(ip);
  960.         cgw_receiver(conn, server);
  961.         conn_destroy(server);
  962.     }
  963.     if (close(privdata->listening_socket) == -1)
  964.         warning(errno, "smsc_cgw: couldn't close listening socket at shutdown");
  965.     gwthread_wakeup(privdata->sender_thread);
  966. }
  968. static void cgw_receiver(SMSCConn *conn, Connection *server)
  969. {
  970.     PrivData *privdata = conn->data;
  971.     Octstr *str = NULL;
  972.     struct cgwop *cgwop;
  974.     while (1) {
  975.         if (conn_eof(server)) {
  976.             info(0, "cgw: receive connection closed by SMSC");
  977.             return ;
  978.         }
  979.         if (conn_read_error(server)) {
  980.             error(0, "cgw: receive connection broken");
  981.             return ;
  982.         }
  983.         if (conn->is_stopped)
  984.     str = NULL;
  986.         cgwop = cgw_read_op(conn->data, conn, server, 0);
  988.         if (cgwop != NULL) {
  989.             cgw_handle_op(conn, server, cgwop);
  990.             cgwop_destroy(cgwop);
  991.         } else
  992.             conn_wait(server, -1);
  994.         if (privdata->shutdown)
  995.             break;
  996.     }
  997.     return ;
  998. }
  1000. /******************************************************************************
  1001.  * This function handles incoming operations. Used by both receiver and sender
  1002.  * threads (i.e. sender thread uses this function for delivery and ack
  1003.  * operations).
  1004.  * Returns 1 if successfull, otherwise 0
  1005.  */
  1006. static int cgw_handle_op(SMSCConn *conn, Connection *server, struct cgwop *cgwop)
  1007. {
  1008.     PrivData *privdata = conn->data;
  1009.     Msg *msg = NULL;
  1010.     Octstr *from, *app, *sid, *to, *msgtype, *msgdata; /* for messages */
  1011.     Octstr *msid, *status, *txt;            /* delivery reports */
  1012.     Octstr *clid;                    /* for acks */
  1013.     struct cgwop *reply = NULL;
  1014.     long trn, stat;                          /* transaction number for ack */
  1015.     Msg *dlrmsg = NULL, *origmsg = NULL;
  1016.     Octstr *ts;
  1018.     if (cgwop == NULL) return 0;
  1020.     from = cgwop_get(cgwop, octstr_imm("from"));
  1021.     app = cgwop_get(cgwop, octstr_imm("app"));
  1022.     sid = cgwop_get(cgwop, octstr_imm("session-id"));
  1023.     to = cgwop_get(cgwop, octstr_imm("to"));
  1024.     msgtype = cgwop_get(cgwop, octstr_imm("type"));
  1025.     msgdata = cgwop_get(cgwop, octstr_imm("msg"));
  1026.     txt = cgwop_get(cgwop, octstr_imm("txt"));
  1028.     msid = cgwop_get(cgwop, octstr_imm("msid"));
  1029.     status = cgwop_get(cgwop, octstr_imm("status"));
  1030.     clid = cgwop_get(cgwop, octstr_imm("client-id"));
  1032.     if (clid != NULL)
  1033.     {
  1034.         octstr_parse_long(&trn, clid, 0, 10);
  1035.         if ((trn < 0) || (trn >= CGW_TRN_MAX)) { /* invalid transaction number */
  1036.     info(0, "cgw: Invalid transaction number: %d", (int) trn);
  1037.             trn = -1;            
  1038.     return 0;
  1039.         }
  1040.     }
  1042.     switch (cgwop->op)
  1043.     {
  1044.     case CGW_OP_MSG:
  1045.         msg = msg_create(sms);
  1046.         time(&msg->sms.time);
  1047.         msg->sms.msgdata = cgw_decode_msg(octstr_duplicate(msgdata));
  1048.         msg->sms.sender = octstr_duplicate(from);
  1049.         msg->sms.receiver = octstr_duplicate(to);
  1050.         msg->sms.smsc_id = octstr_duplicate(conn->id);
  1051.         bb_smscconn_receive(conn, msg);
  1053.         reply = cgwop_create(CGW_OP_OK, -1);
  1054.         cgwop_add(reply, octstr_imm("session-id"), sid);
  1055.         cgwop_send(server, reply);     // send reply
  1057.         cgwop_destroy(reply);
  1059.         break;
  1061.     case CGW_OP_DELIVERY:
  1062.         if (privdata->dlr[trn]) {
  1064.             octstr_parse_long(&stat, status, 0, 10);
  1065.             origmsg = privdata->sendmsg[trn];
  1067.             if (origmsg == NULL) break;
  1069.             ts = octstr_create("");
  1070.             octstr_append(ts, conn->id);
  1071.             octstr_append_char(ts, '-');
  1072.             octstr_append_decimal(ts, trn);
  1074.             switch (stat) {
  1075.             case 0:     /* delivered */
  1076.                 dlrmsg = dlr_find(octstr_get_cstr(conn->id),
  1077.                                   octstr_get_cstr(ts),     /* timestamp */
  1078.                                   octstr_get_cstr(msid),   /* destination */
  1079.                                   DLR_SUCCESS);
  1080.                 break;
  1081.             case 1:     /* buffered */
  1082.                 dlrmsg = dlr_find(octstr_get_cstr(conn->id),
  1083.                                   octstr_get_cstr(ts),     /* timestamp */
  1084.                                   octstr_get_cstr(msid),   /* destination */
  1085.                                   DLR_BUFFERED);
  1086.                 break;
  1087.             case 2:     /* not delivered */
  1088.                 dlrmsg = dlr_find(octstr_get_cstr(conn->id),
  1089.                                   octstr_get_cstr(ts),     /* timestamp */
  1090.                                   octstr_get_cstr(msid),   /* destination */
  1091.                                   DLR_FAIL);
  1092.                 break;
  1093.             }
  1095.             octstr_destroy(ts);
  1096.             if (dlrmsg != NULL) {
  1098.                 dlrmsg->sms.msgdata = octstr_duplicate(txt);
  1099.                 bb_smscconn_receive(conn, dlrmsg);
  1100.             }
  1101.         }
  1103.         break;
  1105.     case CGW_OP_OK:
  1106.         if (trn == -1) break;     /* invalid transaction number */
  1107.         /* info(0, "cgw: Got ACK: %s", octstr_get_cstr(clid)); */
  1109.         privdata->sendtime[trn] = 0;
  1110.         privdata->unacked--;
  1112.         /* add delivery notification request if wanted */
  1114.         msg = privdata->sendmsg[trn];
  1116.         if (msg && msg->sms.dlr_url && (msg->sms.dlr_mask & 0x07)) {
  1117.             Octstr *ts;
  1119.             ts = octstr_create("");
  1120.             octstr_append(ts, conn->id);
  1121.             octstr_append_char(ts, '-');
  1122.             octstr_append_decimal(ts, trn);
  1124.             dlr_add(octstr_get_cstr(conn->id),
  1125.                     octstr_get_cstr(ts),
  1126.                     octstr_get_cstr(msg->sms.sender),
  1127.                     octstr_get_cstr(msg->sms.receiver),
  1128.                     octstr_get_cstr(msg->sms.service),
  1129.                     octstr_get_cstr(msg->sms.dlr_url),
  1130.                     msg->sms.dlr_mask);
  1132.             octstr_destroy(ts);
  1133.             privdata->dlr[trn] = 1;
  1134.         } else {
  1135.             privdata->dlr[trn] = 0;
  1136.         }
  1138.         bb_smscconn_sent(conn, msg);     /* mark as successfully sent */
  1140.         break;
  1142.     case CGW_OP_STATUS:
  1143.         info(0, "CGW: Warning: Got session status");
  1144.         /* op:status messages are sent by ProviderServer to tell if there are problems with
  1145.            the session status. These are not wanted, and should never occur, as the delivery is
  1146.            cancelled, and no end-user billing is done. */
  1148.         break;
  1151.     case CGW_OP_HELLO:
  1152.         info(0, "CGW: Server said: %s", octstr_get_cstr(cgwop_get(cgwop, octstr_imm("hello"))));
  1153.         break;
  1155.     case CGW_OP_ERR:
  1156.         if (trn == -1) break;     /* invalid transaction number */
  1158.         info(0, "CGW: Received error: %s", octstr_get_cstr(txt));
  1160.         privdata->sendtime[trn] = 0;
  1161.         privdata->unacked--;
  1163.         bb_smscconn_send_failed(conn, privdata->sendmsg[trn],
  1164.                                 SMSCCONN_FAILED_REJECTED);
  1166.         break;
  1168.     default:
  1169.         info(0, "cgw: Unknown operation: %d", cgwop->op);
  1170.         return 0;
  1171.     }
  1173.     return 1;
  1174. }