Socket on ZRJ | 学习笔记

再谈对非阻塞的理解

Mon, 20 Jul 2015 19:21:37 +0800

一般来说，现在大家 epoll 都是搭配着非阻塞 IO 一起用的，要问为什么？大家都这么用的啊，而且异步嘛，非阻塞嘛，很自然嘛

但是，非阻塞 IO 具体是怎么对 send 和 recv 起作用的。一般理解，我们之所以要用非阻塞，是为了避免这种情况：

客户端跟我们 tcp 三次握手完了，我们 listen fd 上得到一个 IN 事件了，然后 accept，得到一个新的 client fd，然后如果这个时候，客户端没有发字节流过来，我们调用 recv，就会因为服务器的系统缓冲区中空空如也，陷入阻塞，所以如果这里我们用上非阻塞，就可以让 recv 快速的返回一个 0，从而让 CPU 转而去处理其他 client fd，所以，非阻塞对 recv 的作用效果是很明显的。

但是 send 呢，即使是在阻塞情况下，我们调用 send，系统都是把我们的数据拷贝到系统缓冲区，然后就返回了，而并不需要等到这些数据真正发出来收到 ack 之后才返回，也就是说，这里纯粹是一个内存拷贝的动作，不涉及和远端机器的交互，照理说，应该是不会陷入等待的。那是否就能说阻塞非阻塞对于 send 来说不那么重要呢？也不尽然，考虑到出现系统发送缓冲区满了的情况，这时我们需要等待缓冲区发送一部分之后，腾出地方来，我们 send 的数据才能拷贝进去，在这种情况下，貌似就要依靠非阻塞才行了，非阻塞下 send 会快速的返回一个失败，好让我们采取其他的措施。

那么，接下来看这个代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <time.h>
#include <sys/epoll.h>
#include <map>
#include <string>

#define  _PRINTF_(format, ...) printf("[%s] " format " [%s::%s::%d]\n", getdatetimestr(), ##__VA_ARGS__, __FILE__, __FUNCTION__, __LINE__)

char* getdatetimestr() {
    static char datetimestr[32] = {0};
    static time_t last_update_time = 0;
    struct timeval tv = {0};
    gettimeofday(&tv, NULL);
    time_t nowtime = tv.tv_sec;
    if (nowtime != last_update_time) {
        last_update_time = nowtime;
        struct tm nowtm = {0};
        localtime_r(&nowtime, &nowtm);
        strftime(datetimestr, sizeof(datetimestr), "%Y-%m-%d %H:%M:%S", &nowtm);
    }
    snprintf(datetimestr+19, sizeof(datetimestr)-19, ".%06ld", tv.tv_usec);
    return datetimestr;
}

int ctl_epoll_event(int epoll_fd, int ctl, int fd, int event) {
    // EPOLL IN = 0x001,
    // EPOLL PRI = 0x002,
    // EPOLL OUT = 0x004,
    // EPOLL RDNORM = 0x040,
    // EPOLL RDBAND = 0x080,
    // EPOLL WRNORM = 0x100,
    // EPOLL WRBAND = 0x200,
    // EPOLL MSG = 0x400,
    // EPOLL ERR = 0x008,
    // EPOLL HUP = 0x010,
    // EPOLL ET = (1 << 31)

    // EPOLL_CTL_ADD 1
    // EPOLL_CTL_DEL 2
    // EPOLL_CTL_MOD 3
    
    //_PRINTF_("epoll_fd %d, ctl %d, fd %d, event %d", epoll_fd, ctl, fd, event);
    struct epoll_event ev;
    ev.data.fd = fd;
    ev.events = event;
    return epoll_ctl(epoll_fd, ctl, fd, &ev);
}

