零拷贝接收函数

include

include

include

include

include”sockLib.h”

include “stdio.h”

include “stdlib.h”

include “string.h”

include “cq.h”

include “udpServer.h”

struct sockaddr_in serverAddr1;
struct sockaddr_in clientAddr;

unsigned int sndBuffer[256];
unsigned char RcvBuffer[1024];

SEM_ID SND_SEM;
int sock;

static int cmd=0;
static int cmdId=0;
CMD_BUFFER *udpCmd=NULL;

extern SEM_ID dataSemId;

void udpRecvTask (void)
{

STATUS              ret;
int                 nrecv;  /* number of bytes received */
int sockAddrSize = sizeof(struct sockaddr);

if ((sock = socket (AF_INET, SOCK_DGRAM, 0)) < 0)
{
    printf ("cannot open socket\n");
    return;
}

/*udpCmd.cmdParameter=udpBuffer;*/

inet_aton("192.168.1.10",(struct in_addr *)&serverAddr1.sin_addr);

serverAddr1.sin_family  = AF_INET;
serverAddr1.sin_port    = htons (50000);


bzero((char *)&serverAddr1.sin_zero, 8);  /* zero rest of struct */
bzero((char *)&clientAddr.sin_zero, 8);  /* zero rest of struct */

if (bind (sock, (struct sockaddr *)&serverAddr1, sizeof(serverAddr1)) < 0)
{
    printf ("bind error\n");
    close (sock);
    return;
}


for(;;)
{

    ret=GetCQRxBuffer(&udpCmd);
    if(ret==ERROR)
    {

    }
    nrecv = recvfrom (sock, (char *)udpCmd, sizeof(CMD_BUFFER), 0, (struct sockaddr *)&clientAddr,
                                  (int *)&sockAddrSize);


    printf("client Addr is 0x%x\n",clientAddr.sin_addr.s_addr);
    if(nrecv>0)
    {
        ret=CQRxBufferIn();
        if(ret==ERROR)
        {

        }
    }
 }

}

void initUdp(void)
{

STATUS ret;
ret=CQ_create(MAX_Q_SIZE);
if(ret==ERROR)
{
    printf("Could not create Q for cmd buffer\n");
    return ERROR;
}
taskSpawn("udpRecv",150,0,8192,(FUNCPTR)udpRecvTask,0,1,2,3,4,5,6,7,8,9);
taskSpawn("cmdXproc",150,0,8192,(FUNCPTR)cmdProcess,0,1,2,3,4,5,6,7,8,9);

}

void cmdProcess(void)
{
STATUS ret;
CMD_BUFFER sndCmd;
int sockAddrSize = sizeof(struct sockaddr);

//sndCmd.cmdParameter=sndBuffer;
static int i;
while(1)
{
    i++;
    if(clientAddr.sin_addr.s_addr!=0)
    {
        sndBuffer[0]=i;
        sndBuffer[1]=0x55AACC33;
        sendto(sock, (char *)sndBuffer, 1024, 0, (struct sockaddr *)&clientAddr,
                sockAddrSize);
    }
    taskDelay(1000);

}

}

/
int sockFd;
int newSockFd;

void tcpXtask (void)
{
struct sockaddr_in saddr,caddr;

int bufLen=1500;
char *buffer;

int addrLen;
int nRead=0;

bzero ((char *) &saddr, sizeof (saddr));
bzero ((char *) &caddr, sizeof (caddr));




buffer=malloc(bufLen);

if(bufLen==NULL)
{
    return;
}
if ((sockFd = socket (AF_INET, SOCK_STREAM, 0)) < 0)
{
    free (buffer);
    return;
}

saddr.sin_family       = AF_INET;
saddr.sin_port = htons (50000);
saddr.sin_addr.s_addr=INADDR_ANY;


if(bind(sockFd, (struct sockaddr *)&saddr, sizeof(saddr))<0)
{
    free (buffer);
    return;
}

if(setsockopt(sockFd, SOL_SOCKET, SO_RCVBUF,(char *) &bufLen, sizeof (bufLen)) < 0)
{
    printf ("setsockopt SO_RCVBUF failed\n");
    free (buffer);
    return;
}


if (setsockopt (sockFd, SOL_SOCKET, SO_SNDBUF, (void *)&bufLen,
                 sizeof (bufLen)) < 0)
{
    printf ("setsockopt SO_SNDBUF failed\n");
    free (buffer);
    return;
}

if (listen (sockFd, 5) < 0)
{
    printf ("listen failed\n");
    close (sockFd);
    free (buffer);
    return;
}
addrLen=sizeof(caddr);

while ((newSockFd = accept(sockFd, (struct sockaddr *)&caddr, &addrLen)) == -1);

printf("new socket connected\n");

if(setsockopt(newSockFd, SOL_SOCKET, SO_RCVBUF,(char *) &bufLen, sizeof (bufLen)) < 0)
{
    printf ("setsockopt SO_RCVBUF failed\n");

    free (buffer);
    return;
}


if (setsockopt (newSockFd, SOL_SOCKET, SO_SNDBUF, (void *)&bufLen,
                 sizeof (bufLen)) < 0)
{
    printf ("setsockopt SO_SNDBUF failed\n");
    free (buffer);
    return;
}

while(1)
{
    nRead=recv(newSockFd,buffer,1500,0);
    if(nRead<=0)
    {
        //printf("Read socket data error\n");
    }
    else
    {
        unsigned int i;
        for(i=0;i<20;i++)
        {
            buffer[i]=buffer[i]+1;
        }
        send(newSockFd,buffer,50,0);
    }
}

}
///

