zoukankan      html  css  js  c++  java

  • 转 网络编程学习笔记一：Socket编程

    题外话

    前几天和朋友聊天，朋友问我怎么最近不写博客了，一个是因为最近在忙着公司使用的一些控件的开发，浏览器兼容性搞死人；但主要是因为这段时间一直在看html5的东西，看到web socket时觉得很有意思，动手写几个demo，但web socket需要特定的服务器支持，由于标准制定工作还没完成，所以没有多少主流的服务器支持，自己在网上下载了几个实现，包括php的、C#的、甚至Node.js的，但一个是协议变化比较大，很多代码已经过时了，再就是有一些支持最新的标准，但是我想稍微改造一下，看人家源代码的时候云里雾里，看看别人的代码行数也不多，决定自己实现一个。

    悲剧由此开始，虽然哥们儿国内非知名工科大学毕业，但好歹也是科班CS出身，但大学得过且过，什么TCP/IP协议，什么socket了都没概念。为了做出一个简单的支持广播的websocket server，在网上找了很多相关代码，左抄一句，右抄一句，弄了一个星期竟然还是漏洞百出，调试不起来，只好从头来过了，先补一些基本知识，然后再一步步根据原理实现，今天终于实现了绝大部分功能，由此真的感受到了，搞计算机必须得有理论指导实践，否则只能像个没头苍蝇到处乱撞。

    TCP/IP

    要想理解socket首先得熟悉一下TCP/IP协议族， TCP/IP（Transmission Control Protocol/Internet Protocol）即传输控制协议/网间协议，定义了主机如何连入因特网及数据如何再它们之间传输的标准，

    从字面意思来看TCP/IP是TCP和IP协议的合称，但实际上TCP/IP协议是指因特网整个TCP/IP协议族。不同于ISO模型的七个分层，TCP/IP协议参考模型把所有的TCP/IP系列协议归类到四个抽象层中

    应用层：TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet 等等

    传输层：TCP，UDP

    网络层：IP，ICMP，OSPF，EIGRP，IGMP

    数据链路层：SLIP，CSLIP，PPP，MTU

    每一抽象层建立在低一层提供的服务上，并且为高一层提供服务，看起来大概是这样子的

                            

    估计有兴趣打开此文的同学都对此有一定了解了，加上我也是一知半解，所以就不详细解释，有兴趣同学可以上网上搜一下资料

    维基百科 

    百度百科

    在TCP/IP协议中两个因特网主机通过两个路由器和对应的层连接。各主机上的应用通过一些数据通道相互执行读取操作

     

    socket

    我们知道两个进程如果需要进行通讯最基本的一个前提能能够唯一的标示一个进程，在本地进程通讯中我们可以使用PID来唯一标示一个进程，但PID只在本地唯一，网络中的两个进程PID冲突几率很大，这时候我们需要另辟它径了，我们知道IP层的ip地址可以唯一标示主机，而TCP层协议和端口号可以唯一标示主机的一个进程，这样我们可以利用ip地址＋协议＋端口号唯一标示网络中的一个进程。

    能够唯一标示网络中的进程后，它们就可以利用socket进行通信了，什么是socket呢？我们经常把socket翻译为套接字，socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。

    socket起源于UNIX，在Unix一切皆文件哲学的思想下，socket是一种"打开—读/写—关闭"模式的实现，服务器和客户端各自维护一个"文件"，在建立连接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件。

    socket通信流程

    socket是"打开—读/写—关闭"模式的实现，以使用TCP协议通讯的socket为例，其交互流程大概是这样子的

    服务器根据地址类型（ipv4,ipv6）、socket类型、协议创建socket

    服务器为socket绑定ip地址和端口号

    服务器socket监听端口号请求，随时准备接收客户端发来的连接，这时候服务器的socket并没有被打开

    客户端创建socket

    客户端打开socket，根据服务器ip地址和端口号试图连接服务器socket

    服务器socket接收到客户端socket请求，被动打开，开始接收客户端请求，直到客户端返回连接信息。这时候socket进入阻塞状态，所谓阻塞即accept()方法一直到客户端返回连接信息后才返回，开始接收下一个客户端谅解请求

    客户端连接成功，向服务器发送连接状态信息

    服务器accept方法返回，连接成功

    客户端向socket写入信息

    服务器读取信息

    客户端关闭

    服务器端关闭

    三次握手

    在TCP/IP协议中，TCP协议通过三次握手建立一个可靠的连接

    第一次握手：客户端尝试连接服务器，向服务器发送syn包（同步序列编号Synchronize Sequence Numbers），syn=j，客户端进入SYN_SEND状态等待服务器确认

    第二次握手：服务器接收客户端syn包并确认（ack=j+1），同时向客户端发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态

    第三次握手：第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1），此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手

    定睛一看，服务器socket与客户端socket建立连接的部分其实就是大名鼎鼎的三次握手

     socket编程API

    前面提到socket是"打开—读/写—关闭"模式的实现，简单了解一下socket提供了哪些API供应用程序使用，还是以TCP协议为例，看看Unix下的socket API，其它语言都很类似（PHP甚至名字都几乎一样），这里我就简单解释一下方法作用和参数，具体使用有兴趣同学可以看看博客参考中的链接或者上网搜索

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

    根据指定的地址族、数据类型和协议来分配一个socket的描述字及其所用的资源。

    domain:协议族，常用的有AF_INET、AF_INET6、AF_LOCAL、AF_ROUTE其中AF_INET代表使用ipv4地址

    type:socket类型，常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等

    protocol:协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等

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

    把一个地址族中的特定地址赋给socket

    sockfd:socket描述字，也就是socket引用

    addr:要绑定给sockfd的协议地址

    addrlen:地址的长度

    通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

    int listen(int sockfd, int backlog);

    监听socket

    sockfd:要监听的socket描述字

    backlog:相应socket可以排队的最大连接个数 

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

    连接某个socket

    sockfd:客户端的socket描述字

    addr:服务器的socket地址

    addrlen:socket地址的长度

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

     TCP服务器监听到客户端请求之后，调用accept()函数取接收请求

    sockfd:服务器的socket描述字

    addr:客户端的socket地址

    addrlen:socket地址的长度

    ssize_t read(int fd, void *buf, size_t count);

    读取socket内容

    fd:socket描述字

    buf：缓冲区

    count：缓冲区长度

    ssize_t write(int fd, const void *buf, size_t count);

    向socket写入内容，其实就是发送内容

    fd:socket描述字

    buf：缓冲区

    count：缓冲区长度

    int close(int fd);

    socket标记为以关闭 ，使相应socket描述字的引用计数-1，当引用计数为0的时候，触发TCP客户端向服务器发送终止连接请求。

    参考

    Linux Socket编程（不限Linux）

    揭开Socket编程的面纱 

    PS. 有同学看完后发现没有demo示例，参考中的示例已经很不错了，我就不班门弄斧了，而且我用C#实现了一个websocket server，接下来的博客中会有介绍。另外由于刚刚实际接触socket，文中谬误较多，还望大家批评指正，文章内容主要参考上面两个博文，图片全部来源于网络，在百度图片搜索得来，无法注明第一源地址，如有版权问题请站内信联系，第一时间处理。

    ---------------------------------------------------------------------------------------------------------
     

    面向连接的socket通信就像与对方打电话，首先需要通过电话建立一个连接，连接建立好之后，彼此才能双向通信。它有几个关键步骤

    服务器端通常以守护进程的方式实现:
    1: 创建守护进程
    2：获取或注册服务
    3：创建socket并绑定地址
    4：开始监听
    5：接收客户端连接请求
    6：进行数据传输

    客户端
    1：获取或注册服务
    2：创建socket
    3：发送连接请求

    示例代码
    服务器端的实现（以端口的形式提供给用户使用）

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <netdb.h>
    4. #include <arpa/inet.h>
    5. #include <stddef.h>        /* for offsetof */
    6. #include <string.h>        /* for convenience */
    7. #include <unistd.h>        /* for convenience */
    8. #include <signal.h>        /* for SIG_ERR */
    10. #include <errno.h>
    11. #include <syslog.h>
    12. #include <sys/socket.h>
    14. #include <fcntl.h>
    15. #include <sys/resource.h>
    17. #define BUFLEN    128
    18. #define QLEN 10
    20. #ifndef HOST_NAME_MAX
    21. #define HOST_NAME_MAX 256
    22. #endif
    24. void daemonize(const char *cmd)
    25. {
    26.     int                    i, fd0, fd1, fd2;
    27.     pid_t                pid;
    28.     struct rlimit        rl;
    29.     struct sigaction    sa;
    31.     /*
    32.      * Clear file creation mask.
    33.      */
    34.     umask(0);
    36.     /*
    37.      * Get maximum number of file descriptors.
    38.      */
    39.     if (getrlimit(RLIMIT_NOFILE, &rl) < 0)
    40.         printf("%s: can't get file limit", cmd);
    42.     /*
    43.      * Become a session leader to lose controlling TTY.
    44.      */
    45.     if ((pid = fork()) < 0)
    46.         printf("%s: can't fork", cmd);
    47.     else if (pid != 0) /* parent */
    48.         exit(0);
    49.     setsid();
    51.     /*
    52.      * Ensure future opens won't allocate controlling TTYs.
    53.      */
    54.     sa.sa_handler = SIG_IGN;
    55.     sigemptyset(&sa.sa_mask);
    56.     sa.sa_flags = 0;
    57.     if (sigaction(SIGHUP, &sa, NULL) < 0)
    58.         printf("%s: can't ignore SIGHUP");
    59.     if ((pid = fork()) < 0)
    60.         printf("%s: can't fork", cmd);
    61.     else if (pid != 0) /* parent */
    62.         exit(0);
    64.     /*
    65.      * Change the current working directory to the root so
    66.      * we won't prevent file systems from being unmounted.
    67.      */
    68.     if (chdir("/") < 0)
    69.         printf("%s: can't change directory to /");
    71.     /*
    72.      * Close all open file descriptors.
    73.      */
    74.     if (rl.rlim_max == RLIM_INFINITY)
    75.         rl.rlim_max = 1024;
    76.     for (i = 0; i < rl.rlim_max; i++)
    77.         close(i);
    79.     /*
    80.      * Attach file descriptors 0, 1, and 2 to /dev/null.
    81.      */
    82.     fd0 = open("/dev/null", O_RDWR);
    83.     fd1 = dup(0);
    84.     fd2 = dup(0);
    86.     /*
    87.      * Initialize the log file.
    88.      */
    89.     openlog(cmd, LOG_CONS, LOG_DAEMON);
    90.     if (fd0 != 0 || fd1 != 1 || fd2 != 2) {
    91.         syslog(LOG_ERR, "unexpected file descriptors %d %d %d",
    92.          fd0, fd1, fd2);
    93.         exit(1);
    94.     }
    95. }
    97. int initserver(int type, const struct sockaddr *addr, socklen_t alen,
    98.   int qlen)
    99. {
    100.     int fd;
    101.     int err = 0;
    103.     if ((fd = socket(addr->sa_family, type, 0)) < 0)
    104.         return(-1);
    105.     if (bind(fd, addr, alen) < 0) {
    106.         err = errno;
    107.         goto errout;
    108.     }
    109.     if (type == SOCK_STREAM || type == SOCK_SEQPACKET) {
    110.         if (listen(fd, qlen) < 0) {
    111.             err = errno;
    112.             goto errout;
    113.         }
    114.     }
    115.     return(fd);
    117. errout:
    118.     close(fd);
    119.     errno = err;
    120.     return(-1);
    121. }
    124. void serve(int sockfd)
    125. {
    126.     int        clfd;
    127.     FILE    *fp;
    128.     char    buf[BUFLEN];
    130.     for (;;) {
    131.         clfd = accept(sockfd, NULL, NULL);
    132.         if (clfd < 0) {
    133.             syslog(LOG_ERR, "ruptimed: accept error: %s",
    134.              strerror(errno));
    135.             exit(1);
    136.         }
    137.         if ((fp = popen("/usr/bin/uptime", "r")) == NULL) {
    138.             sprintf(buf, "error: %s ", strerror(errno));
    139.             send(clfd, buf, strlen(buf), 0);
    140.         } else {
    141.             while (fgets(buf, BUFLEN, fp) != NULL)
    142.                 send(clfd, buf, strlen(buf), 0);
    143.             pclose(fp);
    144.         }
    145.         close(clfd);
    146.     }
    147. }
    149. int main(int argc, char *argv[])
    150. {
    151.     struct addrinfo    *ailist, *aip;
    152.     struct addrinfo    hint;
    153.     int                sockfd, err, n;
    154.     char            *host;
    156.     if (argc != 1)
    157.         printf("usage: ruptimed");
    158. #ifdef _SC_HOST_NAME_MAX
    159.     n = sysconf(_SC_HOST_NAME_MAX);
    160.     if (n < 0)    /* best guess */
    161. #endif
    162.         n = HOST_NAME_MAX;
    163.     host = malloc(n);
    164.     if (host == NULL)
    165.         printf("malloc error");
    166.     if (gethostname(host, n) < 0)
    167.         printf("gethostname error");
    168.     printf("hostname=%s ",host);
    170.     daemonize("ruptimed");
    171.     hint.ai_flags = AI_PASSIVE;
    172.     hint.ai_family = 0;
    173.     hint.ai_socktype = SOCK_STREAM;
    174.     hint.ai_protocol = 0;
    175.     hint.ai_addrlen = 0;
    176.     hint.ai_canonname = NULL;
    177.     hint.ai_addr = NULL;
    178.     hint.ai_next = NULL;
    179.     if ((err = getaddrinfo(host, "2001", &hint, &ailist)) != 0) {
    180.         syslog(LOG_ERR, "ruptimed: getaddrinfo error: %s",gai_strerror(err));
    181.         exit(1);
    182.     }
    183.     for (aip = ailist; aip != NULL; aip = aip->ai_next) {
    184.         if ((sockfd = initserver(SOCK_STREAM, aip->ai_addr,aip->ai_addrlen, QLEN)) >= 0) {
    185.             printf("initserver ok ! ");
    186.             serve(sockfd);
    187.             exit(0);
    188.         }
    189.     }
    190.     printf("server err ! ");
    191.     exit(1);
    192. }

    客户端的实现

    1. #include <stdio.h>
    2. #include <stdlib.h>
    3. #include <netdb.h>
    4. #include <arpa/inet.h>
    5. #include <unistd.h>        /* for convenience */
    7. #include <sys/resource.h>
    8. #include <errno.h>
    9. #include <sys/socket.h>
    11. #define MAXADDRLEN    256
    12. #define BUFLEN        128
    14. #define MAXSLEEP 128
    16. int connect_retry(int sockfd, const struct sockaddr *addr, socklen_t alen)
    17. {
    18.     int nsec;
    20.     /*
    21.      * Try to connect with exponential backoff.
    22.      */
    23.     for (nsec = 1; nsec <= MAXSLEEP; nsec <<= 1) {
    24.         if (connect(sockfd, addr, alen) == 0) {
    25.             /*
    26.              * Connection accepted.
    27.              */
    28.             return(0);
    29.         }
    31.         /*
    32.          * Delay before trying again.
    33.          */
    34.         if (nsec <= MAXSLEEP/2)
    35.             sleep(nsec);
    36.     }
    37.     return(-1);
    38. }
    40. void print_uptime(int sockfd)
    41. {
    42.     int        n;
    43.     char    buf[BUFLEN];
    45.     while ((n = recv(sockfd, buf, BUFLEN, 0)) > 0)
    46.         write(STDOUT_FILENO, buf, n);
    47.     if (n < 0)
    48.         printf("recv error");
    49. }
    51. int main(int argc, char *argv[])
    52. {
    53.     struct addrinfo    *ailist, *aip;
    54.     struct addrinfo    hint;
    55.     int                sockfd, err;
    57.     if (argc != 2)
    58.         printf("usage: ruptime hostname");
    59.     hint.ai_flags = AI_CANONNAME;
    60.     hint.ai_family = 0;
    61.     hint.ai_socktype = SOCK_STREAM;
    62.     hint.ai_protocol = 0;
    63.     hint.ai_addrlen = 0;
    64.     hint.ai_canonname = NULL;
    65.     hint.ai_addr = NULL;
    66.     hint.ai_next = NULL;
    67.     if ((err = getaddrinfo(argv[1], "2001", &hint, &ailist)) != 0)
    68.         printf("getaddrinfo error: %s", gai_strerror(err));
    69.     for (aip = ailist; aip != NULL; aip = aip->ai_next) {
    70.         if ((sockfd = socket(aip->ai_family, SOCK_STREAM, 0)) < 0)
    71.             err = errno;
    72.         if (connect_retry(sockfd, aip->ai_addr, aip->ai_addrlen) < 0) {
    73.             err = errno;
    74.         } else {
    75.             print_uptime(sockfd);
    76.             exit(0);
    77.         }
    78.     }
    79.     fprintf(stderr, "can't connect to %s: %s ", argv[1],strerror(err));
    80.     exit(1);
    81. }

    测试流程：服务器端： 修改/etc/hosts如下
    192.168.1.11    X64-server
    127.0.0.1 localhost
    #127.0.1.1       X64-server 

    客户端  修改/etc/hosts如下
    127.0.0.1 localhost
    127.0.1.1 ubuntu
    192.168.1.11 X64-server

    说明：若服务器端以服务的形式提供给用的使用，服务端和客户端都需要在/etc/services中注册服务，但它们的端口号可以不一样，如：ruptime 2001/tcp，然后将getaddrinfo函数中端口号改为服务名就可以了

    面向无连接Socket通信
    而向无连接的socket通信就向发电子邮件一样，数据通信之前不需要建立连接的。

     
    ---------------------------------------------------------------------------------------------------------
     
     
     

    下图是基于TCP协议的客户端/服务器程序的一般流程：

    服务器调用socket()、bind()、listen()完成初始化后，调用accept()阻塞等待，处于监听端口的状态，客户端调用socket()初始化后，调用connect()发出SYN段并阻塞等待服务器应答，服务器应答一个SYN-ACK段，客户端收到后从connect()返回，同时应答一个ACK段，服务器收到后从accept()返回。

    数据传输的过程：

    建立连接后，TCP协议提供全双工的通信服务，但是一般的客户端/服务器程序的流程是由客户端主动发起请求，服务器被动处理请求，一问一答的方式。因此，服务器从accept()返回后立刻调用read()，读socket就像读管道一样，如果没有数据到达就阻塞等待，这时客户端调用write()发送请求给服务器，服务器收到后从read()返回，对客户端的请求进行处理，在此期间客户端调用read()阻塞等待服务器的应答，服务器调用write()将处理结果发回给客户端，再次调用read()阻塞等待下一条请求，客户端收到后从read()返回，发送下一条请求，如此循环下去。

    如果客户端没有更多的请求了，就调用close()关闭连接，就像写端关闭的管道一样，服务器的read()返回0，这样服务器就知道客户端关闭了连接，也调用close()关闭连接。注意，任何一方调用close()后，连接的两个传输方向都关闭，不能再发送数据了。如果一方调用shutdown()则连接处于半关闭状态，仍可接收对方发来的数据。

    在学习socket API时要注意应用程序和TCP协议层是如何交互的： *应用程序调用某个socket函数时TCP协议层完成什么动作，比如调用connect()会发出SYN段 *应用程序如何知道TCP协议层的状态变化，比如从某个阻塞的socket函数返回就表明TCP协议收到了某些段，再比如read()返回0就表明收到了FIN段

    看图所示的socket 通信过程

    图12.9 socket 的通信过程

    1.建立套接字

    在sys/socket.h中。

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

    socket()打开一个网络通讯端口，如果成功的话，就像open()一样返回一个文件描述符，应用程序可以像读写文件一样用read/write在网络上收发数据，如果socket()调用出错则返回-1。对于IPv4，family参数指定为AF_INET。对于TCP协议，type参数指定为SOCK_STREAM，表示面向流的传输协议。如果是UDP协议，则type参数指定为SOCK_DGRAM，表示面向数据报的传输协议。protocol参数的介绍从略，指定为0即可。

    Linux在利用socket()系统调用建立新的套接字时，需要传递套接字的地址族标识符、套接字类型以及协议,其函数定义于net/socket.c中：

       asmlinkagelong sys_socket(int family, int type, int protocol)

       {

            int retval;

            struct socket *sock;

            retval = sock_create(family, type, protocol,&sock);

            if (retval < 0)

                    goto out;

            retval = sock_map_fd(sock);

            if (retval < 0)

                    goto out_release;

    out:

            /* It may be already another descriptor 8) Not kernel problem. */

            return retval;

    out_release:

            sock_release(sock);

            return retval;

    }

       实际上，套接字对于用户程序而言就是特殊的已打开的文件。内核中为套接字定义了一种特殊的文件类型，形成一种特殊的文件系统sockfs，其定义于net/socket.c：

     static struct vfsmount *sock_mnt;

     static DECLARE_FSTYPE(sock_fs_type, "sockfs",sockfs_read_super, FS_NOMOUNT);

        在系统初始化时，要通过kern_mount()安装这个文件系统。安装时有个作为连接件的vfsmount数据结构，这个结构的地址就保存在一个全局的指针sock_mnt中。所谓创建一个套接字，就是在sockfs文件系统中创建一个特殊文件，或者说一个节点，并建立起为实现套接字功能所需的一整套数据结构。所以，函数sock_create()首先是建立一个socket数据结构，然后将其“映射”到一个已打开的文件中，进行socket结构和sock结构的分配和初始化。

    新创建的 BSD socket 数据结构包含有指向地址族专有的套接字例程的指针，这一指针实际就是proto_ops 数据结构的地址。

    BSD 套接字的套接字类型设置为所请求的 SOCK_STREAM 或 SOCK_DGRAM 等。然后，内核利用 proto_ops 数据结构中的信息调用地址族专有的创建例程。

    之后，内核从当前进程的 fd 向量中分配空闲的文件描述符，该描述符指向的 file 数据结构被初始化。初始化过程包括将文件操作集指针指向由 BSD 套接字接口支持的 BSD 文件操作集。所有随后的套接字（文件）操作都将定向到该套接字接口，而套接字接口则会进一步调用地址族的操作例程，从而将操作传递到底层地址族,如图12.10所示。

    实际上，socket结构与sock结构是同一事物的两个方面。如果说socket结构是面向进程和系统调用界面的，那么sock结构就是面向底层驱动程序的。可是，为什么不把这两个数据结构合并成一个呢？

    我们说套接字是一种特殊的文件系统，因此，inode结构内部的union的一个成分就用作socket结构，其定义如下：

    struct inode ｛

        …

      union {

         …

             struct socket            socket_i;

           }

      }

    由于套接字操作的特殊性，这个结构中需要大量的结构成分。可是，如果把这些结构成分全都放在socket结构中，则inode结构中的这个union就会变得很大，从而inode结构也会变得很大，而对于其他文件系统，这个union成分并不需要那么庞大。因此，就把套接字所需的这些结构成分拆成两部分，把与文件系统关系比较密切的那一部分放在socket结构中，把与通信关系比较密切的那一部分则单独组成一个数据结构，即sock结构。由于这两部分数据在逻辑上本来就是一体的，所以要通过指针互相指向对方，形成一对一的关系。

    2．在 INET BSD 套接字上绑定（bind）地址

     为了监听传入的 Internet 连接请求，每个服务器都需要建立一个 INET BSD 套接字，并且将自己的地址绑定到该套接字。绑定操作主要在 INET 套接字层中进行，还需要底层 TCP 层和 IP 层的某些支持。将地址绑定到某个套接字上之后，该套接字就不能用来进行任何其他的通讯，因此，该 socket数据结构的状态必须为 TCP_CLOSE。传递到绑定操作的 sockaddr 数据结构中包含要绑定的 IP地址，以及一个可选的端口地址。通常而言，要绑定的地址应该是赋予某个网络设备的 IP 地址，而该网络设备应该支持 INET 地址族，并且该设备是可用的。利用 ifconfig 命令可查看当前活动的网络接口。被绑定的 IP 地址保存在 sock 数据结构的rcv_saddr 和 saddr 域中，这两个域分别用于哈希查找和发送用的 IP 地址。端口地址是可选的，如果没有指定，底层的支持网络会选择一个空闲的端口。

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

    服务器程序所监听的网络地址和端口号通常是固定不变的，客户端程序得知服务器程序的地址和端口号后就可以向服务器发起连接，因此服务器需要调用bind绑定一个固定的网络地址和端口号。bind()成功返回0，失败返回-1。

    bind()的作用是将参数sockfd和myaddr绑定在一起，使sockfd这个用于网络通讯的文件描述符监听myaddr所描述的地址和端口号。前面讲过，struct sockaddr *是一个通用指针类型，myaddr参数实际上可以接受多种协议的sockaddr结构体，而它们的长度各不相同，所以需要第三个参数addrlen指定结构体的长度。我们的程序中对myaddr参数是这样初始化的：

    bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(SERV_PORT);

    首先将整个结构体清零，然后设置地址类型为AF_INET，网络地址为INADDR_ANY，这个宏表示本地的任意IP地址，因为服务器可能有多个网卡，每个网卡也可能绑定多个IP地址，这样设置可以在所有的IP地址上监听，直到与某个客户端建立了连接时才确定下来到底用哪个IP地址，端口号为SERV_PORT，我们定义为8000。


    当底层网络设备接受到数据包时，它必须将数据包传递到正确的 INET 和 BSD 套接字以便进行处理，因此，TCP维护多个哈希表，用来查找传入 IP 消息的地址，并将它们定向到正确的socket/sock 对。TCP 并不在绑定过程中将绑定的 sock 数据结构添加到哈希表中，在这一过程中，它仅仅判断所请求的端口号当前是否正在使用。在监听操作中，该 sock 结构才被添加到 TCP 的哈希表中。

    3．在 INET BSD 套接字上建立连接（connect）

        创建一个套接字之后，该套接字不仅可以用于监听入站的连接请求，也可以用于建立出站的连接请求。不论怎样都涉及到一个重要的过程：建立两个应用程序之间的虚拟电路。出站连接只能建立在处于正确状态的 INET BSD 套接字上，因此，不能建立于已建立连接的套接字，也不能建立于用于监听入站连接的套接字。也就是说，该 BSD socket 数据结构的状态必须为 SS_UNCONNECTED。

     在建立连接过程中，双方 TCP 要进行三次“握手”，具体过程在 本章第二节——网络协议一文中有详细介绍。如果 TCP sock 正在等待传入消息，则该 sock 结构添加到 tcp_listening_hash 表中，这样，传入的 TCP 消息就可以定向到该 sock 数据结构。

    由于客户端不需要固定的端口号，因此不必调用bind()，客户端的端口号由内核自动分配。注意，客户端不是不允许调用bind()，只是没有必要调用bind()固定一个端口号，服务器也不是必须调用bind()，但如果服务器不调用bind()，内核会自动给服务器分配监听端口，每次启动服务器时端口号都不一样，客户端要连接服务器就会遇到麻烦。

    int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen);

    客户端需要调用connect()连接服务器，connect和bind的参数形式一致，区别在于bind的参数是自己的地址，而connect的参数是对方的地址。connect()成功返回0，出错返回-1。


    4．监听（listen） INET BSD 套接字

     

    int listen(int sockfd, int backlog);

    典型的服务器程序可以同时服务于多个客户端，当有客户端发起连接时，服务器调用的accept()返回并接受这个连接，如果有大量的客户端发起连接而服务器来不及处理，尚未accept的客户端就处于连接等待状态，listen()声明sockfd处于监听状态，并且最多允许有backlog个客户端处于连接待状态，如果接收到更多的连接请求就忽略。listen()成功返回0，失败返回-1。

       当某个套接字被绑定了地址之后，该套接字就可以用来监听专属于该绑定地址的传入连接。网络应用程序也可以在未绑定地址之前监听套接字，这时，INET 套接字层将利用空闲的端口编号并自动绑定到该套接字。套接字的监听函数将 socket 的状态改变为 TCP_LISTEN。

    当接收到某个传入的 TCP 连接请求时，TCP 建立一个新的 sock 数据结构来描述该连接。当该连接最终被接受时，新的 sock 数据结构将变成该 TCP 连接的内核bottom_half部分，这时，它要克隆包含连接请求的传入 sk_buff 中的信息，并在监听 sock 数据结构的 receive_queue 队列中将克隆的信息排队。克隆的 sk_buff 中包含有指向新 sock 数据结构的指针。

    5．接受连接请求 （accept）

     

    接受操作在监听套接字上进行，从监听 socket 中克隆一个新的 socket 数据结构。其过程如下：接受操作首先传递到支持协议层，即 INET 中，以便接受任何传入的连接请求。相反，接受操作进一步传递到实际的协议，例如TCP 上。接受操作可以是阻塞的，也可以是非阻塞的。接受操作为非阻塞的情况下，如果没有可接受的传入连接，则接受操作将失败，而新建立的 socket 数据结构被抛弃。接受操作为阻塞的情况下，执行阻塞操作的网络应用程序将添加到等待队列中，并保持挂起直到接收到一个 TCP 连接请求为至。当连接请求到达之后，包含连接请求的 sk_buff 被丢弃，而由 TCP 建立的新 sock 数据结构返回到 INET 套接字层，在这里，sock 数据结构和先前建立的新 socket 数据结构建立链接。而新 socket 的文件描述符（fd）被返回到网络应用程序，此后，应用程序就可以利用该文件描述符在新建立的 INETBSD 套接字上进行套接字操作。

    int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);

    三方握手完成后，服务器调用accept()接受连接，如果服务器调用accept()时还没有客户端的连接请求，就阻塞等待直到有客户端连接上来。cliaddr是一个传出参数，accept()返回时传出客户端的地址和端口号。addrlen参数是一个传入传出参数（value-result argument），传入的是调用者提供的缓冲区cliaddr的长度以避免缓冲区溢出问题，传出的是客户端地址结构体的实际长度（有可能没有占满调用者提供的缓冲区）。如果给cliaddr参数传NULL，表示不关心客户端的地址。


    注意：服务器接收到传入的请求后，如果能够接受该请求，服务器必须创建一个新的套接字来接受该请求并建立通讯连接（用于监听的套接字不能用来建立通讯连接），这时，服务器和客户就可以利用建立好的通讯连接传输数据。

    转载地址：http://oss.org.cn/kernel-book/ch12/12.3.4.htm

     
    ---------------------------------------------------------------------------------------------------------

     

    网络编程学习笔记一：Socket编程

    “一切皆Socket！”

    话虽些许夸张，但是事实也是，现在的网络编程几乎都是用的socket。

    ——有感于实际编程和开源项目研究。

    我们深谙信息交流的价值，那网络中进程之间如何通信，如我们每天打开浏览器浏览网页时，浏览器的进程怎么与web服务器通信的？当你用QQ聊天时，QQ进程怎么与服务器或你好友所在的QQ进程通信？这些都得靠socket？那什么是socket？socket的类型有哪些？还有socket的基本函数，这些都是本文想介绍的。本文的主要内容如下：

    • 1、网络中进程之间如何通信？
    • 2、Socket是什么？
    • 3、socket的基本操作
      • 3.1、socket()函数
      • 3.2、bind()函数
      • 3.3、listen()、connect()函数
      • 3.4、accept()函数
      • 3.5、read()、write()函数等
      • 3.6、close()函数
    • 4、socket中TCP的三次握手建立连接详解
    • 5、socket中TCP的四次握手释放连接详解
    • 6、一个例子（实践一下）
    • 7、留下一个问题，欢迎大家回帖回答！！！

    1、网络中进程之间如何通信？

    本地的进程间通信（IPC）有很多种方式，但可以总结为下面4类：

    • 消息传递（管道、FIFO、消息队列）
    • 同步（互斥量、条件变量、读写锁、文件和写记录锁、信号量）
    • 共享内存（匿名的和具名的）
    • 远程过程调用（Solaris门和Sun RPC）

    但这些都不是本文的主题！我们要讨论的是网络中进程之间如何通信？首要解决的问题是如何唯一标识一个进程，否则通信无从谈起！在本地可以通过进程PID来唯一标识一个进程，但是在网络中这是行不通的。其实TCP/IP协议族已经帮我们解决了这个问题，网络层的“ip地址”可以唯一标识网络中的主机，而传输层的“协议+端口”可以唯一标识主机中的应用程序（进程）。这样利用三元组（ip地址，协议，端口）就可以标识网络的进程了，网络中的进程通信就可以利用这个标志与其它进程进行交互。

    使用TCP/IP协议的应用程序通常采用应用编程接口：UNIX  BSD的套接字（socket）和UNIX System V的TLI（已经被淘汰），来实现网络进程之间的通信。就目前而言，几乎所有的应用程序都是采用socket，而现在又是网络时代，网络中进程通信是无处不在，这就是我为什么说“一切皆socket”。

    2、什么是Socket？

    上面我们已经知道网络中的进程是通过socket来通信的，那什么是socket呢？socket起源于Unix，而Unix/Linux基本哲学之一就是“一切皆文件”，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。我的理解就是Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭），这些函数我们在后面进行介绍。

    socket一词的起源

    在组网领域的首次使用是在1970年2月12日发布的文献IETF RFC33中发现的，撰写者为Stephen Carr、Steve Crocker和Vint Cerf。根据美国计算机历史博物馆的记载，Croker写道：“命名空间的元素都可称为套接字接口。一个套接字接口构成一个连接的一端，而一个连接可完全由一对套接字接口规定。”计算机历史博物馆补充道：“这比BSD的套接字接口定义早了大约12年。”

    3、socket的基本操作

    既然socket是“open—write/read—close”模式的一种实现，那么socket就提供了这些操作对应的函数接口。下面以TCP为例，介绍几个基本的socket接口函数。

    3.1、socket()函数

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

    socket函数对应于普通文件的打开操作。普通文件的打开操作返回一个文件描述字，而socket()用于创建一个socket描述符（socket descriptor），它唯一标识一个socket。这个socket描述字跟文件描述字一样，后续的操作都有用到它，把它作为参数，通过它来进行一些读写操作。

    正如可以给fopen的传入不同参数值，以打开不同的文件。创建socket的时候，也可以指定不同的参数创建不同的socket描述符，socket函数的三个参数分别为：

    • domain：即协议域，又称为协议族（family）。常用的协议族有，AF_INET、AF_INET6、AF_LOCAL（或称AF_UNIX，Unix域socket）、AF_ROUTE等等。协议族决定了socket的地址类型，在通信中必须采用对应的地址，如AF_INET决定了要用ipv4地址（32位的）与端口号（16位的）的组合、AF_UNIX决定了要用一个绝对路径名作为地址。
    • type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等（socket的类型有哪些？）。
    • protocol：故名思意，就是指定协议。常用的协议有，IPPROTO_TCP、IPPTOTO_UDP、IPPROTO_SCTP、IPPROTO_TIPC等，它们分别对应TCP传输协议、UDP传输协议、STCP传输协议、TIPC传输协议（这个协议我将会单独开篇讨论！）。

    注意：并不是上面的type和protocol可以随意组合的，如SOCK_STREAM不可以跟IPPROTO_UDP组合。当protocol为0时，会自动选择type类型对应的默认协议。

    当我们调用socket创建一个socket时，返回的socket描述字它存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址，就必须调用bind()函数，否则就当调用connect()、listen()时系统会自动随机分配一个端口。

    3.2、bind()函数

    正如上面所说bind()函数把一个地址族中的特定地址赋给socket。例如对应AF_INET、AF_INET6就是把一个ipv4或ipv6地址和端口号组合赋给socket。

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

    函数的三个参数分别为：

    • sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。
    • addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，如ipv4对应的是： 
      struct sockaddr_in {
    sa_family_t    sin_family; /* address family: AF_INET */
    in_port_t      sin_port;   /* port in network byte order */
    struct in_addr sin_addr;   /* internet address */
};

