CMPP短信网关客户端发送程序

最新推荐文章于 2022-02-28 16:03:49 发布
最新推荐文章于 2022-02-28 16:03:49 发布
阅读量589 收藏
点赞数
分类专栏： c/c++/c# 文章标签： Linux GCC Socket Ubuntu RedHat

最近无聊，玩了玩ubuntu，想学点linux,找了几年前写的老代码，编译竟然不通过，就作了点修改。
原来的代码是2002年在红旗下编译通过的，不记得是哪个版本了。和现在不同的地方有
gettimeofday()定义变动
write(),read()等头文件包含不同
pthread_create()中，新的线程变成了void* (*)(void*)类型，感觉更合理了。
化了点时间修改了，在ubuntu5.1下通过编译。

因为是02年写的，当时刚出cmpp2.0，运行是没有问题，只是实现了收发消息的主要功能。而且当时系统主要是在2000下做的，在linux下我经验不多，所以也写不出太高水平的东西，但这个代码相信可以给你帮助。

1.文件cmppapi.c

/*

        腾思CMPP2.0接口程序

        作者：刘斌([email]liubinbj@sohu.com[/email])

        版本：1.01 (linux)

        最后修订：2002/9/30


        2006/05/09日在ubuntu5.1环境下修改了原代码，以适应新的编译环境gcc-4.0
        增加了makefile文件

       

*/
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <stdio.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
/*add on 2006/05/08 for gettimeofday() */
#include <sys/time.h>
/*add for read() write() close() 2006/05/09*/
#include <unistd.h>
/*add for kill()*/
#include <signal.h>


#include "cmpp_message_packet.h"

#define CMPP_SUBMIT_RESPONSE         (1)
#define CMPP_CONNECT_RESPONSE        (2)
#define CMPP_ACTIVE_RESPONSE        (3)
#define CMPP_DELIVER                        (4)
#define CMPP_LINK_ERROR                        (5)
#define CMPP_NONE_RESPONSE                (-1)

int        sockfd;

int         bIsConnected=0;
int                LogStatus=-1;
int                SequenceNum=0;
char        buf[]="abcdefghij";

int         ReturnPackType        =        -1;
int                SubmitResult        =        -1;
int                LoginResult                =        -1;

pthread_t                         ReadThreadID;
pthread_mutex_t         Mutex        =        PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t                 Cond        =        PTHREAD_COND_INITIALIZER;

pthread_mutex_t                Mutex2        =        PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t                Cond2        =        PTHREAD_COND_INITIALIZER;

struct _Deliver_Pack{
        char Phone[12];
        char Dest[15];
        char Message[161];
       
}DeliverPack;


/*Get new id*/
int GetNewSeq()
{
        return         (SequenceNum < 0x7fffffff )? (++SequenceNum):(SequenceNum=1);
}

int Send(int socketnum,unsigned char *buf,int len)
{
        int pos=0;
        int nRet=0;
        while(pos<len)
        {

                nRet=write(socketnum,buf+pos,len-pos);
               
                if(nRet==0)
                {
                        bIsConnected=0;
                        LogStatus=-1;
                        close(sockfd);
                        return -2;
                }
                else if(nRet==-1)
                {
                        bIsConnected=0;
                        LogStatus=-1;
                        close(sockfd);
                        return -1;
                }
                else
                {
                        pos+=nRet;
                        if(pos!=len)
                        {
                                continue;
                        }
                        else
                        {
                                return pos;
                        }
                }
        }
}
/*ok*/
int MoveAhead(unsigned char *buf,int oldbuflen,int movecount)
{
        int i;
        if(oldbuflen == movecount)
                return 0;
        for(i=0; i<movecount; i++)
        {
                *(buf+i)=*(buf+i+movecount);
        }
        return oldbuflen-movecount;
}

