cmppcode.c

cmpp 发送接收短信息程序！是在linux下c 实现的。

/*******************************************************
    NAME:      cmppcode.c
    PURPOSE:   China Mobile Peer to Peer Protocol 2.0
               Permanent connection implementation to
               submit data to Internet Short Message Gateway
               or deliver data from ISMG to upper layer.

               Protocol Data Unit encoding/decoding implementation.

    VERSION:   0.0.1
    AUTHOR:    Ke Heng Zhong
    DATE:      2002/06/17 12:52
    MODIFIED:  2000/06/17 21:12
 ********************************************************/

#include "kevopsall.ext"
#include "cmpp.h"


extern VTASK * gEntity;


int cmpdu_size (uint32 type)
{
    CmppPdu pdu;
    int size = -1;

    size = sizeof(pdu);
/*
    switch (type) {
    case CMPP_CONNECT:
        size = sizeof(pdu.Connect);
        break;

    case CMPP_CONNECT_RESP:
        size = sizeof(pdu.ConnectResp);
        break;

    case CMPP_TERMINATE:
        size = 0;
        break;

    case CMPP_TERMINATE_RESP:
        size = 0;
        break;

    case CMPP_SUBMIT:
        size = sizeof(pdu.Submit);
        break;

    case CMPP_SUBMIT_RESP:
        size = sizeof(pdu.SubmitResp);
        break;

    case CMPP_DELIVER:
        size = sizeof(pdu.Deliver);
        break;

    case CMPP_DELIVER_RESP:
        size = sizeof(pdu.DeliverResp);
        break;

    case CMPP_QUERY:
        size = sizeof(pdu.Query);
        break;

    case CMPP_QUERY_RESP:
        size = sizeof(pdu.QueryResp);
        break;

    case CMPP_CANCEL:
        size = sizeof(pdu.Cancel);
        break;

    case CMPP_CANCEL_RESP:
        size = sizeof(pdu.CancelResp);
        break;

    case CMPP_ACTIVE_TEST:
        size = 0;
        break;

    case CMPP_ACTIVE_TEST_RESP:
        size = 0;
        break;

    default:
        size = -1;
    }
*/
    return size;
}



CmppPdu * cmpdu_alloc (uint32 type)
{
    CmppPdu * pdu = NULL;

/*
info("\n$$$$$$$$$$$$$$$cmpde_alloc invoked, command:0x%x\n", type);
*/

    pdu = (CmppPdu *)kzalloc(sizeof(*pdu));
    if (!pdu) return NULL;

    pdu->command_id = type;

/*
info("$$$$$$$$$$$$$$$cmpde_alloc invoked, command:0x%x, size=%d, pdu=%p\n", 
   pdu->command_id, sizeof(*pdu), pdu);
*/

    return pdu;
}


void cmpdu_free (CmppPdu * pdu)
{
    if (!pdu) return;

#ifdef _DEBUG
info("cmpde_free invoked, command:0x%08x, pdu=%p\n", pdu->command_id, pdu);
#endif

    switch (pdu->command_id) {
    case CMPP_CONNECT:
    case CMPP_CONNECT_RESP:
    case CMPP_TERMINATE:
    case CMPP_TERMINATE_RESP:
    case CMPP_SUBMIT_RESP:
    case CMPP_DELIVER_RESP:
    case CMPP_QUERY:
    case CMPP_QUERY_RESP:
    case CMPP_CANCEL:
    case CMPP_CANCEL_RESP:
    case CMPP_ACTIVE_TEST:
    case CMPP_ACTIVE_TEST_RESP:
        break;

    case CMPP_SUBMIT:
        deleteFrame(&pdu->Submit.dest_terminal_id);
        deleteFrame(&pdu->Submit.msg_content);
        break;

    case CMPP_DELIVER:
        deleteFrame(&pdu->Deliver.msg_content);
        break;

    default:
        break;
    }

    kfree(pdu);
    return;
}