int httpSrv2(short port) {
    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd == -1) {
        _PRINTF_("%m");
        return -1;
    }
    int reuseaddr = 1;
    setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr));
    struct sockaddr_in server_addr = {0};
    server_addr.sin_family = AF_INET;
    server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    server_addr.sin_port = htons(port);
    if (bind(listen_fd, (struct sockaddr*)&server_addr, sizeof(server_addr)) == -1) {
        _PRINTF_("%m");
        return -1;
    }
    if (listen(listen_fd, 32) == -1) {
        _PRINTF_("%m");
        return -1;
    }
    _PRINTF_("listening...");
    int epoll_fd = epoll_create(4096);
    if (ctl_epoll_event(epoll_fd, EPOLL_CTL_ADD, listen_fd, EPOLLIN) == -1) {
        _PRINTF_("%m");
        return -1;
    }
    std::map<int, std::string> fd_buffer_map;
    for (int count = 0; ; ) {        
        struct epoll_event epoll_events[64] = {{0}};
        int epoll_events_num = epoll_wait(epoll_fd, epoll_events, sizeof(epoll_events)/sizeof(epoll_events[0]), 5*1000);
        //_PRINTF_("epoll_events_num, %d", epoll_events_num);
        for (int epoll_events_index =  0; epoll_events_index < epoll_events_num; epoll_events_index++) {
            int event_fd = epoll_events[epoll_events_index].data.fd;
            if (event_fd == listen_fd) {
                if (!(epoll_events[epoll_events_index].events & EPOLLIN)) {
                    _PRINTF_("listen fd event: %d, msg: %m", epoll_events[epoll_events_index].events);
                    continue;
                }                
                int client_fd = accept(listen_fd, (struct sockaddr*)NULL, NULL);
                //int client_fd = accept4(listen_fd, (struct sockaddr*)NULL, NULL, SOCK_NONBLOCK);
                if (client_fd == -1) {
                    _PRINTF_("%m");
                    continue;
                }
                ctl_epoll_event(epoll_fd, EPOLL_CTL_ADD, client_fd, EPOLLIN);
            } else {
                int client_fd = event_fd;
                if (epoll_events[epoll_events_index].events & EPOLLIN) {
                    char recv_buff[64*1024] = {0};
                    int recv_len = recv(client_fd, recv_buff, sizeof(recv_buff), 0);
                    if (recv_len < 0) {
                        _PRINTF_("%m");
                        continue;
                    }
                    fd_buffer_map[client_fd].append(recv_buff, recv_len);
                    //_PRINTF_("fd %d buffer [%s]", client_fd, fd_buffer_map[client_fd].c_str());
                    if (fd_buffer_map[client_fd].find("\r\n\r\n") == std::string::npos) {
                        continue;
                    }
                    char response[] = "HTTP/1.1 200 OK\r\n\r\n<h1>Hello World</h1>";
                    if (send(client_fd, response, sizeof(response)-1, 0) < 0) {
                        _PRINTF_("%m");
                    }
                    if (count++ % 100000 == 0) {
                        _PRINTF_("count %d, last request [%s], last response [%s]", count, fd_buffer_map[client_fd].c_str(), response);
                    }
                    ctl_epoll_event(epoll_fd, EPOLL_CTL_DEL, client_fd, EPOLLIN);
                    close(client_fd);
                    fd_buffer_map.erase(client_fd);
                } else {
                    _PRINTF_("client fd event: %d, msg: %m", epoll_events[epoll_events_index].events);
                }
            }
        }
    }
    close(epoll_fd);
    close(listen_fd);
    return 0;
}

int main(int argc, char** argv) {
    _PRINTF_("starting server...");
    httpSrv2(atoi(argv[1]));
    return 0;
}

这个代码通过 95/96 行可以切换阻塞和非阻塞模式，在两种模式中，其实服务的吞吐量差不多，但是，阻塞的代码，CPU 跑到了 100%（一个核上 100%，其他核空闲），非阻塞的代码，同样的吞吐率，CPU 只用了不到 10%，这是为什么呢？

-———————–

2015-7-20 19:37:42 进一步的观察发现，非阻塞的 10% CPU 使用率，只是在进程刚启动的时候，在进程运行一段时间之后，也会跑到 100% 的 CPU

Linux 多进程监听 socket

Thu, 11 Apr 2013 15:31:17 +0800

首先来看代码

#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/wait.h>

