smsc_emi_x25.c

The Kannel Open Source WAP and SMS gateway works as both an SMS gateway, for implementing keyword b

        if (strcmp(emivars[7], "2") == 0) {
            strcpy(isotext, emivars[8]);
        } else if (strcmp(emivars[7], "3") == 0) {
            parse_emi_to_iso88591(emivars[8], isotext, sizeof(isotext),
                                  smsc->alt_charset);
        } else {
            error(0, "Unknown 01-type EMI SMS (%s)", emivars[7]);
            strcpy(isotext, "");
        }
    } else if (strcmp(emivars[3], "51") == 0) {
        parse_emi_to_iso88591(emivars[24], isotext, sizeof(isotext),
                              smsc->alt_charset);
    } else if (strcmp(emivars[3], "52") == 0) {
        parse_emi_to_iso88591(emivars[24], isotext, sizeof(isotext),
                              smsc->alt_charset);
    } else {
        error(0, "HEY WE SHOULD NOT BE HERE!! Type = %s", emivars[3]);
        strcpy(isotext, "");
    }

    *msg = msg_create(sms);
    if (*msg == NULL) goto error;

    (*msg)->sms.sender = octstr_create(emivars[5]);
    (*msg)->sms.receiver = octstr_create(emivars[4]);
    (*msg)->sms.msgdata = octstr_create(isotext);
    (*msg)->sms.udhdata = NULL;

    return msgnbr;

error:
    return -1;
}

/*
 * notify the SMSC that we got the message
 */
static int acknowledge_from_rawmessage(SMSCenter *smsc,
                                       char *rawmessage, int length)
{

    char emivars[128][1024];
    char timestamp[2048], sender[2048], receiver[2048];
    char emitext[2048], isotext[2048];
    char *leftslash, *rightslash;
    int msgnbr;
    int tmpint;
    int is_backup = 0;

    msgnbr = -1;
    memset(&sender, 0, sizeof(sender));
    memset(&receiver, 0, sizeof(receiver));
    memset(&emitext, 0, sizeof(emitext));
    memset(&isotext, 0, sizeof(isotext));
    memset(&timestamp, 0, sizeof(timestamp));

    strncpy(isotext, rawmessage, length);
    leftslash = isotext;

    if (isotext[length - 1] == 'X')
        is_backup = 1;

    for (tmpint = 0; leftslash != NULL; tmpint++) {
        rightslash = strchr(leftslash + 1, '/');

        if (rightslash == NULL)
            rightslash = strchr(leftslash + 1, '\3');

        if (rightslash == NULL)
            break;

        *rightslash = '\0';
        strcpy(emivars[tmpint], leftslash + 1);
        leftslash = rightslash;
    }

    /* BODY */
    sprintf(isotext, "A//%s:%s", emivars[4], emivars[18]);
    sprintf(isotext, "A//%s:", emivars[5]);
    is_backup = 0;

    /* HEADER */

    debug("bb.sms.emi", 0, "acknowledge: type = '%s'", emivars[3]);

    sprintf(emitext, "%s/%05i/%s/%s", emivars[0], (int) strlen(isotext) + 17,
            "R", emivars[3]);

    smsc->emi_current_msg_number = atoi(emivars[0]) + 1;

    /* FOOTER */
    sprintf(timestamp, "%s/%s/", emitext, isotext);
    generate_checksum(timestamp, receiver);

    sprintf(sender, "%c%s/%s/%s%c", 0x02, emitext, isotext, receiver, 0x03);
    put_data(smsc, sender, strlen(sender), is_backup);

    return msgnbr;

}