define MAX_Q_SIZE (16)

typedef struct cmdBuffer
{
unsigned int m_a;
unsigned int m_b;
unsigned int m_c;
unsigned int m_d;
// unsigned char *cmdParameter;
unsigned int m_Reserved[32];

}CMD_BUFFER;

struct CQ
{
unsigned int head;
unsigned int tail;
unsigned int size;
unsigned int max;
//CMD_BUFFER *ppCmd;
CMD_BUFFER **ppCmd;
}CQ;

extern struct CQ g_CQ;

STATUS CQ_create(int max);

define IS_EMPTY(Q) (Q->head==Q->tail)

define IS_FULL(Q) (((Q->tail+1)%MAX_Q_SIZE)==Q->head)

STATUS GetCQRxBuffer(CMD_BUFFER **p);
STATUS GetCQDoBuffer(CMD_BUFFER **p);
STATUS CQRxBufferIn(void);

struct CQ g_CQ;

STATUS CQ_create(int max)
{

CMD_BUFFER *ppCmd;

g_CQ.head=0;
g_CQ.tail=0;
g_CQ.size=0;
g_CQ.max=MAX_Q_SIZE;

ppCmd=(CMD_BUFFER *)malloc(sizeof(CMD_BUFFER)*MAX_Q_SIZE);
if(NULL==ppCmd)
    return ERROR;

bzero(ppCmd,sizeof(*ppCmd)*MAX_Q_SIZE);

*g_CQ.ppCmd=ppCmd;
//g_CQ.ppCmd=ppCmd;

return OK;

}

STATUS GetCQRxBuffer(CMD_BUFFER **p)
{
struct CQ *Q=&g_CQ;

if(IS_FULL(Q))
{
        printf("Error, Q FULL\n");
        *p=NULL;
        return ERROR;
}
*p=*(Q->ppCmd)+Q->tail;
printf("Q->ppCmd addr is %p ,*p is %p\n",*(Q->ppCmd),*p);

return OK;

}

STATUS CQRxBufferIn(void)
{
struct CQ *Q=&g_CQ;

if(IS_FULL(Q))
{
        printf("Error, Q FULL\n");
        return ERROR;
}
//*p=(Q->ppCmd)+Q->tail;
Q->tail=(Q->tail+1)%MAX_Q_SIZE;
Q->size++;
printf("[CQ_RX]Q->Head=%d,Q->Tail=%d,Q->Size=%d\n",g_CQ.head,g_CQ.tail,g_CQ.size);
return OK;

}

STATUS GetCQDoBuffer(CMD_BUFFER **p)
{
struct CQ *Q=&g_CQ;
CMD_BUFFER *pcmd;

if(IS_EMPTY(Q))
{
   //printf("Error, Q empty\n");
    *p=NULL;
   return ERROR;
}
//*p=Q->ppCmd+Q->head;
*p=*(Q->ppCmd)+Q->head;
Q->head=(Q->head+1)%MAX_Q_SIZE;
Q->size--;
printf("[CQ_DO]Q->Head=%d,Q->Tail=%d,Q->Size=%d\n",g_CQ.head,g_CQ.tail,g_CQ.size);
return OK;      

}