int main() {
    int sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (sockfd == -1 ) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(8080);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }
    if (listen(sockfd, 20) == -1) {
        perror("listen");
        return -1;
    }
    for (int i = 0; i < 2; i++) {
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork");
        } else if (pid == 0) {
            // child process
            while (1) {
                struct sockaddr_in cli_addr;
                memset(&cli_addr, 0, sizeof(cli_addr));
                socklen_t cli_addr_len = 0;
                int connfd = accept(sockfd, (struct sockaddr*)&cli_addr, &cli_addr_len);
                if (connfd == -1) {
                    perror("accept");
                    return -1;
                }
                char *cli_addr_str = inet_ntoa(cli_addr.sin_addr);
                int cli_addr_port = ntohs(cli_addr.sin_port);
                printf("pid: %d, cli addr: %s:%d\n", getpid(), cli_addr_str, cli_addr_port);
                char buff[4096] = {0};
                if (recv(connfd, buff, sizeof(buff), 0) == -1) {
                    perror("recv");
                    return -1;
                }
                char html_resp[] = "HTTP/1.1 200 OK\r\n\r\nhello";
                if (send(connfd, html_resp, strlen(html_resp), 0) == -1) {
                    perror("send");
                    return -1;
                }
                close(connfd);
            }        
        } else if (pid > 0) {
            // parent process
            printf("forked pid: %d\n", pid);
        }
    }
    while (1) {
        pid_t end_pid = wait(NULL);
        if (end_pid == -1) {
            perror("wait");
            return -1;
        }
        printf("child process %d end\n", end_pid);
    }
    close(sockfd);
    return 0;
}

编译一下

g++ -Wall -g main.cpp -o addrreuse.exe

多次模拟请求

wget http://localhost:8080/123

服务端的输出如下：

forked pid: 23278
forked pid: 23279
pid: 23278, cli addr: 0.0.0.0:0
pid: 23279, cli addr: 0.0.0.0:0
pid: 23278, cli addr: 0.0.0.0:0
pid: 23279, cli addr: 0.0.0.0:0

事实证明，是可以多个进程来 accept 一个 sockfd 的，（好吧，高手当我在说废话就行了），然后注意到有一个东西叫惊群效应，http://blog.csdn.net/chenxinl/article/details/6376895

惊群效应：指一个fd的事件被触发后，等候这个fd的所有线程/进程都被唤醒。低版本的linux内核在accept这边有所谓的“惊群效应”，是指一个链接过来，会把堵塞在accept上的所有子进程都唤醒；但是只有一个子进程都读取到链接，其他子进程唤醒后发现没有数据，继续睡觉去了；这样就产生了大量的进程切换开销。但目前的内核版本已经修复了这个问题，一个链接过来，内核只会唤醒一个子进程出来accept，这样就不用担心惊群效应了。但是对于其他类型的fd，惊群效应还是存在的，而且是必须的；比如多个进程wait在一个pipe的读事件上，有数据过来后，多个进程都会被唤醒，因为内核也不知道这些数据就给一个进程读的，还是每个进程都读一点，这个逻辑是应用层控制的；而accept也相当于一个读事件，但内核确认一个进程接受一个链接就可以了。同理，如果多个子进程把同一个listen的fd添加到各自的epoll_wait中，有链接过来会导致所有的子进程唤醒，这也会导致惊群效应；但这个是应用层面需要解决的问题。关于httpserver惊群效应和如何处理：http://bbs3.chinaunix.net/viewthread.php?action=printable&tid=1676724

但是另外看到这里，http://www.iteye.com/topic/561424

在2.6内核下，内核只会wakeup一个进程。就是说，2.6的内核下面，不会出现惊群的现象。

Linux TCP UDP 混合

Mon, 08 Apr 2013 16:07:14 +0800

基本的思路是这样的：在服务器端，有两个机器，一个对外开启 TCP 监听，然后把监听到的请求内容送到后面的另外一台，或者多台轮询机器上，内网之间使用 UDP，然后等待业务逻辑机器处理完成，这个地方可以做成异步的，然后再返回到用户。

即是这样： client <-TCP-> server_front <-UDP-> server_back

下面来看代码，首先是 server_front 的 demo

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

#include "struct.h"