int cmpdu_init (CmppPdu * pdu)
{
    FRAME_PTR temp1, temp2;
    int  type;

    if (!pdu) return -1;

    type = pdu->command_id;

    switch (pdu->command_id) {
    case CMPP_SUBMIT:
        temp1 = pdu->Submit.dest_terminal_id;
        temp2 = pdu->Submit.msg_content;
        emptyFrame(temp1);
        emptyFrame(temp2);
        memset(pdu, 0, sizeof(*pdu));
        pdu->Submit.dest_terminal_id = temp1;
        pdu->Submit.msg_content = temp2;
        pdu->command_id = type;
        break;
    case CMPP_DELIVER:
        temp1 = pdu->Deliver.msg_content;
        emptyFrame(temp1);
        memset(pdu, 0, sizeof(*pdu));
        pdu->Deliver.msg_content = temp1;
        pdu->command_id = type;
        break;
    case CMPP_CONNECT:
    case CMPP_CONNECT_RESP:
    case CMPP_TERMINATE:
    case CMPP_TERMINATE_RESP:
    case CMPP_SUBMIT_RESP:
    case CMPP_DELIVER_RESP:
    case CMPP_QUERY:
    case CMPP_QUERY_RESP:
    case CMPP_CANCEL:
    case CMPP_CANCEL_RESP:
    case CMPP_ACTIVE_TEST:
    case CMPP_ACTIVE_TEST_RESP:
        memset(pdu, 0, sizeof(*pdu));
        pdu->command_id = type;
        break;
    default:
        memset(pdu, 0, sizeof(*pdu));
        break;
    }

    return 0;
}