/*ok*/
/*2.6的线程模型改动了*/
/*void ReadThread(void)*/
void* ReadThread(void* data)
{
        unsigned char readbuf[7000];
        int head=0;
        int ret=0;
        int PackType;

        unsigned char *ptr;
        unsigned char  *pMsg_id,*pRegistered_delivery;
        unsigned char  *pService_id;
        unsigned char  *pTp_pid,*pTp_udhi,*pMsg_fmt;
        unsigned char  *pSrc_terminal_id;
        unsigned char  *pMsg_Length,*pMsg_Content;
        unsigned char  *pDestnation_id;
        memset(readbuf,0,7000);
        while(1)
        {
                ret=read(sockfd,readbuf+head,7000-head);
                if(ret==-1)
                {
                        if(errno!=EWOULDBLOCK)
                        {
                               
                                bIsConnected=0;
                                LogStatus=-1;
                                close(sockfd);
                                sockfd=0;
                                pthread_mutex_lock(&Mutex2);
                                ReturnPackType=CMPP_LINK_ERROR;
                                pthread_cond_signal(&Cond2);
                                pthread_mutex_unlock(&Mutex2);
                                /*return;*/
                                pthread_exit(NULL);//2.6
                        }
                        continue;
                }
                else if(ret==0)
                {
                        bIsConnected=0;
                        LogStatus=-1;
                        close(sockfd);
                        sockfd=0;
                        pthread_mutex_lock(&Mutex2);
                        ReturnPackType=CMPP_LINK_ERROR;
                        pthread_cond_signal(&Cond2);
                        pthread_mutex_unlock(&Mutex2);
                        /*return;*/
                        pthread_exit(NULL);
                }
                else
                {
                        head+=ret;
                        while(head>0)
                        {
                                if(head>=6999)
                                {
                                        head=0;
                                        continue;/*abandon data*/
                                }
                               
                                if(head>0 && head<12)
                                {
                                        head=0;
                                        continue;/*abandon data*/
                                }
                                else
                                {
                                        _CMPP_MsgHead_Pack PackHead;
                                        memset(&PackHead,0,sizeof(PackHead));
                                        memcpy(&PackHead,readbuf,12);
                                        if(ntohl(PackHead.Total_Length)>head)
                                        {
                                                head=0;
                                                continue;/*abandon data*/
                                        }
                                       
                                        if(ntohl(PackHead.Command_ID)==CMPP_Connect_REP)
                                                PackType= CMPP_CONNECT_RESPONSE;
                                        else if(ntohl(PackHead.Command_ID)==CMPP_Submit_REP)
                                                PackType= CMPP_SUBMIT_RESPONSE;
                                        else if(ntohl(PackHead.Command_ID)==CMPP_Active_Test_REP)
                                                PackType= CMPP_ACTIVE_RESPONSE;
                                        else if(ntohl(PackHead.Command_ID)==CMPP_Deliver)
                                                PackType= CMPP_DELIVER;
                                        else PackType=CMPP_NONE_RESPONSE;
                                       
                                        /*get PackType*/
                                        if(PackType==CMPP_SUBMIT_RESPONSE)
                                        {
                                                _CMPP_Submit_REP_Pack csrp;
                                                memcpy(&csrp,readbuf,sizeof(csrp));
                                                if(ntohl(csrp.Total_Length)<23||ntohl(csrp.Total_Length)>25)
                                                {
                                                        head=MoveAhead(readbuf,head,ntohl(csrp.Total_Length));/*not a legal packet*/
                                                        continue;
                                                }
                                                else        /*legal packet*/
                                                {
                                                        pthread_mutex_lock(&Mutex);/*lock right away*/
                                                        ReturnPackType=CMPP_SUBMIT_RESPONSE;/*erase mark*/
                                                        SubmitResult=csrp.Result;
                                                        head=MoveAhead(readbuf,head,ntohl(csrp.Total_Length));/*not a legal packet*/
                                                        pthread_cond_signal(&Cond);
                                                        pthread_mutex_unlock(&Mutex);
                                                        continue;
                                                }
                                        }
                                        else if(PackType==CMPP_CONNECT_RESPONSE)
                                        {
                                                _CMPP_Connect_REP_Pack ccrp;
                                                memcpy(&ccrp,readbuf,sizeof(ccrp));
                                                if(ntohl(ccrp.Total_Length)!=30)
                                                {
                                                        head=MoveAhead(readbuf,head,ntohl(ccrp.Total_Length));/*not a legal packet*/
                                                        continue;
                                                }
                                                else        /*legal packet*/
                                                {
                                                       
                                                        pthread_mutex_lock(&Mutex);/*lock right away*/
                                                        ReturnPackType=CMPP_CONNECT_RESPONSE;/*erase mark*/
                                                        LoginResult=ccrp.Status;
                                                        pthread_cond_signal(&Cond);
                                                        head=MoveAhead(readbuf,head,ntohl(ccrp.Total_Length));/*moved used packet*/
                                                        pthread_mutex_unlock(&Mutex);
                                                        continue;
                                                }
                                               
                                        }
                                        else if(PackType==CMPP_ACTIVE_RESPONSE)
                                        {
                                                 _CMPP_Active_Test_REP_Pack catrp;
                                                memcpy(&catrp,readbuf,sizeof(catrp));
                                                if(ntohl(catrp.Total_Length)!=13)
                                                {
                                                        head=MoveAhead(readbuf,head,ntohl(catrp.Total_Length));/*not a legal packet*/
                                                        continue;
                                                }
                                                else        /*legal packet*/
                                                {
                                                        pthread_mutex_lock(&Mutex);/*lock right away*/
                                                        ReturnPackType=CMPP_ACTIVE_RESPONSE;/*erase mark*/
                                                        head=MoveAhead(readbuf,head,ntohl(catrp.Total_Length));/*not a legal packet*/
                                                        pthread_cond_signal(&Cond);
                                                        pthread_mutex_unlock(&Mutex);
                                                        continue;
                                                }

                                        }
                                        else if(PackType==CMPP_DELIVER)
                                        {
                                                                                               
                                                _CMPP_Deliver_Pack cdp;
                                               
                                                memcpy(&cdp,readbuf,sizeof(cdp));
                                                if(ntohl(cdp.Total_Length)>head)
                                                {
                                                        head=0;
                                                        continue;
                                                }
                                                else if(ntohl(cdp.Total_Length)>159+160)
                                                {
                                                        head=MoveAhead(readbuf,head,ntohl(cdp.Total_Length));/*not a legal packet*/
                                                        continue;       
                                                }       
                                                else
                                                {
                                                       
                                                        pthread_mutex_lock(&Mutex2);
                                                        /*set argment*/
                                                        ptr=&cdp.Free[0];
                                                        pMsg_id=ptr+0;
                                                        pDestnation_id=ptr+8;
                                                        pService_id=ptr+29;
                                                        pTp_pid=ptr+39;
                                                        pTp_udhi=ptr+40;
                                                        pMsg_fmt=ptr+41;
                                                        pSrc_terminal_id=        ptr+42;
                                                        pRegistered_delivery=ptr+63;
                                                        pMsg_Length=ptr+64;
                                                        pMsg_Content=ptr+65;

                                                        if(*pRegistered_delivery)
                                                        {
                                                                head=MoveAhead(readbuf,head,ntohl(cdp.Total_Length));/*not a legal packet*/
                                                                pthread_mutex_unlock(&Mutex2);
                                                        }
                                                        else
                                                        {
                                                                memcpy(DeliverPack.Phone,pSrc_terminal_id,11);
                                                                DeliverPack.Phone[11]=0;
                                                                memcpy(DeliverPack.Dest,pDestnation_id,14);
                                                                DeliverPack.Dest[14]=0;
                                                                memcpy(DeliverPack.Message,pMsg_Content,(*pMsg_Length)>160?160:(*pMsg_Length));

                                                                DeliverPack.Message[(*pMsg_Length)>160?160:(*pMsg_Length)]=0;
                                                                head=MoveAhead(readbuf,head,ntohl(cdp.Total_Length));
                                                                ReturnPackType=CMPP_DELIVER;
                                                                pthread_cond_signal(&Cond2);
                                                                pthread_mutex_unlock(&Mutex2);       
                                                               
                                                        }
                                                }
                                                                                               
                                        }
                                        else
                                        {
                                               
                                                _CMPP_MsgHead_Pack cmp;
                                                memcpy(&cmp,readbuf,sizeof(cmp));
                                                head=MoveAhead(readbuf,head,ntohl(cmp.Total_Length));
                                                continue;
                                               
                                        }
                                       
                                }
                       
                                head=0;
                                ret=0;
                                continue;
                        }
                }
        }
}


