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

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

手机WAP编程

开发平台：

WINDOWS

smsc_cimd2.c：源码内容
  1. /* Driver for CIMD 2 SMS centres.
  2.  * Copyright 2000  WapIT Oy Ltd.
  3.  * Author: Richard Braakman
  4.  */
  6. /* TODO: Check checksums on incoming packets */
  7. /* TODO: Leading or trailing spaces are not allowed on parameters
  8.  * "user identity" and "password".  Check this. */
  9. /* TODO: Try to use the "More messages to send" flag */
  11. /* This code is based on the CIMD 2 spec, version 2-0 en.
  12.  * All USSD-specific parts have been left out, since we only want to
  13.  * communicate with SMSC's.
  14.  *
  15.  * I found one contradiction in the spec:
  16.  *
  17.  * - The definition of Integer parameters specifies decimal digits only,
  18.  *   but at least one Integer parameter (Validity Period Relative) can
  19.  *   be negative.  I assume that this means a leading - is valid.
  20.  */
  22. #include <ctype.h>
  23. #include <time.h>
  24. #include <errno.h>
  25. #include <limits.h>
  26. #include <string.h>
  28. #include <unistd.h>
  30. #include "gwlib/gwlib.h"
  31. #include "smsc_p.h"
  32. #include "sms.h"
  33. #include "dlr.h"
  35. #ifndef CIMD2_TRACE
  36. #define CIMD2_TRACE 0
  37. #endif
  40. /* Microseconds before giving up on a request */
  41. #define RESPONSE_TIMEOUT (10 * 1000000)
  43. /* Textual names for the operation codes defined by the CIMD 2 spec. */
  44. /* If you make changes here, also change the operation table. */
  45. enum {
  46.     /* Requests from client */
  47.     LOGIN = 1,
  48.     LOGOUT = 2,
  49.     SUBMIT_MESSAGE = 3,
  50.     ENQUIRE_MESSAGE_STATUS = 4,
  51.     DELIVERY_REQUEST = 5,
  52.     CANCEL_MESSAGE = 6,
  53.     SET_REQ = 8,
  54.     GET_REQ = 9,
  56.     /* Requests from server */
  57.     DELIVER_MESSAGE = 20,
  58.     DELIVER_STATUS_REPORT = 23,
  60.     /* Requests from either */
  61.     ALIVE = 40,
  63.     /* Not a request; add to any request to make it a response */
  64.     RESPONSE = 50,
  66.     /* Responses not related to requests */
  67.     GENERAL_ERROR_RESPONSE = 98,
  68.     NACK = 99
  69. };
  71. /* Textual names for the parameters defined by the CIMD 2 spec. */
  72. /* If you make changes here, also change the parameter table. */
  73. enum {
  74.     P_USER_IDENTITY = 10,
  75.     P_PASSWORD = 11,
  76.     P_DESTINATION_ADDRESS = 21,
  77.     P_ORIGINATING_ADDRESS = 23,
  78.     P_ORIGINATING_IMSI = 26,
  79.     P_ORIGINATED_VISITED_MSC = 28,
  80.     P_DATA_CODING_SCHEME = 30,
  81.     P_USER_DATA_HEADER = 32,
  82.     P_USER_DATA = 33,
  83.     P_USER_DATA_BINARY = 34,
  84.     P_MORE_MESSAGES_TO_SEND = 44,
  85.     P_VALIDITY_PERIOD_RELATIVE = 50,
  86.     P_VALIDITY_PERIOD_ABSOLUTE = 51,
  87.     P_PROTOCOL_IDENTIFIER = 52,
  88.     P_FIRST_DELIVERY_TIME_RELATIVE = 53,
  89.     P_FIRST_DELIVERY_TIME_ABSOLUTE = 54,
  90.     P_REPLY_PATH = 55,
  91.     P_STATUS_REPORT_REQUEST = 56,
  92.     P_CANCEL_ENABLED = 58,
  93.     P_CANCEL_MODE = 59,
  94.     P_MC_TIMESTAMP = 60,
  95.     P_STATUS_CODE = 61,
  96.     P_STATUS_ERROR_CODE = 62,
  97.     P_DISCHARGE_TIME = 63,
  98.     P_TARIFF_CLASS = 64,
  99.     P_SERVICE_DESCRIPTION = 65,
  100.     P_MESSAGE_COUNT = 66,
  101.     P_PRIORITY = 67,
  102.     P_DELIVERY_REQUEST_MODE = 68,
  103.     P_GET_PARAMETER = 500,
  104.     P_MC_TIME = 501,
  105.     P_ERROR_CODE = 900,
  106.     P_ERROR_TEXT = 901
  107. };
  109. /***************************************************************************/
  110. /* Table of properties of the parameters defined by CIMD 2, and some       */
  111. /* functions to look up fields.                                            */
  112. /***************************************************************************/
  114. /* Parameter types, internal.  CIMD 2 spec considers P_TIME to be "Integer"
  115.  * and P_SMS to be "User Data". */
  116. enum { P_INT, P_STRING, P_ADDRESS, P_TIME, P_HEX, P_SMS };
  118. /* Information about the parameters defined by the CIMD 2 spec.
  119.  * Used for warning about invalid incoming messages, and for validating
  120.  * outgoing messages. */
  121. static const struct
  122. {
  123.     unsigned char *name;
  124.     int number;
  125.     int maxlen;
  126.     int type;  /* P_ values */
  127.     int minval, maxval;  /* For P_INT */
  128. }
  129. parameters[] = {
  130.     { "user identity", P_USER_IDENTITY, 32, P_STRING },
  131.     { "password", P_PASSWORD, 32, P_STRING },
  132.     { "destination address", P_DESTINATION_ADDRESS, 20, P_ADDRESS },
  133.     { "originating address", P_ORIGINATING_ADDRESS, 20, P_ADDRESS },
  134.     /* IMSI is International Mobile Subscriber Identity number */
  135.     { "originating IMSI", P_ORIGINATING_IMSI, 20, P_ADDRESS },
  136.     { "originated visited MSC", P_ORIGINATED_VISITED_MSC, 20, P_ADDRESS },
  137.     { "data coding scheme", P_DATA_CODING_SCHEME, 3, P_INT, 0, 255 },
  138.     { "user data header", P_USER_DATA_HEADER, 280, P_HEX },
  139.     { "user data", P_USER_DATA, 480, P_SMS },
  140.     { "user data binary", P_USER_DATA_BINARY, 280, P_HEX },
  141.     { "more messages to send", P_MORE_MESSAGES_TO_SEND, 1, P_INT, 0, 1 },
  142.     { "validity period relative", P_VALIDITY_PERIOD_RELATIVE, 3, P_INT, -1, 255 },
  143.     { "validity period absolute", P_VALIDITY_PERIOD_ABSOLUTE, 12, P_TIME },
  144.     { "protocol identifier", P_PROTOCOL_IDENTIFIER, 3, P_INT, 0, 255 },
  145.     { "first delivery time relative", P_FIRST_DELIVERY_TIME_RELATIVE, 3, P_INT, -1, 255 },
  146.     { "first delivery time absolute", P_FIRST_DELIVERY_TIME_ABSOLUTE, 12, P_TIME },
  147.     { "reply path", P_REPLY_PATH, 1, P_INT, 0, 1 },
  148.     { "status report request", P_STATUS_REPORT_REQUEST, 2, P_INT, 0, 63 },
  149.     { "cancel enabled", P_CANCEL_ENABLED, 1, P_INT, 0, 1 },
  150.     { "cancel mode", P_CANCEL_MODE, 1, P_INT, 0, 2 },
  151.     { "service centre timestamp", P_MC_TIMESTAMP, 12, P_TIME },
  152.     { "status code", P_STATUS_CODE, 2, P_INT, 0, 9 },
  153.     { "status error code", P_STATUS_ERROR_CODE, 3, P_INT, 0, 999 },
  154.     { "discharge time", P_DISCHARGE_TIME, 12, P_TIME },
  155.     { "tariff class", P_TARIFF_CLASS, 2, P_INT, 0, 99 },
  156.     { "service description", P_SERVICE_DESCRIPTION, 1, P_INT, 0, 9 },
  157.     { "message count", P_MESSAGE_COUNT, 3, P_INT, 0, 999 },
  158.     { "priority", P_PRIORITY, 1, P_INT, 1, 9 },
  159.     { "delivery request mode", P_DELIVERY_REQUEST_MODE, 1, P_INT, 0, 2 },
  160.     { "get parameter", P_GET_PARAMETER, 3, P_INT, 501, 999 },
  161.     { "MC time", P_MC_TIME, 12, P_TIME },
  162.     { "error code", P_ERROR_CODE, 3, P_INT, 0, 999 },
  163.     { "error text", P_ERROR_TEXT, 64, P_STRING },
  164.     { NULL }
  165. };
  167. /* Return the index in the parameters array for this parameter id.
  168.  * Return -1 if it is not found. */
  169. static const int parm_index(int parmno)
  170. {
  171.     int i;
  173.     for (i = 0; parameters[i].name != NULL; i++) {
  174.         if (parameters[i].number == parmno)
  175.             return i;
  176.     }
  178.     return -1;
  179. }
  181. #ifndef NO_GWASSERT
  182. /* Return the type of this parameter id.  Return -1 if the id is unknown. */
  183. static const int parm_type(int parmno)
  184. {
  185.     int i = parm_index(parmno);
  187.     if (i < 0)
  188.         return -1;
  190.     return parameters[i].type;
  191. }
  192. #endif
  194. /* Return the max length for this parameter id.
  195.  * Return -1 if the id is unknown. */
  196. static const int parm_maxlen(int parmno)
  197. {
  198.     int i = parm_index(parmno);
  200.     if (i < 0)
  201.         return -1;
  203.     return parameters[i].maxlen;
  204. }
  206. static const char *parm_name(int parmno)
  207. {
  208.     int i = parm_index(parmno);
  210.     if (i < 0)
  211.         return NULL;
  213.     return parameters[i].name;
  214. }
  216. #ifndef NO_GWASSERT
  217. /* Return 1 if the value for this (Integer) parameter is in range.
  218.  * Return 0 otherwise.  Return -1 if the parameter was not found.  */
  219. static const int parm_in_range(int parmno, long value)
  220. {
  221.     int i;
  223.     i = parm_index(parmno);
  225.     if (i < 0)
  226.         return -1;
  228.     return (value >= parameters[i].minval && value <= parameters[i].maxval);
  229. }
  230. #endif
  232. /* Helper function to check P_ADDRESS type */
  233. static int isphonedigit(int c)
  234. {
  235.     return isdigit(c) || c == '+' || c == '-';
  236. }
  238. static const int parm_valid_address(Octstr *value)
  239. {
  240.     return octstr_check_range(value, 0, octstr_len(value), isphonedigit);
  241. }
  243. /***************************************************************************/
  244. /* Some functions to look up information about operation codes             */
  245. /***************************************************************************/
  247. static int operation_find(int operation);
  248. static Octstr *operation_name(int operation);
  249. static const int operation_can_send(int operation);
  250. static const int operation_can_receive(int operation);
  252. static const struct
  253. {
  254.     unsigned char *name;
  255.     int code;
  256.     int can_send;
  257.     int can_receive;
  258. }
  259. operations[] = {
  260.     { "Login", LOGIN, 1, 0 },
  261.     { "Logout", LOGOUT, 1, 0 },
  262.     { "Submit message", SUBMIT_MESSAGE, 1, 0 },
  263.     { "Enquire message status", ENQUIRE_MESSAGE_STATUS, 1, 0 },
  264.     { "Delivery request", DELIVERY_REQUEST, 1, 0 },
  265.     { "Cancel message", CANCEL_MESSAGE, 1, 0 },
  266.     { "Set parameter", SET_REQ, 1, 0 },
  267.     { "Get parameter", GET_REQ, 1, 0 },
  269.     { "Deliver message", DELIVER_MESSAGE, 0, 1 },
  270.     { "Deliver status report", DELIVER_STATUS_REPORT, 0, 1 },
  272.     { "Alive", ALIVE, 1, 1 },
  274.     { "NACK", NACK, 1, 1 },
  275.     { "General error response", GENERAL_ERROR_RESPONSE, 0, 1 },
  277.     { NULL, 0, 0, 0 }
  278. };
  280. static int operation_find(int operation)
  281. {
  282.     int i;
  284.     for (i = 0; operations[i].name != NULL; i++) {
  285.         if (operations[i].code == operation)
  286.             return i;
  287.     }
  289.     return -1;
  290. }
  292. /* Return a human-readable representation of this operation code */
  293. static Octstr *operation_name(int operation)
  294. {
  295.     int i;
  297.     i = operation_find(operation);
  298.     if (i >= 0)
  299.         return octstr_create(operations[i].name);
  301.     if (operation >= RESPONSE) {
  302.         i = operation_find(operation - RESPONSE);
  303.         if (i >= 0) {
  304.             Octstr *name = octstr_create(operations[i].name);
  305.             octstr_append_cstr(name, " response");
  306.             return name;
  307.         }
  308.     }
  310.     /* Put the operation number here when we have octstr_format */
  311.     return octstr_create("(unknown)");
  312. }
  314. /* Return true if a CIMD2 client may send this operation */
  315. static const int operation_can_send(int operation)
  316. {
  317.     int i = operation_find(operation);
  319.     if (i >= 0)
  320.         return operations[i].can_send;
  322.     /* If we can receive the request, then we can send the response. */
  323.     if (operation >= RESPONSE)
  324.         return operation_can_receive(operation - RESPONSE);
  326.     return 0;
  327. }
  330. /* Return true if a CIMD2 server may send this operation */
  331. static const int operation_can_receive(int operation)
  332. {
  333.     int i = operation_find(operation);
  335.     if (i >= 0)
  336.         return operations[i].can_receive;
  338.     /* If we can send the request, then we can receive the response. */
  339.     if (operation >= RESPONSE)
  340.         return operation_can_send(operation - RESPONSE);
  342.     return 0;
  343. }
  345. /***************************************************************************/
  346. /* Packet encoding/decoding functions.  They handle packets at the octet   */
  347. /* level, and know nothing of the network.                                 */
  348. /***************************************************************************/
  350. struct packet
  351. {
  352.     /* operation and seq are -1 if their value could not be parsed */
  353.     int operation;
  354.     int seq;   /* Sequence number */
  355.     Octstr *data;   /* Encoded packet */
  356.     /* CIMD 2 packet structure is so simple that packet information is
  357.      * stored as a valid encoded packet, and decoded as necessary. 
  358.      * Exceptions: operation code and sequence number are also stored
  359.      * as ints for speed, and the checksum is not added until the packet
  360.      * is about to be sent.  Since checksums are optional, the packet
  361.      * is still valid without a checksum.
  362.      *
  363.      * The sequence number is kept at 0 until it's time to actually
  364.      * send the packet, so that the send functions have control over
  365.      * the sequence numbers.
  366.      */
  367. };
  369. /* These are the separators defined by the CIMD 2 spec */
  370. #define STX 2   /* Start of packet */
  371. #define ETX 3   /* End of packet */
  372. #define TAB 9   /* End of parameter */
  374. /* The same separators, in string form */
  375. #define STX_str "2"
  376. #define ETX_str "3"
  377. #define TAB_str "11"
  379. /* A reminder that packets are created without a valid sequence number */
  380. #define BOGUS_SEQUENCE 0
  382. static Msg *cimd2_accept_delivery_report_message(struct packet *request, SMSCenter *smsc);
  383. /* Look for the STX OO:SSS TAB header defined by CIMD 2, where OO is the
  384.  * operation code in two decimals and SSS is the sequence number in three
  385.  * decimals.  Leave the results in the proper fields of the packet.
  386.  * Try to make sense of headers that don't fit this pattern; validating
  387.  * the packet format is not our job. */
  388. static void packet_parse_header(struct packet *packet)
  389. {
  390.     int pos;
  391.     long number;
  393.     /* Set default values, in case we can't parse the fields */
  394.     packet->operation = -1;
  395.     packet->seq = -1;
  397.     pos = octstr_parse_long(&number, packet->data, 1, 10);
  398.     if (pos < 0)
  399.         return;
  400.     packet->operation = number;
  402.     if (octstr_get_char(packet->data, pos++) != ':')
  403.         return;
  405.     pos = octstr_parse_long(&number, packet->data, pos, 10);
  406.     if (pos < 0)
  407.         return;
  408.     packet->seq = number;
  409. }
  412. /* Accept an Octstr containing one packet, build a struct packet around
  413.  * it, and return that struct.  The Octstr is stored in the struct.
  414.  * No error checking is done here yet. */
  415. static struct packet *packet_parse(Octstr *packet_data)
  416. {
  417.     struct packet *packet;
  419.     packet = gw_malloc(sizeof(*packet));
  420.     packet->data = packet_data;
  422.     /* Fill in packet->operation and packet->seq */
  423.     packet_parse_header(packet);
  425.     return packet;
  426. }
  428. /* Deallocate this packet */
  429. static void packet_destroy(struct packet *packet)
  430. {
  431.     if (packet != NULL) {
  432.         octstr_destroy(packet->data);
  433.         gw_free(packet);
  434.     }
  435. }
  437. /* Find the first packet in "in", delete it from "in", and return it as
  438.  * a struct.  Return NULL if "in" contains no packet.  Always delete
  439.  * leading non-packet data from "in".  (The CIMD 2 spec says we should
  440.  * ignore any data between the packet markers). */
  441. static struct packet *packet_extract(Octstr *in)
  442. {
  443.     int stx, etx;
  444.     Octstr *packet;
  446.     /* Find STX, and delete everything up to it */
  447.     stx = octstr_search_char(in, STX, 0);
  448.     if (stx < 0) {
  449.         octstr_delete(in, 0, octstr_len(in));
  450.         return NULL;
  451.     } else {
  452.         octstr_delete(in, 0, stx);
  453.     }
  455.     /* STX is now in position 0.  Find ETX. */
  456.     etx = octstr_search_char(in, ETX, 1);
  457.     if (etx < 0)
  458.         return NULL;
  460.     /* What shall we do with STX data... STX data... ETX?
  461.      * Either skip to the second STX, or assume an ETX marker before
  462.      * the STX.  Doing the latter has a chance of succeeding, and
  463.      * will at least allow good logging of the error. */
  464.     stx = octstr_search_char(in, STX, 1);
  465.     if (stx >= 0 && stx < etx) {
  466.         warning(0, "CIMD2: packet without end marker");
  467.         packet = octstr_copy(in, 0, stx);
  468.         octstr_delete(in, 0, stx);
  469.         octstr_append_cstr(packet, ETX_str);
  470.     } else {
  471.         /* Normal case. Copy packet, and cut it from the source. */
  472.         packet = octstr_copy(in, 0, etx + 1);
  473.         octstr_delete(in, 0, etx + 1);
  474.     }
  476.     return packet_parse(packet);
  477. }
  479. /* The get_parm functions always return the first parameter with the
  480.  * correct id.  There is only one case where the spec allows multiple
  481.  * parameters with the same id, and that is when an SMS has multiple
  482.  * destination addresses.  We only support one destination address anyway. */
  484. /* Look for the first parameter with id 'parmno' and return its value.
  485.  * Return NULL if the parameter was not found. */
  486. static Octstr *packet_get_parm(struct packet *packet, int parmno)
  487. {
  488.     long pos, next;
  489.     long valuepos;
  490.     long number;
  492.     gw_assert(packet != NULL);
  493.     pos = octstr_search_char(packet->data, TAB, 0);
  494.     if (pos < 0)
  495.         return NULL;  /* Bad packet, nothing we can do */
  497.     /* Parameters have a tab on each end.  If we don't find the
  498.      * closing tab, we're at the checksum, so we stop. */
  499.     for ( ;
  500.           (next = octstr_search_char(packet->data, TAB, pos + 1)) >= 0;
  501.           pos = next) {
  502.         if (octstr_parse_long(&number, packet->data, pos + 1, 10) < 0)
  503.             continue;
  504.         if (number != parmno)
  505.             continue;
  506.         valuepos = octstr_search_char(packet->data, ':', pos + 1);
  507.         if (valuepos < 0)
  508.             continue;  /* badly formatted parm */
  509.         valuepos++;  /* skip the ':' */
  511.         /* Found the right parameter */
  512.         return octstr_copy(packet->data, valuepos, next - valuepos);
  513.     }
  515.     return NULL;
  516. }
  519. /* Look for an Integer parameter with id 'parmno' in the packet and
  520.  * return its value.  Return INT_MIN if the parameter was not found.
  521.  * (Unfortunately, -1 is a valid parameter value for at least one
  522.  * parameter.) */
  523. static long packet_get_int_parm(struct packet *packet, int parmno)
  524. {
  525.     Octstr *valuestr = NULL;
  526.     long value;
  528.     /* Our code should never even try a bad parameter access. */
  529.     gw_assert(parm_type(parmno) == P_INT);
  531.     valuestr = packet_get_parm(packet, parmno);
  532.     if (!valuestr)
  533.         goto error;
  535.     if (octstr_parse_long(&value, valuestr, 0, 10) < 0)
  536.         goto error;
  538.     octstr_destroy(valuestr);
  539.     return value;
  541. error:
  542.     octstr_destroy(valuestr);
  543.     return INT_MIN;
  544. }
  546. /* Look for a String parameter with id 'parmno' in the packet and
  547.  * return its value.  Return NULL if the parameter was not found.
  548.  * No translations are done on the value. */
  549. static Octstr *packet_get_string_parm(struct packet *packet, int parmno)
  550. {
  551.     /* Our code should never even try a bad parameter access. */
  552.     gw_assert(parm_type(parmno) == P_STRING);
  554.     return packet_get_parm(packet, parmno);
  555. }
  557. /* Look for an Address parameter with id 'parmno' in the packet and
  558.  * return its value.  Return NULL if the parameter was not found.
  559.  * No translations are done on the value. */
  560. static Octstr *packet_get_address_parm(struct packet *packet, int parmno)
  561. {
  562.     /* Our code should never even try a bad parameter access. */
  563.     gw_assert(parm_type(parmno) == P_ADDRESS);
  565.     return packet_get_parm(packet, parmno);
  566. }
  568. /* Look for an SMS parameter with id 'parmno' in the packet and return its
  569.  * value.  Return NULL if the parameter was not found.  No translations
  570.  * are done on the value, so it will be in the ISO-Latin-1 character set
  571.  * with CIMD2-specific escapes. */
  572. static Octstr *packet_get_sms_parm(struct packet *packet, int parmno)
  573. {
  574.     /* Our code should never even try a bad parameter access. */
  575.     gw_assert(parm_type(parmno) == P_SMS);
  577.     return packet_get_parm(packet, parmno);
  578. }
  580. /* There is no packet_get_time_parm because the CIMD 2 timestamp
  581.  * format is useless.  It's in the local time of the MC, with
  582.  * a 2-digit year and no DST information.  We can do without.
  583.  */
  585. /* Look for a Hex parameter with id 'parmno' in the packet and return
  586.  * its value.  Return NULL if the parameter was not found.  The value
  587.  * is de-hexed. */
  588. static Octstr *packet_get_hex_parm(struct packet *packet, int parmno)
  589. {
  590.     Octstr *value = NULL;
  592.     /* Our code should never even try a bad parameter access. */
  593.     gw_assert(parm_type(parmno) == P_HEX);
  595.     value = packet_get_parm(packet, parmno);
  596.     if (!value)
  597.         goto error;
  599.     if (octstr_hex_to_binary(value) < 0)
  600.         goto error;
  602.     return value;
  604. error:
  605.     octstr_destroy(value);
  606.     return NULL;
  607. }
  610. /* Check if the header is according to CIMD 2 spec, generating log
  611.  * entries as necessary.  Return -1 if anything was wrong, otherwise 0. */
  612. static int packet_check_header(struct packet *packet)
  613. {
  614.     Octstr *data;
  616.     gw_assert(packet != NULL);
  617.     data = packet->data;
  619.     /* The header must have a two-digit operation code, a colon,
  620.      * and a three-digit sequence number, followed by a tab.
  621.      * (CIMD2, 3.1) */
  622.     if (octstr_len(data) < 8 ||
  623.         !octstr_check_range(data, 1, 2, gw_isdigit) ||
  624.         octstr_get_char(data, 3) != ':' ||
  625.         !octstr_check_range(data, 4, 3, gw_isdigit) ||
  626.         octstr_get_char(data, 7) != TAB) {
  627.         warning(0, "CIMD2 packet header in wrong format");
  628.         return -1;
  629.     }
  631.     return 0;
  632. }
  634. static int packet_check_parameter(struct packet *packet, long pos, long len)
  635. {
  636.     Octstr *data;
  637.     long parm;
  638.     long dpos, dlen;
  639.     int negative;
  640.     long value;
  641.     int i;
  642.     int errors = 0;
  644.     gw_assert(packet != NULL);
  645.     data = packet->data;
  647.     /* The parameter header should be TAB, followed by a three-digit
  648.      * parameter number, a colon, and the data.  We already know about
  649.      * the tab. */
  651.     if (len < 5 ||
  652.         !octstr_check_range(data, pos + 1, 3, gw_isdigit) ||
  653.         octstr_get_char(data, pos + 4) != ':') {
  654.         warning(0, "CIMD2 parameter at offset %ld in wrong format",
  655.                 pos);
  656.         errors++;
  657.     }
  659.     /* If we can't parse a parameter number, there's nothing more
  660.      * that we can check. */
  661.     dpos = octstr_parse_long(&parm, data, pos + 1, 10);
  662.     if (dpos < 0)
  663.         return -1;
  664.     if (octstr_get_char(data, dpos) == ':')
  665.         dpos++;
  666.     dlen = len - (dpos - pos);
  667.     /* dlen can not go negative because octstr_parse_long must have
  668.      * been stopped by the TAB at the end of the parameter data. */
  669.     gw_assert(dlen >= 0);
  671.     i = parm_index(parm);
  673.     if (i < 0) {
  674.         warning(0, "CIMD2 packet contains unknown parameter %ld", parm);
  675.         return -1;
  676.     }
  678.     if (dlen > parameters[i].maxlen) {
  679.         warning(0, "CIMD2 packet has '%s' parameter with length %ld, spec says max %d",
  680.                 parameters[i].name, len, parameters[i].maxlen);
  681.         errors++;
  682.     }
  684.     switch (parameters[i].type) {
  685.     case P_INT:
  686.         /* Allow a leading - */
  687.         negative = (octstr_get_char(data, dpos) == '-');
  688.         if (!octstr_check_range(data, dpos + negative,
  689.                                 dlen - negative, gw_isdigit)) {
  690.             warning(0, "CIMD2 packet has '%s' parameter with non-integer contents", parameters[i].name);
  691.             errors++;
  692.         }
  693.         if (octstr_parse_long(&value, data, dpos, 10) >= 0 &&
  694.             (value < parameters[i].minval || value > parameters[i].maxval)) {
  695.             warning(0, "CIMD2 packet has '%s' parameter out of range (value %ld, min %d, max %d)",
  696.                     parameters[i].name, value,
  697.                     parameters[i].minval, parameters[i].maxval);
  698.             errors++;
  699.         }
  700.         break;
  701.     case P_TIME:
  702.         if (!octstr_check_range(data, dpos, dlen, gw_isdigit)) {
  703.             warning(0, "CIMD2 packet has '%s' parameter with non-digit contents", parameters[i].name);
  704.             errors++;
  705.         }
  706.         break;
  707.     case P_ADDRESS:
  708.         if (!octstr_check_range(data, dpos, dlen, isphonedigit)) {
  709.             warning(0, "CIMD2 packet has '%s' parameter with non phone number contents", parameters[i].name);
  710.             errors++;
  711.         }
  712.         break;
  713.     case P_HEX:
  714.         if (!octstr_check_range(data, dpos, dlen, gw_isxdigit)) {
  715.             warning(0, "CIMD2 packet has '%s' parameter with non-hex contents", parameters[i].name);
  716.             errors++;
  717.         }
  718.         if (dlen % 2 != 0) {
  719.             warning(0, "CIMD2 packet has odd-length '%s' parameter", parameters[i].name);
  720.             errors++;
  721.         }
  722.         break;
  723.     case P_SMS:
  724.     case P_STRING:  /* nothing to check */
  725.         break;
  726.     }
  728.     if (errors > 0)
  729.         return -1;
  730.     return 0;
  731. }
  734. /* Check the packet against the CIMD 2 spec, generating log entries as
  735.  * necessary. Return -1 if anything was wrong, otherwise 0. */
  736. /* TODO: Check if parameters found actually belong in the packet type */
  737. static int packet_check(struct packet *packet)
  738. {
  739.     int errors = 0;
  740.     long pos, len, next;
  741.     Octstr *data;
  743.     gw_assert(packet != NULL);
  744.     data = packet->data;
  746.     if (octstr_search_char(data, 0, 0) >= 0) {
  747.         /* CIMD2 spec does not allow NUL bytes in a packet */
  748.         warning(0, "CIMD2 packet contains NULs");
  749.         errors++;
  750.     }
  752.     /* Assume the packet starts with STX and ends with ETX,
  753.      * because we parsed it that way in the first place. */
  755.     errors += (packet_check_header(packet) < 0);
  757.     /* Parameters are separated by tabs.  After the last parameter
  758.      * there is a tab, an optional two-digit checksum, and the ETX.
  759.      * Check each parameter in turn, by skipping from tab to tab.
  760.      */
  761.     len = octstr_len(data);
  762.     /* Start at the first tab, wherever it is, so that we can still
  763.      * check parameters if the header was weird. */
  764.     pos = octstr_search_char(data, TAB, 0);
  765.     for ( ; pos >= 0; pos = next) {
  766.         next = octstr_search_char(data, TAB, pos + 1);
  767.         if (next >= 0) {
  768.             errors += (packet_check_parameter(packet, pos, next - pos) < 0);
  769.         } else {
  770.             /* Check if the checksum has the right format.  Don't
  771.              * check the sum itself here, that will be done in a
  772.              * separate call later. */
  773.             /* There are two valid formats: TAB ETX (no checksum)
  774.              * and TAB digit digit ETX.  We already know the TAB
  775.              * and the ETX are there. */
  776.             if (!(octstr_len(data) - pos == 2 ||
  777.                   (octstr_len(data) - pos == 4 &&
  778.                    octstr_check_range(data, pos + 1, 2, gw_isxdigit)))) {
  779.                 warning(0, "CIMD2 packet checksum in wrong format");
  780.                 errors++;
  781.             }
  782.         }
  783.     }
  786.     if (errors > 0) {
  787.         octstr_dump(packet->data, 0);
  788.         return -1;
  789.     }
  791.     return 0;
  792. }
  794. static void packet_check_can_receive(struct packet *packet)
  795. {
  796.     gw_assert(packet != NULL);
  798.     if (!operation_can_receive(packet->operation)) {
  799.         Octstr *name = operation_name(packet->operation);
  800.         warning(0, "CIMD2 SMSC sent us %s request",
  801.                 octstr_get_cstr(name));
  802.         octstr_destroy(name);
  803.     }
  804. }
  806. /* Table of known error codes */
  807. static struct
  808. {
  809.     int code;
  810.     unsigned char *text;
  811. }
  812. cimd2_errors[] = {
  813.     { 0, "No error" },
  814.     { 1, "Unexpected operation" },
  815.     { 2, "Syntax error" },
  816.     { 3, "Unsupported parameter error" },
  817.     { 4, "Connection to message center lost" },
  818.     { 5, "No response from message center" },
  819.     { 6, "General system error" },
  820.     { 7, "Cannot find information" },
  821.     { 8, "Parameter formatting error" },
  822.     { 9, "Requested operation failed" },
  823.     /* LOGIN error codes */
  824.     { 100, "Invalid login" },
  825.     { 101, "Incorrect access type" },
  826.     { 102, "Too many users with this login id" },
  827.     { 103, "Login refused by message center" },
  828.     /* SUBMIT MESSAGE error codes */
  829.     { 300, "Incorrect destination address" },
  830.     { 301, "Incorrect number of destination addresses" },
  831.     { 302, "Syntax error in user data parameter" },
  832.     { 303, "Incorrect bin/head/normal user data parameter combination" },
  833.     { 304, "Incorrect data coding scheme parameter usage" },
  834.     { 305, "Incorrect validity period parameters usage" },
  835.     { 306, "Incorrect originator address usage" },
  836.     { 307, "Incorrect pid paramterer usage" },
  837.     { 308, "Incorrect first delivery parameter usage" },
  838.     { 309, "Incorrect reply path usage" },
  839.     { 310, "Incorrect status report request parameter usage" },
  840.     { 311, "Incorrect cancel enabled parameter usage" },
  841.     { 312, "Incorrect priority parameter usage" },
  842.     { 313, "Incorrect tariff class parameter usage" },
  843.     { 314, "Incorrect service description parameter usage" },
  844.     { 315, "Incorrect transport type parameter usage" },
  845.     { 316, "Incorrect message type parameter usage" },
  846.     { 318, "Incorrect mms parameter usage" },
  847.     { 319, "Incorrect operation timer parameter usage" },
  848.     /* ENQUIRE MESSAGE STATUS error codes */
  849.     { 400, "Incorrect address parameter usage" },
  850.     { 401, "Incorrect scts parameter usage" },
  851.     /* DELIVERY REQUEST error codes */
  852.     { 500, "Incorrect scts parameter usage" },
  853.     { 501, "Incorrect mode parameter usage" },
  854.     { 502, "Incorrect parameter combination" },
  855.     /* CANCEL MESSAGE error codes */
  856.     { 600, "Incorrect scts parameter usage" },
  857.     { 601, "Incorrect address parameter usage" },
  858.     { 602, "Incorrect mode parameter usage" },
  859.     { 603, "Incorrect parameter combination" },
  860.     /* SET error codes */
  861.     { 800, "Changing password failed" },
  862.     { 801, "Changing password not allowed" },
  863.     /* GET error codes */
  864.     { 900, "Unsupported item requested" },
  865.     { -1, NULL }
  866. };
  868. static int packet_display_error(struct packet *packet)
  869. {
  870.     int code;
  871.     Octstr *text = NULL;
  872.     Octstr *opname = NULL;
  874.     code = packet_get_int_parm(packet, P_ERROR_CODE);
  875.     text = packet_get_string_parm(packet, P_ERROR_TEXT);
  877.     if (code <= 0) {
  878.         octstr_destroy(text);
  879.         return 0;
  880.     }
  882.     if (text == NULL) {
  883.         /* No error text.  Try to find it in the table. */
  884.         int i;
  885.         for (i = 0; cimd2_errors[i].text != NULL; i++) {
  886.             if (cimd2_errors[i].code == code) {
  887.                 text = octstr_create(cimd2_errors[i].text);
  888.                 break;
  889.             }
  890.         }
  891.     }
  893.     if (text == NULL) {
  894.         /* Still no error text.  Make one up. */
  895.         text = octstr_create("Unknown error");
  896.     }
  898.     opname = operation_name(packet->operation);
  899.     error(0, "CIMD2 %s contained error message:",
  900.           octstr_get_cstr(opname));
  901.     error(0, "code %03d: %s", code, octstr_get_cstr(text));
  902.     octstr_destroy(opname);
  903.     octstr_destroy(text);
  904.     return code;
  905. }
  907. /* Table of special combinations, for convert_gsm_to_latin1. */
  908. /* Each cimd1, cimd2 pair is mapped to a character in the GSM default
  909.  * character set. */
  910. static const struct
  911. {
  912.     unsigned char cimd1, cimd2;
  913.     unsigned char gsm;
  914. }
  915. cimd_combinations[] = {
  916.     { 'O', 'a', 0 },     /* @ */
  917.     { 'L', '-', 1 },     /* Pounds sterling */
  918.     { 'Y', '-', 3 },     /* Yen */
  919.     { 'e', '`', 4 },     /* egrave */
  920.     { 'e', ''', 5 },    /* eacute */
  921.     { 'u', '`', 6 },     /* ugrave */
  922.     { 'i', '`', 7 },     /* igrave */
  923.     { 'o', '`', 8 },     /* ograve */
  924.     { 'C', ',', 9 },     /* C cedilla */
  925.     { 'O', '/', 11 },    /* Oslash */
  926.     { 'o', '/', 12 },    /* oslash */
  927.     { 'A', '*', 14 },    /* Aring */
  928.     { 'a', '*', 15 },    /* aring */
  929.     { 'g', 'd', 16 },    /* greek delta */
  930.     { '-', '-', 17 },    /* underscore */
  931.     { 'g', 'f', 18 },    /* greek phi */
  932.     { 'g', 'g', 19 },    /* greek gamma */
  933.     { 'g', 'l', 20 },    /* greek lambda */
  934.     { 'g', 'o', 21 },    /* greek omega */
  935.     { 'g', 'p', 22 },    /* greek pi */
  936.     { 'g', 'i', 23 },    /* greek psi */
  937.     { 'g', 's', 24 },    /* greek sigma */
  938.     { 'g', 't', 25 },    /* greek theta */
  939.     { 'g', 'x', 26 },    /* greek xi */
  940.     { 'X', 'X', 27 },    /* escape */
  941.     { 'A', 'E', 28 },    /* AE ligature */
  942.     { 'a', 'e', 29 },    /* ae ligature */
  943.     { 's', 's', 30 },    /* german double s */
  944.     { 'E', ''', 31 },   /* Eacute */
  945.     { 'q', 'q', '"' },
  946.     { 'o', 'x', 36 },    /* international currency symbol */
  947.     { '!', '!', 64 },    /* inverted ! */
  948.     { 'A', '"', 91 },    /* Adieresis */
  949.     { 'O', '"', 92 },    /* Odieresis */
  950.     { 'N', '~', 93 },    /* N tilde */
  951.     { 'U', '"', 94 },    /* Udieresis */
  952.     { 's', 'o', 95 },    /* section mark */
  953.     { '?', '?', 96 },    /* inverted ? */
  954.     { 'a', '"', 123 },   /* adieresis */
  955.     { 'o', '"', 124 },   /* odieresis */
  956.     { 'n', '~', 125 },   /* n tilde */
  957.     { 'u', '"', 126 },   /* udieresis */
  958.     { 'a', '`', 127 },   /* agrave */
  959.     { 0, 0, 0 }
  960. };
  963. /* Convert text in the CIMD2 User Data format to the GSM default
  964.  * character set.
  965.  * CIMD2 allows 8-bit characters in this format; they map directly
  966.  * to the corresponding ISO-8859-1 characters.  Since we are heading
  967.  * toward that character set in the end, we don't bother converting
  968.  * those to GSM. */
  969. static void convert_cimd2_to_gsm(Octstr *text)
  970. {
  971.     long pos, len;
  972.     int cimd1, cimd2;
  973.     int c;
  974.     int i;
  976.     /* CIMD2 uses four single-character mappings that do not map
  977.      * to themselves:
  978.      * '@' from 64 to 0, '$' from 36 to 2, ']' from 93 to 14 (A-ring),
  979.      * and '}' from 125 to 15 (a-ring).
  980.      * Other than those, we only have to worry about the escape
  981.      * sequences introduced by _ (underscore).
  982.      */
  984.     len = octstr_len(text);
  985.     for (pos = 0; pos < len; pos++) {
  986.         c = octstr_get_char(text, pos);
  987.         if (c == '@')
  988.             octstr_set_char(text, pos, 0);
  989.         else if (c == '$')
  990.             octstr_set_char(text, pos, 2);
  991.         else if (c == ']')
  992.             octstr_set_char(text, pos, 14);
  993.         else if (c == '}')
  994.             octstr_set_char(text, pos, 15);
  995.         else if (c == '_' && pos + 2 < len) {
  996.             cimd1 = octstr_get_char(text, pos + 1);
  997.             cimd2 = octstr_get_char(text, pos + 2);
  998.             for (i = 0; cimd_combinations[i].cimd1 != 0; i++) {
  999.                 if (cimd_combinations[i].cimd1 == cimd1 &&
  1000.                     cimd_combinations[i].cimd2 == cimd2)
  1001.                     break;
  1002.             }
  1003.             if (cimd_combinations[i].cimd1 == 0)
  1004.                 warning(0, "CIMD2: Encountered unknown "
  1005.                         "escape code _%c%c, ignoring.",
  1006.                         cimd1, cimd2);
  1007.             else {
  1008.                 octstr_delete(text, pos, 2);
  1009.                 octstr_set_char(text, pos, cimd_combinations[i].gsm);
  1010.                 len = octstr_len(text);
  1011.             }
  1012.         }
  1013.     }
  1014. }
  1017. /* Convert text in the GSM default character set to the CIMD2 User Data
  1018.  * format, which is a representation of the GSM default character set
  1019.  * in the lower 7 bits of ISO-8859-1.  (8-bit characters are also
  1020.  * allowed, but it's just as easy not to use them.) */
  1021. static void convert_gsm_to_cimd2(Octstr *text)
  1022. {
  1023.     long pos, len;
  1025.     len = octstr_len(text);
  1026.     for (pos = 0; pos < len; pos++) {
  1027.         int c, i;
  1029.         c = octstr_get_char(text, pos);
  1030.         /* If c is not in the GSM alphabet at this point,
  1031.          * the caller did something badly wrong. */
  1032.         gw_assert(c >= 0);
  1033.         gw_assert(c < 128);
  1035.         for (i = 0; cimd_combinations[i].cimd1 != 0; i++) {
  1036.             if (cimd_combinations[i].gsm == c)
  1037.                 break;
  1038.         }
  1040.         if (cimd_combinations[i].gsm == c) {
  1041.             /* Escape sequence */
  1042.             octstr_insert_data(text, pos, "_ ", 2);
  1043.             pos += 2;
  1044.             len += 2;
  1045.             octstr_set_char(text, pos - 1, cimd_combinations[i].cimd1);
  1046.             octstr_set_char(text, pos, cimd_combinations[i].cimd2);
  1047.         } else if (c == 2) {
  1048.             /* The dollar sign is the only GSM character that
  1049.               * does not have a CIMD escape sequence and does not
  1050.              * map to itself. */
  1051.             octstr_set_char(text, pos, '$');
  1052.         }
  1053.     }
  1054. }
  1057. /***************************************************************************/
  1058. /* Packet encoding functions.  They do not allow the creation of invalid   */
  1059. /* CIMD 2 packets.                                                         */
  1060. /***************************************************************************/
  1062. /* Build a new packet struct with this operation code and sequence number. */
  1063. static struct packet *packet_create(int operation, int seq)
  1064. {
  1065.     struct packet *packet;
  1066.     unsigned char minpacket[sizeof("sOO:SSSte")];
  1068.     packet = gw_malloc(sizeof(*packet));
  1069.     packet->operation = operation;
  1070.     packet->seq = seq;
  1071.     sprintf(minpacket, STX_str "%02d:%03d" TAB_str ETX_str, operation, seq);
  1072.     packet->data = octstr_create(minpacket);
  1074.     return packet;
  1075. }
  1077. /* Add a parameter to the end of packet */
  1078. static void packet_add_parm(struct packet *packet, int parmtype,
  1079.                             int parmno, Octstr *value)
  1080. {
  1081.     unsigned char parmh[sizeof("tPPP:")];
  1082.     long position;
  1083.     long len;
  1084.     int copied = 0;
  1086.     len = octstr_len(value);
  1088.     gw_assert(packet != NULL);
  1089.     gw_assert(parm_type(parmno) == parmtype);
  1091.     if (len > parm_maxlen(parmno)) {
  1092.         warning(0, "CIMD2: %s parameter too long, truncating from "
  1093.                 "%ld to %ld characters", parm_name(parmno),
  1094.                 len, (long) parm_maxlen(parmno));
  1095.         value = octstr_copy(value, 0, parm_maxlen(parmno));
  1096.         copied = 1;
  1097.     }
  1099.     /* There's a TAB and ETX at the end; insert it before those.
  1100.      * The new parameter will come with a new starting TAB. */
  1101.     position = octstr_len(packet->data) - 2;
  1103.     sprintf(parmh, TAB_str "%03d:", parmno);
  1104.     octstr_insert_data(packet->data, position, parmh, strlen(parmh));
  1105.     octstr_insert(packet->data, value, position + strlen(parmh));
  1106.     if (copied)
  1107.         octstr_destroy(value);
  1108. }
  1110. /* Add a String parameter to the packet */
  1111. static void packet_add_string_parm(struct packet *packet, int parmno, Octstr *value)
  1112. {
  1113.     packet_add_parm(packet, P_STRING, parmno, value);
  1114. }
  1116. /* Add an Address parameter to the packet */
  1117. static void packet_add_address_parm(struct packet *packet, int parmno, Octstr *value)
  1118. {
  1119.     gw_assert(octstr_check_range(value, 0, octstr_len(value), isphonedigit));
  1120.     packet_add_parm(packet, P_ADDRESS, parmno, value);
  1121. }
  1123. /* Add an SMS parameter to the packet.  The caller is expected to have done
  1124.  * the translation to the GSM character set already.  */
  1125. static void packet_add_sms_parm(struct packet *packet, int parmno, Octstr *value)
  1126. {
  1127.     packet_add_parm(packet, P_SMS, parmno, value);
  1128. }
  1130. /* There is no function for adding a Time parameter to the packet, because
  1131.  * the format makes Time parameters useless for us.  If you find that you
  1132.  * need to use them, then also add code for querying the SMS center timestamp
  1133.  * and using that for synchronization.  And beware of DST changes. */
  1135. /* Add a Hexadecimal parameter to the packet */
  1136. static void packet_add_hex_parm(struct packet *packet, int parmno, Octstr *value)
  1137. {
  1138.     value = octstr_duplicate(value);
  1139.     octstr_binary_to_hex(value, 1);   /* 1 for uppercase hex, i.e. A .. F */
  1140.     packet_add_parm(packet, P_HEX, parmno, value);
  1141.     octstr_destroy(value);
  1142. }
  1144. /* Add an Integer parameter to the packet */
  1145. static void packet_add_int_parm(struct packet *packet, int parmno, long value)
  1146. {
  1147.     unsigned char buf[128];
  1148.     Octstr *valuestr;
  1150.     gw_assert(parm_in_range(parmno, value));
  1152.     sprintf(buf, "%ld", value);
  1153.     valuestr = octstr_create(buf);
  1154.     packet_add_parm(packet, P_INT, parmno, valuestr);
  1155.     octstr_destroy(valuestr);
  1156. }
  1158. static void packet_set_checksum(struct packet *packet)
  1159. {
  1160.     Octstr *data;
  1161.     int checksum;
  1162.     long pos, len;
  1163.     unsigned char buf[16];
  1165.     gw_assert(packet != NULL);
  1167.     data = packet->data;
  1168.     if (octstr_get_char(data, octstr_len(data) - 2) != TAB) {
  1169.         /* Packet already has checksum; kill it. */
  1170.         octstr_delete(data, octstr_len(data) - 3, 2);
  1171.     }
  1173.     gw_assert(octstr_get_char(data, octstr_len(data) - 2) == TAB);
  1175.     /* Sum all the way up to the last TAB */
  1176.     checksum = 0;
  1177.     for (pos = 0, len = octstr_len(data); pos < len - 1; pos++) {
  1178.         checksum += octstr_get_char(data, pos);
  1179.         checksum &= 0xff;
  1180.     }
  1182.     sprintf(buf, "%02X", checksum);
  1183.     octstr_insert_data(data, len - 1, buf, 2);
  1184. }
  1186. static void packet_set_sequence(struct packet *packet, int seq)
  1187. {
  1188.     unsigned char buf[16];
  1190.     gw_assert(packet != NULL);
  1191.     gw_assert(seq >= 0);
  1192.     gw_assert(seq < 256);
  1194.     sprintf(buf, "%03d", seq);
  1196.     /* Start at 4 to skip the <STX> ZZ: part of the header. */
  1197.     octstr_set_char(packet->data, 4, buf[0]);
  1198.     octstr_set_char(packet->data, 5, buf[1]);
  1199.     octstr_set_char(packet->data, 6, buf[2]);
  1200.     packet->seq = seq;
  1201. }
  1203. static struct packet *packet_encode_message(Msg *msg, Octstr *sender_prefix)
  1204. {
  1205.     struct packet *packet;
  1206.     Octstr *text;
  1207.     int spaceleft;
  1208.     long truncated;
  1209.     int dcs = 0;
  1211.     gw_assert(msg != NULL);
  1212.     gw_assert(msg->type == sms);
  1213.     gw_assert(msg->sms.receiver != NULL);
  1215.     dcs = fields_to_dcs(msg, 0);
  1216.     if (msg->sms.sender == NULL)
  1217.         msg->sms.sender = octstr_create("");
  1219.     if (!parm_valid_address(msg->sms.receiver)) {
  1220.         warning(0, "cimd2_submit_msg: non-digits in "
  1221.                 "destination phone number '%s', discarded",
  1222.                 octstr_get_cstr(msg->sms.receiver));
  1223.         return NULL;
  1224.     }
  1226.     if (!parm_valid_address(msg->sms.sender)) {
  1227.         warning(0, "cimd2_submit_msg: non-digits in "
  1228.                 "originating phone number '%s', discarded",
  1229.                 octstr_get_cstr(msg->sms.sender));
  1230.         return NULL;
  1231.     }
  1233.     packet = packet_create(SUBMIT_MESSAGE, BOGUS_SEQUENCE);
  1235.     packet_add_address_parm(packet, P_DESTINATION_ADDRESS, msg->sms.receiver);
  1237.     /* CIMD2 interprets the originating address as a sub-address to
  1238.      * our connection number (so if the connection is "400" and we
  1239.      * fill in "600" as the sender number, the user sees "400600").
  1240.      * Since we have no way to ask what this number is, it has to
  1241.      * be configured. */
  1242.     if (octstr_len(sender_prefix) == 0) { /* Speed up the default case */
  1243.         packet_add_address_parm(packet, P_ORIGINATING_ADDRESS,
  1244.                                 msg->sms.sender);
  1245.     } else if (octstr_compare(sender_prefix, octstr_imm("never")) != 0) {
  1246.         if (octstr_ncompare(sender_prefix, msg->sms.sender,
  1247.                             octstr_len(sender_prefix)) == 0) {
  1248.             Octstr *sender;
  1249.             sender = octstr_copy(msg->sms.sender,
  1250.                 octstr_len(sender_prefix), octstr_len(msg->sms.sender));
  1251.             packet_add_address_parm(packet, P_ORIGINATING_ADDRESS, sender);
  1252.             octstr_destroy(sender);
  1253.         } else {
  1254.             warning(0, "CIMD2: Sending message with originating address <%s>, "
  1255.                        "which does not start with the sender-prefix.",
  1256.                     octstr_get_cstr(msg->sms.sender));
  1257.         }
  1258.     }
  1260.     /* Explicitly ask not to get status reports.
  1261.      * If we do not do this, the server's default might be to
  1262.      * send status reports in some cases, and we don't do anything
  1263.      * with those reports anyway. */
  1264.     /* ask for the delivery reports if needed*/
  1266.     if (msg->sms.dlr_mask & 0x03)
  1267.     {
  1268. packet_add_int_parm(packet, P_STATUS_REPORT_REQUEST, 14);
  1269.     }
  1270.     else
  1271. packet_add_int_parm(packet, P_STATUS_REPORT_REQUEST, 0);
  1273.     truncated = 0;
  1275.     spaceleft = 140;
  1276.     if (octstr_len(msg->sms.udhdata)) {
  1277.         /* udhdata will be truncated and warned about if
  1278.          * it does not fit. */
  1279.         packet_add_hex_parm(packet, P_USER_DATA_HEADER, msg->sms.udhdata);
  1280.         spaceleft -= octstr_len(msg->sms.udhdata);
  1281.     }
  1282.     if (msg->sms.coding == DC_7BIT)
  1283.         spaceleft = spaceleft * 8 / 7;
  1284.     if (spaceleft < 0)
  1285.         spaceleft = 0;
  1287.     text = octstr_duplicate(msg->sms.msgdata);
  1288.     if (octstr_len(text) > 0 && spaceleft == 0) {
  1289.         warning(0, "CIMD2: message filled up with "
  1290.                 "UDH, no room for message text");
  1291.     } else if (msg->sms.coding == DC_8BIT || msg->sms.coding == DC_UCS2) {
  1292.         if (octstr_len(text) > spaceleft) {
  1293.             truncated = octstr_len(text) - spaceleft;
  1294.             octstr_truncate(text, spaceleft);
  1295.         }
  1296.         packet_add_hex_parm(packet, P_USER_DATA_BINARY, text);
  1297.     } else {
  1298. #if CIMD2_TRACE
  1299.         debug("bb.sms.cimd2", 0, "CIMD2 sending message.  Text:");
  1300.         octstr_dump(text, 0);
  1301. #endif
  1302.         /* Going from latin1 to GSM to CIMD2 may seem like a
  1303.          * detour, but it's the only way to get all the escape
  1304.          * codes right. */
  1305.         charset_latin1_to_gsm(text);
  1306.         truncated = charset_gsm_truncate(text, spaceleft);
  1307.         convert_gsm_to_cimd2(text);
  1308. #if CIMD2_TRACE
  1309.         debug("bb.sms.cimd2", 0, "After CIMD2 encoding:");
  1310.         octstr_dump(text, 0);
  1311. #endif
  1312.         packet_add_sms_parm(packet, P_USER_DATA, text);
  1313.     }
  1315.     if (dcs != 0)
  1316.         packet_add_int_parm(packet, P_DATA_CODING_SCHEME, dcs);
  1318.     if (truncated > 0) {
  1319.         warning(0, "CIMD2: truncating message text to fit "
  1320.                 "in %d characters.", spaceleft);
  1321.     }
  1323.     octstr_destroy(text);
  1324.     return packet;
  1325. }
  1327. /***************************************************************************/
  1328. /* Protocol functions.  These implement various transactions.              */
  1329. /***************************************************************************/
  1331. /* Give this packet a proper sequence number for sending. */
  1332. static void packet_set_send_sequence(struct packet *packet, SMSCenter *smsc)
  1333. {
  1334.     gw_assert(smsc != NULL);
  1335.     /* Send sequence numbers are always odd, receiving are always even */
  1336.     gw_assert(smsc->cimd2_send_seq % 2 == 1);
  1338.     packet_set_sequence(packet, smsc->cimd2_send_seq);
  1339.     smsc->cimd2_send_seq += 2;
  1340.     if (smsc->cimd2_send_seq > 256)
  1341.         smsc->cimd2_send_seq = 1;
  1342. }
  1344. static struct packet *cimd2_get_packet(SMSCenter *smsc, Octstr **ts)
  1345. {
  1346.     struct packet *packet = NULL;
  1348.     gw_assert(smsc != NULL);
  1350.     /* If packet is already available, don't try to read anything */
  1351.     packet = packet_extract(smsc->cimd2_inbuffer);
  1353.     while (packet == NULL) {
  1354.         if (read_available(smsc->socket, RESPONSE_TIMEOUT) != 1) {
  1355.             warning(0, "CIMD2 SMSCenter is not responding");
  1356.             return NULL;
  1357.         }
  1359.         if (octstr_append_from_socket(smsc->cimd2_inbuffer, smsc->socket) <= 0) {
  1360.             error(0, "cimd2_get_packet: read failed");
  1361.             return NULL;
  1362.         }
  1364.         packet = packet_extract(smsc->cimd2_inbuffer);
  1365.     }
  1367.     packet_check(packet);
  1368.     packet_check_can_receive(packet);
  1369. if(ts)
  1370.     *ts = packet_get_parm(packet,P_MC_TIMESTAMP);
  1372.     if (smsc->keepalive > 0)
  1373.         smsc->cimd2_next_ping = time(NULL) + 60 * smsc->keepalive;
  1375.     return packet;
  1376. }
  1378. /* Acknowledge a request.  The CIMD 2 spec only defines positive responses
  1379.  * to the server, because the server is perfect. */
  1380. static void cimd2_send_response(struct packet *request, SMSCenter *smsc)
  1381. {
  1382.     struct packet *response;
  1384.     gw_assert(request != NULL);
  1385.     gw_assert(request->operation < RESPONSE);
  1387.     response = packet_create(request->operation + RESPONSE, request->seq);
  1388.     packet_set_checksum(response);
  1390.     /* Don't check errors here because if there is something
  1391.      * wrong with the socket, the main loop will detect it. */
  1392.     octstr_write_to_socket(smsc->socket, response->data);
  1394.     packet_destroy(response);
  1395. }
  1397. static Msg *cimd2_accept_message(struct packet *request)
  1398. {
  1399.     Msg *message = NULL;
  1400.     Octstr *destination = NULL;
  1401.     Octstr *origin = NULL;
  1402.     Octstr *UDH = NULL;
  1403.     Octstr *text = NULL;
  1404.     int DCS;
  1406.     /* See GSM 03.38.  The bit patterns we can handle are:
  1407.      *   000xyyxx  Uncompressed text, yy indicates alphabet.
  1408.             *                   yy = 00, default alphabet
  1409.      *                   yy = 01, 8-bit data
  1410.      *                   yy = 10, UCS2 (can't handle yet)
  1411.      *                   yy = 11, reserved
  1412.      *   1111xyxx  Data, y indicates alphabet.
  1413.      *                   y = 0, default alphabet
  1414.      *                   y = 1, 8-bit data
  1415.      */
  1416.     DCS = packet_get_int_parm(request, P_DATA_CODING_SCHEME);
  1418.     destination = packet_get_address_parm(request, P_DESTINATION_ADDRESS);
  1419.     origin = packet_get_address_parm(request, P_ORIGINATING_ADDRESS);
  1420.     UDH = packet_get_hex_parm(request, P_USER_DATA_HEADER);
  1421.     /* Text is either in User Data or User Data Binary field. */
  1422.     text = packet_get_sms_parm(request, P_USER_DATA);
  1423.     if (text != NULL) {
  1424. #if CIMD2_TRACE
  1425.         debug("bb.sms.cimd2", 0, "CIMD2 received message.  Text:");
  1426.         octstr_dump(text, 0);
  1427. #endif
  1428.         convert_cimd2_to_gsm(text);
  1429.         charset_gsm_to_latin1(text);
  1430. #if CIMD2_TRACE
  1431.         debug("bb.sms.cimd", 0, "Text in latin1:");
  1432.         octstr_dump(text, 0);
  1433. #endif
  1434.     } else {
  1435.         text = packet_get_hex_parm(request, P_USER_DATA_BINARY);
  1436. #if CIMD2_TRACE
  1437.         debug("bb.sms.cimd2", 0, "CIMD2 received message.  Text:");
  1438.         octstr_dump(text, 0);
  1439. #endif
  1440.     }
  1442.     /* Code elsewhere in the gateway always expects the sender and
  1443.      * receiver fields to be filled, so we discard messages that
  1444.       * lack them.  If they should not be discarded, then the code
  1445.      * handling sms messages should be reviewed.  -- RB */
  1446.     if (!destination || octstr_len(destination) == 0) {
  1447.         info(0, "CIMD2: Got SMS without receiver, discarding.");
  1448.         goto error;
  1449.     }
  1450.     if (!origin || octstr_len(origin) == 0) {
  1451.         info(0, "CIMD2: Got SMS without sender, discarding.");
  1452.         goto error;
  1453.     }
  1455.     if ((!text || octstr_len(text) == 0) && (!UDH || octstr_len(UDH) == 0)) {
  1456.         info(0, "CIMD2: Got empty SMS, ignoring.");
  1457.         goto error;
  1458.     }
  1460.     message = msg_create(sms);
  1461.     if (! dcs_to_fields(&message, DCS)) {
  1462. /* XXX Should reject this message ? */
  1463. debug("CIMD2", 0, "Invalid DCS");
  1464. dcs_to_fields(&message, 0);
  1465.     }
  1466.     message->sms.sender = origin;
  1467.     message->sms.receiver = destination;
  1468.     if (UDH) {
  1469.         message->sms.udhdata = UDH;
  1470.     }
  1471.     message->sms.msgdata = text;
  1472.     return message;
  1474. error:
  1475.     msg_destroy(message);
  1476.     octstr_destroy(destination);
  1477.     octstr_destroy(origin);
  1478.     octstr_destroy(UDH);
  1479.     octstr_destroy(text);
  1480.     return NULL;
  1481. }
  1483. /* Deal with a request from the CIMD2 server, and acknowledge it. */
  1484. static void cimd2_handle_request(struct packet *request, SMSCenter *smsc)
  1485. {
  1486.     Msg *message = NULL;
  1488.     /* TODO: Check if the sequence number of this request is what we
  1489.      * expected. */
  1491.     if (request->operation == DELIVER_STATUS_REPORT) {
  1492.         message = cimd2_accept_delivery_report_message(request,smsc);
  1493.         if (message)
  1494.             list_append(smsc->cimd2_received, message);
  1495.      }
  1496.      else if (request->operation == DELIVER_MESSAGE) {
  1497.          message = cimd2_accept_message(request);
  1498.          if (message)
  1499.              list_append(smsc->cimd2_received, message);
  1500.     }
  1502.     cimd2_send_response(request, smsc);
  1503. }
  1505. /* Send a request and wait for the ack.  If the other side responds with
  1506.  * an error code, attempt to correct and retry. 
  1507.  * If other packets arrive while we wait for the ack, handle them.
  1508.  *
  1509.  * Return -1 if the SMSC refused the request.  Return -2 for other
  1510.  * errors, such as being unable to send the request at all.  If the
  1511.  * function returns -2, the caller would do well to try to reopen the
  1512.  * connection.
  1513.  *
  1514.  * The SMSCenter must be already open.
  1515.  *
  1516.  * TODO: This function has grown large and complex.  Break it up
  1517.  * into smaller pieces.
  1518.  */
  1519. static int cimd2_request(struct packet *request, SMSCenter *smsc, Octstr **ts)
  1520. {
  1521.     int ret;
  1522.     struct packet *reply = NULL;
  1523.     int errorcode;
  1524.     int tries = 0;
  1526.     gw_assert(smsc != NULL);
  1527.     gw_assert(request != NULL);
  1528.     gw_assert(operation_can_send(request->operation));
  1530.     if (smsc->socket < 0) {
  1531.         warning(0, "cimd2_request: socket not open.");
  1532.         goto io_error;
  1533.     }
  1535. retransmit:
  1536.     packet_set_send_sequence(request, smsc);
  1537.     packet_set_checksum(request);
  1539.     ret = octstr_write_to_socket(smsc->socket, request->data);
  1540.     if (ret < 0)
  1541.         goto io_error;
  1543. next_reply:
  1544.     /*reply = cimd2_get_packet(smsc,ts);*/
  1545.     reply = cimd2_get_packet(smsc, NULL);
  1546.     if (!reply)
  1547.         goto io_error;
  1549.     errorcode = packet_display_error(reply);
  1551.     if (reply->operation == NACK) {
  1552.         warning(0, "CIMD2 received NACK");
  1553.         octstr_dump(reply->data, 0);
  1554.         /* Correct sequence number if server says it was wrong,
  1555.          * but only if server's number is sane. */
  1556.         if (reply->seq != request->seq && (reply->seq % 1) == 1) {
  1557.             warning(0, "correcting sequence number from %ld to %ld.",
  1558.                     (long) smsc->cimd2_send_seq, (long) reply->seq);
  1559.             smsc->cimd2_send_seq = reply->seq;
  1560.         }
  1561.         goto retry;
  1562.     }
  1564.     if (reply->operation == GENERAL_ERROR_RESPONSE) {
  1565.         error(0, "CIMD2 received general error response");
  1566.         goto io_error;
  1567.     }
  1569.     /* The server sent us a request.  Handle it, then wait for
  1570.      * a new reply. */
  1571.     if (reply->operation < RESPONSE) {
  1572.         cimd2_handle_request(reply, smsc);
  1573.         packet_destroy(reply);
  1574.         goto next_reply;
  1575.     }
  1577.     if (reply->seq != request->seq) {
  1578.         /* We got a response to a different request number than
  1579.          * what we send.  Strange. */
  1580.         warning(0, "CIMD2: response had unexpected sequence number; ignoring.n");
  1581.         goto next_reply;
  1582.     }
  1584.     if (reply->operation != request->operation + RESPONSE) {
  1585.         /* We got a response that didn't match our request */
  1586.         Octstr *request_name = operation_name(request->operation);
  1587.         Octstr *reply_name = operation_name(reply->operation);
  1588.         warning(0, "CIMD2: %s request got a %s",
  1589.                 octstr_get_cstr(request_name),
  1590.                 octstr_get_cstr(reply_name));
  1591.         octstr_destroy(request_name);
  1592.         octstr_destroy(reply_name);
  1593.         octstr_dump(reply->data, 0);
  1594.         goto retry;
  1595.     }
  1597.     if (errorcode > 0)
  1598.         goto error;
  1600.     /* The reply passed all the checks... looks like the SMSC accepted
  1601.      * our request! */
  1602.     packet_destroy(reply);
  1603.     return 0;
  1605. io_error:
  1606.     packet_destroy(reply);
  1607.     return -2;
  1609. error:
  1610.     packet_destroy(reply);
  1611.     return -1;
  1613. retry:
  1614.     if (++tries < 3) {
  1615.         warning(0, "Retransmitting (take %d)", tries);
  1616.         goto retransmit;
  1617.     }
  1618.     warning(0, "Giving up.");
  1619.     goto io_error;
  1620. }
  1622. /* Close the SMSC socket without fanfare. */
  1623. static void cimd2_close_socket(SMSCenter *smsc)
  1624. {
  1625.     gw_assert(smsc != NULL);
  1627.     if (smsc->socket < 0)
  1628.         return;
  1630.     if (close(smsc->socket) < 0)
  1631.         warning(errno, "error closing CIMD2 socket");
  1632.     smsc->socket = -1;
  1633. }
  1635. /* Open a socket to the SMSC, send a login packet, and wait for ack.
  1636.  * This may block.  Return 0 for success, or -1 for failure. */
  1637. /* Make sure the socket is closed before calling this function, otherwise
  1638.  * we will leak fd's. */
  1639. static int cimd2_login(SMSCenter *smsc)
  1640. {
  1641.     int ret;
  1642.     struct packet *packet = NULL;
  1644.     gw_assert(smsc != NULL);
  1646.     if (smsc->socket >= 0) {
  1647.         warning(0, "cimd2_login: socket was already open; closing");
  1648.         cimd2_close_socket(smsc);
  1649.     }
  1651.     smsc->socket = tcpip_connect_to_server(octstr_get_cstr(smsc->cimd2_hostname), 
  1652.     smsc->cimd2_port, NULL);
  1653.     /* XXX add interface_name if required */
  1654.     if (smsc->socket == -1)
  1655.         goto error;
  1657.     packet = packet_create(LOGIN, BOGUS_SEQUENCE);
  1658.     packet_add_string_parm(packet, P_USER_IDENTITY, smsc->cimd2_username);
  1659.     packet_add_string_parm(packet, P_PASSWORD, smsc->cimd2_password);
  1661.     ret = cimd2_request(packet, smsc, NULL);
  1662.     if (ret < 0)
  1663.         goto error;
  1665.     packet_destroy(packet);
  1666.     info(0, "%s logged in.", smsc_name(smsc));
  1668.     return 0;
  1670. error:
  1671.     error(0, "cimd2_login failed");
  1672.     cimd2_close_socket(smsc);
  1673.     packet_destroy(packet);
  1674.     return -1;
  1675. }
  1677. static void cimd2_logout(SMSCenter *smsc)
  1678. {
  1679.     struct packet *packet = NULL;
  1681.     gw_assert(smsc != NULL);
  1683.     packet = packet_create(LOGOUT, BOGUS_SEQUENCE);
  1684.     /* TODO: Don't wait very long for a response in this case. */
  1685.     cimd2_request(packet, smsc,NULL);
  1686.     packet_destroy(packet);
  1687. }
  1689. static int cimd2_send_alive(SMSCenter *smsc)
  1690. {
  1691.     struct packet *packet = NULL;
  1692.     int ret;
  1694.     gw_assert(smsc != NULL);
  1696.     packet = packet_create(ALIVE, BOGUS_SEQUENCE);
  1697.     ret = cimd2_request(packet, smsc,NULL);
  1698.     packet_destroy(packet);
  1700.     if (ret < 0)
  1701.         warning(0, "CIMD2: SMSC not alive.n");
  1703.     return ret;
  1704. }
  1706. /***************************************************************************/
  1707. /* SMSC Interface, as defined in smsc_interface.def                        */
  1708. /***************************************************************************/
  1710. SMSCenter *cimd2_open(Octstr *hostname, int port, Octstr *username,
  1711. Octstr *password, int keepalive, Octstr *sender_prefix)
  1712. {
  1713.     SMSCenter *smsc = NULL;
  1714.     int maxlen;
  1716.     smsc = smscenter_construct();
  1717.     gw_assert(smsc != NULL);
  1719.     smsc->type = SMSC_TYPE_CIMD2;
  1720.     smsc->keepalive = keepalive;
  1721.     smsc->cimd2_hostname = octstr_duplicate(hostname);
  1722.     smsc->cimd2_port = port;
  1723.     smsc->cimd2_username = octstr_duplicate(username);
  1724.     smsc->cimd2_password = octstr_duplicate(password);
  1725.     smsc->sender_prefix = octstr_duplicate(sender_prefix);
  1726.     sprintf(smsc->name, "CIMD2:%s:%d:%s", octstr_get_cstr(hostname), port, octstr_get_cstr(username));
  1727.     smsc->cimd2_received = list_create();
  1728.     smsc->cimd2_inbuffer = octstr_create("");
  1729.     smsc->cimd2_error = 0;
  1730.     if (keepalive > 0)
  1731.         smsc->cimd2_next_ping = time(NULL) + keepalive * 60;
  1733.     maxlen = parm_maxlen(P_USER_IDENTITY);
  1734.     if (octstr_len(smsc->cimd2_username) > maxlen) {
  1735.         octstr_truncate(smsc->cimd2_username, maxlen);
  1736.         warning(0, "Truncating CIMD2 username to %d chars", maxlen);
  1737.     }
  1739.     maxlen = parm_maxlen(P_PASSWORD);
  1740.     if (octstr_len(smsc->cimd2_password) > maxlen) {
  1741.         octstr_truncate(smsc->cimd2_password, maxlen);
  1742.         warning(0, "Truncating CIMD2 password to %d chars", maxlen);
  1743.     }
  1745.     if (cimd2_login(smsc) < 0)
  1746.         goto error;
  1748.     return smsc;
  1750. error:
  1751.     error(0, "cimd2_open failed");
  1752.     smscenter_destruct(smsc);
  1753.     return NULL;
  1754. }
  1756. int cimd2_reopen(SMSCenter *smsc)
  1757. {
  1758.     gw_assert(smsc != NULL);
  1760.     warning(0, "Attempting to re-open CIMD2 connection");
  1762.     cimd2_close_socket(smsc);
  1764.     /* Restore message counters to their default values */
  1765.     smsc->cimd2_send_seq = 1;
  1766.     smsc->cimd2_receive_seq = 0;
  1768.     /* Clear leftover input */
  1769.     octstr_destroy(smsc->cimd2_inbuffer);
  1770.     smsc->cimd2_inbuffer = octstr_create("");
  1772.     return cimd2_login(smsc);
  1773. }
  1775. int cimd2_close(SMSCenter *smsc)
  1776. {
  1777.     int ret;
  1778.     int discarded;
  1780.     gw_assert(smsc != NULL);
  1782.     debug("bb.sms.cimd2", 0, "Closing CIMD2 SMSC");
  1784.     if (smsc->socket < 0) {
  1785.         warning(0, "cimd2_close: already closed.n");
  1786.         return 0;
  1787.     }
  1789.     cimd2_logout(smsc);
  1791.     ret = close(smsc->socket);
  1792.     smsc->socket = -1;
  1794.     smsc->cimd2_send_seq = 0;
  1795.     smsc->cimd2_receive_seq = 1;
  1796.     octstr_destroy(smsc->cimd2_hostname);
  1797.     octstr_destroy(smsc->cimd2_username);
  1798.     octstr_destroy(smsc->cimd2_password);
  1799.     octstr_destroy(smsc->cimd2_inbuffer);
  1801.     discarded = list_len(smsc->cimd2_received);
  1802.     list_destroy(smsc->cimd2_received, msg_destroy_item);
  1804.     if (discarded > 0)
  1805.         warning(0, "CIMD2: discarded %d received messages", discarded);
  1807.     return ret;
  1808. }
  1810. int cimd2_submit_msg(SMSCenter *smsc, Msg *msg)
  1811. {
  1812.     struct packet *packet;
  1813.     int ret = 0;
  1814.     int tries;
  1815.     Octstr *ts;
  1816.     ts = NULL;
  1818.     gw_assert(smsc != NULL);
  1820.     packet = packet_encode_message(msg, smsc->sender_prefix);
  1821.     if (!packet)
  1822.         return 0;   /* We can't signal protocol errors yet */
  1824.     for (tries = 0; tries < 3; tries++) {
  1825.         ret = cimd2_request(packet, smsc,&ts);
  1826.         if((ret == 0) && (ts) && (msg->sms.dlr_mask & 0x03))
  1827.         {
  1828.             dlr_add(smsc->name,
  1829.                 octstr_get_cstr(ts), 
  1830.                 octstr_get_cstr(msg->sms.sender),
  1831.                 octstr_get_cstr(msg->sms.receiver),
  1832.                 octstr_get_cstr(msg->sms.service),
  1833.                 octstr_get_cstr(msg->sms.dlr_url),
  1834.                 msg->sms.dlr_mask);
  1835.             octstr_destroy(ts);
  1836.             ts = NULL;
  1837. }
  1838. if (ret == 0 || ret == -1)
  1839.             break;
  1840.         if (cimd2_reopen(smsc) < 0) {
  1841.             ret = -1;
  1842.             break;
  1843.         }
  1844.     }
  1846.     packet_destroy(packet);
  1847.     return ret;
  1848. }
  1850. /* The bearerbox really doesn't like it if pending_smsmessage returns
  1851.  * an error code.  We work around it until the bearerbox is rewritten.
  1852.  * Record the error here, and return it in cimd2_receive_msg.  Return
  1853.  * "message available" if there is an error so that cimd2_receive_msg
  1854.  * is called. */
  1855. int cimd2_pending_smsmessage(SMSCenter *smsc)
  1856. {
  1857.     long ret;
  1858.     struct packet *packet;
  1860.     gw_assert(smsc != NULL);
  1861.     gw_assert(smsc->type == SMSC_TYPE_CIMD2);
  1863.     if (list_len(smsc->cimd2_received) > 0)
  1864.         return 1;
  1866.     if (smsc->socket < 0) {
  1867.         /* XXX We have to assume that smsc_send_message is
  1868.          * currently trying to reopen, so we have to make
  1869.          * this thread wait.  It should be done in a nicer
  1870.          * way. */ 
  1871.         return 0;
  1872.     }
  1874.     ret = read_available(smsc->socket, 0);
  1875.     if (ret == 0) {
  1876.         if (smsc->keepalive > 0 && smsc->cimd2_next_ping < time(NULL)) {
  1877.             if (cimd2_send_alive(smsc) < 0) {
  1878.                 smsc->cimd2_error = 1;
  1879.                 return 1;
  1880.             }
  1881.         }
  1882.         return 0;
  1883.     }
  1885.     if (ret < 0) {
  1886.         warning(errno, "cimd2_pending_smsmessage: read_available failed");
  1887.         smsc->cimd2_error = 1;
  1888.         return 1;
  1889.     }
  1891.     /* We have some data waiting... see if it is an sms delivery. */
  1892.     ret = octstr_append_from_socket(smsc->cimd2_inbuffer, smsc->socket);
  1894.     if (ret == 0) {
  1895.         warning(0, "cimd2_pending_smsmessage: service center closed connection.");
  1896.         smsc->cimd2_error = 1;
  1897.         return 1;
  1898.     }
  1899.     if (ret < 0) {
  1900.         warning(0, "cimd2_pending_smsmessage: read failed");
  1901.         smsc->cimd2_error = 1;
  1902.         return 1;
  1903.     }
  1905.     for (;;) {
  1906.         packet = packet_extract(smsc->cimd2_inbuffer);
  1907.         if (!packet)
  1908.             break;
  1910.         packet_check(packet);
  1911.         packet_check_can_receive(packet);
  1913.         if (packet->operation < RESPONSE)
  1914.             cimd2_handle_request(packet, smsc);
  1915.         else {
  1916.             error(0, "cimd2_pending_smsmessage: unexpected response packet");
  1917.             octstr_dump(packet->data, 0);
  1918.         }
  1920.         packet_destroy(packet);
  1921.     }
  1923.     if (list_len(smsc->cimd2_received) > 0)
  1924.         return 1;
  1926.     return 0;
  1927. }
  1929. int cimd2_receive_msg(SMSCenter *smsc, Msg **msg)
  1930. {
  1931.     gw_assert(smsc != NULL);
  1932.     gw_assert(msg != NULL);
  1934.     if (smsc->cimd2_error) {
  1935.         smsc->cimd2_error = 0;
  1936.         return -1;
  1937.     }
  1939.     *msg = list_consume(smsc->cimd2_received);
  1941.     return 1;
  1942. }
  1946. static Msg *cimd2_accept_delivery_report_message(struct packet *request, SMSCenter *smsc)
  1947. {
  1948.     Msg *msg = NULL;
  1949.     Octstr *destination = NULL;
  1950.     Octstr *timestamp = NULL;
  1951.     Octstr *statuscode = NULL;
  1952.     int st_code; 
  1953.     int code;
  1955.     destination = packet_get_parm(request, P_DESTINATION_ADDRESS);
  1956.     timestamp = packet_get_parm(request, P_MC_TIMESTAMP);
  1957.     statuscode = packet_get_parm(request, P_STATUS_CODE);
  1959.     st_code = atoi(octstr_get_cstr(statuscode));
  1960.     
  1961.     switch(st_code)
  1962.     {
  1963.     case 2:  /* validity period expired */
  1964.     case 3:  /* delivery failed */
  1965. code = DLR_FAIL;
  1966.      break;
  1967.     case 4: /* delivery successful */
  1968.      code = DLR_SUCCESS;
  1969.      break;
  1970.     default:
  1971.         code = 0;
  1972.     }
  1973.     if(code)
  1974.      msg = dlr_find(smsc->name,
  1975.             octstr_get_cstr(timestamp), 
  1976.             octstr_get_cstr(destination),
  1977.             code);
  1978.     else
  1979.         msg = NULL;
  1980.     octstr_destroy(statuscode);
  1981.     octstr_destroy(destination);
  1982.     octstr_destroy(timestamp);
  1984.     /* recode the body into msgdata */
  1985.     if (msg) {
  1986.         msg->sms.msgdata = packet_get_parm(request, P_USER_DATA);
  1987.     }
  1989.     return msg;
  1990.  }