TCP socket编程实现

下面是TCP socket的经典流程图
服务器端依次调用socket()、bind()、listen()之后，开始监听指定的socket地址。客户端调用socket()，然后再调用connect()向服务器发送一个连接请求。服务器监听到这个请求之后，就会调用accept()完成接收请求，并且返回一个新的套接字描述符，可用于向客户端读取或发送数据，用的分别是recv()和send()函数。同样，客户端connect()成功之后，也可以向服务器读取或发送数据。

接下来，客户端和服务器端分别写一个程序，然后在不同的终端中运行试验。

/*client.c*/
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <netdb.h>
#include <netinet/in.h>
#include <pthread.h>

#define PORT 8019
#define BUFFER_SIZE 4096
#define FILE_NAME_MAX 512

int main(int argc,char* argv[])
{
    int sockfd;
    //char buff[BUFFER_SIZE];
    struct hostent *host;
    struct sockaddr_in serv_addr;

    if(argc != 2)
    {
        fprintf(stderr,"Usage: ./client Hostname(or ip address) \ne.g. ./client 127.0.0.1 \n");
        exit(1);
    }

    //地址解析函数
    if ((host = gethostbyname(argv[1])) == NULL)
    {
        perror("gethostbyname");
        exit(1);
    }
    //创建socket
    if ((sockfd = socket(AF_INET,SOCK_STREAM,0)) == -1)
    {
        perror("socket");
        exit(1);
    }
    bzero(&serv_addr,sizeof(serv_addr)); 
    //设置sockaddr_in 结构体中相关参数
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(PORT); //将16位的主机字符顺序转换成网络字符顺序
    serv_addr.sin_addr = *((struct in_addr *)host->h_addr); //获取IP地址
    bzero(&(serv_addr.sin_zero), 8);  //填充0以保持struct sockaddr同样大小

    //调用connect函数主动发起对服务器端的连接
    if(connect(sockfd,(struct sockaddr *)&serv_addr, sizeof(serv_addr))== -1)
    {
        perror("connect");
        exit(1);
    }

    char buff[BUFFER_SIZE]= "<letter>getPwd</letter>"; //读写缓冲区
    int count;
    count=send(sockfd,buff,100,0);
    if(count<0)
    {
        perror("Send file informantion");
        exit(1);
    }
    printf("client send OK count = %d\n",count);
    //接收来自server的数据
    char pbuf[BUFFER_SIZE] = {0};
    int length=recv(sockfd,pbuf,100,0);
    printf("data from pon is %s\n",pbuf);
    close(sockfd);
    return 0;
}

从上面的程序可以看到，客户端创建socket，然后向服务器发出connect，连接成功后，
会发送字符串”getPwd“到服务器，然后等待接收来自服务器的反馈数据。

/*server.c*/
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <netinet/in.h>
/*
如果把IP地址比作一间房子 ，端口就是出入这间房子的门。端口号就是打开门的钥匙。
真正的房子只有几个门，但是一个IP地址的端口 可以有65536个之多！
端口是通过端口号来标记的，端口号只有整数，范围是从0 到65535。
地址中的端口号必须不小于1024，除非该进程具有相应的特权(即超级用户)。
*/
#define PORT 8019
#define RCV_BUF_SIZE 0x1000
#define MAX_QUE_CONN_NM 1

char * getPwdFunc()
{
    //获取密码
    printf("Began to get the password\n ");
    printf("Send the parsed msg to client\n ");
    char * result = "result=ok|id=test|pwd=test";
    return result;
}

char * setPwdFunc()
{
    printf("Began to get the password\n ");
    printf("Send the parsed msg to client\n ");
    char * result = "result=ok";
    return result;
}

typedef char *(*func)();
struct processFun {
    char *name;
    func process;
};

struct processFun cmdFunc[] = {
    {"setPwd",         setPwdFunc},
    {"getPwd",         getPwdFunc}
};

char * client_acquire_server_info(char *msg)
{
    char *pMsgTmp;
    int i;
    for(i=0; i< sizeof(cmdFunc)/sizeof(struct processFun); i++)
    {
        if(0 == strcmp(msg,cmdFunc[i].name))
        {
            printf("found it \n");
            printf("%s: parameter %s \n",__FUNCTION__,msg);
            pMsgTmp = cmdFunc[i].process();
            break;
        }
    }
    return pMsgTmp;
}

//获取消息主体 
char *getBodyOfMsg(char *buf)
{
    char * pStr1 = NULL;
    char * pStr2 = NULL;
    pStr1 = strstr(buf,"<letter>");
    pStr2 = strstr(buf,"</letter>");
    if (pStr2 == NULL || pStr1 == NULL)
    {
        return NULL;
    }
    *pStr2 = '\0';
    return (pStr1 + strlen("<letter>"));
}