/*initial an connect to host*/

int ConnectHost(char *Server,int Port)
{
        struct sockaddr_in servaddr;
        int ret;
       
        if(LogStatus==0)
                LogStatus=2;
        if(bIsConnected)
                bIsConnected=1;

        if(ReadThreadID)
        {
                kill(ReadThreadID,0);
                ReadThreadID=0;
                shutdown(sockfd,0);
        }

        sockfd=socket(AF_INET,SOCK_STREAM,0);
        if(sockfd<0)
                return -1;/*create socket error*/

        memset(&servaddr,0,sizeof(struct sockaddr_in));
        servaddr.sin_family=AF_INET;
        servaddr.sin_port=htons(Port);
        if(inet_pton(AF_INET,Server,&servaddr.sin_addr)<=0)
                return -2;/*Ip Error*/
        if(connect(sockfd,(struct sockaddr*)&servaddr,sizeof(struct sockaddr_in))<0)
                return -3;/*connect error*/
        else
                bIsConnected=1;

        ret=pthread_create(&ReadThreadID,NULL,ReadThread,NULL/*传递给线程的入口参数*/);
        if(ret!=0)
                return -4;/*create thread error*/

        return 0;/*ok*/
}

/*logto server*/

int Log(char *User,char *Pass)
{
        char packbuf[30];
        _CMPP_Connect_Pack        ccp;
       
        /*make login packet*/
        struct timeval now;
        struct timezone tz; /*add on 2006/05/09 for linux 2.6.x*/
        struct timespec timeout;
        int retcode;

        int LogReturn=-1;

        if(LogStatus==0)
                return 9;/*already logged ok*/
        if(!bIsConnected)
                return 8;/*not connected*/

        memset(&ccp,0,sizeof(ccp));
        ccp.Total_Length=htonl(39);
        ccp.Command_ID=htonl(CMPP_Connect);
        SequenceNum=0;
        ccp.Sequence_ID=htonl(GetNewSeq());
        ccp.Version=0x20;
        if(strlen(User)<=6)
                strcpy((char*)(&ccp.Source_Addr[0]),User);
        else
                memcpy(&ccp.Source_Addr[0],User,6);
        if(Send(sockfd,(unsigned char*)&ccp,39)==39)
        {
                /*send ok*/
                pthread_mutex_lock(&Mutex);/*lock right away*/
                gettimeofday(&now,&tz);/*changed for 2.6*/
                timeout.tv_sec = now.tv_sec + 1;
                timeout.tv_nsec = now.tv_usec*100;

                while(ReturnPackType!=CMPP_CONNECT_RESPONSE &&retcode!=ETIMEDOUT)
                {
                        retcode=pthread_cond_timedwait(&Cond,&Mutex,&timeout);
                }
                if(retcode==ETIMEDOUT)
                {
                        LogReturn=-3;
                }
                else
                {
                        /*do something*/
                        LogReturn = LoginResult;/*log response ok*/
                        LogStatus = LoginResult;
                        LoginResult = -1;
                }
                ReturnPackType=CMPP_NONE_RESPONSE;/*erase mark*/
               
                pthread_mutex_unlock(&Mutex);/*unlock*/

                return LogReturn;
        }
        else
        {
                return -1;/*network error*/
        }
}
/*send short msg to gateway*/