int cmpdu_encode (CmppPdu * pdu, FRAME_PTR * data)
{
    int size;
    uint32  netord = 0;

    if (!pdu || !data) return -1;

    emptyFrame (*data);

    /* encode the header of CMPP message */
    netord = htonl(pdu->total_length);
    putnLastBytes(data, (uint8 *)&netord, 4);
    netord = htonl(pdu->command_id);
    putnLastBytes(data, (uint8 *)&netord, 4);
    netord = htonl(pdu->sequence_id);
    putnLastBytes(data, (uint8 *)&netord, 4);

    switch (pdu->command_id) {
    case CMPP_CONNECT:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_CONNECT.\n", pdu->command_id);
#endif
        putnLastBytes(data, pdu->Connect.source_addr, 
                       sizeof(pdu->Connect.source_addr));
        putnLastBytes(data, pdu->Connect.auth_src, 
                       sizeof(pdu->Connect.auth_src));
        putLastByte (data, pdu->Connect.version);
        netord = htonl(pdu->Connect.time_stamp);
        putnLastBytes (data, (uint8 *)&netord, 4);
        break;

    case CMPP_CONNECT_RESP:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_CONNECT_RESP.\n", pdu->command_id);
#endif

        /* ignored by SP-side implementation */
        break;

    case CMPP_TERMINATE:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_TERMINATE.\n", pdu->command_id);
#endif
        break;

    case CMPP_TERMINATE_RESP:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_TERMINATE_RESP.\n", pdu->command_id);
#endif
        break;

    case CMPP_SUBMIT:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_SUBMIT.\n", pdu->command_id);
#endif
        putnLastBytes (data, (uint8 *)&pdu->Submit.msg_id, 
                          sizeof(pdu->Submit.msg_id));
        putLastByte   (data, pdu->Submit.pk_total);
        putLastByte   (data, pdu->Submit.pk_number);
        putLastByte   (data, pdu->Submit.reg_delivery);
        putLastByte   (data, pdu->Submit.msg_level);
        putnLastBytes (data, pdu->Submit.service_id, 
                            sizeof(pdu->Submit.service_id));
        putLastByte   (data, pdu->Submit.fee_usertype);
        putnLastBytes (data, pdu->Submit.fee_terminal_id,
                            sizeof(pdu->Submit.fee_terminal_id));
        putLastByte   (data, pdu->Submit.tp_pid);
        putLastByte   (data, pdu->Submit.tp_udhi);
        putLastByte   (data, pdu->Submit.msg_fmt);
        putnLastBytes (data, pdu->Submit.msg_src, 
                            sizeof(pdu->Submit.msg_src));
        putnLastBytes (data, pdu->Submit.feetype, 
                            sizeof(pdu->Submit.feetype));
        putnLastBytes (data, pdu->Submit.feecode, 
                            sizeof(pdu->Submit.feecode));
        putnLastBytes (data, pdu->Submit.valid_time, 
                            sizeof(pdu->Submit.valid_time));
        putnLastBytes (data, pdu->Submit.at_time,  
                            sizeof(pdu->Submit.at_time));
        putnLastBytes (data, pdu->Submit.src_id, 
                            sizeof(pdu->Submit.src_id));
        putLastByte   (data, pdu->Submit.destusr_tl);
        appendFrame   (data, pdu->Submit.dest_terminal_id);
        putLastByte   (data, pdu->Submit.msg_length);
        appendFrame   (data, pdu->Submit.msg_content);
        appendnBytes  (data, '\0', 8);
        break;

    case CMPP_SUBMIT_RESP:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_SUBMIT_RESP.\n", pdu->command_id);
#endif
        /* ignored by SP-side implementation */
        break;

    case CMPP_DELIVER:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_DELIVER.\n", pdu->command_id);
#endif
        /*putLastByte (data, ); added temperoryily*/
        /* ignored by SP-side implementation */
        break;

    case CMPP_DELIVER_RESP:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_DELIVER_RESP.\n", pdu->command_id);
#endif
        putnLastBytes (data, pdu->DeliverResp.msg_id, 
                          sizeof(pdu->DeliverResp.msg_id));
        putLastByte   (data, pdu->DeliverResp.result);
        break;

    case CMPP_QUERY:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_QUERY.\n", pdu->command_id);
#endif
        break;

    case CMPP_QUERY_RESP:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_QUERY_RESP.\n", pdu->command_id);
#endif
        /* ignored by SP-side implementation */
        break;

    case CMPP_CANCEL:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_CANCEL.\n", pdu->command_id);
#endif
        putnLastBytes  (data, pdu->Cancel.msg_id, 
                           sizeof(pdu->Cancel.msg_id));
        break;

    case CMPP_CANCEL_RESP:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_CANCEL_RESP.\n", pdu->command_id);
#endif
        /* ignored by SP-side implementation */
        break;

    case CMPP_ACTIVE_TEST:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_ACTIVE_TEST.\n", pdu->command_id);
#endif
        break;

    case CMPP_ACTIVE_TEST_RESP:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  CMPP_ACTIVE_TEST_RESP.\n", pdu->command_id);
#endif
        putLastByte (data, '\0');
        break;

    default:
#ifdef _DEBUG
info("cmpdu_encode: pdu type 0x%08x  UNKNOWN.\n", pdu->command_id);
#endif
        break;
    }

    size = frameLength(*data);
    size = htonl(size);
    setnBytes(*data, 0, (uint8 *)&size, 4);

#ifdef _DEBUG
info("cmpp_encode: encode pdu 0x%08x bytes %d:\n", pdu->command_id, frameLength(*data));
printFrame(INFO, *data, 0);
#endif

    return 0;
}


