• Linux下C语言实现HTTP文件服务器和TCP协议实现网络数据传输

           在实际开发中经常用到web框架，比如Servlet，SpringBoot等，这些开发框架提高了我们的开发效率，节省了开发时间。但是这会令我们技术人员处于浮云之上，看不到其本质。说实话，Java语言那么流行，其本质是运行在JRE虚拟机上的，而JRE是用C/C++语言开发的。与其说java跨平台，不如说是因为在不同平台上各自实现JRE，从而屏蔽了java语言直接与不同平台打交道。http协议广泛应用，也是基于TCP协议之上的封装。本节博主将带领大家用C语言在Linux环境下开发HTTP服务器，支持浏览器下载和浏览文件。另外还使用TCP协议开发了服务端和客户端来实现服务端监听客户端连接，然后向其发送一首唐诗。

    目录

    1. 关键函数说明

    1.1 IP地址字节序转换

    1.2 端口字节序转换

    1.3 socket

    1.4 bind

    1.5 listen

    1.6 accept

    1.7 接收数据

    1.8 发送数据

    1.9 connect

    2. HTTP服务器

    2.1 源码

    2.2 效果

    3.TCP服务器和客户端

    3.1 源码

    3.2 效果

    1. 关键函数说明

    1.1 IP地址字节序转换

      IP 地址本质是整数，但是为了方便，在使用的过程中都是用字符串来描述，超过两个字节的数据单元，在跨网络传输时候就需要考虑本地字节序和网络字节序的转换，Linux下主要使用api如下：

    1）本地字节序转网络字节序
    int inet_pton(int af, const char *src, void *dst); 
    参数:
    af: 地址族协议，IPV4或者IPV6
    AF_INET: IPV4  地址
    AF_INET6: IPV6地址
    src: 点分十进制的 ip 地址，例如192.168.1.2
    dst: 传出参数，存放大端整形IP地址
    返回值：成功返回 1，失败返回 0 或者 - 1

    2）网络字节序转本机字节序    
    const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

    参数
    af: 地址族协议，IPV4或者IPV6
    AF_INET: IPV4  地址
    AF_INET6: IPV6地址
    src: 大端的整形 IP 地址
    dst: 存储转换得到的小端的点分十进制的IP地址
    size: dst内存中占用字节数
    返回值:
    成功：指针指向第三个参数对应的内存地址，通过返回值可以直接取出转换得到的IP字符串
    失败: NULL

    只能处理IPV4地址的api
    (1)点分十进制IP转大端整形
    in_addr_t inet_addr (const char *cp);

    (2)大端整形转点分十进制IP
    char* inet_ntoa(struct in_addr in);

    1.2 端口字节序转换

    1）主机字节序转网络字节序
    uint16_t htons(uint16_t hostshort);    
    uint32_t htonl(uint32_t hostlong);    

    2）网络字节序转主机字节序
    uint16_t ntohs(uint16_t netshort)
    uint32_t ntohl(uint32_t netlong);

    1.3 socket

    int socket(int domain, int type, int protocol);

    作用：创建socket文件描述符，通过该文件描述符可以操作内核中的某一块内存，用来进行网络通信

    参数:
    domain: 使用的地址族协议
    AF_INET:  IPv4 格式的 ip 地址
    AF_INET6:  IPv6 格式的 ip 地址
    type:
    SOCK_STREAM: 流式传输协议
    SOCK_DGRAM: 报式 (报文) 传输协议
    protocol: 一般写 0 ，表示使用默认的协议
    SOCK_STREAM: 流式传输默认是 tcp
    SOCK_DGRAM: 报式传输默认是udp
    返回值:
    成功：可用于套接字通信的文件描述符
    失败: -1

    1.4 bind

    int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

    作用：将文件描述符和本地的IP与端口进行绑定   

    参数:
    sockfd: 监听的文件描述符，通过 socket () 调用得到
    addr: 要绑定的 IP 和端口信息需要初始化到这个结构体中，IP和端口要转换为网络字节序
    addrlen: 参数 addr 指向的内存大小
    返回值：成功返回 0，失败返回 - 1

    1.5 listen

    作用：监听套接字
    int listen(int sockfd, int backlog);
    参数:
    sockfd: 文件描述符，调用 socket () 得到
    backlog: 同时能处理的最大连接，最大值为 128
    返回值：成功返回 0，失败返回 -1

    1.6 accept

    int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
    作用：等待并接受客户端的连接请求, 建立新的连接, 得到一个通信的文件描述符，函数是一个阻塞函数，当没有新的客户端连接请求的时候，该函数阻塞。
    当检测到有新的客户端连接时，解除阻塞，得到的描述符就可以和客户端通信。
    参数:
    sockfd: 监听的文件描述符
    addr: 建立连接的客户端的地址信息
    addrlen:  addr 指向的内存大小
    返回值：函数调用成功，得到一个文件描述符，调用失败返回 -1

    1.7 接收数据

    ssize_t read(int sockfd, void *buf, size_t size);
    ssize_t recv(int sockfd, void *buf, size_t size, int flags);

    参数:
    sockfd: accept 或者connect函数的返回值
    buf: 接收数据内存
    size: 参数 buf 指向的内存的容量
    flags: 一般不使用，指定为 0
    返回值:
    大于 0：实际接收的字节数
    等于 0：对方断开了连接
    -1：接收数据失败了
    如果连接没有断开，接收不到数据，会阻塞等待数据到达，数据到达后函数解除阻塞，开始接收数据，当发送端断开连接，接收端无法接收到任何数据，时候就不会阻塞了，直接返回0。

    1.8 发送数据

    ssize_t write(int fd, const void *buf, size_t len);
    ssize_t send(int fd, const void *buf, size_t len, int flags);
    参数:
    fd: accept 或者connect函数的返回值
    buf: 发送的数据
    len: 要发送数据长度
    flags: 一般不使用，指定为 0
    返回值：
    大于 0：实际发送的字节数，等于参数 len
    -1：发送数据失败了

    1.9 connect

    int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
    作用：与服务器建立连接
    参数:
    sockfd: socket 返回值
    addr: 要连接的服务器的 iP 和 端口，这个 IP 和端口都是大端的
    addrlen: addr内存大小
    返回值：连接成功返回 0，连接失败返回 - 1

    2. HTTP服务器

    http服务器实现建立在tcp协议之上，采用epoll和多线程的方式接收和处理客户端。解析从TCP传过来的数据，解析请求行，找到需要访问的资源。如果是目录则使用html的a标签href属性进行重定位，进入目录。如果是文件，txt和png文件浏览器在线预览，其他文件则让浏览器进行下载。

    2.1 源码

    头文件：

    1. #pragma once
    2. #include 
    3.  
    4. //线程参数结构
    5. struct ThreadParam {
    6.     pthread_t tid;
    7.     int fd;
    8.     int epfd;
    9. };
    10.  
    11. int initListenFd(unsigned short port);
    12.  
    13. int epoolRun(int lfd);
    14.  
    15. void* acceptClient(void *);
    16.  
    17. void* recvHttpRequest(void *);
    18.  
    19. int parseRequestLine(int cfd, const char *line);
    20.  
    21. int sendFile(int cfd, const char *fileName);
    22.  
    23. int sendHeadMsg(int cfd, int status, const char *descr, const char *type, int length);
    24.  
    25. const char *getFileType(const char *name);
    26.  
    27. int sendDir(int cfd, const char*dirName);
    28.  
    29. int hex2dec (char c);
    30.  
    31. char dec2hex (short int c);
    32.  
    33. void urlDecode(char* from, char *to);

    源文件

    1. #include "HttpServer.h"
    2. #include 
    3. #include  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16.  
    17. int initListenFd(unsigned short port) {
    18.     int lfd = socket(AF_INET, SOCK_STREAM, 0);
    19.     if (-1 == lfd) {
    20.         perror("scoket");
    21.         return -1;
    22.     }
    23.     int opt = -1;
    24.     int ret = setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    25.     if (-1 == ret) {
    26.         perror("setsockopt");
    27.         return -1;
    28.     }
    29.     struct sockaddr_in addr;
    30.     addr.sin_family = AF_INET;
    31.     addr.sin_port = htons(port);
    32.     addr.sin_addr.s_addr = INADDR_ANY;
    33.     ret = bind(lfd, (const struct sockaddr *)&addr, sizeof(addr));
    34.     if (-1 == ret) {
    35.         perror("bind");
    36.         return -1;
    37.     }
    38.     ret = listen(lfd, 128);
    39.     if (-1 == ret) {
    40.         perror("listen");
    41.         return -1;
    42.     }
    43.     return lfd;
    44. }
    45.  
    46. int epoolRun(int lfd) {
    47.     int epfd = epoll_create(1);
    48.     if (-1 == epfd) {
    49.         perror("epoll_create");
    50.         return -1;
    51.     }
    52.     struct epoll_event ev;
    53.     ev.data.fd = lfd;
    54.     ev.events = EPOLLIN;
    55.     int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);
    56.     if (-1 == ret) {
    57.         perror("epoll_ctl");
    58.         return -1;
    59.     }
    60.     struct epoll_event evs[2048];
    61.     int maxwait = sizeof(evs) / sizeof(struct epoll_event);
    62.     while (1) {
    63.         int num = epoll_wait(epfd, evs, maxwait, -1);
    64.         for (int i = 0; i <= num; i++) {
    65.             int fd = evs[i].data.fd;
    66.             pthread_t tid;
    67.             struct ThreadParam *param = 
    68.                 (struct ThreadParam *)malloc(sizeof(struct ThreadParam));
    69.             param->fd = fd;
    70.             param->epfd = epfd;
    71.             param->tid = tid;
    72.             if (fd == lfd) {
    73.                 pthread_create(&tid, NULL, acceptClient, param);
    74.                 pthread_detach(tid);
    75.             }
    76.             else {
    77.                 pthread_create(&tid, NULL, recvHttpRequest, param);
    78.                 pthread_detach(tid);
    79.             }
    80.         }
    81.     }
    82.     
    83.     return 0;
    84. }
    85.  
    86. void* acceptClient(void *arg) {
    87.     struct ThreadParam *param = (struct ThreadParam *)arg;
    88.     if (!param) {
    89.         return NULL;
    90.     }
    91.     int lfd = param->fd;
    92.     int epfd = param->epfd;
    93.     int cfd = accept(lfd, NULL, NULL);
    94.     if (-1 == cfd) {
    95.         perror("accept");
    96.         return NULL;
    97.     }
    98.     int flag = fcntl(cfd, F_GETFL);
    99.     flag |= O_NONBLOCK;
    100.     fcntl(cfd, F_SETFL, flag);
    101.     struct epoll_event ev;
    102.     ev.data.fd = cfd;
    103.     ev.events = EPOLLIN | EPOLLET; //cfd边缘非阻塞模式，效率最高
    104.     int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);
    105.     if (-1 == cfd) {
    106.         perror("epoll_ctl");
    107.     }
    108.     free(param);
    109.     param = NULL;
    110.     printf("accept thread %ld\n", pthread_self());
    111.     return NULL;
    112. }
    113.  
    114. void* recvHttpRequest(void *arg) {
    115.     struct ThreadParam *param = (struct ThreadParam *)arg;
    116.     char buf[8192] = {0};
    117.     int len = 0;
    118.     int total = 0;
    119.     char tmpBuf[1024] = {0};
    120.     if (!param) {
    121.         return NULL;
    122.     }
    123.     int cfd = param->fd;
    124.     int epfd = param->epfd;
    125.     while ((len = recv(cfd, tmpBuf, sizeof(tmpBuf), 0)) > 0) {
    126.         if (total + len < sizeof(buf)) {
    127.             memcpy(buf + total, tmpBuf, len);
    128.         }
    129.         total += len;
    130.     }
    131.     if (-1 == len && errno == EAGAIN && total > 0) { //接收数据完毕
    132.         //解析http协议
    133.         char *pt = strstr(buf, "\r\n");
    134.         int reqLen = pt - buf;
    135.         buf[reqLen] = '\0';
    136.         parseRequestLine(cfd, buf);
    137.     }
    138.     else if (0 == len) { //客户端断开了连接
    139.         epoll_ctl(epfd, EPOLL_CTL_DEL, cfd, NULL);
    140.         close(cfd);
    141.     }
    142.     else {
    143.         perror("recv");
    144.     }
    145.     free(param);
    146.     param = NULL;
    147.     printf("client thread %ld\n", pthread_self());
    148.     return NULL;
    149. }
    150.  
    151. int parseRequestLine(int cfd, const char *line) {
    152.     char method[32] = {0};
    153.     char path[2048] = {0};
    154.     char decodePath[1024] = {0};
    155.     char protocol[128] = {0};
    156.     //sscanf解析格式化字符串
    157.     sscanf(line, "%[^ ] %[^ ] %s", method, path, protocol);
    158.     printf("method: %s, path: %s protocol: %s\n", method, path, protocol);
    159.     if (0 != strcasecmp(method, "get")) {
    160.         return -1;
    161.     }
    162.     urlDecode(path, decodePath);
    163.     //http中/代表服务端工作的资源根目录
    164.     char *file = NULL;
    165.     if (0 == strcmp(decodePath, "/")) {
    166.         file = ".";
    167.     }
    168.     else {
    169.         file = decodePath + 1;
    170.     }
    171.     struct stat st;
    172.     int ret = stat(file, &st);
    173.     if (-1 == ret) {
    174.         //回复404页面
    175.         sendHeadMsg(cfd, 404, "Not Found", getFileType(".html"), -1); //-1表示不知道长度，让浏览器自己解析去
    176.         sendFile(cfd, "404.html");
    177.         return 0;
    178.     }
    179.     if (S_ISDIR(st.st_mode)) {
    180.         sendHeadMsg(cfd, 200, "OK", getFileType(".html"), -1);
    181.         sendDir(cfd, file);
    182.     }
    183.     else {
    184.         sendHeadMsg(cfd, 200, "OK", getFileType(file), st.st_size);
    185.         sendFile(cfd, file);
    186.     }
    187.  
    188.     return 0;
    189. }
    190.  
    191. int sendFile(int cfd, const char *fileName) {
    192.     //读一部分数据，发送一部分数据，因为tcp是面向连接的流式的
    193.     int fd = open(fileName, O_RDONLY);
    194.     assert(fd > 0);
    195. #if 0
    196.     while (1) {
    197.         char buf[1024];
    198.         int len = read(fd, buf, sizeof(buf));
    199.         if (len > 0) {
    200.             send(cfd, buf, len, 0);
    201.             usleep(20); //减轻接收端压力
    202.         }
    203.         else if (0 == len) {
    204.             break;
    205.         }
    206.         else {
    207.             perror("read");
    208.         }
    209.     }
    210. #endif
    211. #if 1
    212.     off_t len = 0;
    213.     int size = lseek(fd, 0, SEEK_END);
    214.     lseek(fd, 0, SEEK_SET);
    215.     while (len < size) {
    216.         int ret = sendfile(cfd, fd, &len, size - len);
    217.         printf("ret value %d \n", ret);
    218.         if (-1 == ret) {
    219.             if (EAGAIN == errno) {
    220.                 printf("no data\n");
    221.                 perror("sendfile");
    222.             }
    223.             else {
    224.                 printf("client quit \n");
    225.                 break;
    226.             }
    227.         }
    228.         
    229.     }
    230. #endif
    231.     return 0;
    232. }
    233.  
    234. int sendHeadMsg(int cfd, int status, const char *descr, const char *type, int length) {
    235.     char buf[8192] = {0};
    236.     int offset = 0;
    237.     int ret = sprintf(buf + offset, "http/1.1 %d %s\r\n", status, descr);
    238.     offset += ret;
    239.     ret = sprintf(buf + offset, "content-type: %s\r\n", type);
    240.     offset += ret;
    241.     ret = sprintf(buf + offset, "content-length: %d\r\n\r\n", length);
    242.     offset += ret;
    243.     send(cfd, buf, offset, 0);
    244.     return 0;
    245. }
    246.  
    247. const char *getFileType(const char *name) {
    248.     const char* dot = strrchr(name, '.');
    249.     if (NULL == dot) {
    250.         return "text/palin; charset=utf-8";
    251.     }
    252.     if (0 == strcasecmp(dot, ".html")) {
    253.         return "text/html; charset=utf-8";
    254.     }
    255.     if (0 == strcasecmp(dot, ".png")) {
    256.         return "image/png; charset=utf-8";
    257.     }
    258.     if (0 == strcasecmp(dot, ".txt")) {
    259.         return "text/palin; charset=utf-8";
    260.     }
    261.     // ...
    262.     return "application/octet-stream; charset=utf-8";
    263. }
    264.  
    265. int sendDir(int cfd, const char*dirName) {
    266.     char buf[2048] = {0};
    267.     int len = 0;
    268.     int ret = sprintf(buf + len, "%s", dirName);
    269.     len += ret;
    270.     struct dirent** namelist = NULL;
    271.     int num = scandir(dirName, &namelist, NULL, alphasort);
    272.     for (int i = 0; i < num; i++) {
    273.         char * name = namelist[i]->d_name;
    274.         struct stat st;
    275.         char path[1024] = {0};
    276.         sprintf(path, "%s/%s", dirName, name);
    277.         stat(path, &st);
    278.         if (S_ISDIR(st.st_mode)) {
    279.             if (!strcmp(".", name) || !strcmp("..", name)) {
    280.                 continue;
    281.             }
    282.             ret = sprintf(buf + len, "
      283. ", \
    283.                         name, name, st.st_size);
    284.         }
    285.         else {
    286.             ret = sprintf(buf + len, "
      287. ",
    287.                         name, name, st.st_size);
    288.         }
    289.         len += ret;
    290.         send(cfd, buf, len, 0);
    291.         len = 0;
    292.         memset(buf, 0x00, sizeof(buf));
    293.         free(namelist[i]);
    294.     }
    295.     len = sprintf(buf, "
      296. %s    %ld
      %s    %ld
      "      );
    296.     send(cfd, buf, len, 0);
    297.     free(namelist);
    298.     return 0;
    299. }
    300.  
    301. int hex2dec (char c) {
    302.     if ('0' <= c && c <= '9') return c - '0';
    303.     else if ('a' <= c && c <= 'f') return c - 'a' + 10;
    304.     else if ('A' <= c && c <= 'F') return c - 'A' + 10;
    305.     return 0;
    306. }
    307.  
    308. char dec2hex (short int c) {
    309.     if (0 <= c && c <= 9) return c + '0';
    310.     else if (10 <= c && c <= 15) return c + 'A' - 10;
    311.     return 0;
    312. }
    313.  
    314. void urlDecode(char* org, char *obj) {
    315.     if (!org || !obj) {
    316.         return;
    317.     }
    318.     //isxdigit:判断字符是否是十六进制字符
    319.     for (; *org != '\0'; ++org, ++obj) {
    320.         if ('%' == org[0] && isxdigit(org[1]) && isxdigit(org[2])) {
    321.             *obj = hex2dec(org[1]) * 16 + hex2dec(org[2]);
    322.             org += 2;
    323.         }
    324.         else {
    325.             *obj = *org;
    326.         }
    327.     }
    328. }

    主程序：

    1. #include 
    2. #include 
    3. #include "HttpServer.h"
    4.  
    5. int main(int argc, char** argv) {
    6.     unsigned short int port;
    7.     if (argc < 3) {
    8.         printf("program {port} {path}\n");
    9.         return -1;
    10.     }
    11.     sscanf(argv[1], "%hu", &port);
    12.     printf("begin start http server, listen %d ...\n", port);
    13.     //修改进程的工作目录
    14.     chdir(argv[2]);
    15.     int lfd = initListenFd(port);
    16.     epoolRun(lfd);
    17.  
    18.     return 0;
    19. }

    Makefile 编译脚本：

    1. app: httpServer tcpServer tcpClient
    2.  
    3. #说明：$^代表依赖项
    4. httpServer: CommonUtil.c HttpServer.c main.c
    5. 	gcc -g $^ -o httpServer -lpthread 
    6.  
    7. tcpServer: CommonUtil.c TcpServer.c
    8. 	gcc -g $^ -o tcpServer
    9.  
    10. tcpClient: CommonUtil.c TcpClient.c
    11. 	gcc -g $^ -o tcpClient
    12.  
    13. clean:
    14. 	-rm httpServer tcpServer tcpClient -f

    2.2 效果

     

     展示web服务器的根目录：

    在线浏览文件：

    下载文件：

    3.TCP服务器和客户端

    tcp协议作用途广泛，它是面向连接的流式协议，三次握手建立连接，四次挥手断开连接，其通信流程如下:

    3.1 源码

    头文件：

    1. #pragma once
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6.  
    7. int isLittleEndian();
    8.  
    9. int readn(int fd, char* buf, int len);
    10.  
    11. int writen(int fd, char *buf, int len);

    源文件

    1.  #include 
    2. #include 
    3. #include  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include "CommonUtil.h"
    13.  
    14. static const char* _s_showMsg [] = {
    15.     "次北固山下",
    16.     "【作者】王湾 【朝代】唐",
    17.     "客路青山外，行舟绿水前。",
    18.     "潮平两岸阔，风正一帆悬。",
    19.     "海日生残夜，江春入旧年。",
    20.     "乡书何处达？归雁洛阳边。"
    21. };
    22.  
    23. static void sendMsg(int fd, const char *data, int len) {
    24.     char *buf = (char *)malloc(sizeof(int) + len);
    25.     int nlen = len;
    26.     if (isLittleEndian()) {
    27.         nlen = htonl(len);
    28.     }
    29.     memcpy(buf, &nlen, sizeof(int));
    30.     memcpy(buf + sizeof(int), data, len);
    31.     printf("发送数据长度:: [%d] 内容:: [%s]\n", len, data);
    32.     writen(fd, buf, sizeof(int) + len);
    33.     if (buf) {
    34.         free(buf);
    35.     }
    36. }
    37.  
    38. static int startTcpServer(unsigned short port)
    39. {
    40.     int lfd = socket(AF_INET, SOCK_STREAM, 0);
    41.     if (-1 == lfd) {
    42.         perror("scoket");
    43.         return -1;
    44.     }
    45.     int opt = -1;
    46.     int ret = setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
    47.     if (-1 == ret) {
    48.         perror("setsockopt");
    49.         return -1;
    50.     }
    51.     struct sockaddr_in addr;
    52.     addr.sin_family = AF_INET;
    53.     addr.sin_port = htons(port);
    54.     addr.sin_addr.s_addr = INADDR_ANY;
    55.     ret = bind(lfd, (const struct sockaddr *)&addr, sizeof(addr));
    56.     if (-1 == ret) {
    57.         perror("bind");
    58.         return -1;
    59.     }
    60.     ret = listen(lfd, 128);
    61.     if (-1 == ret) {
    62.         perror("listen");
    63.         return -1;
    64.     }
    65.     struct sockaddr_in client;
    66.     socklen_t client_addrlen = sizeof(client);
    67.      printf("port %d, wait client accept ...\n", port);
    68.     int connfd = accept(lfd, (struct sockaddr*)(&client), &client_addrlen);
    69.     if (connfd < 0) {
    70.         perror("accept");
    71.         return -1;
    72.     }
    73.     printf("connect client info: addr = %s, port = %d\n",
    74.             inet_ntoa(client.sin_addr), ntohs(client.sin_port));
    75.     int lineNum = sizeof(_s_showMsg) / sizeof(_s_showMsg[0]);
    76.     for (int i = 0; i < lineNum; i++) {
    77.         sendMsg(connfd, _s_showMsg[i], strlen(_s_showMsg[i]));
    78.         usleep(1000 * 100); //此处为了减轻客户端压力
    79.     }
    80.     printf("我活干完了，数据已经全部发送到客户端！\n");
    81.     getchar();
    82.     close(connfd);
    83.     close(lfd);
    84.  
    85.     return 1;
    86. }
    87.  
    88. int main(int argc, char**argv) {
    89.     if (argc < 2) {
    90.         printf("a.out {port}\n");
    91.         return -1;
    92.     }
    93.     unsigned short port;
    94.     sscanf(argv[1], "%hu", &port);
    95.     startTcpServer(port);
    96.     return 0;
    97. }
    1. #include 
    2. #include  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include "CommonUtil.h"
    9.  
    10. static void recvMsg(int fd, char **data, int *len) {
    11.    int nlen = 0;
    12.    int ret = readn(fd, (char*)&nlen, sizeof(int));
    13.    *len = nlen;
    14.    if (isLittleEndian()) {
    15.         *len = ntohl(nlen);
    16.    }
    17.    char *tmp = (char *)malloc(*len + 1);
    18.    readn(fd, tmp, *len);
    19.    tmp[*len] = '\0';
    20.    *data = tmp;
    21. }
    22.  
    23. static int startTcpClient(unsigned short port)
    24. {
    25.     int sockfd = socket(AF_INET, SOCK_STREAM, 0);    
    26. 	assert(-1 != sockfd);
    27. 	//指定服务器的ip和端口
    28. 	struct sockaddr_in saddr;  
    29.     memset(&saddr, 0, sizeof(saddr)); 
    30.     saddr.sin_family = AF_INET;   
    31.     saddr.sin_port = htons(port);    
    32.     //saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    33.     inet_pton(sockfd, "127.0.0.1", &saddr.sin_addr.s_addr);
    34.     //作为客户端不需要指定端口，系统自动给客户端设置端口，连接上后直接收发数据
    35.     printf("begin connect port %d\n", port);
    36.     int ret = connect(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));   
    37.     if (-1 == ret) {
    38.         perror("connect");
    39.         return 0;
    40.     }
    41.     while(1)    
    42.     {               
    43.     	char *buff = NULL;          
    44.         int ret = 0;
    45.         recvMsg(sockfd, &buff, &ret);
    46.         if (-1 == ret) {
    47.             perror("read");
    48.             break;
    49.         }
    50.         else if (0 == ret) {
    51.             perror("server quit ");
    52.             break;
    53.         }
    54.         else {
    55.             if (buff) {
    56.                 printf("接收数据长度:: [%d] 内容:: [%s]\n", ret, buff);
    57.                 free(buff);
    58.             }
    59.         }
    60.         printf("\r\n------------------------------\n\r");
    61.         sleep(rand() % 10);
    62.      }
    63.     close(sockfd);    
    64.     exit(0); 
    65. }
    66.  
    67. int main(int argc, char**argv) {
    68.     if (argc < 2) {
    69.         printf("a.out {port}\n");
    70.         return -1;
    71.     }
    72.     unsigned short port;
    73.     sscanf(argv[1], "%hu", &port);
    74.     startTcpClient(port);
    75.     return 0;
    76. }
    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include "CommonUtil.h"
    6.  
    7. int isLittleEndian() {
    8.     static unsigned short data = 0x1234;
    9.     if (*((char*)&data) == 0x34) {
    10.         return 1;
    11.     }
    12.     else {
    13.         return 0;
    14.     }
    15. }
    16.  
    17.  
    18. int readn(int fd, char* buf, int len) {
    19.     int nleft = len;
    20.     int nread = 0;
    21.     char *pbuf = buf;
    22.     while (nleft > 0) {
    23.         nread = read(fd, pbuf, nleft);
    24.         if (-1 == nread) {
    25.             perror("read");
    26.             return -1;
    27.         }
    28.         else if (0 == nread) {
    29.             return len - nleft;
    30.         }
    31.         pbuf += nread;
    32.         nleft -= nread;
    33.     }
    34.     return len;
    35. }
    36.  
    37. int writen(int fd, char *buf, int len) {
    38.     int nleft = len;
    39.     int nwrite = 0;
    40.     char *pbuf = buf;
    41.     while (nleft > 0) {
    42.         nwrite = write(fd, pbuf, nleft);
    43.         if (-1 == nwrite) {
    44.             perror("write");
    45.             return -1;
    46.         }
    47.         else if (0 == nwrite) {
    48.             continue;
    49.         }
    50.         pbuf += nwrite;
    51.         nleft -= nwrite;
    52.     }
    53.     return len;
    54. }

    编译脚本：

    1. app: httpServer tcpServer tcpClient
    2.  
    3. #说明：$^代表依赖项
    4. httpServer: CommonUtil.c HttpServer.c main.c
    5. 	gcc -g $^ -o httpServer -lpthread 
    6.  
    7. tcpServer: CommonUtil.c TcpServer.c
    8. 	gcc -g $^ -o tcpServer
    9.  
    10. tcpClient: CommonUtil.c TcpClient.c
    11. 	gcc -g $^ -o tcpClient
    12.  
    13. clean:
    14. 	-rm httpServer tcpServer tcpClient -f

    3.2 效果

    源码下载路径如下：
    https://download.csdn.net/download/hsy12342611/87183336

    只有平时多接触底层编程才能体会到一些技术的本质，做技术不能被表面的虚幻所迷惑，要从本质上去理解一些东西，好的，今天就到这里了，该去休息了。

  • 相关阅读:
    （数据科学学习手札142）dill：Python中增强版的pickle
    SpringSecurity实战（陈木鑫）读书笔记
    redux-获取导航标题案例(+react-intl 国际化)
    HTML5 新元素
    pytorch-过拟合&欠拟合
    GridLayout使用小记2022-08-11
    vue3在子组件中触发的父组件函数方式
    我为什么会性格内向，能不能内向性格？
    JAVA基于J2ME的手机游戏开发免费
    软件测试基本常识
  • 原文地址：https://blog.csdn.net/hsy12342611/article/details/128070982