int SubmitMsg(
                          char *Phone,        /*Dest*/
                          char *Content,   /*message buffer*/
                          unsigned char Length,                /*message length*/
                          char *Source,                                /*from*/
                          char* Spid,                                /*SPID*/
                          unsigned char MsgFmt,                /*message format*/
                          unsigned int Feetype,                /*Feetype*/
                          unsigned int Feecode,                /*feecode*/
                          char *ServType                        /*Server_id*/
                          )
{
        struct        timeval now;
        struct         timezone tz;
        struct        timespec timeout;
        int                retcode;

        int                SubmitReturn=0;
        _CMPP_Submit_Pack csp;
        unsigned char  *ptr;
        unsigned char  * pMsg_id,*pPk_total,*pPk_number,*pRegistered_delivery,*pMsg_level,*pService_id,*pFee_usertype,*pFee_terminal_id;
        unsigned char  * pTp_pid,*pTp_udhi,*pMsg_fmt,*pMsg_src,*pFeetype,*pFeecode,*pValid_time,*pAt_time,*pSrc_terminal_id,*pDestUsr_tl;
        unsigned char   *pDest_terminal_id,*pMsg_Length,*pMsg_Content;/* *pReserve; */

        if(strlen(Phone) !=11 || (Length>160) || (Length>140 &&MsgFmt==4) || strlen(ServType)>10)
                return -4;

        memset(&csp,0,sizeof(csp));
        ptr= &csp.Free[0];
        pMsg_id=ptr+0;
        pPk_total=ptr+8;
        pPk_number=ptr+9;
        pRegistered_delivery=ptr+10;
        pMsg_level=ptr+11;
        pService_id=ptr+12;
        pFee_usertype=ptr+22;
        pFee_terminal_id=ptr+23;
        pTp_pid=ptr+44;
        pTp_udhi=ptr+45;
        pMsg_fmt=ptr+46;
        pMsg_src=ptr+47;
        pFeetype=ptr+53;
        pFeecode=ptr+55;
        pValid_time=ptr+61;
        pAt_time=ptr+78;
        pSrc_terminal_id=ptr+95;
        pDestUsr_tl=ptr+116;
        pDest_terminal_id=ptr+117;
        pMsg_Length=ptr+138;
        pMsg_Content=ptr+139;

        *pMsg_fmt=MsgFmt;

        *pDestUsr_tl=1;
        *pPk_total=1;
        *pPk_number=1;
        *pMsg_level=1;
        *pRegistered_delivery=0;

        strcpy((char*)pService_id,ServType);
        strcpy((char*)pDest_terminal_id,Phone);
        *pMsg_Length=Length;
        strcpy((char*)pMsg_src,Spid);

        strcpy((char*)pSrc_terminal_id,Source);

        switch(Feetype)
        {
        case 0:
                memcpy(pFeetype,"00",2);break;
        case 1:
                memcpy(pFeetype,"01",2);break;
        case 2:
                memcpy(pFeetype,"02",2);break;
        case 3:
                memcpy(pFeetype,"03",2);break;
        case 4:
                memcpy(pFeetype,"04",2);break;
        case 5:
                memcpy(pFeetype,"05",2);break;
        default :
                memcpy(pFeetype,"02",2);break;
        }
       
        memcpy(pMsg_Content,Content,Length);

        sprintf((char*)pFeecode,"%06d",Feecode);

        /*make the packet*/
        csp.Total_Length=htonl(159+Length);
        csp.Command_ID=htonl(CMPP_Submit);
        csp.Sequence_ID=htonl(GetNewSeq());

        if(Send(sockfd,(unsigned char*)&csp,159+Length)==159+Length)
        {
                /*send ok*/
                pthread_mutex_lock(&Mutex);/*lock right away*/
                gettimeofday(&now,&tz);
                timeout.tv_sec = now.tv_sec+1 ;
                timeout.tv_nsec = now.tv_usec*1000;

                while(ReturnPackType!=CMPP_SUBMIT_RESPONSE &&retcode!=ETIMEDOUT)
                {
                        retcode=pthread_cond_timedwait(&Cond,&Mutex,&timeout);
                }
                if(retcode==ETIMEDOUT)
                {
                        SubmitReturn=-3;/*time out*/
                       
                }
                else
                {
                        SubmitReturn=SubmitResult;
                        SubmitResult=-1;
                }
                ReturnPackType=CMPP_NONE_RESPONSE;/*erase mark*/
                pthread_mutex_unlock(&Mutex);/*unlock*/

                return SubmitReturn;
        }
        else
        {
                return -1;/*connection error.*/
        }

}

int ActiveTest()
{
        struct timeval now;
        struct timezone tz;
        struct timespec timeout;
        int retcode;
        int ActiveTestReturn=0;
        /*make the packet*/
        _CMPP_Active_Test_Pack catp;
        catp.Total_Length=htonl(12);
        catp.Command_ID=htonl(CMPP_Active_Test);
        catp.Sequence_ID=htonl(GetNewSeq());
       
        if(Send(sockfd,(unsigned char*)&catp,12)==12)
        {
                pthread_mutex_lock(&Mutex);/*lock right away*/
                gettimeofday(&now,&tz);
                timeout.tv_sec = now.tv_sec + 1;
                timeout.tv_nsec = now.tv_usec*1000;
       
                while(ReturnPackType!=CMPP_ACTIVE_RESPONSE && retcode!=ETIMEDOUT)
                {
                        retcode=pthread_cond_timedwait(&Cond,&Mutex,&timeout);
                }
               
                if(retcode==ETIMEDOUT)
                {
                        ActiveTestReturn=-3;/*time out*/
                }
                else
                {
                        ActiveTestReturn=0;/*activetest ok*/
                }
                ReturnPackType=CMPP_NONE_RESPONSE;/*erase mark*/
                pthread_mutex_unlock(&Mutex);/*unlock*/

                return ActiveTestReturn;
        }
        else
        {
                return -1;/*connection error.*/
        }
}

 