/* Internet address. */
struct in_addr {
    uint32_t       s_addr;     /* address in network byte order */
};
      ipv6对应的是： 
      struct sockaddr_in6 { 
    sa_family_t     sin6_family;   /* AF_INET6 */ 
    in_port_t       sin6_port;     /* port number */ 
    uint32_t        sin6_flowinfo; /* IPv6 flow information */ 
    struct in6_addr sin6_addr;     /* IPv6 address */ 
    uint32_t        sin6_scope_id; /* Scope ID (new in 2.4) */ 
};

struct in6_addr { 
    unsigned char   s6_addr[16];   /* IPv6 address */ 
};
      Unix域对应的是： 
      #define UNIX_PATH_MAX    108

struct sockaddr_un { 
    sa_family_t sun_family;               /* AF_UNIX */ 
    char        sun_path[UNIX_PATH_MAX];  /* pathname */ 
};
    • addrlen：对应的是地址的长度。

    通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

    网络字节序与主机字节序

    主机字节序就是我们平常说的大端和小端模式：不同的CPU有不同的字节序类型，这些字节序是指整数在内存中保存的顺序，这个叫做主机序。引用标准的Big-Endian和Little-Endian的定义如下：

    　　a) Little-Endian就是低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。

    　　b) Big-Endian就是高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。

    网络字节序：4个字节的32 bit值以下面的次序传输：首先是0～7bit，其次8～15bit，然后16～23bit，最后是24~31bit。这种传输次序称作大端字节序。由于TCP/IP首部中所有的二进制整数在网络中传输时都要求以这种次序，因此它又称作网络字节序。字节序，顾名思义字节的顺序，就是大于一个字节类型的数据在内存中的存放顺序，一个字节的数据没有顺序的问题了。

    所以：在将一个地址绑定到socket的时候，请先将主机字节序转换成为网络字节序，而不要假定主机字节序跟网络字节序一样使用的是Big-Endian。由于这个问题曾引发过血案！公司项目代码中由于存在这个问题，导致了很多莫名其妙的问题，所以请谨记对主机字节序不要做任何假定，务必将其转化为网络字节序再赋给socket。

    3.3、listen()、connect()函数

    如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。

    int listen(int sockfd, int backlog);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

    listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。

    connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

    3.4、accept()函数

    TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O操作了，即类同于普通文件的读写I/O操作。

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

    accept函数的第一个参数为服务器的socket描述字，第二个参数为指向struct sockaddr *的指针，用于返回客户端的协议地址，第三个参数为协议地址的长度。如果accpet成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。

    注意：accept的第一个参数为服务器的socket描述字，是服务器开始调用socket()函数生成的，称为监听socket描述字；而accept函数返回的是已连接的socket描述字。一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。

    3.5、read()、write()等函数

    万事具备只欠东风，至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了，即实现了网咯中不同进程之间的通信！网络I/O操作有下面几组：

    • read()/write()
    • recv()/send()
    • readv()/writev()
    • recvmsg()/sendmsg()
    • recvfrom()/sendto()

    我推荐使用recvmsg()/sendmsg()函数，这两个函数是最通用的I/O函数，实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下：

           #include <unistd.h>

       ssize_t read(int fd, void *buf, size_t count);
       ssize_t write(int fd, const void *buf, size_t count);

       #include <sys/types.h>
       #include <sys/socket.h>

       ssize_t send(int sockfd, const void *buf, size_t len, int flags);
       ssize_t recv(int sockfd, void *buf, size_t len, int flags);

       ssize_t sendto(int sockfd, const void *buf, size_t len, int flags,
                      const struct sockaddr *dest_addr, socklen_t addrlen);
       ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,
                        struct sockaddr *src_addr, socklen_t *addrlen);

       ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags);
       ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);

    read函数是负责从fd中读取内容.当读成功时，read返回实际所读的字节数，如果返回的值是0表示已经读到文件的结束了，小于0表示出现了错误。如果错误为EINTR说明读是由中断引起的，如果是ECONNREST表示网络连接出了问题。

    write函数将buf中的nbytes字节内容写入文件描述符fd.成功时返回写的字节数。失败时返回-1，并设置errno变量。 在网络程序中，当我们向套接字文件描述符写时有俩种可能。1)write的返回值大于0，表示写了部分或者是全部的数据。2)返回的值小于0，此时出现了错误。我们要根据错误类型来处理。如果错误为EINTR表示在写的时候出现了中断错误。如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接)。

    其它的我就不一一介绍这几对I/O函数了，具体参见man文档或者baidu、Google，下面的例子中将使用到send/recv。

    3.6、close()函数

    在服务器与客户端建立连接之后，会进行一些读写操作，完成了读写操作就要关闭相应的socket描述字，好比操作完打开的文件要调用fclose关闭打开的文件。

    #include <unistd.h>
