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

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

手机WAP编程

开发平台：

WINDOWS

smsc_ois.c：源码内容
  1. /*****************************************************************************
  2.  * smsc_ois.c - Sema Group SMS2000 (G6.0) Center (OIS 5.0).
  3.  * Jouko Koski (EDS) for WapIT Ltd.
  4.  *
  5.  * The SMS2000 has a general X.25 access gateway for accessing the SMSC,
  6.  * as described in the Open Interface Specification 5.0 document.
  7.  * A protocol translator - like the Cisco 2501 router - hides all the
  8.  * X.25 trickery from us. We just connect to a preconfigured router
  9.  * address/port, and the translator forwards the connection to the SMS2000.
  10.  * Correspondingly, if the SMSC has something to say, it looks like
  11.  * the router were contacting our port. The router should be configured so,
  12.  * that it has a pre-defined address and tcp port in X.25 automode establishing
  13.  * a X.25 link and a similar configuration in X.25 side connecting to a pre-
  14.  * defined address and port, it shall not encapsulate everything in Telnet
  15.  * (set the stream mode), and it should suppress banner messages like "Trying
  16.  * 9876...Open" (set the quiet mode).
  17.  *
  18.  * Whenever possible, I've tried to steal ideas and code from other smsc_*
  19.  * files, particularly from Hao Shi's (EDS) original implementation for a
  20.  * serial-line-connected PAD. However, the code is highly evolutionary,
  21.  * because during the implementation new technical details kept popping
  22.  * up all the time (initially, PAD commands were supposed to be used,
  23.  * but the router was configured to "automode", so they weren't necessary;
  24.  * instead the router gave banner messages and wanted some telnet negotiations;
  25.  * the router insisted echoing everything and delayed <nul>s after <cr>s;
  26.  * telnet transmit-binary mode solved that; then the stream mode (no telnet
  27.  * encapsulation) was discovered; suddenly the banners were turned off also;
  28.  * but still the smsc didn't deliver mo messages, because it wanted to
  29.  * connect instead of using our existing connection; then we began to use
  30.  * short connection sessions for transmitting instead of a single ever-
  31.  * lasting connection, and also started to specifically listen for smsc
  32.  * initiated connections, which yielded two separate input buffers; then
  33.  * suddenly the banners were there again, so some intelligence had to be
  34.  * added to adapt their (non-)existence; then revealed the spec version 4.5
  35.  * had been obsolete all the time and we got 5.0; the router apparently
  36.  * caused some extra packets on the x.25 side and everybody was blaming the
  37.  * application; then the connection maintenance and buffering was again
  38.  * revisited to achieve better performance and reliability... Really an
  39.  * interesting story but think if it were about you instead of me :-)
  40.  *
  41.  * Really funny thing is that according to the spec the SMS2000 does have
  42.  * a direct TCP/IP access interface. However, here we have the general X.25
  43.  * access interface, since we started with the old spec and probably the
  44.  * simpler TCP/IP access is not available in our particular customer's
  45.  * installation, not at least when this was written. In the direct access
  46.  * only single ever-lasting connection is necessary, and the messages are
  47.  * the same but their format is different. Encoding tricks are the same.
  48.  * So, if you are implementing that access mode some day, there are probably
  49.  * differences between this access mode and yours on so many levels, that
  50.  * simple if () selections won't work; write your own code from (nearly)
  51.  * scratch and take appropriate encoding conversion functions here. Or do
  52.  * just whatever you want, what should I care :-).
  53.  */
  55. #include <unistd.h>
  56. #include <ctype.h>
  57. #include <errno.h>
  58. #include <string.h>
  59. #include <sys/time.h>
  60. #include <sys/types.h>
  61. #include <sys/timeb.h>
  62. #include <sys/socket.h>
  63. #include <netinet/in.h>
  64. #include <arpa/inet.h>
  66. #include "smsc.h"
  67. #include "smsc_p.h"
  68. #include "gwlib/gwlib.h"
  69. #include "sms.h"
  71. /* XXX Delete me and replace dcs with dcs_to_fields */
  72. enum dcs_body_type {
  73.     DCS_GSM_TEXT = 0,
  74.     DCS_OCTET_DATA = 4    /* flag_8bit */
  75. };
  78. /* 'private:' */
  80. int ois_debug_level = 0; /* some extra verbosity in debug logging */
  81. /* 0=just normal debugging, 1=input/output messages, 2=function entries, */
  82. /* 3=message assembly/disassembly, 4=disconnection tracing, */
  83. /* 5=message conversions, and 8=message polling (=too much) */
  85. #define SAY(d,s) { if (d<=ois_debug_level) debug("bb.sms.ois",0,s); }
  86. #define SAY2(d,s,t) { if (d<=ois_debug_level) debug("bb.sms.ois",0,s,t); }
  87. #define SAY3(d,s,t,u) { if (d<=ois_debug_level) debug("bb.sms.ois",0,s,t,u); }
  88. #define IOTRACE(x,s,l) SAY3(1,"%s [%s]",x,ois_debug_str(s,l))
  91. #define BUFLEN (511) /* sure enough for ois messages */
  92. #define OIS_OPEN_WAITTIME (15) /* seconds, waiting for banners */
  93. #define OIS_MESSAGE_WAITTIME (30) /* seconds, until closing idle connection */
  94. #define OIS_WAITTIME (999999) /* microseconds, waiting for banners at a time */
  95. #define OIS_NOWAIT (0) /* microseconds, not waiting */
  96. #define MAXCOUNTER (10000) /* ois message id */
  97. #define EOL ('r') /* ois definition for the eol */
  99. typedef struct ois_listentry {
  100.     struct ois_listentry *next;
  101.     Msg *msg;
  102. } ois_listentry;
  104. #define OIS_FLAG_DEBUG (0x000f)
  105. #define OIS_FLAG_ERROR (0x0100)
  106. #define OIS_FLAG_NOBANNER (0x0200)
  107. #define OIS_FLAG_MULTIPLE_CALL (0x0400)
  108. #define OIS_FLAG_CLOSED (0x0800)
  110. static int ois_counter = 0; /* [0..MAXCOUNTER), ois "unique" message id */
  111. static int ois_open_listener(SMSCenter *smsc);
  112. static int ois_open_sender(SMSCenter *smsc);
  113. static int ois_open_receiver(SMSCenter *smsc);
  114. static void ois_disconnect_all(SMSCenter *smsc);
  115. static void ois_disconnect(SMSCenter *smsc);
  116. static int ois_read_into_buffer(SMSCenter *smsc, long wait_usec);
  117. static int ois_check_input(SMSCenter *smsc, long wait_usec);
  118. static int ois_check_incoming(SMSCenter *smsc, long wait_usec);
  119. static void ois_append_to_list(ois_listentry **head, Msg *msg);
  120. static int ois_int_to_i4(char *raw, int nbr);
  121. static int ois_increment_counter(void);
  122. static int ois_submit_sm_invoke(SMSCenter *smsc, const Msg *msg);
  123. static int ois_encode_submit_sm_invoke(char *str, const Msg *msg);
  124. static int ois_append_msisdn(char *raw, const Msg *msg);
  125. static int ois_append_sme_reference_number(char *raw);
  126. static int ois_append_priority(char *raw);
  127. static int ois_append_originating_address(char *raw);
  128. static int ois_append_validity_period(char *raw);
  129. static int ois_append_data_coding_scheme(char *raw, const Msg *msg);
  130. static int ois_append_status_report_request(char *raw);
  131. static int ois_append_protocol_id(char *raw);
  132. static int ois_append_submission_options(char *raw, const Msg *msg);
  133. static int ois_append_sm_text(char *raw, const Msg *msg);
  134. static int ois_submit_sm_result(SMSCenter *smsc, const char *buffer);
  135. static int ois_decode_submit_sm_result(int *code, const char *str);
  136. static int ois_deliver_sm_invoke(SMSCenter *smsc, const char *buffer);
  137. static int ois_decode_deliver_sm_invoke(Msg *msg, const char *str);
  138. static int ois_check_deliver_sm_invoke(const char *str);
  139. static int ois_adjust_destination_address(Msg *msg, const char *raw);
  140. static int ois_ignore_smsc_reference_number(const char *raw);
  141. static int ois_adjust_originating_address(Msg *msg, const char *raw);
  142. static int ois_adjust_data_coding_scheme(Msg *msg, const char *raw);
  143. static int ois_ignore_protocol_id(const char *raw);
  144. static int ois_adjust_additional_information(Msg *msg, const char *raw);
  145. static int ois_adjust_sm_text(Msg *msg, const char *raw);
  146. static int ois_ignore_time(const char *raw);
  147. static int ois_deliver_sm_result(SMSCenter *smsc, int result, const char *str);
  148. static int ois_encode_deliver_sm_result(char *str, int result);
  149. static int ois_expand_gsm7(char *raw8, const char *raw7, int len);
  150. static int ois_expand_gsm7_to_bits(char *bits, const char *raw7, int len);
  151. static char ois_expand_gsm7_from_bits(const char *bits, int pos);
  152. static int ois_convert_to_ia5(char *str, const char *raw, int len);
  153. static int ois_convert_from_ia5(char *raw, const char *str);
  154. static int ois_convert_to_iso88591(char *raw, int len);
  155. static int ois_extract_msg_from_buffer(char *str, SMSCenter *smsc);
  156. static int ois_extract_line_from_buffer(char *str, SMSCenter *smsc);
  157. static void ois_swap_buffering(SMSCenter *smsc);
  158. static const char *ois_debug_str(const char *raw, int len);
  160. /* 'public:' */
  162. /*
  163.  * Establish a connection to the SMSC.
  164.  */
  166. SMSCenter *ois_open(int receiveport, const char *hostname, int port, int debug_level)
  167. {
  168.     SMSCenter *smsc;
  169.     int ret;
  171.     ois_debug_level = debug_level & OIS_FLAG_DEBUG;
  172.     SAY(2, "ois_open");
  174.     /* create a SMSCenter structure */
  176.     smsc = smscenter_construct();
  177.     if (smsc == NULL) {
  178. goto error;
  179.     }
  181.     smsc->type = SMSC_TYPE_OIS;
  182.     smsc->receive_port = receiveport;
  183.     smsc->hostname = gw_strdup(hostname);
  184.     smsc->port = port;
  185.     smsc->ois_flags = ois_debug_level;
  187.     ret = ois_open_listener(smsc);
  188.     if (ret < 0) {
  189. goto error;
  190.     }
  191.     sprintf(smsc->name, "OIS:TCP/X.25-Translator:localhost:%d:TCP:%.512s:%d",
  192.     smsc->receive_port, smsc->hostname, smsc->port);
  194.     return smsc;
  196.  error:
  197.     error(0, "ois_open: could not open");
  198.     smscenter_destruct(smsc);
  199.     return NULL;
  200. }
  203. /*
  204.  * Terminate the SMSC connection.
  205.  */
  207. int ois_close(SMSCenter *smsc)
  208. {
  209.     ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
  210.     SAY(2, "ois_close");
  212.     if (smsc->type != SMSC_TYPE_OIS) {
  213. warning(0, "ois_close: closing a not-ois connection...");
  214.     }
  216.     ois_swap_buffering(smsc);
  217.     smscenter_remove_from_buffer(smsc, smsc->buflen);
  218.     ois_swap_buffering(smsc);
  219.     smscenter_remove_from_buffer(smsc, smsc->buflen);
  220.     SAY(4, "ois_close: ois_disconnect_all");
  221.     ois_disconnect_all(smsc);
  223.     return 0;
  224. }
  227. /*
  228.  * Re-establish a SMSC connection.
  229.  */
  231. int ois_reopen(SMSCenter *smsc)
  232. {
  233.     int ret;
  235.     ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
  236.     SAY(2, "ois_reopen");
  238.     ois_close(smsc);
  240.     if (smsc->type == SMSC_TYPE_OIS) {
  241. ret = ois_open_listener(smsc);
  242. if (ret < 0) {
  243.     goto error;
  244. }
  245.     } else {
  246. error(0, "ois_reopen: wrong smsc type");
  247. goto error;
  248.     }
  249.     return 0;
  251.  error:
  252.     error(0, "ois_reopen: could not open");
  253.     return -1;
  254. }
  257. /*
  258.  * Check for MO messages.
  259.  * Put all incoming MO messages into an internal queue.
  260.  */
  262. int ois_pending_smsmessage(SMSCenter *smsc)
  263. {
  264.     int ret;
  266.     ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
  267.     SAY(8, "ois_pending_smsmessage");
  269.     ret = ois_check_incoming(smsc, OIS_NOWAIT);
  270.     if (ret == 0 && smsc->socket != -1) {
  271. ret = ois_check_input(smsc, OIS_NOWAIT);
  272.     }
  273.     if (ret == 0 && smsc->ois_socket != -1) {
  274. ois_swap_buffering(smsc);
  275. ret = ois_check_input(smsc, OIS_NOWAIT);
  276. ois_swap_buffering(smsc);
  277. if (smsc->ois_socket == -1 && smsc->ois_ack_debt != 0) {
  278.     warning(0, "ois_pending_smsmessage: missing %d ack(s)...",
  279.     smsc->ois_ack_debt);
  280. }
  281.     }
  282.     return ret;
  283. }
  286. /*
  287.  * Send a MT message.
  288.  */
  290. int ois_submit_msg(SMSCenter *smsc, const Msg *msg)
  291. {
  292.     int ret;
  294.     ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
  295.     SAY(2, "ois_submit_msg");
  296.     ois_swap_buffering(smsc);
  298.     if (msg_type((Msg *)msg) != sms) {
  299. error(0, "ois_submit_msg: can not handle message types other than smart_msg");
  300. goto error;
  301.     }
  303.     if (smsc->socket == -1) {
  304. ret = ois_open_sender(smsc);
  305. if (ret < 0) {
  306.     goto error;
  307. }
  308.     }
  310.     ret = ois_submit_sm_invoke(smsc, msg);
  311.     if (ret < 0) {
  312. goto error_close;
  313.     }
  315.     ++smsc->ois_ack_debt;
  316.     time(&smsc->ois_alive);
  317.     ret = 0;
  318.     goto out;
  320.  error_close:
  321.     if (smsc->ois_ack_debt != 0) {
  322. warning(0, "ois_submit_msg: missing %d ack(s)...",
  323. smsc->ois_ack_debt);
  324.     }
  325.     SAY(4, "ois_submit_msg: ois_disconnect in error_close");
  326.     ois_disconnect(smsc);
  327.  error:
  328.     SAY(2, "ois_submit_msg error");
  329.     ret = -1;
  330.  out:
  331.     ois_swap_buffering(smsc);
  332.     return ret;
  333. }
  336. /*
  337.  * Receive a MO message (from the internal queue).
  338.  */
  340. int ois_receive_msg(SMSCenter *smsc, Msg **msg)
  341. {
  342.     ois_listentry *item;
  344.     ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
  345.     SAY(2, "ois_receive_msg");
  347.     item = smsc->ois_received_mo;
  348.     if (item == NULL) { /* no mo messages */
  349. if ((smsc->ois_flags & OIS_FLAG_ERROR) == 0) {
  350.     return 0;   /* should actually not happen */
  351. } else {
  352.     return -1;  /* error pending, reopen? */
  353. }
  354.     } else {            /* we have a message waiting */
  355. smsc->ois_received_mo = item->next;
  356. *msg = item->msg;
  357. gw_free(item);
  358. return 1;       /* got the message */
  359.     }
  360. }
  363. /*
  364.  * Destruct the internal queue.
  365.  */
  367. void ois_delete_queue(SMSCenter *smsc)
  368. {
  369.     Msg *msg;
  371.     ois_debug_level = smsc->ois_flags & OIS_FLAG_DEBUG;
  372.     SAY(2, "ois_delete_queue");
  374.     while (ois_receive_msg(smsc, &msg) > 0) {
  375. gw_free(msg);
  376.     }
  377.     return;
  378. }
  387. /*
  388.  * Implementation of 'private:'
  389.  */
  392. static int ois_open_listener(SMSCenter *smsc)
  393. {
  394.     SAY(2, "ois_open_listener");
  396.     smsc->ois_listening_socket = make_server_socket(smsc->receive_port, 
  397.     NULL);
  398. /* XXX add interface_name if required */
  399.     if (smsc->ois_listening_socket < 0) {
  400. goto error;
  401.     }
  402.     if (socket_set_blocking(smsc->ois_listening_socket, 0) < 0) {
  403. ois_close(smsc);
  404. goto error;
  405.     }
  406.     smsc->ois_flags &= ~OIS_FLAG_ERROR;
  407.     smsc->ois_flags &= ~OIS_FLAG_NOBANNER;
  408.     smsc->ois_alive2 = time(&smsc->ois_alive);
  410.     SAY2(2, "ois_open_listener fd=%d", smsc->ois_listening_socket);
  411.     return 0;
  413.  error:
  414.     error(0, "ois_open_listener: failed to open listening socket");
  415.     return -1;
  416. }
  419. static int ois_open_sender(SMSCenter *smsc)
  420. {
  421.     int ret;
  422.     char buffer[BUFLEN+1];
  423.     time_t now;
  424.     time_t beginning;
  425.     
  426.     SAY(2, "ois_open_sender");
  427.     debug("bb.sms.ois", 0, "connecting to host %s port %d",
  428.   smsc->hostname, smsc->port);
  430.     time(&beginning);
  431.     smsc->socket = tcpip_connect_to_server(smsc->hostname, smsc->port,
  432.     NULL);
  433. /* XXX add interface_name if required */
  434.     if (smsc->socket < 0) {
  435. return -1;
  436.     } else {
  437. smsc->buflen = 0;
  438. time(&smsc->ois_alive);
  439. smsc->ois_ack_debt = 0;
  440.     }
  442.     SAY2(2, "ois_open_sender fd=%d", smsc->socket);
  443.     if (smsc->ois_flags & OIS_FLAG_NOBANNER) {
  444. return 0;
  445.     }
  447.     buffer[0] = '';
  448.     for (time(&now); (now - beginning) < OIS_OPEN_WAITTIME; time(&now)) {
  449. ret = ois_read_into_buffer(smsc, OIS_WAITTIME);
  450. if (ret < 0) {
  451.     goto error;
  452. }
  454. if (smsc->buflen == 0) {
  455.     /* assume that the router is in the quiet mode */
  456.     /* there will be no banners */
  457.     smsc->ois_flags |= OIS_FLAG_NOBANNER;
  458.     debug("bb.sms.ois", 0, "assuming that %s:%d is in the quiet mode",
  459.   smsc->hostname, smsc->port);
  460.     return 0;
  461. }
  462. ret = ois_extract_line_from_buffer(buffer, smsc);
  463. if (ret > 0) {
  464.     if (strncmp(buffer, "Trying", 6) == 0 &&
  465. strstr(buffer, "...Openrn") != NULL) {
  466. time(&smsc->ois_alive);
  467. return 0;
  468.     } else {
  469. break;
  470.     }
  471. }
  472.     }
  474.  error:
  475.     SAY(4, "ois_open_sender: ois_disconnect in error");
  476.     ois_disconnect(smsc);
  477.     error(0, "ois_open_sender: failed to connect [%s%s]",
  478.   buffer, ois_debug_str(smsc->buffer, smsc->buflen));
  479.     return -1;
  480. }
  483. static int ois_open_receiver(SMSCenter *smsc)
  484. {
  485.     struct sockaddr_in addr;
  486.     int addrlen;
  487.     Octstr *os;
  489.     SAY(2, "ois_open_receiver");
  491.     /* the listening socket should be non-blocking... */
  493.     addrlen = sizeof(addr);
  494.     smsc->socket = accept(smsc->ois_listening_socket,
  495.   (struct sockaddr *)&addr, &addrlen);
  496.     if (smsc->socket == -1) {
  497. if (errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)
  498.     /* || errno == ECONNABORTED || errno == EPROTO) -Kalle 6.7 */
  499. {
  500.     return 0;
  501. } else {
  502.     error(errno, "ois_open_receiver: accept failed");
  503.     smsc->ois_flags |= OIS_FLAG_ERROR;
  504.     return -1;
  505. }
  506.     }
  508.     SAY2(2, "ois_open_receiver fd=%d", smsc->socket);
  509.     os = gw_netaddr_to_octstr(AF_INET, &addr.sin_addr);
  510.     debug("bb.sms.ois", 0, "connection from host %s port %hu",
  511.   octstr_get_cstr(os), ntohs(addr.sin_port));
  512.     octstr_destroy(os);
  513.     time(&smsc->ois_alive);
  514.     return 0;
  515. }
  518. static void ois_disconnect_all(SMSCenter *smsc)
  519. {
  520.     SAY2(2, "ois_disconnect_all fd=%d", smsc->ois_listening_socket);
  522.     ois_swap_buffering(smsc);
  523.     SAY(4, "ois_disconnect_all: ois_disconnect");
  524.     ois_disconnect(smsc); /* smsc->socket */
  525.     ois_swap_buffering(smsc);
  526.     SAY(4, "ois_disconnect_all: ois_disconnect");
  527.     ois_disconnect(smsc); /* smsc->socket */
  529.     if (smsc->ois_listening_socket != -1) {
  530. if (close(smsc->ois_listening_socket) == -1) {
  531.     warning(errno, "ois_disconnect_all: close failed...");
  532. }
  533. smsc->ois_listening_socket = -1;
  534.     }
  535.     return;
  536. }
  539. static void ois_disconnect(SMSCenter *smsc)
  540. {
  541.     SAY2(2, "ois_disconnect fd=%d", smsc->socket);
  543.     if (smsc->socket != -1) {
  544. if (close(smsc->socket) == -1) {
  545.     warning(errno, "ois_disconnect: close failed...");
  546. }
  547. smsc->socket = -1;
  548.     }
  549.     return;
  550. }
  553. static int ois_read_into_buffer(SMSCenter *smsc, long wait_usec)
  554. {
  555.     int ret;
  557.     SAY(8, "ois_read_into_buffer");
  559.     if (smsc->socket == -1) {
  560. if ((smsc->ois_flags & OIS_FLAG_CLOSED) == 0) {
  561.     debug("bb.sms.ois", 0, "attempting to read from a closed socket");
  562.     smsc->ois_flags |= OIS_FLAG_CLOSED;
  563. }
  564. return 0;
  565.     } else {
  566. smsc->ois_flags &= ~OIS_FLAG_CLOSED;
  567.     }
  569.     ret = read_available(smsc->socket, wait_usec);
  570.     if (ret > 0) {
  571. time(&smsc->ois_alive);
  572. ret = smscenter_read_into_buffer(smsc);
  573. if (ret > 0 || (ret == 0 && smsc->buflen > 0)) {
  574.     SAY(2, "ois_read_into_buffer got something");
  575. } else if (ret == 0) {
  576.     if (smsc->buflen > 0) {
  577. SAY(2, "ois_read_into_buffer has something");
  578. ret = 1;
  579.     }
  580.     SAY(4, "ois_read_into_buffer: ois_disconnect");
  581.     ois_disconnect(smsc);
  582. }
  583.     }
  584.     return ret;
  585. }
  588. static int ois_check_input(SMSCenter *smsc, long wait_usec)
  589. {
  590.     char buffer[BUFLEN+1];
  591.     time_t now;
  592.     int ret;
  594.     SAY(8, "ois_check_input");
  596.     ret = ois_read_into_buffer(smsc, wait_usec);
  597.     if (ret < 0) {
  598. goto error;
  599.     }
  601.     ret = ois_extract_msg_from_buffer(buffer, smsc);
  602.     if (ret > 0) {
  603. IOTRACE("received", buffer, ret);
  604. switch (buffer[0]) {
  605. case 's':
  606.     ret = ois_submit_sm_result(smsc, buffer);
  607.     if (ret > 0) {
  608. warning(0, "ois_check_input: submit sm result signals (%d)...", ret);
  609.     } else if (ret < 0) {
  610. error(0, "ois_check_input: invalid submit sm result");
  611. goto error;
  612.     }
  613.     --smsc->ois_ack_debt;
  614.     time(&smsc->ois_alive);
  615.     break;
  616. case 'M':
  617.     ret = ois_deliver_sm_invoke(smsc, buffer);
  618.     if (ret >= 0) {
  619. ret = ois_deliver_sm_result(smsc, ret, buffer);
  620. if (ret < 0) {
  621.     goto error;
  622. }
  623.     } else {
  624. error(0, "ois_check_input: invalid deliver sm invoke");
  625. goto error;
  626.     }
  627.     time(&smsc->ois_alive);
  628.     break;
  629. default:
  630.     warning(0, "ois_check_input: unexpected message [%s]...",
  631.     ois_debug_str(buffer, ret));
  632.     break;
  633. }
  634.     } else {
  635. if (smsc->socket != -1) {
  636.     time(&now);
  637.     if ((now - smsc->ois_alive) > OIS_MESSAGE_WAITTIME) {
  638. debug("bb.sms.ois", 0, "closing an idle connection");
  639. SAY(4, "ois_check_input: ois_disconnect");
  640. ois_disconnect(smsc);
  641.     }
  642. }
  643.     }
  645.     if (ret < 0) {
  646. error(0, "ois_check_input: malformatted message [%s]",
  647.       ois_debug_str(buffer, -ret));
  648. goto error;
  649.     }
  651.     if (smsc->ois_received_mo != NULL ||
  652. (smsc->ois_flags & OIS_FLAG_ERROR) != 0) {
  653. SAY(2, "ois_check_input has something");
  654. return 1; /* at least one message in the queue or an error pending */
  655.     } else {
  656. return 0; /* no messages this time */
  657.     }
  659.  error:
  660.     smsc->ois_flags |= OIS_FLAG_ERROR;
  661.     return 1;
  662. }
  665. static int ois_check_incoming(SMSCenter *smsc, long wait_usec)
  666. {
  667.     fd_set read_fd;
  668.     struct timeval tv;
  669.     int ret;
  671.     SAY(8, "ois_check_incoming");
  673.     tv.tv_sec = 0;
  674.     tv.tv_usec = wait_usec;
  676.     FD_ZERO(&read_fd);
  677.     FD_SET(smsc->ois_listening_socket, &read_fd);
  678.     ret = select(smsc->ois_listening_socket + 1, &read_fd, NULL, NULL, &tv);
  679.     if (ret == -1) {
  680. if (errno == EINTR || errno == EAGAIN) {
  681.     return 0;
  682. } else {
  683.     error(errno, "ois_check_incoming: select failed");
  684.     smsc->ois_flags |= OIS_FLAG_ERROR;
  685.     return -1;
  686. }
  687.     } else if (ret == 0) {
  688. return 0;
  689.     }
  691.     /* if we end up here, someone is trying to connect */
  693.     if (smsc->socket != -1) {
  694. if ((smsc->ois_flags & OIS_FLAG_MULTIPLE_CALL) == 0) {
  695.     /* if you see lots of these, maybe we should accept */
  696.     /* multiple incoming connections at a time... */
  697.     debug("bb.sms.ois", 0, "letting an incoming call to wait until the old one disconnects");
  698.     smsc->ois_flags |= OIS_FLAG_MULTIPLE_CALL;
  699. }
  700. return 0;
  701.     }
  703.     smsc->ois_flags &= ~OIS_FLAG_MULTIPLE_CALL;
  704.     return ois_open_receiver(smsc);
  705. }
  708. static void ois_append_to_list(ois_listentry **head, Msg *msg)
  709. {
  710.     ois_listentry *item;
  711.     ois_listentry *tail;
  713.     SAY(2, "ois_append_to_list");
  715.     item = gw_malloc(sizeof(ois_listentry));
  716.     item->next = NULL;
  717.     item->msg = msg;
  719.     if (*head == NULL) {
  720. *head = item;
  721.     } else { /* not so bright algorithm, but ok with relatively short lists */
  722. for (tail = *head; tail->next != NULL; tail = tail->next) ;
  723. tail->next = item;
  724.     }
  725.     return;
  726. }
  730. static int ois_int_to_i4(char *raw, int nbr)
  731. {
  732.     int pos;
  734.     SAY(3, "ois_int_to_i4");
  736.     for (pos = 0; pos < 4; ++pos) {
  737. raw[pos] = (char)(nbr % 0x100);
  738. nbr /= 0x100;
  739.     }
  740.     return 4;
  741. }
  743. static int ois_increment_counter(void)
  744. {
  745.     SAY(3, "ois_increment_counter");
  747.     ois_counter = (ois_counter+1) % MAXCOUNTER;
  748.     return ois_counter;
  749. }
  752. static int ois_submit_sm_invoke(SMSCenter *smsc, const Msg *msg)
  753. {
  754.     char body[BUFLEN+1];
  755.     char buffer[BUFLEN+1];
  756.     int len;
  757.     int count;
  758.     int i;
  759.     int ret;
  761.     SAY(2, "ois_submit_sm_invoke");
  763.     /* construct a message */
  765.     ois_increment_counter();                  /* once per invoke */
  766.     len = ois_encode_submit_sm_invoke(body, msg);
  768.     /* the x.25 gear should be capable to fragment large messages, but... */
  769.     /* let's just use an explicit 128 byte blocks */
  771.     count = (len-1) / 121;                    /* 121 = 128 - 6 - 1 */
  773.     /* first part */
  775.     sprintf(buffer, "%c%c%04d%.121s%c",
  776.     'S',                              /* submit sm invoke */
  777.     (char)(0x50|count),               /* ia5 encoding, first part */
  778.     ois_counter,
  779.     &body[0],
  780.     EOL);
  781.     IOTRACE("sending", buffer, strlen(buffer));
  782.     ret = write_to_socket(smsc->socket, buffer);
  783.     if (ret < 0) {
  784. goto error;
  785.     }
  787.     /* additional parts */
  789.     for (i = 1; i <= count; ++i) {
  790. sprintf(buffer, "%c%c%04d%.121s%c",
  791. 'S',                          /* submit sm invoke */
  792. (char)(0x60|(count-i)),       /* ia5, additional part */
  793. ois_counter,
  794. &body[i*121],
  795. EOL);
  796. IOTRACE("sending", buffer, strlen(buffer));
  797. ret = write_to_socket(smsc->socket, buffer);
  798. if (ret < 0) {
  799.     goto error;
  800. }
  801.     }
  803.     SAY(2, "ois_submit_sm_invoke ok");
  804.     return 0;
  806.  error:
  807.     SAY(2, "ois_submit_sm_invoke error");
  808.     return -1;
  809. }
  812. static int ois_encode_submit_sm_invoke(char *str, const Msg *msg)
  813. {
  814.     char raw[BUFLEN];
  815.     int pos;
  816.     int ret;
  818.     SAY(3, "ois_encode_submit_sm_invoke");
  820.     /* construct the submit sm invoke body content */
  822.     pos = 0;
  823.     pos += ois_append_msisdn(&raw[pos], msg);
  824.     pos += ois_append_sme_reference_number(&raw[pos]);
  825.     pos += ois_append_priority(&raw[pos]);
  826.     pos += ois_append_originating_address(&raw[pos]);
  827.     pos += ois_append_validity_period(&raw[pos]);
  828.     pos += ois_append_data_coding_scheme(&raw[pos], msg);
  829.     pos += ois_append_status_report_request(&raw[pos]);
  830.     pos += ois_append_protocol_id(&raw[pos]);
  831.     pos += ois_append_submission_options(&raw[pos], msg);
  832.     pos += ois_append_sm_text(&raw[pos], msg);
  834.     ret = ois_convert_to_ia5(str, raw, pos);
  835.     return ret;
  836. }
  838. static int ois_append_msisdn(char *raw, const Msg *msg)
  839. {
  840.     int len;
  842.     SAY(3, "ois_append_msisdn");
  844.     len = octstr_len(msg->sms.receiver);
  845.     raw[0] = (char) len;
  846.     memcpy(&raw[1], octstr_get_cstr(msg->sms.receiver), len);
  847.     return 1 + len;
  848. }
  850. static int ois_append_sme_reference_number(char *raw)
  851. {
  852.     SAY(3, "ois_append_sme_reference_number");
  854.     /* 1=key, 2=not key (OIS 4.5) */
  855.     /* or 1=reject duplicates, 2=allow duplicates (OIS 5.0) */
  856.     raw[0] = (char) 2;
  857.     return 1 + ois_int_to_i4(&raw[1], ois_counter);
  858. }
  860. static int ois_append_priority(char *raw)
  861. {
  862.     SAY(3, "ois_append_priority");
  864.     raw[0] = (char) 1; /* 0=high, 1=normal */
  865.     return 1;
  866. }
  868. static int ois_append_originating_address(char *raw)
  869. {
  870.     SAY(3, "ois_append_originating_address");
  872.     raw[0] = (char) 2; /* length */
  873.     raw[1] = 'A'; /* A3=address type, actual address is unnecessary */
  874.     raw[2] = '3';
  876.     return 3;
  877. }
  879. static int ois_append_validity_period(char *raw)
  880. {
  881.     SAY(3, "ois_append_validity_period");
  883.     raw[0] = (char) 2; /* 0=none, 1=absolute, 2=relative */
  884.     raw[1] = (char) 1; /* relative, (v+1)*5 minutes, v<144 */
  885.     return 2;
  886. }
  888. static int ois_append_data_coding_scheme(char *raw, const Msg *msg)
  889. {
  890.     SAY(3, "ois_append_data_coding_scheme");
  892.     /* 0x0f is a special code for ASCII text, the SMSC will convert
  893.      * this to GSM and set the DCS to 0.
  894.      * FIXME: Convert to GSM ourselves and use DCS_GSM_TEXT.
  895.      * FIXME: use fields_to_dcs and try to support DC_UCS2 too ;) */
  896.     raw[0] = (char) (msg->sms.coding == DC_8BIT ? DCS_OCTET_DATA : 0x0f);
  897.     return 1;
  898. }
  900. static int ois_append_status_report_request(char *raw)
  901. {
  902.     SAY(3, "ois_append_status_report_request");
  904.     raw[0] = (char) 0x00; /* bit field, bit 0=abandoned, bit 2=delivered */
  905.     return 1;
  906. }
  908. static int ois_append_protocol_id(char *raw)
  909. {
  910.     SAY(3, "ois_append_protocol_id");
  912.     raw[0] = (char) 0; /* 0=default */
  913.     return 1;
  914. }
  916. static int ois_append_submission_options(char *raw, const Msg *msg)
  917. {
  918.     SAY(3, "ois_append_submission_options");
  920.     /* bit field, bit 0=reply path, bit 1=udh, bits 3-4=dcs interpretation */
  921.     raw[0] = (char) 0x00;
  922.     if (octstr_len(msg->sms.udhdata)) {
  923. raw[0] |= (char) 0x02;
  924.     }
  925.     if (msg->sms.coding == DC_8BIT) { /* XXX UCS2? */
  926. raw[0] |= (char) 0x10;
  927.     }
  928.     return 1;
  929. }
  932. static int ois_append_sm_text(char *raw, const Msg *msg)
  933. {
  934.     int udhlen7, udhlen8;
  935.     int msglen7, msglen8;
  936.     int len;
  938.     SAY(3, "ois_append_sm_text");
  940.     if (msg->sms.coding == DC_7BIT) {
  941.         charset_latin1_to_gsm(msg->sms.udhdata);
  942.         charset_latin1_to_gsm(msg->sms.msgdata);
  943.     }
  946.     /* calculate lengths */
  948.     udhlen8 = octstr_len(msg->sms.udhdata);
  949.     msglen8 = octstr_len(msg->sms.msgdata);
  951.     udhlen7 = udhlen8;
  952.     msglen7 = msglen8;
  953.     len = udhlen8 + msglen8;
  955.     /* copy text */
  957.     raw[0] = (char) (len);
  958.     raw[1] = (char) (udhlen7 + msglen7);
  959.     memcpy(&raw[2], octstr_get_cstr(msg->sms.udhdata), udhlen8);
  960.     memcpy(&raw[2+udhlen8], octstr_get_cstr(msg->sms.msgdata), msglen8);
  962.     IOTRACE("encoding", &raw[2], len);
  964.     return 2 + len;
  965. }
  968. static int ois_submit_sm_result(SMSCenter *smsc, const char *buffer)
  969. {
  970.     int status;
  971.     int ret;
  973.     SAY(2, "ois_submit_sm_result");
  975.     ret = ois_decode_submit_sm_result(&status, buffer);
  976.     if (ret < 0) {
  977. goto error;
  978.     }
  980.     return status;
  982.  error:
  983.     return -1;
  984. }
  987. static int ois_decode_submit_sm_result(int *code, const char *str)
  988. {
  989.     int buflen;
  990.     char raw[BUFLEN];
  991.     int len;
  993.     SAY(3, "ois_decode_submit_sm_result");
  995.     buflen = strlen(str) - 1;
  996.     if (buflen < 7 || str[0] != 's' || str[1] != 0x50 || str[buflen] != EOL) {
  997. goto error;
  998.     }
  1000.     len = ois_convert_from_ia5(raw, &str[6]);
  1001.     if (len <= 0) {
  1002. goto error;
  1003.     }
  1005.     *code = raw[0];
  1006.     *code &= 0xff;
  1008.     /* there is smsc reference number and accept time, but we ignore them */
  1010.     return 0;
  1012.  error:
  1013.     return -1;
  1014. }
  1017. static int ois_deliver_sm_invoke(SMSCenter *smsc, const char *buffer)
  1018. {
  1019.     Msg *msg;
  1020.     int ret;
  1022.     SAY(2, "ois_deliver_sm_invoke");
  1024.     msg = msg_create(sms);
  1026.     ret = ois_decode_deliver_sm_invoke(msg, buffer);
  1027.     if (ret < 0) {
  1028. goto error;
  1029.     }
  1031.     ois_append_to_list((ois_listentry **) &smsc->ois_received_mo, msg);
  1033.     return 0;
  1034.     
  1035.  error:
  1036.     msg_destroy(msg);
  1037.     return -1;
  1038. }
  1041. static int ois_decode_deliver_sm_invoke(Msg *msg, const char *str)
  1042. {
  1043.     char body[BUFLEN+1];
  1044.     char raw[BUFLEN];
  1045.     int len;
  1046.     int i;
  1047.     int pos;
  1048.     int ret;
  1050.     SAY(3, "ois_decode_deliver_sm_invoke");
  1052.     ret = ois_check_deliver_sm_invoke(str);
  1053.     if (ret < 0) {
  1054. goto error;
  1055.     }
  1057.     /* extract body */
  1059.     len = strlen(str);
  1060.     for (pos = 0, i = 6; i < len; ++i) {
  1061. if (str[i] != EOL) {
  1062.     body[pos++] = str[i];
  1063. } else {
  1064.     i += 6;
  1065. }
  1066.     }
  1067.     body[pos] = '';
  1068.     memset(raw, '', sizeof(raw));
  1069.     len = ois_convert_from_ia5(raw, body);
  1071.     /* adjust msg values */
  1073.     pos = 0;
  1074.     pos += ois_adjust_destination_address(msg, &raw[pos]);
  1075.     pos += ois_ignore_smsc_reference_number(&raw[pos]);
  1076.     pos += ois_adjust_originating_address(msg, &raw[pos]);
  1077.     pos += ois_adjust_data_coding_scheme(msg, &raw[pos]);
  1078.     pos += ois_ignore_protocol_id(&raw[pos]);
  1079.     pos += ois_adjust_additional_information(msg, &raw[pos]);
  1080.     pos += ois_adjust_sm_text(msg, &raw[pos]);
  1081.     pos += ois_ignore_time(&raw[pos]); /* accept time */
  1082.     pos += ois_ignore_time(&raw[pos]); /* invoke time */
  1083.     if (pos != len) {
  1084. error(0, "ois_decode_deliver_sm_invoke: message parsing error (%d!=%d)",
  1085.       pos, len);
  1086. goto error;
  1087.     }
  1088.     return 0;
  1090.  error:
  1091.     return -1;
  1092. }
  1095. static int ois_check_deliver_sm_invoke(const char *str)
  1096. {
  1097.     int buflen;
  1098.     char buffer[BUFLEN+1];
  1099.     int count;
  1101.     SAY(3, "ois_check_deliver_sm_invoke");
  1103.     /* check the (initial) header and trailer */
  1105.     buflen = strlen(str) - 1;
  1106.     if (buflen < 7 || str[0] != 'M' || (str[1] & 0x50) != 0x50
  1107. || str[buflen] != EOL) {
  1108. goto error;
  1109.     }
  1111.     count = str[1] & 0x0f;
  1112.     while (--count >= 0)
  1113.     {
  1114. /* check the additional header */
  1116. sprintf(buffer, "%c%c%c%.4s",
  1117. EOL,
  1118. 'M',                      /* deliver sm invoke */
  1119. (char)(0x60|count),       /* ia5 encoding, additional part */
  1120. &str[2]);
  1121. if (strstr(str, buffer) == NULL) {
  1122.     goto error;
  1123. }
  1124.     }
  1126.     return 0;
  1127.     
  1128.  error:
  1129.     return -1;
  1130. }
  1133. static int ois_adjust_destination_address(Msg *msg, const char *raw)
  1134. {
  1135.     int len;
  1137.     SAY(3, "ois_adjust_destination_address");
  1139.     len = raw[0] & 0xff;
  1140.     msg->sms.receiver = octstr_create_from_data(&raw[1+2], len-2);
  1142.     return 1 + len;
  1143. }
  1145. static int ois_ignore_smsc_reference_number(const char *raw)
  1146. {
  1147.     int value;
  1149.     SAY(3, "ois_ignore_smsc_reference_number");
  1151.     value = raw[3] & 0xff;
  1152.     value <<= 8;
  1153.     value |= raw[2] & 0xff;
  1154.     value <<= 8;
  1155.     value |= raw[1] & 0xff;
  1156.     value <<= 8;
  1157.     value |= raw[0] & 0xff;
  1159.     return 4;
  1160. }
  1162. static int ois_adjust_originating_address(Msg *msg, const char *raw)
  1163. {
  1164.     int len;
  1166.     SAY(3, "ois_adjust_originating_address");
  1168.     len = raw[0] & 0xff;
  1169.     msg->sms.sender = octstr_create_from_data(&raw[1+2], len-2);
  1171.     return 1 + len;
  1172. }
  1174. static int ois_adjust_data_coding_scheme(Msg *msg, const char *raw)
  1175. {
  1176.     SAY(3, "ois_adjust_data_coding_scheme");
  1178.     /* we set the value only temporarily: */
  1179.     /* ois_adjust_sm_text will set the correct value */
  1181.     msg->sms.coding = (raw[0] & 0xff) + 1;
  1183.     return 1;
  1184. }
  1186. static int ois_ignore_protocol_id(const char *raw)
  1187. {
  1188.     int value;
  1190.     SAY(3, "ois_ignore_protocol_id");
  1192.     value = raw[0] & 0xff;
  1194.     return 1;
  1195. }
  1197. static int ois_adjust_additional_information(Msg *msg, const char *raw)
  1198. {
  1199.     SAY(3, "ois_adjust_additional_information");
  1201.     /* we set the value only temporarily: */
  1202.     /* ois_adjust_sm_text will set the correct value */
  1204.     /* XXX I used mc temporarily. use fields_to_dcs! */
  1205.     msg->sms.mclass = raw[0] & 0xff;
  1207.     return 1;
  1208. }
  1210. static int ois_adjust_sm_text(Msg *msg, const char *raw)
  1211. {
  1212.     int msglen7, msglen8;
  1213.     char buffer[BUFLEN+1];
  1215.     SAY(3, "ois_adjust_sm_text");
  1217.     /* calculate lengths */
  1219.     msglen7 = raw[0] & 0xff;
  1220.     msglen8 = raw[1] & 0xff;
  1222.     /* copy text, note: flag contains temporarily the raw type description */
  1224.     switch ((msg->sms.coding - 1) & 0xff) {
  1225.     case 0x00: /* gsm7 */
  1226. ois_expand_gsm7(buffer, &raw[2], msglen7);
  1227. ois_convert_to_iso88591(buffer, msglen7);
  1228. if (msg->sms.mclass & 0x02) { /* XXX mclass temporarily */
  1229.     msg->sms.msgdata = octstr_create("");
  1230.     msg->sms.udhdata = octstr_create_from_data(buffer, msglen7);
  1231. } else {
  1232.     msg->sms.msgdata = octstr_create_from_data(buffer, msglen7);
  1233.     msg->sms.udhdata = octstr_create("");
  1234. }
  1235. msg->sms.coding = DC_7BIT;
  1236. break;
  1237.     case 0x0f: /* ia5 */
  1238. memcpy(buffer, &raw[2], msglen8);
  1239. ois_convert_to_iso88591(buffer, msglen8);
  1240. if (msg->sms.mclass & 0x02) { /* XXX mclass temporarily */
  1241.     msg->sms.msgdata = octstr_create("");
  1242.     msg->sms.udhdata = octstr_create_from_data(buffer, msglen8);
  1243. } else {
  1244.     msg->sms.msgdata = octstr_create_from_data(buffer, msglen8);
  1245.     msg->sms.udhdata = octstr_create("");
  1246. }
  1247. msg->sms.coding = DC_7BIT;
  1248. break;
  1249.     default: /* 0xf4, 0xf5, 0xf6, 0xf7; 8bit to disp, mem, sim or term */ 
  1250. if (msg->sms.mclass & 0x02) { /* XXX mclass temporarily */
  1251.     msg->sms.msgdata = octstr_create("");
  1252.     msg->sms.udhdata = octstr_create_from_data(&raw[2], msglen8);
  1253. } else {
  1254.     msg->sms.msgdata = octstr_create_from_data(&raw[2], msglen8);
  1255.     msg->sms.udhdata = octstr_create("");
  1256. }
  1257. msg->sms.coding = DC_8BIT;
  1258. break;
  1259.     }
  1260.     msg->sms.mclass = MC_UNDEF;
  1262.     if (octstr_len(msg->sms.udhdata)) {
  1263. IOTRACE("decoded udh", octstr_get_cstr(msg->sms.udhdata),
  1264. octstr_len(msg->sms.udhdata));
  1265.     } else {
  1266. IOTRACE("decoded", octstr_get_cstr(msg->sms.msgdata),
  1267. octstr_len(msg->sms.msgdata));
  1268.     }
  1270.     return 2 + msglen8;
  1271. }
  1274. static int ois_ignore_time(const char *raw)
  1275. {
  1276.     char str[15];
  1278.     SAY(3, "ois_ignore_time");
  1280.     strncpy(str, raw, 14); str[14] = '';
  1282.     return 14;
  1283. }
  1287. static int ois_deliver_sm_result(SMSCenter *smsc, int result, const char *str)
  1288. {
  1289.     char body[BUFLEN+1];
  1290.     char buffer[BUFLEN+1];
  1291.     int len;
  1292.     int ret;
  1294.     SAY(2, "ois_deliver_sm_result");
  1296.     /* construct a message */
  1298.     len = ois_encode_deliver_sm_result(body, result);
  1300.     /* first and only part */
  1302.     sprintf(buffer, "%c%c%.4s%.121s%c",
  1303.     'm',                              /* deliver sm result */
  1304.     (char)(0x50),                     /* ia5 encoding, the only part */
  1305.     &str[2],
  1306.     &body[0],
  1307.     EOL);
  1309.     IOTRACE("sending", buffer, strlen(buffer));
  1310.     ret = write_to_socket(smsc->socket, buffer);
  1311.     if (ret < 0) {
  1312. goto error;
  1313.     }
  1315.     return 0;
  1317.  error:
  1318.     return -1;
  1319. }
  1322. static int ois_encode_deliver_sm_result(char *str, int result)
  1323. {
  1324.     char raw[4];
  1326.     SAY(3, "ois_encode_deliver_sm_result");
  1328.     /* construct the deliver sm result body content */
  1330.     raw[0] = (char) result;
  1332.     return ois_convert_to_ia5(str, raw, 1);
  1333. }
  1336. static int ois_expand_gsm7(char *raw8, const char *raw7, int len)
  1337. {
  1338.     int i;
  1339.     char bits[8*(BUFLEN+1)];
  1341.     SAY2(3, "ois_expand_gsm7 len=%d", len);
  1343.     /* yeah, there are also better algorithms, but... */
  1344.     /* well, at least this is fairly portable and ok for small messages... */
  1346.     ois_expand_gsm7_to_bits(bits, raw7, len);
  1347.     for (i = 0; i < len; ++i) {
  1348. raw8[i] = ois_expand_gsm7_from_bits(bits, i);
  1349.     }
  1351.     SAY2(5, "ois_expand_gsm7 gave [%s]", ois_debug_str(raw8, i));
  1352.     return i;
  1353. }
  1355. static int ois_expand_gsm7_to_bits(char *bits, const char *raw7, int len)
  1356. {
  1357.     int i, j, k;
  1358.     char ch;
  1360.     SAY(3, "ois_expand_gsm7_to_bits");
  1362.     len *= 7; /* number of bits in the gms 7-bit msg */
  1364.     for (j = i = 0; j < len; ++i) {
  1365. ch = raw7[i];
  1366. for (k = 0; k < 8; ++k) {
  1367.     bits[j++] = (char) (ch & 0x01);
  1368.     ch >>= 1;
  1369. }
  1370.     }
  1372.     return j;
  1373. }
  1375. static char ois_expand_gsm7_from_bits(const char *bits, int pos)
  1376. {
  1377.     int i;
  1378.     char ch;
  1380.     SAY2(8, "ois_expand_gsm7_from_bits pos=%d", pos);
  1382.     pos *= 7; /* septet position in bits */
  1383.     ch = '';
  1384.     for (i = 6; i >= 0; --i) {
  1385. ch <<= 1;
  1386. ch |= bits[pos+i];
  1387.     }
  1389.     return ch;
  1390. }
  1393. static int ois_convert_to_ia5(char *str, const char *raw, int len)
  1394. {
  1395.     int j;
  1396.     int i;
  1397.     int ch;
  1399.     SAY2(3, "ois_convert_to_ia5 len=%d", len);
  1401.     for (j = i = 0; i < len; ++i) {
  1402. ch = raw[i] & 0xff;
  1403. if (ch == 0x5c || ch == 0x5e || ch == 0x60 || ch == 0x7e) {
  1404.        str[j++] = (char) 0x5c;
  1405.        str[j++] = (char) ch;
  1406. } else if (0x20 <= ch && ch < 0x7f) {
  1407.     str[j++] = (char) ch;
  1408. } else if (0x00 <= ch && ch < 0x20) {
  1409.     str[j++] = (char) 0x5e;
  1410.     str[j++] = (char) ch + 0x40;
  1411. } else if (0xa0 <= ch && ch < 0xff) {
  1412.     str[j++] = (char) 0x60;
  1413.     str[j++] = (char) ch - 0x80;
  1414. } else if (0x80 <= ch && ch < 0xa0) {
  1415.     str[j++] = (char) 0x7e;
  1416.     str[j++] = (char) ch - 0x40;
  1417. } else if (ch == 0x7f) {
  1418.     str[j++] = (char) 0x5e;
  1419.     str[j++] = (char) 0x7e;
  1420. } else { /* ch == 0xff */
  1421.     str[j++] = (char) 0x7e;
  1422.     str[j++] = (char) 0x7e;
  1423. }
  1424.     }
  1426.     str[j] = '';
  1427.     SAY2(5, "ois_convert_to_ia5 gave [%s]", ois_debug_str(str, j));
  1428.     return j;
  1429. }
  1432. static int ois_convert_from_ia5(char *raw, const char *str)
  1433. {
  1434.     int j;
  1435.     int i;
  1436.     int ch;
  1438.     SAY(3, "ois_convert_from_ia5");
  1440.     for (j = i = 0; ; ++i) {
  1441. ch = str[i] & 0xff;
  1442. if (ch < 0x20 || 0x7f <= ch) {
  1443.     break;
  1444. } else if (ch == 0x5c) {
  1445.     ch = str[++i] & 0xff;
  1446.     if (ch == 0x5c || ch == 0x5e || ch == 0x60 || ch == 0x7e) {
  1447. raw[j++] = (char) ch;
  1448.     } else {
  1449. break;
  1450.     }
  1451. } else if (ch == 0x5e) {
  1452.     ch = str[++i] & 0xff;
  1453.     if (0x40 <= ch && ch < 0x60) {
  1454. raw[j++] = (char) ch - 0x40;
  1455.     } else if (ch == 0x7e) {
  1456. raw[j++] = (char) 0x7f;
  1457.     } else {
  1458. break;
  1459.     }
  1460. } else if (ch == 0x60) {
  1461.     ch = str[++i] & 0xff;
  1462.     if (0x20 <= ch && ch < 0x7f) {
  1463. raw[j++] = (char) ch + 0x80;
  1464.     } else {
  1465. break;
  1466.     }
  1467. } else if (ch == 0x7e) {
  1468.     ch = str[++i] & 0xff;
  1469.     if (0x40 <= ch && ch < 0x60) {
  1470. raw[j++] = (char) ch + 0x40;
  1471.     } else if (ch == 0x7e) {
  1472. raw[j++] = (char) 0xff;
  1473.     } else {
  1474. break;
  1475.     }
  1476. } else { /* 0x20 <= ch && ch < 0x7f */
  1477.     raw[j++] = (char) ch;
  1478. }
  1479.     }
  1481.     SAY2(5, "ois_convert_from_ia5 gave [%s]", ois_debug_str(raw, j));
  1482.     return j;
  1483. }
  1486. static int ois_convert_to_iso88591(char *raw, int len)
  1487. {
  1488.     /* a best effort 1-to-1 conversion according to ois appendix a */
  1490.     static const char gsm_to_iso88591[] = {
  1491. '@', 0xa3,'$', 0xa5,0xe8,0xe9,0xf9,0xec, /* 0x00 - 0x07 */
  1492. 0xf2,0xc7,'n',0xd8,0xf8,'r',0xc5,0xe5, /* 0x08 - 0x0f */
  1493. 'D', ' ', 'F', 'G', 'L', 'W', 'P', 'Y',  /* 0x10 - 0x17, poor! */
  1494. 'Y', 'S', 'X', ' ', 0xc6,0xe6,'b', 0xc9, /* 0x18 - 0x1f, poor! */
  1495. ' ', '!', '"', '#', 0xa4, '%', '&', ''',/* 0x20 - 0x27 */
  1496. '(', ')', '*', '+', ',', '-', '.', '/',  /* 0x28 - 0x2f */
  1497. '0', '1', '2', '3', '4', '5', '6', '7',  /* 0x30 - 0x37 */
  1498. '8', '9', ':', ';', '<', '=', '>', '?',  /* 0x38 - 0x3f */
  1499. 0xa1,'A', 'B', 'C', 'D', 'E', 'F', 'G',  /* 0x40 - 0x47 */
  1500. 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',  /* 0x48 - 0x4f */
  1501. 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',  /* 0x50 - 0x57 */
  1502. 'X', 'Y', 'Z', 0xc4,0xd6,0xd1,0xdc,0xa7, /* 0x58 - 0x5f */
  1503. 0xbf,'a', 'b', 'c', 'd', 'e', 'f', 'g',  /* 0x60 - 0x67 */
  1504. 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',  /* 0x68 - 0x6f */
  1505. 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',  /* 0x70 - 0x77 */
  1506. 'x', 'y', 'z', 0xe4,0xf6,0xf1,0xfc,0xe0  /* 0x78 - 0x7f */
  1507.     };
  1509.     int i;
  1511.     SAY2(3, "ois_convert_to_iso88591 len=%d", len);
  1513.     for (i = 0; i < len; ++i) {
  1514. raw[i] = gsm_to_iso88591[raw[i] & 0x7f];
  1515.     }
  1517.     SAY2(5, "ois_convert_to_iso88591 gave [%s]", ois_debug_str(raw, i));
  1518.     return i;
  1519. }
  1522. /*
  1523.  * Extract a message from the internal buffer.
  1524.  */
  1526. static int ois_extract_msg_from_buffer(char *str, SMSCenter *smsc)
  1527. {
  1528.     int len;
  1529.     int count;
  1531.     SAY2(8, "ois_extract_msg_from_buffer buflen=%d", smsc->buflen);
  1533.     str[0] = '';
  1535.     if (smsc->buflen < 7) {             /* 7 = 6 + 1 */
  1536. return 0;              /* we don't have a message yet */
  1537.     }
  1539.     if (strchr("SRDATECQLMPOVsrdatecqlmpov", smsc->buffer[0]) == NULL
  1540. || (smsc->buffer[1] & 0xf0) != 0x50) {
  1542. goto error;
  1543.     }
  1545.     /* a valid message type, find the end of the message */
  1547.     count = smsc->buffer[1] & 0x0f;
  1548.     for (len = 0; (size_t) len < smsc->buflen; ++len) {
  1549. if (smsc->buffer[len] == EOL) {
  1550.     if (--count < 0) {
  1551. ++len;
  1552. break;
  1553.     }
  1554. }
  1555.     }
  1557.     if (count >= 0) {          /* we don't have all the pieces */
  1558. if (len < BUFLEN) {
  1559.     return 0;          /* ...but maybe later */
  1560. }
  1561. goto error;
  1562.     }
  1564.     /* the buffer contains a promising message candidate */
  1566.     memcpy(str, smsc->buffer, len);
  1567.     str[len] = '';
  1568.     smscenter_remove_from_buffer(smsc, len); /* just the message */
  1570.     return len;
  1572.  error:
  1573.     for (len = 0; (size_t) len < smsc->buflen && smsc->buffer[len] != EOL; 
  1574.          ++len) ;
  1575.     if (len > BUFLEN) len = BUFLEN;
  1577.     memcpy(str, smsc->buffer, len);
  1578.     str[len] = '';
  1579.     smscenter_remove_from_buffer(smsc, smsc->buflen); /* everything */
  1581.     return -len;
  1582. }
  1586. /*
  1587.  * Extract a line from the internal buffer.
  1588.  */
  1590. static int ois_extract_line_from_buffer(char *str, SMSCenter *smsc)
  1591. {
  1592.     int len;
  1594.     SAY2(3, "ois_extract_line_from_buffer buflen=%d", smsc->buflen);
  1596.     str[0] = '';
  1598.     for (len = 0; (size_t) len < smsc->buflen && smsc->buffer[len] != 'n'; 
  1599.          ++len) ;
  1601.     if ((size_t) len >= smsc->buflen) {
  1602. return 0;
  1603.     } else {
  1604. ++len;
  1605.     }
  1607.     /* the buffer contains a line */
  1609.     memcpy(str, smsc->buffer, len);
  1610.     str[len] = '';
  1611.     smscenter_remove_from_buffer(smsc, len); /* just the line */
  1613.     return len;
  1614. }
  1617. static void ois_swap_buffering(SMSCenter *smsc)
  1618. {
  1619.     time_t alive;
  1620.     int socket;
  1621.     char *buffer;
  1622.     size_t bufsize;
  1623.     size_t buflen;
  1625.     SAY(8, "ois_swap_buffering");
  1627.     if (smsc->ois_bufsize == 0) {
  1628. smsc->ois_buflen = 0;
  1629. smsc->ois_bufsize = smsc->bufsize;
  1630. smsc->ois_buffer = gw_malloc(smsc->ois_bufsize);
  1631. memset(smsc->ois_buffer, 0, smsc->ois_bufsize);
  1632.     }
  1634.     alive = smsc->ois_alive;
  1635.     smsc->ois_alive = smsc->ois_alive2;
  1636.     smsc->ois_alive2 = alive;
  1638.     socket = smsc->socket;
  1639.     smsc->socket = smsc->ois_socket;
  1640.     smsc->ois_socket = socket;
  1642.     buffer = smsc->buffer;
  1643.     smsc->buffer = smsc->ois_buffer;
  1644.     smsc->ois_buffer = buffer;
  1646.     buflen = smsc->buflen;
  1647.     smsc->buflen = smsc->ois_buflen;
  1648.     smsc->ois_buflen = buflen;
  1650.     bufsize = smsc->bufsize;
  1651.     smsc->bufsize = smsc->ois_bufsize;
  1652.     smsc->ois_bufsize = bufsize;
  1654.     return;
  1655. }
  1658. static const char *ois_debug_str(const char *raw, int len)
  1659. {
  1660.     static const char hex[] = "0123456789abcdef";
  1661.     static char str[4*(BUFLEN+1)+1];
  1662.     int pos;
  1663.     int ch;
  1664.     int i;
  1666.     pos = 0;
  1667.     for (i = 0; i < len; ++i) {
  1668. ch = raw[i] & 0xff;
  1669. if (0x20 <= ch && ch < 0x7f && ch != 0x5c) {
  1670.     str[pos++] = (char) ch;
  1671. } else {
  1672.     str[pos++] = '\';
  1673.     str[pos++] = 'x';
  1674.     str[pos++] = hex[ch/16];
  1675.     str[pos++] = hex[ch%16];
  1676. }
  1677.     }
  1678.     str[pos] = '';
  1679.     return str;
  1680. }