int ReceiveMsg(char *Phone,char *Dest, char *Content)
{
        int nRet;
       
        if(!bIsConnected)
                return 1;

        pthread_mutex_lock(&Mutex2);

        while(ReturnPackType!=CMPP_DELIVER && ReturnPackType!=CMPP_LINK_ERROR)
                pthread_cond_wait(&Cond2,&Mutex2);
        if(ReturnPackType==CMPP_LINK_ERROR)
        {
                nRet=-1;
                ReturnPackType=CMPP_NONE_RESPONSE;/*erase mark*/
        }
        else
        {

                strcpy(Phone,DeliverPack.Phone);
                strcpy(Dest,DeliverPack.Dest);
                strcpy(Content,DeliverPack.Message);
                nRet=0;
                ReturnPackType=CMPP_NONE_RESPONSE;/*erase mark*/
        }       
        pthread_mutex_unlock(&Mutex2);
        return nRet;
}

文件2：cmpp_command_id.h 这个没什么变化。

//CMPP_COMMAND_ID.H
/*
        this file contains CMPP protocol Command_ID
        Author: Rolland
        Create Date:        2001/07/24
        Last Revision:        2001/07/24
*/
#ifndef _CMPP_COMMAND_ID_H
#define _CMPP_COMMAND_ID_H
//Begin of CMPP COMMAND ID define
#define CMPP_Connect                        0x00000001        //请求连接
#define CMPP_Connect_REP                0x80000001        //请求连接应答
#define CMPP_Terminate                        0x00000002        //终止连接
#define CMPP_Terminate_REP                0x80000002        //终止连接应答
#define CMPP_Submit                                0x00000004        //提交短信
#define CMPP_Submit_REP                        0x80000004        //提交短信应答
#define CMPP_Deliver                        0x00000005        //短信下发
#define CMPP_Deliver_REP                0x80000005        //短信下发应答
#define CMPP_Query                                0x00000006        //发送短信状态查询
#define CMPP_Query_REP                        0x80000006        //发送短信状态查询应答
#define CMPP_Cancel                                0x00000007        //删除短信
#define CMPP_Cancel_REP                        0x80000007        //删除短信应答
#define CMPP_Active_Test                0x00000008        //激活测试
#define CMPP_Active_Test_REP        0x80000008        //激活测试应答
#define CMPP_Fwd                                0x00000009        //消息前转
#define CMPP_Fwd_REP                        0x80000009        //消息前转应答
#define CMPP_Route                                0x00000003        //路由请求
#define CMPP_Route_REP                        0x80000003        //路由请求应答

//End of CMPP COMMAND ID define
#endif

你运气还不错［2］

文件3：cmpp_message_packet.h 这个文件也没改过

//CMPP_MESSAGE_PACK_DEFINE.H
//
//CMPP 1.2版协议消息包定义
/*
        This file defines CMPP protocol Packets
        CMPP Version: 1.2

        Author: Rolland
        Create Date:        2001/07/26
        Last Revision:        2001/07/26
*/
#ifndef _CMPP_MESSAGE_PACK_DEFINE_H
#define _CMPP_MESSAGE_PACK_DEFINE_H

#include "cmpp_command_id.h"
//CMPP Messsage Head  define
typedef struct {
        unsigned int Total_Length;                //消息全长
        unsigned int Command_ID;                //命令类型
        unsigned int Sequence_ID;        //消息流水号
}_CMPP_MsgHead_Pack;
//End of CMPP Messsage Head define

//CMPP_Connect message head and body
typedef struct {
        unsigned int        Total_Length;        //消息全长
        unsigned int        Command_ID;                //命令类型
        unsigned int        Sequence_ID;        //消息流水号
        unsigned char        Source_Addr[6];        //SP_ID
        unsigned char        AuthenticatorSP[16];//SP认证码
        unsigned char        Version;        //协商的协议版本号
        unsigned int        Timestamp;        //时间戳的明文,由客户端产生,格式为MMDDHHMMSS，即月日时分秒，10位,右对齐
}_CMPP_Connect_Pack;
//End of CMPP_Connect message head and body

//CMPP_Connect_REP message head and body
typedef struct {
        unsigned int        Total_Length;        //消息全长
        unsigned int        Command_ID;                //命令类型
        unsigned int        Sequence_ID;        //消息流水号       
        unsigned char        Status;                //状态 0：正确；1：消息结构错 ；2：非法SP_ID ；3：SP认证错 ；4：版本太高  ；5~ ：其他错误
        unsigned char        AuthenticatorISMG[16];        //ISMG认证码 ，SP认证出错时，此项为空
        unsigned char        Version;                //服务器支持的最高版本号
}_CMPP_Connect_REP_Pack;

//End of CMPP_Connect_REP message head and body

//CMPP_Terminate message head (no body)
typedef struct {
        unsigned int Total_Length;        //消息全长
        unsigned int Command_ID;        //命令类型
        unsigned int Sequence_ID;        //消息流水号
}_CMPP_Terminate_Pack;
//End of CMPP_Terminate message head (no body)

//CMPP_Terminate_REP message head (no body)
typedef struct {
        unsigned int Total_Length;        //消息全长
        unsigned int Command_ID;        //命令类型
        unsigned int Sequence_ID;        //消息流水号
}_CMPP_Terminate_REP_Pack;
//End of CMPP_Terminate_REP message head (no body)


