clientdlg.c

Linux 下的socket客户端服务端代码

#include "clientdlg.h"

/* **********************************************************************
-----------  Socket Communication 
********************************************************************** */

#define MAXRECLEN            4096    /* Request Packet Lenght */
#define CHIPBUFLENGTH        1024    /* 子包大小*/

/* **********************************************************************
* Globle Veriable for ACCEPT THREADs for server
* **********************************************************************/

struct sockaddr_in addr_client;
int client_ConnectRun=0;        /* Socket connect Thread Handle */

void fDebug( char *msg,int err)
{
    printf("Error(%d): %s",err,msg);
}

SOCKET Client_Open( char *pszHost, u_short iPort)
{
    SOCKET sd_client;
    struct hostent *ptrHost;
    u_int  error;
    u_long  lret;
    
    /* Initialize Socket Ports */
    InitSockets();
    /*  open socket */
    sd_client = socket(AF_INET, SOCK_STREAM, 0);
    if (sd_client == INVALID_SOCKET)
    {
        WSA_ERROR("no more socket resources");
        
        fDebug("no more socket resources",WSAGetLastError());
        return 0;
    }
    
    ptrHost = gethostbyname((char*)pszHost);
    
    if (ptrHost==NULL)
    {
        WSA_ERROR("cannot resolve hostname")
            fDebug("cannot resolve hostname",WSAGetLastError());
        return 0;
    }    
    
    memset((void*)(&addr_client),0,sizeof(addr_client));
    
    addr_client.sin_family = AF_INET;
    addr_client.sin_port = htons(iPort);
    addr_client.sin_addr=*((struct in_addr *)ptrHost->h_addr);
    
    
    /*  connect to socket */
    lret = connect(sd_client,(struct sockaddr *)(&addr_client), sizeof(struct sockaddr_in));
    error = WSAGetLastError();
    if(lret >= 0||lret==WSAEWOULDBLOCK)
    {
    } 
    else
    {
        fDebug("cannot connect to server2",WSAGetLastError());
        return 0;
    }
    
    /*   create anylsis*/
    
    if (fork() == 0)
    {
        /* I am child process*/
        client_ConnectRun=1;
        Client_AnalysisPro(sd_client);
        exit(0);
    }
    
    return sd_client;    
}

int Client_Close(void)
{
    int err;    
    client_ConnectRun=0;
    WSACleanup();    
    return err;
}


