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

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

手机WAP编程

开发平台：

WINDOWS

smsc_emi.c：源码内容
  1. /*****************************************************************************
  2. * smsc_emi.c - implement interface to the CMG SMS Center (UCP/EMI).
  3. * Mikael Gueck for WapIT Ltd.
  4. */
  6. /* This file implements two smsc interfaces: EMI and EMI_IP */
  8. #include <errno.h>
  9. #include <string.h>
  10. #include <stdio.h>
  11. #include <unistd.h>
  12. #include <fcntl.h>
  13. #include <termios.h>
  14. #include <stdarg.h>
  15. #include <stdlib.h>
  16. #include <string.h>
  17. #include <strings.h>
  19. #include <sys/time.h>
  20. #include <sys/types.h>
  21. #include <sys/socket.h>
  22. #include <sys/param.h>
  23. #include <sys/ioctl.h>
  25. #include "config.h"
  27. #include "smsc.h"
  28. #include "smsc_p.h"
  29. #include "gwlib/gwlib.h"
  30. #include "alt_charsets.h"
  31. #include "sms.h"
  33. #ifndef CRTSCTS
  34. #define CRTSCTS 0
  35. #endif
  37. /******************************************************************************
  38. * Static functions
  39. */
  40. static int get_data(SMSCenter *smsc, char *buff, int length);
  42. static int put_data(SMSCenter *smsc, char *buff, int length, int is_backup);
  44. static int memorybuffer_append_data(SMSCenter *smsc, char *buff, int length);
  46. static int memorybuffer_insert_data(SMSCenter *smsc, char *buff, int length);
  48. static int memorybuffer_has_rawmessage(SMSCenter *smsc, int type, char auth);
  50. static int memorybuffer_cut_rawmessage(SMSCenter *smsc, char *buff, int length);
  52. static int parse_rawmessage_to_msg(SMSCenter *smsc, Msg **msg,
  53.                                    char *rawmessage, int length);
  55. static int parse_msg_to_rawmessage(SMSCenter *smsc, Msg *msg,
  56.                                    char *rawmessage, int length);
  58. static int acknowledge_from_rawmessage(SMSCenter *smsc,
  59.                                    char *rawmessage, int length);
  61. static int parse_emi_to_iso88591(char *from, char *to,
  62.                                  int length, int alt_charset);
  64. static int parse_iso88591_to_emi(char *from, char *to,
  65.                                  int length, int alt_charset);
  66. static int parse_binary_to_emi(char *from, char *to, int length);
  68. static int at_dial(char *device, char *phonenum,
  69.                    char *at_prefix, time_t how_long);
  70. static int guarantee_link(SMSCenter *smsc);
  73. static void generate_checksum(const unsigned char *buffer,
  74.                               unsigned char *checksum_out);
  75. static int wait_for_ack(SMSCenter *smsc, int op_type);
  78. static char char_iso_to_sms(unsigned char from, int alt_charset);
  79. static char char_sms_to_iso(unsigned char from, int alt_charset);
  81. /******************************************************************************
  82. * Open the connection and log in - handshake baby
  83. */
  84. static int emi_open_connection(SMSCenter *smsc)
  85. {
  86.     char tmpbuff[1024];
  88.     sprintf(tmpbuff, "/dev/%s", smsc->emi_serialdevice);
  89.     smsc->emi_fd = at_dial(tmpbuff, smsc->emi_phonenum, "ATD", 30);
  91.     if (smsc->emi_fd <= 0)
  92.         return -1;
  94.     return 0;
  95. }
  97. /* open EMI smscenter */
  99. SMSCenter *emi_open(char *phonenum, char *serialdevice, char *username, char *password)
  100. {
  101.     SMSCenter *smsc;
  103.     smsc = smscenter_construct();
  104.     if (smsc == NULL)
  105.         goto error;
  107.     smsc->type = SMSC_TYPE_EMI;
  109.     smsc->emi_phonenum = gw_strdup(phonenum);
  110.     smsc->emi_serialdevice = gw_strdup(serialdevice);
  111.     smsc->emi_username = gw_strdup(username);
  112.     smsc->emi_password = gw_strdup(password);
  114.     smsc->emi_current_msg_number = 0;
  116.     if (emi_open_connection(smsc) < 0)
  117.         goto error;
  119.     sprintf(smsc->name, "EMI:%s:%s", smsc->emi_phonenum,
  120.             smsc->emi_username);
  121.     return smsc;
  123. error:
  124.     error(0, "emi_open failed");
  125.     smscenter_destruct(smsc);
  126.     return NULL;
  127. }
  129. int emi_reopen(SMSCenter *smsc)
  130. {
  131.     emi_close(smsc);
  133.     if (emi_open_connection(smsc) < 0) {
  134.         error(0, "emi_reopen failed");
  135.         return -1;
  136.     }
  137.     return 0;
  138. }
  140. int emi_close(SMSCenter *smsc)
  141. {
  142.     return emi_close_ip(smsc);
  143. }
  145. static int emi_fill_ucp60_login(char *buf, char *OAdC, char *passwd) {
  146.     int max_ia5passwd_len;
  147.     char *ia5passwd;
  149.     max_ia5passwd_len = strlen(passwd) * 2 + 1;
  150.     ia5passwd = gw_malloc(max_ia5passwd_len);
  152.     if (parse_binary_to_emi(passwd, ia5passwd, strlen(passwd)) < 0) {
  153.         error(0, "parse_binary_to_emi failed");
  154.         gw_free(ia5passwd);
  155.         return -1;
  156.     }
  158.     sprintf(buf, "%s/%c/%c/%c/%s//%s/////",
  159.     OAdC,      /* OAdC: Address code originator */
  160.     '6',       /* OTON: 6 = Abbreviated number (short number alias) */
  161.     '5',       /* ONPI: 5 = Private (TCP/IP address/abbreviated number address) */
  162.     '1',       /* STYP: 1 = open session */
  163.     ia5passwd, /* PWD:  Current password encoded into IA5 characters */
  164.     "0100"     /* VERS: Version number  0100 */
  165.     );
  167.     gw_free(ia5passwd);
  168.     return 0;
  169. }
  171. static int emi_open_session(SMSCenter *smsc)
  172. {
  173.     char message_whole  [1024];
  174.     char message_body   [1024];
  175.     char message_header [50];
  176.     char message_footer [10];
  177.     char my_buffer      [1024];
  178.     int length;
  180.     memset(message_whole,  0, sizeof(message_whole));
  181.     memset(message_body,   0, sizeof(message_body));
  182.     memset(message_header, 0, sizeof(message_header));
  183.     memset(message_footer, 0, sizeof(message_footer));
  185.     if (emi_fill_ucp60_login(message_body, smsc->emi_username, smsc->emi_password) < 0) {
  186.         error(0, "emi_fill_ucp60_login failed");
  187.         return -1;
  188.     }
  190.     length = strlen(message_body);
  191.     length += 13;  /* header (fixed) */
  192.     length += 2;   /* footer (fixed) */
  193.     length += 2;   /* slashes between header, body, footer */
  195.     sprintf(message_header, "%02i/%05i/O/60",
  196.             (smsc->emi_current_msg_number++ % 100), length);
  197.     
  198.     /* FOOTER */
  200.     sprintf(my_buffer, "%s/%s/", message_header, message_body);
  201.     generate_checksum(my_buffer, message_footer);
  203.     sprintf(message_whole, "x02%s/%s/%sx03", message_header,
  204.             message_body, message_footer);
  206.     debug("bb.sms.emi", 0, "final UCP60 msg: <%s>", message_whole);
  208.     put_data(smsc, message_whole, strlen(message_whole), 0);
  210.     if (!wait_for_ack(smsc, 60)) {
  211. info(0, "emi_open_session: wait for ack failed!");
  212. return -1;
  213.     }
  215.     return 0;
  216. }
  219. /*******************************************************
  220.  * the actual protocol open... quite simple here */
  222. static int emi_open_connection_ip(SMSCenter *smsc)
  223. {
  224.     smsc->emi_fd =
  225.         tcpip_connect_to_server_with_port(smsc->emi_hostname,
  226.                                           smsc->emi_port, smsc->emi_our_port,
  227.   NULL);
  228.     /* XXX add interface_name if required */
  229.     if (smsc->emi_fd < 0)
  230.         return -1;
  232.     if (smsc->emi_username && smsc->emi_password) {
  233. return emi_open_session(smsc);
  234.     }
  235.     
  236.     return 0;
  237. }
  240. /******************************************************************************
  241. * Open the connection and log in
  242. */
  243. SMSCenter *emi_open_ip(char *hostname, int port, char *username,
  244.                        char *password, int receive_port, char *allow_ip,
  245.        int our_port)
  246. {
  248.     SMSCenter *smsc;
  250.     smsc = smscenter_construct();
  251.     if (smsc == NULL)
  252.         goto error;
  254.     smsc->type = SMSC_TYPE_EMI_IP;
  256.     smsc->emi_hostname = gw_strdup(hostname);
  257.     smsc->emi_port = port;
  258.     smsc->emi_username = username ? gw_strdup(username) : NULL;
  259.     smsc->emi_password = password ? gw_strdup(password) : NULL;
  260.     smsc->emi_backup_port = receive_port;
  261.     smsc->emi_backup_allow_ip = allow_ip ? gw_strdup(allow_ip) : NULL;
  262.     smsc->emi_our_port = our_port;
  264.     if (receive_port > 0 && allow_ip == NULL)
  265. warning(0, "EMI IP: receive-port set but no IPs allowed to connect!");
  267.     smsc->emi_current_msg_number = 0;
  269.     if (emi_open_connection_ip(smsc) < 0)
  270.         goto error;
  272.     sprintf(smsc->name, "EMIIP:%s:%s", smsc->emi_hostname,
  273.             username ? smsc->emi_username : "n/a");
  275.     /* if receive-port is defined, set it ready */
  277.     if (receive_port > 0) {
  278.         if ((smsc->emi_backup_fd = make_server_socket(receive_port, NULL)) <= 0)
  279. /* XXX add interface_name if required */
  280.             goto error;
  282.         debug("bb.sms.emi", 0, "EMI IP backup port at %d opened", receive_port);
  283.     }
  284.     return smsc;
  286. error:
  287.     error(0, "emi_open_ip failed");
  288.     smscenter_destruct(smsc);
  289.     return NULL;
  291. }
  293. int emi_reopen_ip(SMSCenter *smsc)
  294. {
  295.     emi_close_ip(smsc);
  297.     return emi_open_connection_ip(smsc);
  298. }
  301. int emi_close_ip(SMSCenter *smsc)
  302. {
  304.     if (smsc->emi_fd == -1) {
  305.         info(0, "Trying to close already closed EMI, ignoring");
  306.         return 0;
  307.     }
  308.     close(smsc->emi_fd);
  309.     smsc->emi_fd = -1;
  311.     return 0;
  312. }
  315. /******************************************************************************
  316. * Check if the buffers contain any messages
  317. */
  318. int emi_pending_smsmessage(SMSCenter *smsc)
  319. {
  321.     char *tmpbuff;
  322.     int n = 0;
  323.     /* time_t timenow; */
  325.     /* Block until we have a connection */
  326.     guarantee_link(smsc);
  328.     /* If we have MO-message, then act (return 1) */
  329.     if (memorybuffer_has_rawmessage(smsc, 52, 'O') > 0 ||
  330.         memorybuffer_has_rawmessage(smsc, 1, 'O') > 0 )
  331.         return 1;
  333.     tmpbuff = gw_malloc(10 * 1024);
  334.     memset(tmpbuff, 0, 10*1024);
  336.     /* check for data */
  337.     n = get_data(smsc, tmpbuff, 10 * 1024);
  338.     if (n > 0)
  339.         memorybuffer_insert_data(smsc, tmpbuff, n);
  341.     /* delete all ACKs/NACKs/whatever */
  342.     while (memorybuffer_has_rawmessage(smsc, 51, 'R') > 0 ||
  343.            memorybuffer_has_rawmessage(smsc, 1, 'R') > 0)
  344.         memorybuffer_cut_rawmessage(smsc, tmpbuff, 10*1024);
  346.     gw_free(tmpbuff);
  348.     /* If we have MO-message, then act (return 1) */
  350.     if (memorybuffer_has_rawmessage(smsc, 52, 'O') > 0 ||
  351.         memorybuffer_has_rawmessage(smsc, 1, 'O') > 0)
  352.         return 1;
  354.     /*
  355.      time(&timenow);
  356.      if( (smsc->emi_last_spoke + 60*20) < timenow) {
  357.      time(&smsc->emi_last_spoke);
  358.      }
  359.     */
  361.     return 0;
  363. }
  368. /******************************************************************************
  369.  * Submit (send) a Mobile Terminated message to the EMI server
  370.  */
  371. int emi_submit_msg(SMSCenter *smsc, Msg *omsg)
  372. {
  373.     char *tmpbuff = NULL;
  375.     if (smsc == NULL) goto error;
  376.     if (omsg == NULL) goto error;
  378.     tmpbuff = gw_malloc(10 * 1024);
  379.     memset(tmpbuff, 0, 10*1024);
  381.     if (parse_msg_to_rawmessage(smsc, omsg, tmpbuff, 10*1024) < 1)
  382.         goto error;
  384.     if (put_data(smsc, tmpbuff, strlen(tmpbuff), 0) < 0) {
  385.         info(0, "put_data failed!");
  386.         goto error;
  387.     }
  389.     if (smsc->type == SMSC_TYPE_EMI_IP) {
  390.         if (!wait_for_ack(smsc, 51)) {
  391.             info(0, "emi_submit_smsmessage: wait for ack failed!");
  392.             goto error;
  393.         }
  394.     }
  396.     if (smsc->type == SMSC_TYPE_EMI)
  397.         wait_for_ack(smsc, 51);
  399.     /* smsc->emi_current_msg_number += 1; */
  400.     debug("bb.sms.emi", 0, "Submit Ok...");
  402.     gw_free(tmpbuff);
  403.     return 0;
  405. error:
  406.     debug("bb.sms.emi", 0, "Submit Error...");
  408.     gw_free(tmpbuff);
  409.     return -1;
  410. }
  412. /******************************************************************************
  413. * Receive a Mobile Terminated message to the EMI server
  414. */
  415. int emi_receive_msg(SMSCenter *smsc, Msg **tmsg)
  416. {
  417.     char *tmpbuff;
  418.     Msg *msg = NULL;
  420.     *tmsg = NULL;
  422.     tmpbuff = gw_malloc(10 * 1024);
  423.     memset(tmpbuff, 0, 10*1024);
  425.     /* get and delete message from buffer */
  426.     memorybuffer_cut_rawmessage(smsc, tmpbuff, 10*1024);
  427.     parse_rawmessage_to_msg(smsc, &msg, tmpbuff, strlen(tmpbuff));
  429.     /* yeah yeah, I got the message... */
  430.     acknowledge_from_rawmessage(smsc, tmpbuff, strlen(tmpbuff));
  432.     /* return with the joyful news */
  433.     gw_free(tmpbuff);
  435.     if (msg == NULL) goto error;
  437.     *tmsg = msg;
  439.     return 1;
  441. error:
  442.     gw_free(tmpbuff);
  443.     msg_destroy(msg);
  444.     return -1;
  445. }
  448. /******************************************************************************
  449. * Internal functions
  450. */
  453. /******************************************************************************
  454. * Guarantee that we have a link
  455. */
  456. static int guarantee_link(SMSCenter *smsc)
  457. {
  458.     int need_to_connect = 0;
  460.     if (smsc->type == SMSC_TYPE_EMI_IP) {
  461.         /* We don't currently guarantee TCP connections. */
  462.         return 0;
  463.     }
  465.     /* If something is obviously wrong. */
  466.     if (strstr(smsc->buffer, "OK")) need_to_connect = 1;
  467.     if (strstr(smsc->buffer, "NO CARRIER")) need_to_connect = 1;
  468.     if (strstr(smsc->buffer, "NO DIALTONE")) need_to_connect = 1;
  470.     /* Clear the buffer */
  471.     while (need_to_connect) {
  472.         /* Connect */
  473.         need_to_connect = emi_open_connection(smsc) < 0;
  475.         /* Clear the buffer so that the next call to guarantee
  476.            doesn't find the "NO CARRIER" string again. */
  477.         smsc->buflen = 0;
  478.         memset(smsc->buffer, 0, smsc->bufsize);
  479.     }
  481.     return 0;
  482. }
  484. static int at_dial(char *device, char *phonenum, char *at_prefix, time_t how_long)
  485. {
  486.     char tmpbuff[1024];
  487.     int howmanyread = 0;
  488.     int thistime = 0;
  489.     int redial;
  490.     int fd = -1;
  491.     int ret;
  492.     time_t timestart;
  493.     struct termios tios;
  495.     /* The time at the start of the function is used when
  496.        determining whether we have used up our allotted
  497.        dial time and have to abort. */
  498.     time(&timestart);
  500.     /* Open the device properly. Remember to set the
  501.        access codes correctly. */
  502.     fd = open(device, O_RDWR | O_NONBLOCK | O_NOCTTY);
  503.     if (fd == -1) {
  504.         error(errno, "at_dial: error opening character device <%s>", device);
  505.         goto error;
  506.     }
  507.     tcflush(fd, TCIOFLUSH);
  509.     /* The speed initialisation is pretty important. */
  510.     tcgetattr(fd, &tios);
  511.     cfsetospeed(&tios, B115200);
  512.     cfsetispeed(&tios, B115200);
  513.     kannel_cfmakeraw(&tios);
  514.     tios.c_cflag |= (HUPCL | CREAD | CRTSCTS);
  515.     tcsetattr(fd, TCSANOW, &tios);
  517.     /* Dial using an AT command string. */
  518.     for (redial = 1; redial; ) {
  519.         info(0, "at_dial: dialing <%s> on <%s> for <%i> seconds",
  520.              phonenum, device,
  521.              (int)(how_long - (time(NULL) - timestart)));
  523.         /* Send AT dial request. */
  524.         howmanyread = 0;
  525.         sprintf(tmpbuff, "%s%srn", at_prefix, phonenum);
  526.         ret = write(fd, tmpbuff, strlen(tmpbuff));  /* errors... -mg */
  527.         memset(&tmpbuff, 0, sizeof(tmpbuff));
  529.         /* Read the answer to the AT command and react accordingly. */
  530.         for (; ; ) {
  531.             /* We don't want to dial forever */
  532.             if (how_long != 0 && time(NULL) > timestart + how_long)
  533.                 goto timeout;
  535.             /* We don't need more space for dialout */
  536.             if (howmanyread >= (int) sizeof(tmpbuff))
  537.                 goto error;
  539.             /* We read 1 char a time so that we don't
  540.                accidentally read past the modem chat and
  541.                into the SMSC datastream -mg */
  542.             thistime = read(fd, &tmpbuff[howmanyread], 1);
  543.             if (thistime == -1) {
  544.                 if (errno == EAGAIN) continue;
  545.                 if (errno == EINTR) continue;
  546.                 goto error;
  547.             } else {
  548.                 howmanyread += thistime;
  549.             }
  551.             /* Search for the newline on the AT status line. */
  552.             if (tmpbuff[howmanyread - 1] == 'r'
  553.                 || tmpbuff[howmanyread - 1] == 'n') {
  555.                 /* XXX ADD ALL POSSIBLE CHAT STRINGS XXX */
  557.                 if (strstr(tmpbuff, "CONNECT") != NULL) {
  558.                     debug("bb.sms.emi", 0, "at_dial: CONNECT");
  559.                     redial = 0;
  560.                     break;
  562.                 } else if (strstr(tmpbuff, "NO CARRIER") != NULL) {
  563.                     debug("bb.sms.emi", 0, "at_dial: NO CARRIER");
  564.                     redial = 1;
  565.                     break;
  567.                 } else if (strstr(tmpbuff, "BUSY") != NULL) {
  568.                     debug("bb.sms.emi", 0, "at_dial: BUSY");
  569.                     redial = 1;
  570.                     break;
  572.                 } else if (strstr(tmpbuff, "NO DIALTONE") != NULL) {
  573.                     debug("bb.sms.emi", 0, "at_dial: NO DIALTONE");
  574.                     redial = 1;
  575.                     break;
  577.                 }
  579.             } /* End of if lastchr=='r'||'n'. */
  581.             /* Thou shall not consume all system resources
  582.                by repeatedly looping a strstr search when
  583.                the string update latency is very high as it
  584.                is in serial communication. -mg */
  585.             usleep(1000);
  587.         } /* End of read loop. */
  589.         /* Thou shall not flood the modem with dial requests. -mg */
  590.         sleep(1);
  592.     } /* End of dial loop. */
  594.     debug("bb.sms.emi", 0, "at_dial: done with dialing");
  595.     return fd;
  597. timeout:
  598.     error(0, "at_dial timed out");
  599.     close(fd);
  600.     return -1;
  602. error:
  603.     error(0, "at_dial failed");
  604.     close(fd);
  605.     return -1;
  606. }
  608. /******************************************************************************
  609.  * Wait for an ACK or NACK from the remote
  610.  *
  611.  * REQUIRED by the protocol that it must be waited...
  612.  */
  613. static int wait_for_ack(SMSCenter *smsc, int op_type)
  614. {
  615.     char *tmpbuff;
  616.     int found = 0;
  617.     int n;
  618.     time_t start;
  620.     tmpbuff = gw_malloc(10 * 1024);
  621.     memset(tmpbuff, 0, 10*1024);
  622.     start = time(NULL);
  623.     do {
  624.         /* check for data */
  625.         n = get_data(smsc, tmpbuff, 1024 * 10);
  627.         if (smsc->type == SMSC_TYPE_EMI) {
  628.             /* At least the X.31 interface wants to append the data.
  629.                Kalle, what about the TCP/IP interface? Am I correct
  630.                that you are assuming that the message arrives in a 
  631.                single read(2)? -mg */
  632.             if (n > 0)
  633. memorybuffer_append_data(smsc, tmpbuff, n);
  634.         } else if (smsc->type == SMSC_TYPE_EMI_IP) {
  635.             if (n > 0)
  636. memorybuffer_insert_data(smsc, tmpbuff, n);
  637.         }
  639.         /* act on data */
  640.         if (memorybuffer_has_rawmessage(smsc, op_type, 'R') > 0) {
  641.             memorybuffer_cut_rawmessage(smsc, tmpbuff, 10*1024);
  642.             debug("bb.sms.emi", 0, "Found ACK/NACK: <%s>", tmpbuff);
  643.             found = 1;
  644.         }
  645.     } while (!found && ((time(NULL) - start) < 5));
  647.     gw_free(tmpbuff);
  648.     return found;
  649. }
  652. /******************************************************************************
  653.  * Get the modem buffer data to buff, return the amount read
  654.  *
  655.  * Reads from main fd, but also from backup-fd - does accept if needed
  656.  */
  657. static int get_data(SMSCenter *smsc, char *buff, int length)
  658. {
  659.     int n = 0;
  661.     struct sockaddr_in client_addr;
  662.     socklen_t client_addr_len;
  664.     fd_set rf;
  665.     struct timeval to;
  666.     int ret;
  668.     memset(buff, 0, length);
  670.     if (smsc->type == SMSC_TYPE_EMI) {
  671.         tcdrain(smsc->emi_fd);
  672.         n = read(smsc->emi_fd, buff, length);
  673.         return n;
  674.     }
  676.     FD_ZERO(&rf);
  677.     if (smsc->emi_fd >= 0) FD_SET(smsc->emi_fd, &rf);
  678.     if (smsc->emi_secondary_fd >= 0) FD_SET(smsc->emi_secondary_fd, &rf);
  679.     if (smsc->emi_backup_fd > 0) FD_SET(smsc->emi_backup_fd, &rf);
  681.     FD_SET(0, &rf);
  682.     to.tv_sec = 0;
  683.     to.tv_usec = 100;
  685.     ret = select(FD_SETSIZE, &rf, NULL, NULL, &to);
  687.     if (ret > 0) {
  688.         if (smsc->emi_secondary_fd >= 0 && FD_ISSET(smsc->emi_secondary_fd, &rf)) {
  689.             n = read(smsc->emi_secondary_fd, buff, length - 1);
  691.             if (n == -1) {
  692.                 error(errno, "Error - Secondary socket closed");
  693.                 close(smsc->emi_secondary_fd);
  694.                 smsc->emi_secondary_fd = -1;
  695.             } else if (n == 0) {
  696.                 info(0, "Secondary socket closed by SMSC");
  697.                 close(smsc->emi_secondary_fd);
  698.                 smsc->emi_secondary_fd = -1;
  699.             } else { /* UGLY! We  put 'X' after message */
  700.                 buff[n] = 'X';  /* if it is from secondary fd!!!  */
  701.                 n++;
  702.             }
  703.         } else if (smsc->emi_fd >= 0 && FD_ISSET(smsc->emi_fd, &rf)) {
  704.             n = read(smsc->emi_fd, buff, length);
  705.             if (n == 0) {
  706.                 close(smsc->emi_fd);
  707.                 info(0, "Main EMI socket closed by SMSC");
  708.                 smsc->emi_fd = -1;  /* ready to be re-opened */
  709.             }
  710.         }
  711.         if ((smsc->emi_backup_fd > 0) && FD_ISSET(smsc->emi_backup_fd, &rf)) {
  712.             if (smsc->emi_secondary_fd == -1) {
  713. Octstr *ip, *allow;
  715.                 smsc->emi_secondary_fd = accept(smsc->emi_backup_fd,
  716.   (struct sockaddr *)&client_addr, &client_addr_len);
  718. ip = host_ip(client_addr);
  719. if (smsc->emi_backup_allow_ip == NULL)
  720.     allow = NULL;
  721. else
  722.     allow = octstr_create(smsc->emi_backup_allow_ip);
  723. if (is_allowed_ip(allow, octstr_imm("*.*.*.*"), ip) == 0) {
  724.     info(0, "SMSC secondary connection tried from <%s>, "
  725.          "disconnected",
  726.     octstr_get_cstr(ip));
  727.     octstr_destroy(ip);
  728.     octstr_destroy(allow);
  729.     close(smsc->emi_secondary_fd);
  730.     smsc->emi_secondary_fd = -1;
  731.     return 0;
  732. }
  733.                 info(0, "Secondary socket opened by SMSC from <%s>",
  734.      octstr_get_cstr(ip));
  735. octstr_destroy(ip);
  736. octstr_destroy(allow);
  737.             } else
  738.                 info(0, "New connection request while old secondary is open!");
  739.         }
  740.     }
  741.     if (n > 0) {
  742.         debug("bb.sms.emi", 0, "get_data:Read %d bytes: <%.*s>", n, n, buff);
  743.         debug("bb.sms.emi", 0, "get_data:smsc->buffer == <%s>", smsc->buffer);
  744.     }
  745.     return n;
  747. }
  749. /******************************************************************************
  750. * Put the buff data to the modem buffer, return the amount of data put
  751. */
  752. static int put_data(SMSCenter *smsc, char *buff, int length, int is_backup)
  753. {
  754.     size_t len = length;
  755.     int ret;
  756.     int fd = -1;
  758.     if (smsc->type == SMSC_TYPE_EMI_IP) {
  759.         if (is_backup) {
  760.             fd = smsc->emi_secondary_fd;
  761.             info(0, "Writing into secondary (backup) fd!");
  762.         } else {
  763.             if (smsc->emi_fd == -1) {
  764.                 info(0, "Reopening connection to SMSC");
  765. if (emi_open_connection_ip(smsc) < 0) {
  766.                     error(0, "put_data: Reopening failed!");
  767.                     return -1;
  768. }
  769.             }
  770.             fd = smsc->emi_fd;
  771.         }
  772.     }
  774.     if (smsc->type == SMSC_TYPE_EMI) {
  775.         fd = smsc->emi_fd;
  776.         tcdrain(smsc->emi_fd);
  777.     }
  779.     /* Write until all data has been successfully written to the fd. */
  780.     while (len > 0) {
  781.         ret = write(fd, buff, len);
  782.         if (ret == -1) {
  783.             if (errno == EINTR) continue;
  784.             if (errno == EAGAIN) continue;
  785.             error(errno, "Writing to fd failed");
  786.             if (fd == smsc->emi_fd && smsc->type == SMSC_TYPE_EMI_IP) {
  787.                 close(fd);
  788.                 smsc->emi_fd = -1;
  789.                 info(0, "Closed main EMI socket.");
  790.             }
  791.             return -1;
  792.         }
  793.         /* ret may be less than len, if the writing
  794.            was interrupted by a signal. */
  795.         len -= ret;
  796.         buff += ret;
  797.     }
  799.     if (smsc->type == SMSC_TYPE_EMI) {
  800.         /* Make sure the data gets written immediately.
  801.            Wait a while just to add some latency so
  802.            that the modem (or the UART) doesn't choke
  803.            on the data. */
  804.         tcdrain(smsc->emi_fd);
  805.         usleep(1000);
  806.     }
  808.     return 0;
  809. }
  811. /******************************************************************************
  812. * Append the buff data to smsc->buffer
  813. */
  814. static int memorybuffer_append_data(SMSCenter *smsc, char *buff, int length)
  815. {
  816.     while (smsc->bufsize < (smsc->buflen + length)) { /* buffer too small */
  817.         char *p = gw_realloc(smsc->buffer, smsc->bufsize * 2);
  818.         smsc->buffer = p;
  819.         smsc->bufsize *= 2;
  820.     }
  822.     memcpy(smsc->buffer + smsc->buflen, buff, length);
  823.     smsc->buflen += length;
  824.     return 0;
  826. }
  828. /******************************************************************************
  829. * Insert (put to head) the buff data to smsc->buffer
  830. */
  831. static int memorybuffer_insert_data(SMSCenter *smsc, char *buff, int length)
  832. {
  833.     while (smsc->bufsize < (smsc->buflen + length)) { /* buffer too small */
  834.         char *p = gw_realloc(smsc->buffer, smsc->bufsize * 2);
  835.         smsc->buffer = p;
  836.         smsc->bufsize *= 2;
  837.     }
  838.     memmove(smsc->buffer + length, smsc->buffer, smsc->buflen);
  839.     memcpy(smsc->buffer, buff, length);
  840.     smsc->buflen += length;
  841.     return 0;
  843. }
  845. /******************************************************************************
  846. * Check the smsc->buffer for a raw STX...ETX message
  847. */
  848. static int memorybuffer_has_rawmessage(SMSCenter *smsc, int type, char auth)
  849. {
  850.     char tmpbuff[1024], tmpbuff2[1024];
  851.     char *stx, *etx;
  853.     stx = memchr(smsc->buffer, '2', smsc->buflen);
  854.     etx = memchr(smsc->buffer, '3', smsc->buflen);
  856.     if (stx && etx && stx < etx) {
  857.         strncpy(tmpbuff, stx, etx - stx + 1);
  858.         tmpbuff[etx - stx + 1] = '';
  859.         if (auth)
  860.             sprintf(tmpbuff2, "/%c/%02i/", auth, type);
  861.         else
  862.             sprintf(tmpbuff2, "/%02i/", type);
  864.         if (strstr(tmpbuff, tmpbuff2) != NULL) {
  865.             debug("bb.sms.emi", 0, "found message <%c/%02i>...msg <%s>", auth, type, tmpbuff);
  866.             return 1;
  867.         }
  868.     }
  869.     return 0;
  871. }
  873. /******************************************************************************
  874. * Cut the first raw message from the smsc->buffer
  875. * and put it in buff, return success 0, failure -1
  876. */
  877. static int memorybuffer_cut_rawmessage(SMSCenter *smsc, char *buff, int length)
  878. {
  880.     char *stx, *etx;
  881.     int size_of_cut_piece;
  882.     int size_of_the_rest;
  884.     /* We don't check for NULLs since we're sure that nobody has fooled
  885.        around with smsc->buffer since has_rawmessage was last called... */
  887.     stx = memchr(smsc->buffer, '2', smsc->buflen);
  888.     etx = memchr(smsc->buffer, '3', smsc->buflen);
  890.     if (*(etx + 1) == 'X') /* secondary! UGLY KLUDGE */
  891.         etx++;
  893.     size_of_cut_piece = (etx - stx) + 1;
  894.     size_of_the_rest = (smsc->buflen - size_of_cut_piece);
  896.     if (length < size_of_cut_piece) {
  897.         error(0, "the buffer you provided for cutting was too small");
  898.         return -1;
  899.     }
  901.     /* move the part before our magic rawmessage to the safe house */
  902.     memcpy(buff, stx, size_of_cut_piece);
  903.     buff[size_of_cut_piece] = '';  /* NULL-terminate */
  905.     /* move the stuff in membuffer one step down */
  906.     memmove(stx, etx + 1, (smsc->buffer + smsc->bufsize) - stx );
  908.     smsc->buflen -= size_of_cut_piece;
  910.     return 0;
  912. }
  914. /******************************************************************************
  915. * Parse the raw message to the Msg structure
  916. */
  917. static int parse_rawmessage_to_msg(SMSCenter *smsc, Msg **msg,
  918.                                    char *rawmessage, int length)
  919. {
  921.     char emivars[128][1024];
  922.     char *leftslash, *rightslash;
  923.     char isotext[2048];
  924.     int msgnbr;
  925.     int tmpint;
  927.     msgnbr = -1;
  929.     memset(isotext, 0, sizeof(isotext));
  931.     strncpy(isotext, rawmessage, length);
  932.     leftslash = isotext;
  934.     for (tmpint = 0; leftslash != NULL; tmpint++) {
  935.         rightslash = strchr(leftslash + 1, '/');
  937.         if (rightslash == NULL)
  938.             rightslash = strchr(leftslash + 1, '3');
  940.         if (rightslash == NULL)
  941.             break;
  943.         *rightslash = '';
  944.         strcpy(emivars[tmpint], leftslash + 1);
  945.         leftslash = rightslash;
  946.     }
  948.     if (strcmp(emivars[3], "01") == 0) {
  949.         if (strcmp(emivars[7], "2") == 0) {
  950.             strcpy(isotext, emivars[8]);
  951.         } else if (strcmp(emivars[7], "3") == 0) {
  952.             parse_emi_to_iso88591(emivars[8], isotext, sizeof(isotext),
  953.                                   smsc->alt_charset);
  954.         } else {
  955.             error(0, "Unknown 01-type EMI SMS (%s)", emivars[7]);
  956.             strcpy(isotext, "");
  957.         }
  958.     } else if (strcmp(emivars[3], "51") == 0) {
  959.         parse_emi_to_iso88591(emivars[24], isotext, sizeof(isotext),
  960.                               smsc->alt_charset);
  961.     } else if (strcmp(emivars[3], "52") == 0) {
  962.         parse_emi_to_iso88591(emivars[24], isotext, sizeof(isotext),
  963.                               smsc->alt_charset);
  964.     } else {
  965.         error(0, "HEY WE SHOULD NOT BE HERE!! Type = %s", emivars[3]);
  966.         strcpy(isotext, "");
  967.     }
  969.     *msg = msg_create(sms);
  970.     if (*msg == NULL) goto error;
  972.     (*msg)->sms.sender = octstr_create(emivars[5]);
  973.     (*msg)->sms.receiver = octstr_create(emivars[4]);
  974.     (*msg)->sms.msgdata = octstr_create(isotext);
  975.     (*msg)->sms.udhdata = NULL;
  977.     return msgnbr;
  979. error:
  980.     return -1;
  981. }
  983. /*
  984.  * notify the SMSC that we got the message
  985.  */
  986. static int acknowledge_from_rawmessage(SMSCenter *smsc,
  987.                                        char *rawmessage, int length)
  988. {
  990.     char emivars[128][1024];
  991.     char timestamp[2048], sender[2048], receiver[2048];
  992.     char emitext[2048], isotext[2048];
  993.     char *leftslash, *rightslash;
  994.     int msgnbr;
  995.     int tmpint;
  996.     int is_backup = 0;
  998.     msgnbr = -1;
  999.     memset(&sender, 0, sizeof(sender));
  1000.     memset(&receiver, 0, sizeof(receiver));
  1001.     memset(&emitext, 0, sizeof(emitext));
  1002.     memset(&isotext, 0, sizeof(isotext));
  1003.     memset(&timestamp, 0, sizeof(timestamp));
  1005.     strncpy(isotext, rawmessage, length);
  1006.     leftslash = isotext;
  1008.     if (isotext[length - 1] == 'X')
  1009.         is_backup = 1;
  1011.     for (tmpint = 0; leftslash != NULL; tmpint++) {
  1012.         rightslash = strchr(leftslash + 1, '/');
  1014.         if (rightslash == NULL)
  1015.             rightslash = strchr(leftslash + 1, '3');
  1017.         if (rightslash == NULL)
  1018.             break;
  1020.         *rightslash = '';
  1021.         strcpy(emivars[tmpint], leftslash + 1);
  1022.         leftslash = rightslash;
  1023.     }
  1026.     /* BODY */
  1027.     if (smsc->type == SMSC_TYPE_EMI) {
  1028.         sprintf(isotext, "A//%s:%s", emivars[4], emivars[18]);
  1029.         sprintf(isotext, "A//%s:", emivars[5]);
  1030.         is_backup = 0;
  1031.     }
  1033.     if (smsc->type == SMSC_TYPE_EMI_IP) {
  1034.         if (strcmp(emivars[3], "01") == 0)
  1035.             sprintf(isotext, "A/%s:", emivars[4]);
  1036.         else
  1037.             sprintf(isotext, "A//%s:%s", emivars[4], emivars[18]);
  1038.     }
  1040.     /* HEADER */
  1042.     debug("bb.sms.emi", 0, "acknowledge: type = '%s'", emivars[3]);
  1044.     sprintf(emitext, "%s/%05i/%s/%s", emivars[0], (int) strlen(isotext) + 17,
  1045.             "R", emivars[3]);
  1047.     smsc->emi_current_msg_number = atoi(emivars[0]) + 1;
  1049.     /* FOOTER */
  1050.     sprintf(timestamp, "%s/%s/", emitext, isotext);
  1051.     generate_checksum(timestamp, receiver);
  1053.     sprintf(sender, "%c%s/%s/%s%c", 0x02, emitext, isotext, receiver, 0x03);
  1054.     put_data(smsc, sender, strlen(sender), is_backup);
  1056.     return msgnbr;
  1058. }
  1061. /******************************************************************************
  1062. * Parse the Msg structure to the raw message format
  1063. */
  1064. static int parse_msg_to_rawmessage(SMSCenter *smsc, Msg *msg, char *rawmessage, int rawmessage_length)
  1065. {
  1066.     char message_whole[10*1024];
  1067.     char message_body[10*1024];
  1068.     char message_header[1024];
  1069.     char message_footer[1024];
  1071.     char my_buffer[10*1024];
  1072.     char my_buffer2[10*1024];
  1073.     char msgtext[1024];
  1074.     int length;
  1075.     char mt;
  1076.     char mcl[20];
  1077.     char snumbits[20];
  1078.     char xser[1024];
  1079.     int udh_len;
  1081.     memset(&message_whole, 0, sizeof(message_whole));
  1082.     memset(&message_body, 0, sizeof(message_body));
  1083.     memset(&message_header, 0, sizeof(message_header));
  1084.     memset(&message_footer, 0, sizeof(message_footer));
  1085.     memset(&my_buffer, 0, sizeof(my_buffer));
  1086.     memset(&my_buffer2, 0, sizeof(my_buffer2));
  1087.     mt = '3';
  1088.     memset(&snumbits, 0, sizeof(snumbits));
  1089.     memset(&xser, 0, sizeof(xser));
  1091.     /* XXX parse_iso88591_to_emi shouldn't use NUL terminated
  1092.      * strings, but Octstr directly, or a char* and a length.
  1093.      */
  1094.     if (octstr_len(msg->sms.udhdata)) {
  1095.         char xserbuf[258];
  1096.         /* we need a properly formated UDH here, there first byte contains his length
  1097.          * this will be formatted in the xser field of the EMI Protocol
  1098.          */
  1099.         udh_len = octstr_get_char(msg->sms.udhdata, 0) + 1;
  1100.         xserbuf[0] = 1;
  1101.         xserbuf[1] = udh_len;
  1102.         octstr_get_many_chars(&xserbuf[2], msg->sms.udhdata, 0, udh_len);
  1103.         parse_binary_to_emi(xserbuf, xser, udh_len + 2);
  1104.     } else {
  1105.         udh_len = 0;
  1106.     }
  1108.     if (msg->sms.coding == DC_7BIT ) {
  1109.         octstr_get_many_chars(msgtext, msg->sms.msgdata, 0, octstr_len(msg->sms.msgdata));
  1110.         msgtext[octstr_len(msg->sms.msgdata)] = '';
  1111.         parse_iso88591_to_emi(msgtext, my_buffer2,
  1112.                                            octstr_len(msg->sms.msgdata),
  1113.                                            smsc->alt_charset);
  1115.         strcpy(snumbits, "");
  1116.         mt = '3';
  1117.         strcpy(mcl, "");
  1118.     } else {
  1119.         octstr_get_many_chars(msgtext, msg->sms.msgdata, 0, octstr_len(msg->sms.msgdata));
  1121.         parse_binary_to_emi(msgtext, my_buffer2, octstr_len(msg->sms.msgdata));
  1123.         sprintf(snumbits, "%04ld", octstr_len(msg->sms.msgdata)*8);
  1124.         mt = '4';
  1125.         strcpy(mcl, "1");
  1126.     }
  1128.     /* XXX Where is DCS ? Is it in XSER like in emi2 ? 
  1129.      * Please someone encode it with fields_to_dcs 
  1130.      */
  1132.     sprintf(message_body,
  1133.             "%s/%s/%s/%s/%s//%s////////////%c/%s/%s////%s//////%s//",
  1134.             octstr_get_cstr(msg->sms.receiver),
  1135.             msg->sms.sender ? octstr_get_cstr(msg->sms.sender) : "",
  1136.             "",
  1137.             "",
  1138.             "",
  1139.             "0100",
  1140.             mt,
  1141.             snumbits,
  1142.             my_buffer2,
  1143.             mcl,
  1144.             xser);
  1146.     /* HEADER */
  1148.     length = strlen(message_body);
  1149.     length += 13;  /* header (fixed) */
  1150.     length += 2;  /* footer (fixed) */
  1151.     length += 2;  /* slashes between header, body, footer */
  1153.     sprintf(message_header, "%02i/%05i/%s/%s", (smsc->emi_current_msg_number++ % 100), length, "O", "51");
  1155.     /* FOOTER */
  1157.     sprintf(my_buffer, "%s/%s/", message_header, message_body);
  1158.     generate_checksum(my_buffer, message_footer);
  1160.     sprintf(message_whole, "%c%s/%s/%s%c", 0x02, message_header, message_body, message_footer, 0x03);
  1162.     strncpy(rawmessage, message_whole, rawmessage_length);
  1164.     if (smsc->type == SMSC_TYPE_EMI) {
  1165.         /* IC3S braindead EMI stack chokes on this... must fix it at the next time... */
  1166.         strcat(rawmessage, "r");
  1167.     }
  1168.     debug("bb.sms.emi", 0, "emi %d message %s",
  1169.           smsc->emi_current_msg_number, rawmessage);
  1170.     return strlen(rawmessage);
  1171. }
  1173. /******************************************************************************
  1174. * Parse the data from the two byte EMI code to normal ISO-8869-1
  1175. */
  1176. static int parse_emi_to_iso88591(char *from, char *to, int length,
  1177.                                  int alt_charset)
  1178. {
  1179.     int hmtg = 0;
  1180.     unsigned int mychar;
  1181.     char tmpbuff[128];
  1183.     for (hmtg = 0; hmtg <= (int)strlen(from); hmtg += 2) {
  1184.         strncpy(tmpbuff, from + hmtg, 2);
  1185.         sscanf(tmpbuff, "%x", &mychar);
  1186.         to[hmtg / 2] = char_sms_to_iso(mychar, alt_charset);
  1187.     }
  1189.     to[(hmtg / 2)-1] = '';
  1191.     return 0;
  1193. }
  1195. /******************************************************************************
  1196. * Parse the data from normal ISO-8869-1 to the two byte EMI code
  1197. */
  1198. static int parse_iso88591_to_emi(char *from, char *to,
  1199.         int length, int alt_charset)
  1200. {
  1201.     char buf[10];
  1202.     unsigned char tmpchar;
  1203.     char *ptr;
  1205.     if (!from || !to || length <= 0)
  1206.         return -1;
  1208.     *to = '';
  1210.     debug("bb.sms.emi", 0, "emi parsing <%s> to emi, length %d", from, length);
  1212.     for (ptr = from; length > 0; ptr++, length--) {
  1213.         tmpchar = char_iso_to_sms(*ptr, alt_charset);
  1214.         sprintf(buf, "%02X", tmpchar);
  1215.         strncat(to, buf, 2);
  1216.     }
  1217.     return 0;
  1218. }
  1220. /******************************************************************************
  1221. * Parse the data from binary to the two byte EMI code
  1222. */
  1223. static int parse_binary_to_emi(char *from, char *to, int length)
  1224. {
  1225.     char buf[10];
  1226.     char *ptr;
  1228.     if (!from || !to || length <= 0)
  1229.         return -1;
  1231.     *to = '';
  1233.     for (ptr = from; length > 0; ptr++, length--) {
  1234.         sprintf(buf, "%02X", (unsigned char)*ptr);
  1235.         strncat(to, buf, 2);
  1236.     }
  1238.     return 0;
  1239. }
  1242. /******************************************************************************
  1243. * Generate the EMI message checksum
  1244. */
  1245. static void generate_checksum(const unsigned char *buf, unsigned char *out)
  1246. {
  1247.     const unsigned char *p;
  1248.     int j;
  1250.     j = 0;
  1251.     for (p = buf; *p != ''; p++) {
  1252.         j += *p;
  1254.         if (j >= 256)
  1255.             j -= 256;
  1256.     }
  1258.     sprintf(out, "%02X", j);
  1259. }
  1263. /******************************************************************************
  1264. * Translate character from iso to emi_mt
  1265. * PGr鰊holm
  1266. */
  1267. static char char_iso_to_sms(unsigned char from, int alt_charset)
  1268. {
  1270.     switch ((char)from) {
  1272.     case 'A':
  1273.         return 0x41;
  1274.     case 'B':
  1275.         return 0x42;
  1276.     case 'C':
  1277.         return 0x43;
  1278.     case 'D':
  1279.         return 0x44;
  1280.     case 'E':
  1281.         return 0x45;
  1282.     case 'F':
  1283.         return 0x46;
  1284.     case 'G':
  1285.         return 0x47;
  1286.     case 'H':
  1287.         return 0x48;
  1288.     case 'I':
  1289.         return 0x49;
  1290.     case 'J':
  1291.         return 0x4A;
  1292.     case 'K':
  1293.         return 0x4B;
  1294.     case 'L':
  1295.         return 0x4C;
  1296.     case 'M':
  1297.         return 0x4D;
  1298.     case 'N':
  1299.         return 0x4E;
  1300.     case 'O':
  1301.         return 0x4F;
  1302.     case 'P':
  1303.         return 0x50;
  1304.     case 'Q':
  1305.         return 0x51;
  1306.     case 'R':
  1307.         return 0x52;
  1308.     case 'S':
  1309.         return 0x53;
  1310.     case 'T':
  1311.         return 0x54;
  1312.     case 'U':
  1313.         return 0x55;
  1314.     case 'V':
  1315.         return 0x56;
  1316.     case 'W':
  1317.         return 0x57;
  1318.     case 'X':
  1319.         return 0x58;
  1320.     case 'Y':
  1321.         return 0x59;
  1322.     case 'Z':
  1323.         return 0x5A;
  1325.     case 'a':
  1326.         return 0x61;
  1327.     case 'b':
  1328.         return 0x62;
  1329.     case 'c':
  1330.         return 0x63;
  1331.     case 'd':
  1332.         return 0x64;
  1333.     case 'e':
  1334.         return 0x65;
  1335.     case 'f':
  1336.         return 0x66;
  1337.     case 'g':
  1338.         return 0x67;
  1339.     case 'h':
  1340.         return 0x68;
  1341.     case 'i':
  1342.         return 0x69;
  1343.     case 'j':
  1344.         return 0x6A;
  1345.     case 'k':
  1346.         return 0x6B;
  1347.     case 'l':
  1348.         return 0x6C;
  1349.     case 'm':
  1350.         return 0x6D;
  1351.     case 'n':
  1352.         return 0x6E;
  1353.     case 'o':
  1354.         return 0x6F;
  1355.     case 'p':
  1356.         return 0x70;
  1357.     case 'q':
  1358.         return 0x71;
  1359.     case 'r':
  1360.         return 0x72;
  1361.     case 's':
  1362.         return 0x73;
  1363.     case 't':
  1364.         return 0x74;
  1365.     case 'u':
  1366.         return 0x75;
  1367.     case 'v':
  1368.         return 0x76;
  1369.     case 'w':
  1370.         return 0x77;
  1371.     case 'x':
  1372.         return 0x78;
  1373.     case 'y':
  1374.         return 0x79;
  1375.     case 'z':
  1376.         return 0x7A;
  1378.     case '0':
  1379.         return 0x30;
  1380.     case '1':
  1381.         return 0x31;
  1382.     case '2':
  1383.         return 0x32;
  1384.     case '3':
  1385.         return 0x33;
  1386.     case '4':
  1387.         return 0x34;
  1388.     case '5':
  1389.         return 0x35;
  1390.     case '6':
  1391.         return 0x36;
  1392.     case '7':
  1393.         return 0x37;
  1394.     case '8':
  1395.         return 0x38;
  1396.     case '9':
  1397.         return 0x39;
  1398.     case ':':
  1399.         return 0x3A;
  1400.     case ';':
  1401.         return 0x3B;
  1402.     case '<':
  1403.         return 0x3C;
  1404.     case '=':
  1405.         return 0x3D;
  1406.     case '>':
  1407.         return 0x3E;
  1408.     case '?':
  1409.         return 0x3F;
  1411.     case '