int close(int fd);

    close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。

    注意：close操作只是使相应socket描述字的引用计数-1，只有当引用计数为0的时候，才会触发TCP客户端向服务器发送终止连接请求。

    4、socket中TCP的三次握手建立连接详解

    我们知道tcp建立连接要进行“三次握手”，即交换三个分组。大致流程如下：

    • 客户端向服务器发送一个SYN J
    • 服务器向客户端响应一个SYN K，并对SYN J进行确认ACK J+1
    • 客户端再想服务器发一个确认ACK K+1

    只有就完了三次握手，但是这个三次握手发生在socket的那几个函数中呢？请看下图：

    image

    图1、socket中发送的TCP三次握手

    从图中可以看出，当客户端调用connect时，触发了连接请求，向服务器发送了SYN J包，这时connect进入阻塞状态；服务器监听到连接请求，即收到SYN J包，调用accept函数接收请求向客户端发送SYN K ，ACK J+1，这时accept进入阻塞状态；客户端收到服务器的SYN K ，ACK J+1之后，这时connect返回，并对SYN K进行确认；服务器收到ACK K+1时，accept返回，至此三次握手完毕，连接建立。

    总结：客户端的connect在三次握手的第二个次返回，而服务器端的accept在三次握手的第三次返回。

    5、socket中TCP的四次握手释放连接详解

    上面介绍了socket中TCP的三次握手建立过程，及其涉及的socket函数。现在我们介绍socket中的四次握手释放连接的过程，请看下图：

    image

    图2、socket中发送的TCP四次握手

    图示过程如下：

    • 某个应用进程首先调用close主动关闭连接，这时TCP发送一个FIN M；
    • 另一端接收到FIN M之后，执行被动关闭，对这个FIN进行确认。它的接收也作为文件结束符传递给应用进程，因为FIN的接收意味着应用进程在相应的连接上再也接收不到额外数据；
    • 一段时间之后，接收到文件结束符的应用进程调用close关闭它的socket。这导致它的TCP也发送一个FIN N；
    • 接收到这个FIN的源发送端TCP对它进行确认。

    这样每个方向上都有一个FIN和ACK。

    6、一个例子（实践一下）

    说了这么多了，动手实践一下。下面编写一个简单的服务器、客户端（使用TCP）——服务器端一直监听本机的6666号端口，如果收到连接请求，将接收请求并接收客户端发来的消息；客户端与服务器端建立连接并发送一条消息。

    服务器端代码：

     1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<string.h>
 4 #include<errno.h>
 5 #include<sys/types.h>
 6 #include<sys/socket.h>
 7 #include<netinet/in.h>
 8 
 9 #define MAXLINE 4096
