socket通讯的简单实现（C）

服务端多线程版本代码：

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <pthread.h>

#define SERVER_PORT 9002              // 判断是否被占用 netstat -an | grep 9001
#define LENGTH_OF_LISTEN_QUEUE 10     // 监听客户端链接数量

void handle_client_connect(void *new_server_socket);

int main()
{
    printf("server start ......\n");

    struct sockaddr_in server_addr;
    memset(&server_addr,0x00,sizeof(struct sockaddr_in));

    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htons(INADDR_ANY);    // 必须是网络字节序（大端）
    server_addr.sin_port = htons(SERVER_PORT);          // 必须是网络字节序（大端）
   int  server_socket;
    server_socket = socket(AF_INET,SOCK_STREAM,0);                             // socket
    bind(server_socket,(struct sockaddr *)&server_addr,sizeof(server_addr));   // bind
    listen(server_socket,LENGTH_OF_LISTEN_QUEUE);                  // listen

    struct sockaddr_in client_addr;
    socklen_t length = sizeof(client_addr);

    while(1){
        pthread_t threadnew;
        int new_server_socket = accept(server_socket,(struct sockaddr *)&client_addr,&length);
        printf("start clinet connect!\n");

        pthread_create(&threadnew, NULL, (void *)(&handle_client_connect), (void *)(&new_server_socket));
    }

    close(server_socket);
    return 0;
}

void handle_client_connect(void *new_server_socket){
    int cli_socket = *((int *)new_server_socket);
    while(1)
    {
        char recvbuf[1024];
        memset(recvbuf,0x00,sizeof(recvbuf));
        int rlength = recv(cli_socket,recvbuf,1024,0);
        printf("recv buf len is [%d]\n", rlength);
        recvbuf[rlength] = '\0';
        if(strncmp(recvbuf,"q", 1) == 0)
        {
              printf("clent quit!\n");
            break;
        }
        printf("recv from client:[%s]\n",recvbuf);
    }
    close(cli_socket);
    pthread_exit(NULL);

服务端代码：

#include <stdio.h>
#include <sys/types.h>    // socket()
#include <sys/socket.h>   // socket() bind() listen() accept() recv()
#include <arpa/inet.h>    // htons() htonl()
#include <string.h>       // strerror()
#include <errno.h>        // errno
#include <unistd.h>       // close()
#include <stdlib.h>       // exit()

#define SERVER_PORT 9001      // 检测是否被占用 netstat -an | grep 9001
#define MAX_CONNECT_NUM 10    // 最大连接数 
#define RECV_LENGTH 1024      // recv 接收的字节数

int main(){

    printf("sercer start...\n");
    int ret = -1;

    // socket()
    int server_socket = socket(AF_INET, SOCK_STREAM, 0);

    // bind()
    struct sockaddr_in  server_in;
    memset(&server_in, 0x00, sizeof(struct sockaddr_in));
    server_in.sin_family = AF_INET;
    server_in.sin_addr.s_addr = htonl(INADDR_ANY);    // 转换为网络字节序（大端）
    server_in.sin_port = htons(SERVER_PORT);          // 转换为网络字节序（大端）
    ret = bind(server_socket, (struct sockaddr *)&server_in, sizeof(server_in));
    if(-1 == ret){
        printf("bind error[%s, errno:%d]\n", strerror(errno), errno);
        exit(0);
    }

    // listen()
    ret = listen(server_socket, MAX_CONNECT_NUM);
    if(-1 == ret){
        printf("listen error[%s, errno:%d]\n", strerror(errno), errno);
        exit(0);
    }

    // accept()
    char recvbuf[RECV_LENGTH];
    memset(recvbuf, 0x00, sizeof(recvbuf));
    
    while(1){
        int new_server_socket = accept(server_socket, (struct sockaddr *)NULL, NULL);  // 阻塞模式
        if(-1 == new_server_socket){
            printf("server accept error[%s, errno:%d]\n", strerror(errno), errno);
            continue;
        }
        printf("client connnect success...\n");

        int length = recv(new_server_socket, recvbuf, RECV_LENGTH, 0);
        recvbuf[length] = '\0';
        printf("client:[%s]\n", recvbuf);
        close(new_server_socket);
    }
    
    // close()
    close(server_socket);

    return 0;
}

客户端代码：

#include <stdio.h>
#include <sys/types.h>   // socket()
#include <sys/socket.h>  // socket() connect() send() close()
#include <arpa/inet.h>   // inet_pton()
#include <string.h>      // strerror
#include <errno.h>       // errno
#include <stdlib.h>      // exit()

#define SERVER_PORT 9001  // 服务端端口号

int main(){
    printf("client start...\n");

    int ret = -1;

    // socket()
    int client_socket = socket(AF_INET, SOCK_STREAM, 0);

    // connect()
    struct sockaddr_in client_in;
    memset(&client_in, 0x00, sizeof(client_in));
    client_in.sin_family = AF_INET;
    client_in.sin_port = htons(SERVER_PORT);  // 必须是网络字节序（大端）
    ret = inet_pton(AF_INET, "127.0.0.1", &client_in.sin_addr);
    if(ret < 0){
        printf("inet_pton error[%s, errno:%d]\n", strerror(errno), errno);
        exit(0);
    }
    ret = connect(client_socket, (struct sockaddr *)&client_in, sizeof(client_in));
    if(ret < 0){
        printf("connect error[%s, errno:%d]\n", strerror(errno), errno);
        exit(0);
    }

    // send()
    char sendbuf[1024];
    memset(sendbuf, 0x00, sizeof(sendbuf));
    printf("client input:\n");
    gets(sendbuf);
    int in_length = strlen(sendbuf);
    sendbuf[in_length] = '\0';

    ret = send(client_socket, sendbuf, 1024, 0);
    if(ret < 0){
        printf("send error[%s, errno:%d]\n", strerror(errno), errno);
        exit(0);
    }

    // close()
    close(client_socket);
    return 0;
}

Makefile:

CC=cc

all:server client 
cleanlist=server client *.o

server:server.o
	${CC} $@.c -o $@ 

client:client.o
	${CC} $@.c -o $@ 

clean:
	rm -f ${cleanlist}