//CMPP_Submit_REP message head and body
typedef struct {
        unsigned int Total_Length;        //消息全长
        unsigned int Command_ID;        //命令类型
        unsigned int Sequence_ID;        //消息流水号

        unsigned int Msg_Id[2];        //信息标识，由SP侧短信网关本身产生
                                        //生成MsgID的算法如下：
                                        //采用64位（8字节）的整数：
                                        //(1)时间（从月精确到分）       
                                        //63――44位（bit）
                                        //(2)SMC（短讯中心）号码 43――17位（bit）
                                        //(3)序列号  16――0位（bit）顺序累加,
                                        //步长为1,循环使用.各分段如不能填满，左补零

        unsigned char        Result;        //结果0：正确1：消息结构错 2：命令字错 3：消息序号重复4：消息长度错5：资费代码错6：超过最大信息长7：业务代码错8：流量控制错9~ ：其他错误
}_CMPP_Submit_REP_Pack;
//End of CMPP_Submit_REP message head and body

//CMPP_Query message head and body
typedef struct {
        unsigned int Total_Length;        //消息全长
        unsigned int Command_ID;        //命令类型
        unsigned int Sequence_ID;        //消息流水号

        unsigned char Time[8];//时间(精确至日)
        unsigned char Query_Type;//查询类别  0：总数查询 1：按业务代码查询
        unsigned char Query_Code[10];//查询码 (业务类型)  当Query_Type为0时，此项无效；当Query_Type为1时，此项填写业务代码Service_id.
        unsigned char Reserve[8];
}_CMPP_Query_Pack;
//End of CMPP_Query message head and body

//CMPP_Query_REP message head and body
typedef struct {
        unsigned int Total_Length;        //消息全长
        unsigned int Command_ID;        //命令类型
        unsigned int Sequence_ID;        //消息流水号

        unsigned char Time[8];                        //时间(精确至日)
        unsigned char Query_Type;                //查询类别0：总数查询1：按业务代码查询
        unsigned char Query_Code[10];        //查询码
        int MT_TLMsg;                //从SP接收信息总数
        int MT_TLusr;                //从SP接收用户总数
        int MT_Scs;                        //成功转发数量
        int MT_WT;                        //待转发数量
        int MT_FL;                        //转发失败数量
        int MO_Scs;                        //向SP成功送达数量
        int MO_WT;                        //向SP待送达数量
        int MO_FL;                        //向SP送达失败数量
}_CMPP_Query_REP_Pack;
//End of CMPP_Query_REP  message head and body


//CMPP_Deliver_REP message head and body
typedef struct {
        unsigned int        Total_Length;        //消息全长
        unsigned int        Command_ID;        //命令类型
        unsigned int        Sequence_ID;        //消息流水号
       
        unsigned int        Msg_Id[2];        //消息标识
        unsigned char        Result;        //结果0：正确1：消息结构错 2：命令字错 3：消息序号重复4：消息长度错5：资费代码错6：超过最大信息长7：业务代码错8: 流量控制错9~ ：其他错误
}_CMPP_Deliver_REP_Pack;
//End of CMPP_Deliver_REP message head and body

//CMPP_Cancel
typedef  struct {
        unsigned int        Total_Length;        //消息全长
        unsigned int        Command_ID;        //命令类型
        unsigned int        Sequence_ID;        //消息流水号

        unsigned int        Msg_Id[2];        //消息标识
}_CMPP_Cancel_Pack;
//End of CMPP_Cancel

//CMPP_Cancel_REP message head and body
typedef  struct {
        unsigned int        Total_Length;        //消息全长
        unsigned int        Command_ID;        //命令类型
        unsigned int        Sequence_ID;        //消息流水号

        unsigned char        Succeed_Id;                //成功标识(0：成功;  1：失败)
}_CMPP_Cancel_REP_Pack;
//End of CMPP_Cancel_REP message head and body

//CMPP_Active_Test message head (no body)
typedef  struct {
        unsigned int Total_Length;        //消息全长
        unsigned int Command_ID;        //命令类型
        unsigned int Sequence_ID;        //消息流水号
}_CMPP_Active_Test_Pack;

//End of _CMPP_Active_Test

//CMPP_Active_Test_REP message head and body
typedef struct {
        unsigned int Total_Length;        //消息全长
        unsigned int Command_ID;        //命令类型
        unsigned int Sequence_ID;        //消息流水号

        unsigned char        Succeed_Id;                //成功标识(0：成功；其它：不成功)
}_CMPP_Active_Test_REP_Pack;
//End of _CMPP_Active_Test

typedef struct {
        unsigned int Total_Length;        //消息全长
        unsigned int Command_ID;        //命令类型
        unsigned int Sequence_ID;        //消息流水号
        unsigned char Free[240];
}_CMPP_Deliver_Pack;

typedef struct {
        unsigned int Total_Length;        //消息全长
        unsigned int Command_ID;        //命令类型
        unsigned int Sequence_ID;        //消息流水号
        unsigned char Free[310];
}_CMPP_Submit_Pack;

#endif


文件4：makefile  这个是新加的，当时不会写
cmppapi.so:cmppapi.c
        gcc -o cmppapi.so -shared -fPIC -O2 cmppapi.c

# cc cmppapi1.c
/usr/lib/gcc-lib/i386-redhat-linux/3.2.3/../../../crt1.o(.text+0x18): In function `_start':
: undefined reference to `main'
collect2: ld returned 1 exit status

请问这是怎么回事？

gcc -o cmppapi1.so  -shared -fPIC -O2 cmppapi1.c
可以了，编译出来的 cmppapi1.so怎么用？

