TCP 服务端/客户端 传输数据结构

参考学习：《unix网络编程 卷1》

编写4个文件 server.c , client.c , sum.h , Makefile

主要是客户端 与服务端在传输数据的时候，不是直接传递字符串，而是传递自定义的数据结构

注意：TCP传送的信息是以字节为单位保证顺序的.当两台机器都同时小端机或大端机时，传输是正常的。否则，可能会出现异常情况。

server.c

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>
#include <arpa/inet.h>
#include <signal.h>
#include "sum.h"

#define MYPORT  9877
#define QUEUE   20
#define BUFFER_SIZE 1024


void sig_child(int signo)
{
    pid_t pid;
    int stat;

    while( (pid = waitpid(-1, &stat, WNOHANG)) > 0)
        printf("child %d terminated\n", pid);
    return;
}

/* read n bytes to a descrpiter */
ssize_t Readn(int fd,const void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nread;
    const char *ptr;
    ptr = vptr;
    nleft = n;
    while (nleft > 0) 
    {
        if( (nread = read(fd, ptr, nleft)) < 0)
        {
            if( nread < 0)
                nread = 0;
            else
                return -1; // error
        }
        nleft -= nread;
        ptr += nread;
    }
    return n-nleft; 
}

/* write n bytes to a descrpiter */
ssize_t Writen(int fd,const void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nwritten;
    const char *ptr;
    ptr = vptr;
    nleft = n;
    while (nleft > 0) 
    {
        if( (nwritten = write(fd, ptr, nleft)) <= 0)
        {
            if( nwritten < 0)
                nwritten = 0;
            else
                return -1; // error
        }
        nleft = -nwritten;
        ptr += nwritten;
    }
    return n;   
}

void str_echo(int sockfd)
{
    ssize_t n;
    //char buf[BUFFER_SIZE];
    struct args args;
    struct result result;
    for(; ;) {
        if( (n = Readn(sockfd, &args, sizeof(args))) == 0 )
            return;
        result.sum = args.arg1 + args.arg2;
        Writen(sockfd, &result, sizeof(result));
    }
}

int main()
{
    // 定义sockfd
    int server_sockfd = socket(AF_INET,SOCK_STREAM, 0);

    // 定义sockaddr_in
    struct sockaddr_in server_sockaddr;
    server_sockaddr.sin_family = AF_INET;//协议族
    server_sockaddr.sin_port = htons(MYPORT); //端口
    server_sockaddr.sin_addr.s_addr = htonl(INADDR_ANY); //地址

    // bind，成功返回0，出错返回-1
    if(bind(server_sockfd,(struct sockaddr *)&server_sockaddr,sizeof(server_sockaddr))==-1)
    {
        perror("bind");
        exit(1);
    }

    // listen，成功返回0，出错返回-1
    if(listen(server_sockfd,QUEUE) == -1)
    {
        perror("listen");
        exit(1);
    }

    signal(SIGCHLD, sig_child);// 信号处理

    while(1){
        ///客户端套接字
        struct sockaddr_in client_addr;
        socklen_t length = sizeof(client_addr);

        ///成功返回非负描述字，出错返回-1
        int conn = accept(server_sockfd, (struct sockaddr*)&client_addr, &length);
        if(conn<0)
        {
            perror("connect");
            exit(1);
        }

        char buff[BUFFER_SIZE];
        // 显示连接的客户端
        printf("connection from %s, port %d\n", 
            inet_ntop(AF_INET, &client_addr.sin_addr, buff, sizeof(buff)),
            ntohs(client_addr.sin_port));

        pid_t child_pid ;

        if( (child_pid = fork()) == 0 ) // 为客户端fork子进程
        {
            close(server_sockfd);
            str_echo(conn);     
            exit(0);
        }
        close(conn);
    }

    return 0;
}

client.c

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/shm.h>
#include "sum.h"

#define MYPORT  9877
#define BUFFER_SIZE 1024

/* read n bytes to a descrpiter */
ssize_t Readn(int fd,const void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nread;
    const char *ptr;
    ptr = vptr;
    nleft = n;
    while (nleft > 0) 
    {
        if( (nread = read(fd, ptr, nleft)) < 0)
        {
            if( nread < 0)
                nread = 0;
            else
                return -1; // error
        }
        nleft -= nread;
        ptr += nread;
    }
    return n-nleft; 
}


/* write n bytes to a descrpiter */
ssize_t Writen(int fd,const void *vptr, size_t n)
{
    size_t nleft;
    ssize_t nwritten;
    const char *ptr;
    ptr = vptr;
    nleft = n;
    while (nleft > 0) 
    {
        if( (nwritten = write(fd, ptr, nleft)) <= 0)
        {
            if( nwritten < 0)
                nwritten = 0;
            else
                return -1; // error
        }
        nleft = -nwritten;
        ptr += nwritten;
    }
    return n;   
}

ssize_t readline(int fd, void *vptr, size_t maxlen)
{
    ssize_t n, rc;
    char c, *ptr;
    ptr = vptr;
    for(n = 1 ;n < maxlen; n++)
    {
        if( (rc = read(fd, &c, 1)) == 1)
        {
            *ptr++ = c;
            if(c == '\n')
                break;
        }else if( rc == 0) {
            *ptr = 0;
            return (n-1);
        }else{
            return -1;
        }
    }
    *ptr = 0;
    return n;
}

void str_cli(FILE *fp, int sockfd)
{
    char sendline[BUFFER_SIZE];
    struct args args;
    struct result result;
    while( fgets(sendline, BUFFER_SIZE , fp) != NULL)
    {
        if (sscanf(sendline, "%ld%ld", &args.arg1, &args.arg2) != 2) {
            printf("invalid input: %s\n", sendline);
            continue;
        }
        Writen(sockfd, &args, sizeof(args));

        if (Readn(sockfd, &result, sizeof(result)) == 0)
            perror("str_cli: server terminated prematurely");
        printf("%ld\n", result.sum);
    }
}


int main()
{
    ///定义sockfd
    int sock_cli = socket(AF_INET,SOCK_STREAM, 0);

    ///定义sockaddr_in
    struct sockaddr_in servaddr;
    memset(&servaddr, 0, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(MYPORT);  ///服务器端口
    servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");  ///服务器ip

    ///连接服务器，成功返回0，错误返回-1
    if (connect(sock_cli, (struct sockaddr *)&servaddr, sizeof(servaddr)) < 0)
    {
        perror("connect");
        exit(1);
    }

    str_cli(stdin,sock_cli); //回射客户端的程序
    exit(0);
}

sum.h

struct args{
    long arg1;
    long arg2;  
};

struct result{
    long sum;
};

Makefile

.PHONY: build clean

CC=gcc
HEADERS=-I.
DEBUG=-g -ggdb  
WALL=-Wall -W  
CFLAGS=$(WALL) $(DEBUG)  
L_CC=$(CC) $(CFLAGS) $(HEADERS)     

build:server client

server:server.c
    $(L_CC) $< -o $@

client:client.c
    $(L_CC) $< -o $@

clean:
    @-if [ -f server ]; then rm server; fi
    @-if [ -f client ]; then rm client; fi

运行结果如下