void Client_AnalysisPro(SOCKET sd)
{
    SOCKET sd_client ;
    sd_client = (SOCKET)sd ;
    
    unsigned char request[MAXRECLEN] ;
    int recvlen=1 , res=0;
    int error=0;
    
    /* added by leexb for ache buffer  */    
    unsigned char R_TRANSACHE[MAXRECLEN*3*5];        /* more than 5 packet for protocal */
    unsigned char R_CHIPACHE[CHIPBUFLENGTH*30];        /* more than 30 chip packet for receive */
    ACHSTATUS R_PKTAche,R_CHIPAche ;
    unsigned char r_chipbuf[CHIPBUFLENGTH+8];
    
    unsigned char r_transbuf[MAXRECLEN*3+8];
    int r_chiplen=0,r_translen=0;
    /* reset status of packet ache  */
    ResetAchStatus(&R_PKTAche,R_TRANSACHE,MAXRECLEN*3*5,EXTRANS_FP_HEAD,EXTRANS_FP_TAIL,0xFF);
    SetAcheMode(&R_PKTAche, ACHE_AS_QUEUE,ACHERW_TRANS,ACHERW_NOTRANS);
    
    ResetAchStatus(&R_CHIPAche,R_CHIPACHE,CHIPBUFLENGTH*30,EXTRANS_CP_HEAD,EXTRANS_CP_TAIL,0xFF);
    SetAcheMode(&R_CHIPAche, ACHE_AS_QUEUE,ACHERW_TRANS,ACHERW_NOTRANS);
    /*  add end  */
    
    /* while both sockets are open */
    while (client_ConnectRun)
    {
        if(CheckSocketRead(sd_client)>0)
        {
            /* initialize Request veriable */
            memset(r_chipbuf , 0 ,CHIPBUFLENGTH);
            r_chiplen=0;
            /*  read the request THREAD WILL BLOCKING HERE !!!     */
            res=recv(sd_client, (char*)r_chipbuf, CHIPBUFLENGTH, 0);            
            if (res==INVALID_SOCKET)
            {
                error=WSAGetLastError();
                WSA_ERROR("Receive data failed!\n");
                client_ConnectRun=0;
            }
            else
                r_chiplen=res;            
            /* if closing down, exit thread */
            if (r_chiplen==0 || error==WSAECONNRESET || error==WSAECONNABORTED){
                break;
            }
            /*  add read data to chip ahces  */
            if(r_chiplen>0)
            {
                WriterAche(&R_CHIPAche, r_chipbuf,r_chiplen);
            }
        }
        
        /*       read chip buffer and add this data to packet buf   */
        r_chiplen= ReaderAche(&R_CHIPAche, r_chipbuf);
        if(r_chiplen>0)
        {
            WriterAche(&R_PKTAche, r_chipbuf,r_chiplen);
        }
        
        /* 
        TODO: Analyse Request Packet AND Construct Response Packet
        */
        r_translen=ReaderAche(&R_PKTAche, r_transbuf);
        if(r_translen>0)
        {
            recvlen=ExTransPacket((unsigned char *)request, r_transbuf, r_translen);
            if(recvlen>0)
            {
                int returnCmd=Client_RequestPro(sd_client, (unsigned char*)request , recvlen) ;
                /* added Cmd here */
                switch(returnCmd) 
                {
                case 0:
                    {
                    }break;
                default:
                    ;
                };/*switch(returnCmd)*/
            }/*    if(recvlen>0)*/
        }/*    if(r_translen>0)*/
    };/*while(ifconnect)*/
    
    closesocket(sd_client);
}


int Client_Send(SOCKET sd_client, unsigned char *dest, int sendlen)
{
    
    unsigned char s_chipbuf[CHIPBUFLENGTH+8];
    unsigned char s_transbuf[MAXRECLEN*3+8];
    int s_chiplen=0,s_translen=0;
    int freei,chipn=0,alllen=0;
    int res;
    
    s_transbuf[0]=EXTRANS_FP_HEAD&0xFF;
    s_translen=TransPacket(
        (unsigned char *)(s_transbuf+1),
        (unsigned char *)(dest),
        sendlen);
    
    if(s_translen>0)
    {
        s_transbuf[1+s_translen]=EXTRANS_FP_TAIL&0xFF;
        s_translen+=2;
        /*    flit the packet to chip buf   */
        
        chipn=s_translen/(CHIPBUFLENGTH-2)+(int)(s_translen%(CHIPBUFLENGTH-2)>0);
        for(freei=0;freei<chipn;freei++)
        {
            if(s_translen%(CHIPBUFLENGTH-2)==0)
                s_chiplen=(CHIPBUFLENGTH-2);
            else if(freei>=chipn-1)
                s_chiplen=s_translen%(CHIPBUFLENGTH-2);
            else 
                s_chiplen=(CHIPBUFLENGTH-2);
            
            s_chipbuf[0]=EXTRANS_CP_HEAD&0xFF;
            memcpy((void*)(s_chipbuf+1),(void*)(s_transbuf+freei*(CHIPBUFLENGTH-2)),s_chiplen);
            s_chipbuf[1+s_chiplen]=EXTRANS_CP_TAIL&0xFF;
            s_chiplen+=2;                                
            res=send(sd_client,(char*)(s_chipbuf),s_chiplen, 0);    
            if (res==INVALID_SOCKET)
            {
                char msg[20];
                sprintf(msg,"%d",s_chiplen);
                
                fDebug(msg,WSAGetLastError());
                
                WSA_ERROR("Send data failed!\n");
                return -1;
            }
        }/*    for(freei=0;freei<chipn;freei++)*/
    }/*    if(s_translen>0)*/        
    
    return chipn*2+s_translen;
}


int Client_RequestPro(SOCKET sd_client,unsigned char *lpbuf,int recvlen)
{         
    return 0;
}