回复 5楼 xzh2002 的帖子

so是共享库阿。调用发送和接受函数就OK了，可以写一个cmppserver用来测试，我写过1.2和2.0两个server,不过不是linux下的，不适合你。你可以直接在移动接口上测，可能有些地方需要根据不同的平台作调整。不同提供商登录处理有些不同。给你发的这个版本Log函数中没有照规范作，因为是连接我们自己的2.0平台给别人提供服务的，我们的平台不验证password的md5(当时定义就比较含糊)，我们是服务器上作ip检验来限制登录。你需要在Log函数中依照协议增加md5校验。
总体是这样来用的：
ConnectHost（）建立连接
Log()登录
ReceiveMsg()接收消息
SubmitMsg()发送消息
ActiveTest()活动测试

ReceiveMsg()是同步的，有消息来就返回，没消息就锁定。
SubmitMsg()是异步的，发送成功就返回，是否成功发送要从ReceiveMsg()反馈来判断。

so库的用法看看书。

tsunzhang
关注
专栏目录
cmpp发送超长短信息
eric_cheung的专栏
04-30 4355
注:1、长短信息：是指超过70个汉字，140个字节的信息内容。               最近在做一个某地市公司运营商的GPRS导引项目的时候，运营商要求将对用户的提示短信息（超过140个字节）发送到用户手机，在用户的手机上一次全显示。        上网搜索了一些相关的资料，现在将实现总结如下:一、CMPP协议相关字段分析（在此只讲发长短信相关的cmpp_submit消息，cmpp
CMPP3.0 短信发送
03-01
CMPP3.0 短信发送 CMPP3.0 短信发送
cmpp发送短信
jockha的博客
02-28 284
思路： 把各种操作解耦，创建各种线程异步进行 1.创建一个阻塞队列用来存储任务 2.创建一个任务线程，从待发表里取数据（待发表里有专门标明是否被处理过的字段），注入任务队列 3.创建n个接收线程，向接收表中塞入数据 4.创建n个发送进程，从任务队列里取数据，发送 一共有待发表，接收表，已发表，发送错误表，回执状态表5张基础表 具体基础代码参考cmpp2.0文档，或者自己搜索 ...
cmpp发送超长短信息1
xiaolang85的专栏
11-10 1289
 注:1、长短信息：是指超过70个汉字，140个字节的信息内容。               最近在做一个某地市公司运营商的GPRS导引项目的时候，运营商要求将对用户的提示短信息（超过140个字节）发送到用户手机，在用户的手机上一次全显示。        上网搜索了一些相关的资料，现在将实现总结如下:一、CMPP协议相关字段分析（在此只讲发长短信相关的cmpp_submit消息，c