10 
11 int main(int argc, char** argv)
12 {
13     int    listenfd, connfd;
14     struct sockaddr_in     servaddr;
15     char    buff[4096];
16     int     n;
17 
18     if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1 ){
19     printf("create socket error: %s(errno: %d)
",strerror(errno),errno);
20     exit(0);
21     }
22 
23     memset(&servaddr, 0, sizeof(servaddr));
24     servaddr.sin_family = AF_INET;
25     servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
26     servaddr.sin_port = htons(6666);
27 
28     if( bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) == -1){
29     printf("bind socket error: %s(errno: %d)
",strerror(errno),errno);
30     exit(0);
31     }
32 
33     if( listen(listenfd, 10) == -1){
34     printf("listen socket error: %s(errno: %d)
",strerror(errno),errno);
35     exit(0);
36     }
37 
38     printf("======waiting for client's request======
");
39     while(1){
40     if( (connfd = accept(listenfd, (struct sockaddr*)NULL, NULL)) == -1){
41         printf("accept socket error: %s(errno: %d)",strerror(errno),errno);
42         continue;
43     }
44     n = recv(connfd, buff, MAXLINE, 0);
45     buff[n] = '';
46     printf("recv msg from client: %s
", buff);
47     close(connfd);
48     }
49 
50     close(listenfd);
51 }

    客户端代码：

     1 #include<stdio.h>
 2 #include<stdlib.h>
 3 #include<string.h>
 4 #include<errno.h>
 5 #include<sys/types.h>
 6 #include<sys/socket.h>
 7 #include<netinet/in.h>
 8 
 9 #define MAXLINE 4096
10 
11 int main(int argc, char** argv)
12 {
13     int    sockfd, n;
14     char    recvline[4096], sendline[4096];
15     struct sockaddr_in    servaddr;
16 
17     if( argc != 2){
18     printf("usage: ./client <ipaddress>
");
19     exit(0);
20     }
21 
22     if( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
23     printf("create socket error: %s(errno: %d)
", strerror(errno),errno);
24     exit(0);
25     }
26 
27     memset(&servaddr, 0, sizeof(servaddr));
28     servaddr.sin_family = AF_INET;
29     servaddr.sin_port = htons(6666);
30     if( inet_pton(AF_INET, argv[1], &servaddr.sin_addr) <= 0){
31     printf("inet_pton error for %s
",argv[1]);
32     exit(0);
33     }
34 
35     if( connect(sockfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0){
36     printf("connect error: %s(errno: %d)
",strerror(errno),errno);
37     exit(0);
38     }
39 
40     printf("send msg to server: 
");
41     fgets(sendline, 4096, stdin);
42     if( send(sockfd, sendline, strlen(sendline), 0) < 0)
43     {
44     printf("send msg error: %s(errno: %d)
", strerror(errno), errno);
45     exit(0);
46     }
47 
48     close(sockfd);
49     exit(0);
50 }

    当然上面的代码很简单，也有很多缺点，这就只是简单的演示socket的基本函数使用。其实不管有多复杂的网络程序，都使用的这些基本函数。上面的服务器使用的是迭代模式的，即只有处理完一个客户端请求才会去处理下一个客户端的请求，这样的服务器处理能力是很弱的，现实中的服务器都需要有并发处理能力！为了需要并发处理，服务器需要fork()一个新的进程或者线程去处理请求等。

    7、动动手

    留下一个问题，欢迎大家回帖回答！！！是否熟悉Linux下网络编程？如熟悉，编写如下程序完成如下功能：

    服务器端：

    接收地址192.168.100.2的客户端信息，如信息为“Client Query”，则打印“Receive Query”

    客户端：

    向地址192.168.100.168的服务器端顺序发送信息“Client Query test”，“Cleint Query”，“Client Query Quit”，然后退出。

    题目中出现的ip地址可以根据实际情况定。

    ——本文只是介绍了简单的socket编程。

    更为复杂的需要自己继续深入。

    （unix domain socket）使用udp发送>=128K的消息会报ENOBUFS的错误（一个实际socket编程中遇到的问题，希望对你有帮助）

     

    作者：吴秦
    出处：http://www.cnblogs.com/skynet/
    本文基于署名 2.5 中国大陆许可协议发布，欢迎转载，演绎或用于商业目的，但是必须保留本文的署名吴秦（包含链接）.

    http://www.cnblogs.com/skynet/archive/2010/12/12/1903949.html
  • 相关阅读:
    Spark 学习笔记
    python-write_text
    python-logging
    耳机能听到自己说话的声音
    AudiosessionSetActive
    error link 2019 waveout
    unknow Unknown type name 'NSString'
    windbg获取打印
    立体声混音设备
    MAC book 无法删除普通用户的解决办法
  • 原文地址：https://www.cnblogs.com/njczy2010/p/5795053.html
Copyright © 2011-2022 走看看