//解析接收到的字符串，然后调用相应的zte接口返回相关数据发送给客户端
char * parseDataFromClient(char *pmsg)
{
    char *pTmp = getBodyOfMsg(pmsg);
    if (pTmp == NULL)
    {
        printf("parse data failed!\n");
        return NULL;
    }
    printf("the parsed data is %s \n",pTmp);
    char * acquireDataFromServer = client_acquire_server_info(pTmp);
    return acquireDataFromServer;
}

int main(int argc,char* argv[])
{
    int sockfd;
    struct sockaddr_in server_sockaddr, client_sockaddr;
    //建立socket连接
    if ((sockfd = socket(AF_INET,SOCK_STREAM,0))== -1)
    {
        perror("socket");
        exit(1);
    }
    printf("Socket id = %d\n",sockfd);

    //设置sockaddr_in 结构体中相关参数
    server_sockaddr.sin_family = AF_INET;
    server_sockaddr.sin_port = htons(PORT);
    server_sockaddr.sin_addr.s_addr = INADDR_ANY;
    bzero(&(server_sockaddr.sin_zero), 8);

    //setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));

    //绑定函数bind
    if (bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(struct sockaddr))== -1)
    {
        perror("bind");
        exit(1);
    }
    printf("Bind success!\n");

    //调用listen函数
    if (listen(sockfd, MAX_QUE_CONN_NM) == -1)
    {
        perror("listen");
        exit(1);
    }
    printf("Listening....\n");

    char *pbuf = NULL;
    int client_fd,length;
    int addrlen = sizeof(server_sockaddr);
    char *ptmp = NULL;
    pbuf = (char *)malloc(RCV_BUF_SIZE);
    if(NULL == pbuf)
    {
        printf("igdserver:main:malloc failed in callback\n");
    }
    while(1)
    {
        if ((client_fd = accept(sockfd, (struct sockaddr *)&client_sockaddr, (socklen_t *)&addrlen)) == -1)
        {
            perror("accept");
            exit(1);
        }
        memset(pbuf, RCV_BUF_SIZE, 0);
        length=recv(client_fd,pbuf,100,0);
        printf("string from client is %s ,length = %d\n",pbuf,length);
        //服务器开始解析从客户端传过来的数据，并做出相应的处理
        ptmp = parseDataFromClient(pbuf);
        //把得到的结果返回给客户端
        int count=send(client_fd,ptmp,100,0);
        if(count<0)
        {
            perror("Send file informantion");
            exit(1);
        }
        printf("client send OK, count = %d,result = %s\n",count,ptmp);  
    }
    free(pbuf);
    close(sockfd);
    close(client_fd);
    return 0;
}

程序干了几件事：
1. 服务器创建socket，调用bind绑定地址，listen监听客户端
2. 当监听到客户端的连接，accept返回新的套接字描述符client_fd，通过client_fd，用recv()函数可以接收到客户端发送过来的数据”getPwd”
3. 解析数据，调用getBodyOfMsg得到来自客户端的命令为”getPwd”。调用client_acquire_server_info(char *msg)处理命令，这个函数会去查找匹配到cmdFunc[]数组中的{“getPwd”, getPwdFunc}，找到客户端发送命令相对应的getPwdFunc()函数并执行这个函数。
4. 把获取到的密码通过send()函数发送到客户端。

这样写的好处是，以后如果客户端指定更多的命令，服务器端只需要在cmdFunc[]添加相对应的命令和函数，使得程序扩展方便。

接下来实验一下程序。打开终端编译程序，然后执行./server

//终端A：
ubuntu:~/test/aa$ gcc client.c -o client
ubuntu:~/test/aa$ gcc server.c -o server
ubuntu:~/test/aa$ ls
client  client.c  server  server.c
ubuntu:~/test/aa$ ./server
Socket id = 3
Bind success!
Listening....

打开另外一个终端，执行./client 127.0.0.1
得到来自服务器端获取的账号test和密码test

//终端B:
ubuntu:~/test/aa$  ./client 127.0.0.1 
client send OK count = 100
data from pon is result=ok|id=test|pwd=test

这时查看执行server程序的终端，查看下面打印，可以发现接收客户端的命令是getPwd ，并且程序做出相应处理后把数据发送给了客户端

 //终端A:
string from client is <letter>getPwd</letter> ,length = 100
the parsed data is getPwd 
found it 
client_acquire_server_info: parameter getPwd 
Began to get the password
Send the parsed msg to client
client send OK, count = 100,result = result=ok|id=test|pwd=test