/******************************************************************************
* Parse the Msg structure to the raw message format
*/
static int parse_msg_to_rawmessage(SMSCenter *smsc, Msg *msg, char *rawmessage, int rawmessage_length)
{
    char message_whole[10*1024];
    char message_body[10*1024];
    char message_header[1024];
    char message_footer[1024];

    char my_buffer[10*1024];
    char my_buffer2[10*1024];
    char msgtext[1024];
    int length;
    char mt;
    char mcl[20];
    char snumbits[20];
    char xser[1024];
    int udh_len;

    memset(&message_whole, 0, sizeof(message_whole));
    memset(&message_body, 0, sizeof(message_body));
    memset(&message_header, 0, sizeof(message_header));
    memset(&message_footer, 0, sizeof(message_footer));
    memset(&my_buffer, 0, sizeof(my_buffer));
    memset(&my_buffer2, 0, sizeof(my_buffer2));
    mt = '3';
    memset(&snumbits, 0, sizeof(snumbits));
    memset(&xser, 0, sizeof(xser));

    /* XXX parse_iso88591_to_emi shouldn't use NUL terminated
     * strings, but Octstr directly, or a char* and a length.
     */
    if (octstr_len(msg->sms.udhdata)) {
        char xserbuf[258];
        /* we need a properly formated UDH here, there first byte contains his length
         * this will be formatted in the xser field of the EMI Protocol
         */
        udh_len = octstr_get_char(msg->sms.udhdata, 0) + 1;
        xserbuf[0] = 1;
        xserbuf[1] = udh_len;
        octstr_get_many_chars(&xserbuf[2], msg->sms.udhdata, 0, udh_len);
        parse_binary_to_emi(xserbuf, xser, udh_len + 2);
    } else {
        udh_len = 0;
    }

    if (msg->sms.coding == DC_7BIT || msg->sms.coding == DC_UNDEF) {
        octstr_get_many_chars(msgtext, msg->sms.msgdata, 0, octstr_len(msg->sms.msgdata));
        msgtext[octstr_len(msg->sms.msgdata)] = '\0';
        parse_iso88591_to_emi(msgtext, my_buffer2,
                                           octstr_len(msg->sms.msgdata),
                                           smsc->alt_charset);

        strcpy(snumbits, "");
        mt = '3';
        strcpy(mcl, "");
    } else {
        octstr_get_many_chars(msgtext, msg->sms.msgdata, 0, octstr_len(msg->sms.msgdata));

        parse_binary_to_emi(msgtext, my_buffer2, octstr_len(msg->sms.msgdata));

        sprintf(snumbits, "%04ld", octstr_len(msg->sms.msgdata)*8);
        mt = '4';
        strcpy(mcl, "1");
    }

    /* XXX Where is DCS ? Is it in XSER like in emi2 ? 
     * Please someone encode it with fields_to_dcs 
     */

    sprintf(message_body,
            "%s/%s/%s/%s/%s//%s////////////%c/%s/%s////%s//////%s//",
            octstr_get_cstr(msg->sms.receiver),
            msg->sms.sender ? octstr_get_cstr(msg->sms.sender) : "",
            "",
            "",
            "",
            "0100",
            mt,
            snumbits,
            my_buffer2,
            mcl,
            xser);

    /* HEADER */

    length = strlen(message_body);
    length += 13;  /* header (fixed) */
    length += 2;  /* footer (fixed) */
    length += 2;  /* slashes between header, body, footer */

    sprintf(message_header, "%02i/%05i/%s/%s", (smsc->emi_current_msg_number++ % 100), length, "O", "51");

    /* FOOTER */

    sprintf(my_buffer, "%s/%s/", message_header, message_body);
    generate_checksum(my_buffer, message_footer);

    sprintf(message_whole, "%c%s/%s/%s%c", 0x02, message_header, message_body, message_footer, 0x03);

    strncpy(rawmessage, message_whole, rawmessage_length);

    if (smsc->type == SMSC_TYPE_EMI_X25) {
        /* IC3S braindead EMI stack chokes on this... must fix it at the next time... */
        strcat(rawmessage, "\r");
    }
    debug("bb.sms.emi", 0, "emi %d message %s",
          smsc->emi_current_msg_number, rawmessage);
    return strlen(rawmessage);
}

/******************************************************************************
* Parse the data from the two byte EMI code to normal ISO-8869-1
*/
static int parse_emi_to_iso88591(char *from, char *to, int length,
                                 int alt_charset)
{
    int hmtg = 0;
    unsigned int mychar;
    char tmpbuff[128];

    for (hmtg = 0; hmtg <= (int)strlen(from); hmtg += 2) {
        strncpy(tmpbuff, from + hmtg, 2);
        sscanf(tmpbuff, "%x", &mychar);
        to[hmtg / 2] = char_sms_to_iso(mychar, alt_charset);
    }

    to[(hmtg / 2)-1] = '\0';

    return 0;

}