int main() {
    int tcpfd = socket(AF_INET, SOCK_STREAM, 0);
    if (tcpfd == -1) {
        perror("tcpfd socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(38080);
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    if (bind(tcpfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("tcpfd bind");
        return -1;
    }
    if (listen(tcpfd, 10) == -1) {
        perror("tcpfd listen");
        return -1;
    }
    
    // udp
    int udpfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (udpfd == -1) {
        perror("udpfd socket");
        return -1;
    }
    struct sockaddr_in udp_serv_addr;
    memset(&udp_serv_addr, 0, sizeof(udp_serv_addr));
    udp_serv_addr.sin_family = AF_INET;
    udp_serv_addr.sin_port = htons(8080);
    if (inet_pton(AF_INET, "10.1.164.18", &udp_serv_addr.sin_addr) <= 0) {
        perror("udpfd inet pton");
        return -1;
    }
    
    while (1) {
        int tcp_conn_fd = accept(tcpfd, NULL, NULL);
        if (tcp_conn_fd == -1) {
            perror("tcpfd accept");
            return -1;
        }
        char buff[2048];
        memset(buff, 0, sizeof(buff));
        int recvn = recv(tcp_conn_fd, buff, sizeof(buff), 0);
        if (recvn == -1) {
            perror("tcpfd recv");
            return -1;
        }
        printf("recv: [%s]\n", buff);
        //char html_resp[] = "HTTP/1.1 200 OK\r\n\r\ntcp udp mix";
        UDP_MSG udp_msg;
        memset(&udp_msg, 0, sizeof(udp_msg));
        strcpy(udp_msg.str1, "HTTP/1.1 200 OK\r\n\r\n");
        strcpy(udp_msg.str2, "send to udp for cat");
        if (sendto(udpfd, &udp_msg, sizeof(udp_msg), 0, (struct sockaddr*)&udp_serv_addr, sizeof(udp_serv_addr)) == -1) {
            perror("udp send to");
            return -1;
        }
        if (recvfrom(udpfd, &udp_msg, sizeof(udp_msg), 0, NULL, NULL) == -1) {
            perror("udp recv from");
            return -1;
        }
        if (send(tcp_conn_fd, udp_msg.cat, strlen(udp_msg.cat), 0) == -1) {
            perror("tcp send");
            return -1;
        }
        close(tcp_conn_fd);
    }
    close(tcpfd);
    return 0;
}

然后是内部的报文格式 struct.h

#ifndef STRUCT_H
#define STRUCT_H

typedef struct _UDP_MSG {
    int add1;
    int add2;
    int sum;
    char str1[128];
    char str2[128];
    char cat[256];
} UDP_MSG;

#endif /* STRUCT_H */

然后是后端的业务逻辑服务器

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_serv();

int main() {
    return udp_serv();
}

int udp_serv() {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(SERV_PORT);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }

    while (1) {
        struct sockaddr_in cli_addr;
        memset(&cli_addr, 0, sizeof(cli_addr));
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        socklen_t cli_addr_len = sizeof(cli_addr);
        recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        msg.sum = msg.add1 + msg.add2;
        strcpy(msg.cat, msg.str1);
        strcat(msg.cat, msg.str2);
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, cli_addr_len);
    }

    return 0;
}

编译一下，就可以测试了

$ wget http://localhost:38080/123 && nl 123
--16:05:03--  http://localhost:38080/123
           => `123.2'
Resolving localhost... 127.0.0.1
Connecting to localhost|127.0.0.1|:38080... connected.
HTTP request sent, awaiting response... 200 OK
Length: unspecified

    [<=> ] 19            --.--K/s             

16:05:03 (3.62 MB/s) - `123.2' saved [19]

     1	send to udp for cat

期间，server_front 的输出应该是这样的

recv: [GET /123 HTTP/1.0
User-Agent: Wget/1.10.2
Accept: */*
Host: localhost:38080
Connection: Keep-Alive

]

后台业务逻辑服务器的输出应该是这样的

msg.add1 is: 0
msg.add2 is: 0
msg.sum is: 0
msg.str1 is: HTTP/1.1 200 OK


msg.str2 is: send to udp for cat
msg.cat is: HTTP/1.1 200 OK

send to udp for cat

Linux UDP 收发实例

Sun, 07 Apr 2013 18:33:05 +0800

首先我们需要一个 struct.h

#ifndef STRUCT_H
#define STRUCT_H

typedef struct _UDP_MSG {
    int add1;
    int add2;
    int sum;
    char str1[128];
    char str2[128];
    char cat[256];
} UDP_MSG;

#endif /* STRUCT_H */

然后是服务端的

#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>
#include <netinet/in.h>
#include <stdio.h>
#include <stdlib.h>

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_serv();

int main() {
    return udp_serv();
}

int udp_serv() {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
    serv_addr.sin_port = htons(SERV_PORT);

    if (bind(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("bind");
        return -1;
    }

    while (1) {
        struct sockaddr_in cli_addr;
        memset(&cli_addr, 0, sizeof(cli_addr));
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        socklen_t cli_addr_len = sizeof(cli_addr);
        recvfrom(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, &cli_addr_len);
        msg.sum = msg.add1 + msg.add2;
        strcpy(msg.cat, msg.str1);
        strcat(msg.cat, msg.str2);
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        sendto(sockfd, &msg, sizeof(msg), 0, (struct sockaddr*)&cli_addr, cli_addr_len);
    }

    return 0;
}

然后是客户端的

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

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_cli(const char* serv_ip);

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s serv_ip\n", argv[0]);
        return 1;
    }
    return udp_cli(argv[1]);
}

int udp_cli(const char* serv_ip) {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    if (inet_pton(AF_INET, serv_ip, &serv_addr.sin_addr) <= 0) {
        perror("inet_pton");
        return -1;
    }
    while (1) {
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        msg.add1 = 1;
        msg.add2 = 2;
        sprintf(msg.str1, "hello ");
        sprintf(msg.str2, "world");
        if (sendto(sockfd, &msg, sizeof(msg), 0,
            (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
            perror("write");
            return -1;
        }
        socklen_t serv_addr_len = sizeof(serv_addr);
        if (recvfrom(sockfd, &msg, sizeof(msg), 0,
            (struct sockaddr*)&serv_addr, &serv_addr_len) == -1) {
            perror("read");
            return -1;
        }
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        break;
    }
    return 0;
}

客户端另外一种，像这样的写法也行。。

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

#include "struct.h"

#define MAX_LINE 1024
#define SERV_PORT 8080

int udp_cli(const char* serv_ip);

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Usage: %s serv_ip\n", argv[0]);
        return 1;
    }
    return udp_cli(argv[1]);
}

int udp_cli(const char* serv_ip) {
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd == -1) {
        perror("socket");
        return -1;
    }
    struct sockaddr_in serv_addr;
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    if (inet_pton(AF_INET, serv_ip, &serv_addr.sin_addr) <= 0) {
        perror("inet_pton");
        return -1;
    }
    if (connect(sockfd, (struct sockaddr*)&serv_addr, sizeof(serv_addr)) == -1) {
        perror("connect");
        return -1;
    }
    while (1) {
        UDP_MSG msg;
        memset(&msg, 0, sizeof(msg));
        msg.add1 = 1;
        msg.add2 = 2;
        sprintf(msg.str1, "hello ");
        sprintf(msg.str2, "world");
        if (write(sockfd, &msg, sizeof(msg)) == -1) {
            perror("write");
            return -1;
        }
        if (read(sockfd, &msg, sizeof(msg)) == -1) {
            perror("read");
            return -1;
        }
        printf("msg.add1 is: %d\n", msg.add1);
        printf("msg.add2 is: %d\n", msg.add2);
        printf("msg.sum is: %d\n", msg.sum);
        printf("msg.str1 is: %s\n", msg.str1);
        printf("msg.str2 is: %s\n", msg.str2);
        printf("msg.cat is: %s\n", msg.cat);
        break;
    }
    return 0;
}

然后编译

g++ -Wall -g serv.cpp -o serv.exe
g++ -Wall -g cli.cpp -o cli.exe

就可以运行了

历史评论

ZRJ (2013-04-07 18:33:34):

补充来源：http://www.chinaitpower.com/A200508/2005-08-02/182672.html