.Net/C# 实现 中国移动 CMPP v3.0 ISMG SP 收发短信的 SP 客户端 (CMPP SP Client)
weixin_33709590的博客
03-18 204
/* .Net/C# 实现 中国移动 CMPP v3.0 ISMG <-> SP 收发短信的 SP 客户端 (CMPP SP Client) 本程序严格按 《中国移动通信企业标准》之《中国移动通信互联网短信网关接口协议(China Mobile Point to Point)》(版本号: 3.0.0) 即: CMPP v3.0.0 http://www.spzone.net...
中国移动短信接口CMPP3.0SP客户端源码
03-22
中国移动短信接口CMPP3.0SP客户端源码是一款专门用于SP（Service Provider，服务提供商）与ISMG（Internet Short Message Gateway，互联网短信网关）之间交互的程序，它基于中国移动的CMPP3.0协议标准。这个源码是...
移动短信CMPP3.0客户端调试程序
02-23
1. **接口模拟**：程序可以模拟CMPP3.0协议的客户端，连接到指定的短信网关服务器，模拟提交、查询和接收短信的过程。 2. **报文解析与构造**：程序能解析和构造CMPP3.0协议的各类报文，包括报文头、业务参数、消息...
cmpp2_cmpp2客户端和服务端测试工具_
09-29
CMPP2，全称为China Mobile Peer-to-Peer Protocol Version 2，是中国移动通信集团制定的一种基于TCP/IP协议的通信协议，主要用于短信中心（SMSC）与短信网关（SP Gateway）之间的数据传输，支持大批量、高并发的...
cmpp短信网关
11-06
cmpp短信网关，支持cmpp3.0协议
CMPP.rar_CSharp cmpp_cmpp_cmpp 2.0 C#_短信网关_网关
09-19
本项目"CMPP.rar"是一个基于C#实现的CMPP协议版本2.0的短信网关程序。CMPP 2.0相较于早期版本，进行了优化和增强，提供了更稳定和高效的数据交换机制。开发者通过这个程序可以实现与移动运营商的短信平台进行交互，...
cmpp测试工具 cmpp测试工具 cmpp测试工具
12-20
cmpp测试工具 cmpp测试工具 cmpp测试工具 cmpp测试工具
CMPP3.0 长短信实现方案
weixin_33711647的博客
07-26 911
长短信息：是指超过70个汉字，140个字节的信息内容 一、CMPP协议相关字段分析 CMPP协议具体部分请参考《中国移动互联网短信网关接口协议（V3.0.0）.doc》   CMPP_SUBMIT消息定义（SP---&gt;SMG）   字段名 字节数 属性 描述 Msg_Id 8 Unsigned I...
CMPP3.0短信网关.netcore(c#)源代码（亲测可用）
05-17
功能特点： 1.遵照CMPP3.0协议实现，模拟了短信网关,支持CONNECT,SUBMIT,DELIVER,QUERY,CANCEL,TERMINATE消息； 2.net5.0开发支持windows/liunx系统； 3.支持长短信； 4.支持心跳协议； 5.支持多线程； 6.支持收/发短信； 7.支持中文短信； 8.支持长号码。 自带测试网关
Net/C# 实现中国移动CMPP v3.0 ISMG SP 收发短信的 SP 客户端
09-07
.Net/C# 实现 中国移动 CMPP v3.0 ISMG SP 收发短信的 SP 客户端 (第2版)(CMPP SP Client) 增加了 CMPP Client 类本程序严格按 《中国移动通信企业标准》之《中国移动通信互联网短信网关接口协议(China Mobile Point to Point)》(版本号: 3.0.0) 即: CMPP v3.0.0 http://www.spzone.net/protocol/CMPPV3.0.rar 文档,实现了下面消息的定义及其相关协议级交互: 8.4 业务提供商 (SP) 与互联网短信网关 (ISMG) 间的消息定义 8 8.4.1 SP 请求连接到 ISMG(CMPP_CONNECT) 操作 8 8.4.1.1 CMPP_CONNECT 消息定义 (SP -> ISMG) 8 8.4.1.2 CMPP_CONNECT_RESP消息定义 (ISMG -> SP) 9 8.4.2 SP 或 ISMG 请求拆除连接 (CMPP_TERMINATE)操作 9 8.4.2.1 CMPP_TERMINATE 消息定义 (SP -> ISMG 或 ISMG -> SP) 9 8.4.2.2 CMPP_TERMINATE_RESP 消息定义 (SP -> ISMG 或 ISMG -> SP) 10 8.4.3 SP 向 ISMG提交短信 (CMPP_SUBMIT) 操作 10 8.4.3.1 CMPP_SUBMIT 消息定义 (SP -> ISMG) 10 8.4.3.2 CMPP_SUBMIT_RESP 消息定义 (ISMG -> SP) 11 8.4.5 ISMG 向 SP 送交短信 (CMPP_DELIVER) 操作 13 8.4.5.1 CMPP_DELIVER 消息定义 (ISMG -> SP) 13 8.4.5.2 CMPP_DELIVER_RESP 消息定义 (SP -> ISMG) 16 8.4.7 链路检测 (CMPP_ACTIVE_TEST) 操作 17 8.4.7.1 CMPP_ACTIVE_TEST定义 (SP -> ISMG 或 ISMG <- SP) 17 8.4.7.2 CMPP_ACTIVE_TEST_RESP定义 (SP -> ISMG 或 ISMG <- SP) 17 可采用《中国移动通信 CMPP v3.0 短消息网关模拟器 v1.10》进行测试: 下载于: 《北京风起水流软件工作室》 http://www.zealware.com/download/cmpp3smg.rar本程序以熟悉理解 CMPP 3.0 协议为主要目的,只将 "消息定义" 对象化,其相关协议级交互并未作更深层次的 OO! 也暂无任何错误处理程序! 消息定义的所有字段名称及其数据类型均与上述之 CMPP v3.0.0 文档完全一致! 其间参阅过 shanhe@CSDN or yexiong@cnBlogs 大作(在此鸣谢): http://blog.csdn.net/shanhe/archive/2004/07/19/45383.aspx http://cnblogs.com/yexiong/articles/115330.aspx 但其中有些消息定义字节错位,因此不能正常交互?!且对象化层次较高,不利于理解协议本身! 遂自己动手,丰衣足食,实现部分主要协议(SP 收发短信):
中国移动通信cmppV3.0 短信模拟网关
03-16
中国移动通信cmppV3.0 短信模拟网关中国移动通信cmppV3.0 短信模拟网关
CMPP短信收发程序
02-23
这是一个用vc开发的基于CMPP的短信收发程序
cmpp2.0模拟短信网关
06-20
1. **连接管理**：模拟短信网关能够模拟真实的短信网关，接受和响应CMPP连接请求，建立与客户端的TCP连接。 2. **报文处理**：实现CMPP2.0协议规定的各种报文处理，如提交、接收、查询和取消等操作。 3. **消息模拟*...
CMPP协议客户端测试工具
02-21
测试CMPP协议的客户端，使用简单。支持下行、上行和长短信。
CMPP3.0-超长短信
来啊 快活啊
03-10 2055
超长短信：短信内容超过70个汉字，提交给网关时候需要分成多条，但是用户手机接收时候是一条（sp角度，手机发送长短信概念一样）。在cmpp协议里，CMPP-_SUBMIT消息定义中有相应的参数配置： TP_udhi ：0代表内容体里不含有协议头信息 1代表内容含有协议头信息（长短信，push短信等都是在内容体上含有头内容的,也就是说把基本参数(TP-MTI/VFP)值设置成0X51）当设置内容体包
基于 CMPP3.0 协议 SP 端的实现（C#）
IT码农-三叔的专栏
11-09 1726
      最近一段是时间项目可能需要提供短信功能，客户作为一个 SP 端提供短信业务；网上搜索了一番，找到了比较不错的 CMPP30 类的代码，该代码基本实现了 CMPP3.0 协议中的短信收发、网络重连等功能。本人将其重新改造，提供了同步发送、异步发送的支持（原先版本的异步发送并非标准的 .NET 异步发送模式，这部分代码是一个异步操作实现的“范本”，可供大家参考），增加了对 PROV
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值