/******************************************************************************
* Parse the data from normal ISO-8869-1 to the two byte EMI code
*/
static int parse_iso88591_to_emi(char *from, char *to,
        int length, int alt_charset)
{
    char buf[10];
    unsigned char tmpchar;
    char *ptr;

    if (!from || !to || length <= 0)
        return -1;

    *to = '\0';

    debug("bb.sms.emi", 0, "emi parsing <%s> to emi, length %d", from, length);

    for (ptr = from; length > 0; ptr++, length--) {
        tmpchar = char_iso_to_sms(*ptr, alt_charset);
        sprintf(buf, "%02X", tmpchar);
        strncat(to, buf, 2);
    }
    return 0;
}

/******************************************************************************
* Parse the data from binary to the two byte EMI code
*/
static int parse_binary_to_emi(char *from, char *to, int length)
{
    char buf[10];
    char *ptr;

    if (!from || !to || length <= 0)
        return -1;

    *to = '\0';

    for (ptr = from; length > 0; ptr++, length--) {
        sprintf(buf, "%02X", (unsigned char)*ptr);
        strncat(to, buf, 2);
    }

    return 0;
}


/******************************************************************************
* Generate the EMI message checksum
*/
static void generate_checksum(const unsigned char *buf, unsigned char *out)
{
    const unsigned char *p;
    int	j;

    j = 0;
    for (p = buf; *p != '\0'; p++) {
        j += *p;

        if (j >= 256)
            j -= 256;
    }

    sprintf(out, "%02X", j);
}



/******************************************************************************
* Translate character from iso to emi_mt
* PGr鰊holm
*/
static char char_iso_to_sms(unsigned char from, int alt_charset)
{

    switch ((char)from) {

    case 'A':
        return 0x41;
    case 'B':
        return 0x42;
    case 'C':
        return 0x43;
    case 'D':
        return 0x44;
    case 'E':
        return 0x45;
    case 'F':
        return 0x46;
    case 'G':
        return 0x47;
    case 'H':
        return 0x48;
    case 'I':
        return 0x49;
    case 'J':
        return 0x4A;
    case 'K':
        return 0x4B;
    case 'L':
        return 0x4C;
    case 'M':
        return 0x4D;
    case 'N':
        return 0x4E;
    case 'O':
        return 0x4F;
    case 'P':
        return 0x50;
    case 'Q':
        return 0x51;
    case 'R':
        return 0x52;
    case 'S':
        return 0x53;
    case 'T':
        return 0x54;
    case 'U':
        return 0x55;
    case 'V':
        return 0x56;
    case 'W':
        return 0x57;
    case 'X':
        return 0x58;
    case 'Y':
        return 0x59;
    case 'Z':
        return 0x5A;

    case 'a':
        return 0x61;
    case 'b':
        return 0x62;
    case 'c':
        return 0x63;
    case 'd':
        return 0x64;
    case 'e':
        return 0x65;
    case 'f':
        return 0x66;
    case 'g':
        return 0x67;
    case 'h':
        return 0x68;
    case 'i':
        return 0x69;
    case 'j':
        return 0x6A;
    case 'k':
        return 0x6B;
    case 'l':
        return 0x6C;
    case 'm':
        return 0x6D;
    case 'n':
        return 0x6E;
    case 'o':
        return 0x6F;
    case 'p':
        return 0x70;
    case 'q':
        return 0x71;
    case 'r':
        return 0x72;
    case 's':
        return 0x73;
    case 't':
        return 0x74;
    case 'u':
        return 0x75;
    case 'v':
        return 0x76;
    case 'w':
        return 0x77;
    case 'x':
        return 0x78;
    case 'y':
        return 0x79;
    case 'z':
        return 0x7A;

    case '0':
        return 0x30;
    case '1':
        return 0x31;
    case '2':
        return 0x32;
    case '3':
        return 0x33;
    case '4':
        return 0x34;
    case '5':
        return 0x35;
    case '6':
        return 0x36;
    case '7':
        return 0x37;
    case '8':
        return 0x38;
    case '9':
        return 0x39;
    case ':':
        return 0x3A;
    case ';':
        return 0x3B;
    case '<':
        return 0x3C;
    case '=':
        return 0x3D;
    case '>':
        return 0x3E;
    case '?':
        return 0x3F;

    case '