CmppPdu * cmpdu_decode (FRAME_PTR * data)
{
    CmppPdu * pdu = NULL;
    uint32    cmdid = 0;

#ifdef _DEBUG
info("cmpdu_decode begin...\n");
#endif

    if (!data || frameLength(*data)==0) 
        return NULL;

    getnFirstBytes (data, (uint8 *)&cmdid, 4);
    cmdid = ntohl(cmdid);

    if (cmdid == CMPP_SUBMIT_RESP) {
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_SUBMIT_RESP.\n");
#endif
        pdu = get_recycle_submitresp_pdu(gEntity);
        if (pdu)
            cmpdu_init (pdu);
    } else if (cmdid == CMPP_DELIVER) {
	pdu = get_recycle_deliver_pdu(gEntity);
	if (pdu)
	    cmpdu_init (pdu);
    }

    if (!pdu)
        pdu = cmpdu_alloc (cmdid);
    if (!pdu) return NULL;

    getnFirstBytes (data, (uint8 *)&pdu->sequence_id, 4);
    pdu->sequence_id = ntohl(pdu->sequence_id);

    switch (cmdid) {
    case CMPP_CONNECT:
        /* ignored by SP-side implementation */
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_CONNECT.\n");
#endif
        break;

    case CMPP_CONNECT_RESP:
        pdu->ConnectResp.status = getFirstByte (data);
        getnFirstBytes (data, (uint8 *)&pdu->ConnectResp.auth_ismg, 
                         sizeof(pdu->ConnectResp.auth_ismg));
        pdu->ConnectResp.version = getFirstByte (data);

#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_CONNECT_RESP.\n");
#endif
        break;

    case CMPP_TERMINATE:
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_TERMINATE.\n");
#endif
        break;

    case CMPP_TERMINATE_RESP:
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_TERMINATE_RESP.\n");
#endif
        break;

    case CMPP_SUBMIT:
        /* ignored by SP-side implementation */
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_SUBMIT.\n");
#endif
        break;

    case CMPP_SUBMIT_RESP:
        getnFirstBytes (data, (uint8 *)&pdu->SubmitResp.msg_id, 
                         sizeof(pdu->SubmitResp.msg_id));
        pdu->SubmitResp.result = getFirstByte (data);
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_SUBMIT_RESP.\n");
#endif
        break;

    case CMPP_DELIVER:
        getnFirstBytes (data, (uint8 *)pdu->Deliver.msg_id,
                         sizeof(pdu->Deliver.msg_id));
        getnFirstBytes (data, (uint8 *)pdu->Deliver.dest_id,
                         sizeof(pdu->Deliver.dest_id));
        getnFirstBytes (data, (uint8 *)pdu->Deliver.service_id,
                         sizeof(pdu->Deliver.service_id));
        pdu->Deliver.tp_pid = getFirstByte (data);
        pdu->Deliver.tp_udhi = getFirstByte (data);
        pdu->Deliver.msg_fmt = getFirstByte (data);
        getnFirstBytes (data, (uint8 *)pdu->Deliver.src_terminal_id, 
                          sizeof(pdu->Deliver.src_terminal_id));
        pdu->Deliver.reg_delivery = getFirstByte (data);
        pdu->Deliver.msg_length = getFirstByte (data);
	
	emptyFrame(pdu->Deliver.msg_content);
	appendFrameBytes(&pdu->Deliver.msg_content, *data, 
			 0, (int)pdu->Deliver.msg_length);
        /*pdu->Deliver.msg_content = splitFrame(data, 
                                         (int)pdu->Deliver.msg_length);*/
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_DELIVER.\n");
#endif
        break;

    case CMPP_DELIVER_RESP:
        /* ignored by SP-side implementation */
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_DELIVER_RESP.\n");
#endif
        break;

    case CMPP_QUERY:
        /* ignored by SP-side implementation */
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_QUERY.\n");
#endif
        break;

    case CMPP_QUERY_RESP:
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_QUERY_RESP.\n");
#endif
        break;

    case CMPP_CANCEL:
        /* ignored by SP-side implementation */
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_CANCEL.\n");
#endif
        break;

    case CMPP_CANCEL_RESP:
        pdu->CancelResp.success_id = getFirstByte (data);
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_CANCEL_RESP.\n");
#endif
        break;

    case CMPP_ACTIVE_TEST:
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_ACTIVE_TEST.\n");
#endif
        break;

    case CMPP_ACTIVE_TEST_RESP:
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_ACTIVE_TEST___RESP.\n");
#endif
        break;

    default:
#ifdef _DEBUG
info("cmpdu_decode: cmdid=CMPP_UNKNOWN.\n");
#endif
        break;
    }

    return pdu;
}