Linux网络编程

一、网络编程简介 精美博文 tcp三次握手4次挥手
回忆之前学过的多种进程间通信的方式，他们是不同的进程之间进行消息的的交互。他们都有一个共同的特点就是都是基于内核（系统调用）来实现通信，那么就必然有一个弱点，就是只能在一台主机上进行交互。
要想在多机之间进行信息交互，除了UART、I2C、SPI等之外的，还有还可以进行网络通信。

网络编程的两个重要元素：
地址：当一个客户端想要连接服务器时就必须要知道服务器的地址。地址分为两部分IP地址和端口号。

IP地址：IP地址用于确定服务器位于哪一台主机（哪个设备）。一台主机可以运行多个服务，如FTP服务、Web服务等
端口号：一台主机上可以同时运行多个服务，光凭IP显然无法准确的找到我们想要的服务，所以有了端口号，确定我们想要连接的服务。（一些知名的服务端口号是固定的，如FTP服务的TCP端口号是21，Telnet服务的TCP端口号是23等等。）
通信协议（数据格式约定）：确定了双方之后，我们想要进行数据的交互，肯定要有事先约定好的协议，才能进行数据的识别。网络通信协议有很多种，如http、tcp、udp等等。

网络编程的入门：socket（套接字），它可以使用tcp、udp等多种协议。

二、TCP和UDP
TCP 和UDP各自的特点：

TCP：

面向于连接（类似于打电话，进行数据传输之前需要先建立连接）。
准确可靠的。也就是说，通过TCP连接传送的数据，无差错、不丢失、不重复，且保证按序到达。
TCP面向字节流，实际上TCP把数据看成是一串无结构的字节流。
每一条TCP连接只能是点到点的。（只支持一对一）
TCP 首部开销20字节。
TCP 的逻辑通信信道是双全工的可靠信道。
UDP:

无需连接，即发数据之前不需要建立连接（类似于短信）。
不可靠的。UDP尽最大的努力去交付，不保证数据的准确性。UDP数据量大。
UDP是面向报文的。UDP没有拥塞控制，即在网络出现拥塞时也不会使主机降低发送的速率。（对实时应用很有用，如IP电话、实时视频会议等）
UDP支持一对一、一对多、多对一、多对多的交互通信。
UDP首部开销8个字节。
UDP是不可靠信道。
总结来说tcp相对可靠，数据准确，适用于精准的场合。UDP数据量大，并且不会因为网络拥塞而降低速度，更适用于视频、视频电话等场合（丢失几个字节肉眼也无法发现）。

三、字节序
字节序是指多字节数据在 计算机内存中存储 或者 网络传输 时各字节的存储顺序。

字节序又分为小端字节序和大端字节序。
小端字节序：将低序字节存储在起始地址。（低位数据放在低地址）x86芯片都是使用小端字节序。
大端字节序：将高序字节存储在起始地址。（高位数据放在低地址）

字节序的意义：在进行数据交换时，两个设备的字节序可能是不一样的，直接通信必然会造成数据的损坏，所以传输前要先进行字节序转换。
网络字节序=大端字节序

四、socket客户端和服务端的开发步骤
我们进行socket网络编程实质上由内核完成，调用相应的接口函数，支配内核干活。
在这里插入图片描述

socket函数 参考博文 参考博文
创建一个套接字，返回文件描述符fd，依靠fd完成后续的一系列操作。

int socket(int domain, int type, int protocol);
//返回一个文件描述符fd，类似于open
1
2
正如可以给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决定了要用一个绝对路径名作为地址。我们通常使用AF_INET。

type：指定socket类型。常用的socket类型有，SOCK_STREAM、SOCK_DGRAM、SOCK_RAW、SOCK_PACKET、SOCK_SEQPACKET等等。

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()时系统会自动随机分配一个端口。

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

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
1
sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。
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 */ //IP地址结构体
};

/* Internet address. /
struct in_addr {
uint32_t s_addr; / address in network byte order */
};
1
2
3
4
5
6
7
8
9
10
addrlen：对应的是地址的长度。结构体大小
通常服务器在启动的时候都会绑定一个众所周知的地址（如ip地址+端口号），用于提供服务，客户就可以通过它来接连服务器；而客户端就不用指定，有系统自动分配一个端口号和自身的ip地址组合。这就是为什么通常服务器端在listen之前会调用bind()，而客户端就不会调用，而是在connect()时由系统随机生成一个。

htons函数
参考文章
在C/C++写网络程序的时候，往往会遇到字节的网络顺序和主机顺序的问题。这是就可能用到htons(), ntohl(), ntohs()，htons()这4个函数。

#include <arpa/inet.h>

   uint32_t htonl(uint32_t hostlong);

   uint16_t htons(uint16_t hostshort);

   uint32_t ntohl(uint32_t netlong);

   uint16_t ntohs(uint16_t netshort);

1
2
3
4
5
6
7
8
9
10
inet_aton函数和inet_ntoa函数
在添加IP地址或者从网络中获取IP地址的时候，例如我们添加的是“192.168.4.111”这个IP，然而这是字符串，网络并不认识，所以需要调用相关API，进行格式转换。

//函数功能：将网络地址转换成“.”点隔的字符串格式
char *inet_ntoa (struct in_addr);
//返回转换后的字符串
//将strptr所指C字符串转换成一个32位的网络字节序二进制值，并同过addrptr指针来存储
int inet_aton(const char *strptr,struct in_addr *addrptr)
//成功返回1，失败返回0
1
2
3
4
5
6
listen()、connect()函数
监听函数（等待客户端的连接）
如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。

int listen(int sockfd, int backlog);
int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
1
2
scokfd：socket描述符

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

addr：地址的结构体，和bind的一样

addrlen：结构体长度

listen函数的第一个参数即为要监听的socket描述字，第二个参数为相应socket可以排队的最大连接个数。socket()函数创建的socket默认是一个主动类型的，listen函数将socket变为被动类型的，等待客户的连接请求。
connect函数的第一个参数即为客户端的socket描述字，第二参数为服务器的socket地址，第三个参数为socket地址的长度。客户端通过调用connect函数来建立与TCP服务器的连接。

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);
1
sockfd：为服务器的socket描述字。
addr：指向struct sockaddr *的指针，用于返回客户端的协议地址。
addrlen：协议地址的长度。
如果accpet成功，那么其返回值是由内核自动生成的一个全新的描述字，代表与返回客户的TCP连接。

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

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

read()/write()
recv()/send()
readv()/writev()
recvmsg()/sendmsg()
recvfrom()/sendto()
#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);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
close函数
在服务器与客户端建立连接之后，会进行一些读写操作，完成了读写操作就要关闭相应的socket描述字，好比操作完打开的文件要调用fclose关闭打开的文件。

#include <unistd.h>
int close(int fd);
1
2
close一个TCP socket的缺省行为时把该socket标记为以关闭，然后立即返回到调用进程。该描述字不能再由调用进程使用，也就是说不能再作为read或write的第一个参数。

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

五、TCP的三次握手和四次挥手
tcp报文结构
在这里插入图片描述
如图就是tcp的报文结构，其中每一行都代表了32位（4字节），其中重点是32位序号（seq）（tcp为了数据的准确，给每个字节的数据都配备了唯一的序号（客户端和服务器都拥有各自的序号））、32位确认序号（ack）（比如客户端向服务器发送一个了一个数据（有序号z），那么服务器在应答时，必须带上相应的z+1的32位确认序号，至于为什么要+1，我的理解是这个数据消耗了一个序号，那么下一个就是z+1）、应答信号（ACK）、请求连接信号（同步信号）（SYN）、请求释放（FIN）。

32位序号：TCP有重传机制，如果发现回应的序号（ack确认序号）不对，那就重新开始上一个动作，不管是连接请求还是，正在的发送数据都一样。（也就是说每一次发送的数据都会有一个回应，这就使得tcp的传输速度很慢）

三次握手
最开始的时候客户端和服务器都处于CLOSED状态（关闭态）。客户端主动打开连接，服务器被动打开连接。

服务器先创建TCB（传输控制模块），接着进入LISTEN（监听）状态，随时等待客户端的连接

（第一次握手）客户端也是先创建TCB，接着主动发起连接请求（SYN置一，并且随机抽取一个序号x，seq=x），此时客户端已经进入了SYN-SENT（同步已发送状态（已发送等待状态）），等待服务器的回应。TCP规定，SYN报文段（SYN=1的报文段）不能携带数据，但需要消耗掉一个序号。

（第二次握手）服务器接收到了客户端的连接请求，向它回应（SYN=1,因为是回应 应答信号ACK也要置一，并且确认回应序号ack=x+1，同时服务也给出自己的随机序号y），此时服务器进入SYN-RCVD（同步已接收到等待）状态。这个报文也不能携带数据，但是同样要消耗一个序号。

（第三次握手）客户端接收到了服务器的回应信号，此时它也要给服务器一个回应信号（应答信号置（ACK=1），应答确认序号ack=y+1,自己的序号seq=x+1），接着客户端进入ESTABLISHED（已建立连接状态），注意：此时只是半连接，因为服务器还没进入连接状态。TCP规定，ACK报文段可以携带数据，但是如果不携带数据则不消耗序号。

服务器接收到客户端的应答进入ESTABLISHED（已连接）状态。三次握手就完成了，可以收发数据了哦（通信的序号是从以上动作最后的序号开始）。

以上场景，若其中一个没有及时响应（回复）或者接收到的话，（它就会以为自己没有发送能力）发送方就会重复发送，并且重新进入当时所在的状态。直到接收完成，那么这一个动作（发送）才算完成。

在这里插入图片描述

为什么是三次握手，两次握手行不行呢
不行。（假设有这么一个场景）经历过两次握手，客户端就知道了自己能发送到服务器，也能接收到服务器的回应。但是服务器此时只知道，自己能接收客户端的消息，并不知道自己的数据能否到达客户端。所以三次是最少的验证接收与发送有效的握手次数。
（还有一种说法）一句话，主要防止已经失效的连接请求报文突然又传送到了服务器，从而产生错误。
如果使用的是两次握手建立连接，假设有这样一种场景，客户端发送了第一个请求连接并且没有丢失，只是因为在网络结点中滞留的时间太长了，由于TCP的客户端迟迟没有收到确认报文，以为服务器没有收到，此时重新向服务器发送这条报文，此后客户端和服务器经过两次握手完成连接，传输数据，然后关闭连接。
此时此前滞留的那一次请求连接，网络通畅了到达了服务器，这个报文本该是失效的，但是，两次握手的机制将会让客户端和服务器再次建立连接，导致不必要的错误和资源的浪费。
如果采用的是三次握手，就算是那一次失效的报文传送过来了，服务端接受到了那条失效报文并且回复了确认报文，但是客户端不会再次发出确认。由于服务器收不到确认，就知道客户端并没有请求连接。

四次挥手
挥手前：服务器和客户端都处于ESTABLISHED（已连接状态）。

（第一次挥手）客户端发送完数据了，主动向服务器提出了断开连接的申请（FIN置一，客户端最后一个数据的序号+1 seq=u）。此时客户端进入FIN-WAIT-1（终止等待1）状态。TCP规定，FIN报文段即使不携带数据，也要消耗一个序号。
（第二次挥手）服务器接收到了客户端的断开请求，回应他（应答信号置一ACK=1，应答序号ack=u+1；服务器上一次最后的数据序号+1 seq=v），让客户端知道了自己已经收到了它的断开请求（注意：这里并没有FIN（断开）信号，也就是还没准备好断开），服务器进入CLOSE-WAIT（关闭等待）状态（但是此时服务器并没有准备好断开（他可能还有数据要给客户端），所以要等待一段时间，这一段时间也就是关闭等待状态的时间，那么这一段时间服务器去做什么了呢？服务器通知高层的应用进程，客户端向服务器的方向就释放了）。此时连接是处于**半关闭（单向断开）**的状态，即客户端的往服务器的连接已经断开（就是数据不能发了），但是服务器往客户端的连接并没有释放，服务器要想向客户端发送数据，客户端依然需要接受。
客户端接收到服务器的回应，进入FIN-WAIT-1（终止等待2）状态，等待服务器的释放报文信号。在这之前还需要接受服务器发送的最后的数据
（第三次挥手）服务器发送完数据之后，就给客户端发送释放信号（断开连接）（FIN=1，ACK=1，ack=u+1（第一次挥手后客户端并没有给服务器发送任何信号所以还是u+1），seq=w（上一次传输数据后的序号，假设=w）），服务器进入LAST-ACK（最后确认）状态（等待客户端回应）。此时的FIN报文应该也是要消耗一个序号的，因为下一次是w+1
（第四次挥手）客户端回应服务器的断开信号（ACK=1，ack=w+1；（自己的序号）seq=u+1）。客户端此时会进入TIME-WAIT（时间等待）状态。注意此时TCP连接还没有释放，必须经过2∗ *∗MSL（最长报文段寿命）的时间后，当客户端撤销相应的TCB后，才进入CLOSED状态。
服务器只要收到了客户端发出的确认，立即进入CLOSED状态。同样，撤销TCB后，就结束了这次的TCP连接。可以看到，服务器结束TCP连接的时间要比客户端早一些。
在这里插入图片描述
为什么客户端最后还要等待2MSL？
第一，保证客户端发送的最后一个ACK报文能够到达服务器，因为这个ACK报文可能丢失，站在服务器的角度看来，我已经发送了FIN+ACK报文请求断开了，客户端还没有给我回应，应该是我发送的请求断开报文它没有收到，于是服务器又会重新发送一次，而客户端就能在这个2MSL时间段内收到这个重传的报文，接着给出回应报文，并且会重启2MSL计时器。
第二，防止类似与“三次握手”中提到了的“已经失效的连接请求报文段”出现在本连接中。客户端发送完最后一个确认报文后，在这个2MSL时间中，就可以使本连接持续的时间内所产生的所有报文段都从网络中消失。这样新的连接中不会出现旧连接的请求报文。
为什么建立连接是三次握手，关闭连接确是四次挥手呢？
建立连接的时候， 服务器在LISTEN状态下，收到建立连接请求的SYN报文后，把ACK和SYN放在一个报文里发送给客户端。
而关闭连接时，服务器收到对方的FIN报文时，仅仅表示对方不再发送数据了但是还能接收数据，而自己也未必全部数据都发送给对方了，所以己方可以立即关闭，也可以发送一些数据给对方后，再发送FIN报文给对方来表示同意现在关闭连接，因此，己方ACK和FIN一般都会分开发送，从而导致多了一次。
简而言之，就是连接时，服务器已经进入LISTEN状态，随时准备迎接客户端信号的到来；而断开的时候客户端请求断开，只是客户端单方面准备好了，服务器可能还有数据要给客户端，也有可能没有，那么服务器就是可以在发送完应答信号后，立即发送断开连接信号（没数据的情况下），也可以发送完应答信号，接着发送数据，再发送断开连接信号（有数据情况下）。

总结
TCP：是可靠的传输协议，因为拥有确认、重传、窗口、拥塞等机制，但是也因此会消耗大量的时间和资源。而且，因为TCP有确认机制、三次握手机制，这些也导致了TCP容易被人利用，实现DOS,DDOS,CC等攻击。

所以使用TCP的场合就是：
当对网络通信质量有要求的时候，比如： 整个数据要准确无误的传递给对方，这往往用于一些要求可靠的应用，如QQ，游览器， HTTP,HTTPS,FTP等传输文件的协议，POP,SITP等邮件传输的协议。

UDP：快速，比TCP稍安全，UDP没有TCP的握手，确认，窗口，重传，拥塞控制等机制，UDP是一个无状态的传输协议，所以它在传递数据时非常快。没有TCP的这些机制，UDP较TCP被攻击者利用的漏洞就要少一点。但是UDP也是无法避免攻击； 不可靠，不稳定 因为UDP没有TCP那些可靠的机制，在数据传递时，如果网络质量不好，就很容易丢失包。

使用UDP的场合是：
当对我拿过来通信质量要求不高的时候，要求网络通讯能尽量的快，这时就可以使用UDP，比如qq语音，qq视频FTFP

六、例程
服务器
利用fork函数，每次有新的客户端接入就创建子进程来进行对接，这样可以实现服务多个客户端。

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

/socket 创建套接字
int socket(int domain, int type, int protocol);/

/*bind 绑定IP地址和端口号
int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
此处结构体类型有改动，
可以使用 grep “struct sockaddr_in {” * -nir 在/usr/include/目录下寻找
*/

//listen 监听，等待客户端连接

//accept 收到请求，建立连接
//int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

int main()
{
int s_fd=0;
int c_fd=0;

int nread=0;
int nwrite=0;

char readbuf[128]={0};
char writebuf[128]={0};

struct sockaddr_in  s_addrs;      //服务器的地址
struct sockaddr_in  c_addrs;       //客户端的地址
int c_len=0;
memset(&s_addrs,0,sizeof(struct sockaddr_in));
memset(&c_addrs,0,sizeof(struct sockaddr_in));  //净化结构体空间

s_fd=socket(AF_INET,SOCK_STREAM,0);    //tcp 连接
if(s_fd==-1)
	perror("socket");


s_addrs.sin_family=AF_INET;       //协议族
s_addrs.sin_port=htons(8888);    //在绑定端口号之前需要先进行字节序转换，本机to网络的意思
inet_aton("192.168.2.100",&s_addrs.sin_addr);     //IP地址从字符串——网络格式，并写入结构体

if(bind(s_fd,(struct sockaddr *)&s_addrs,sizeof(struct sockaddr_in))==-1)
	perror("bind");

if(listen(s_fd,10)==-1) //转为监听状态，允许这个socket排队连接最大的数量10，
	perror("listen");

c_len=sizeof(struct sockaddr_in);
while(1)
{
	c_fd=accept(s_fd,(struct sockaddr*)&c_addrs,&c_len);        //没有客户端连接的时候阻塞在此
	if(c_fd==-1)
	{
		perror("accept");
		exit(-1);
	}
	//打印接入客户端的IP地址
	printf("client_ip:%s\n",inet_ntoa(c_addrs.sin_addr));   //char *inet_ntoa(struct in_addr in);

	if(fork()==0)          //每当接入一个新的客户端，就创建一个子进程和其对接
	{
		//打印客户端的IP地址，首先从网络格式——字符串
		if(fork()==0)      //在创建一个子进程负责随时接收客户端的消息
		{
			while(1)
			{
				memset(readbuf,0,sizeof(readbuf));  //每次读取前先清空上一次遗留的数据
				nread=read(c_fd,readbuf,sizeof(readbuf));//没有读取到数据的时候默认阻塞
				if(nread==-1)
					perror("read");
				printf("client:%s\n",readbuf);
			}
		}
		while(1)    //一个进程负责随时写消息给客户端
		{
            memset(writebuf,0,sizeof(writebuf));   //每次写前先清空上一次遗留的数据   
            printf("input:");
            gets(writebuf);
            printf("1");
			nwrite=write(c_fd,writebuf,strlen(writebuf));
			if(nwrite==-1)
				perror("write");
		}
        printf("2");
	}
}   
return 0;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
客户端

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

//socket 获取套接字

//connect 连接服务器,int connect(int sockfd, const struct sockaddr *addr,socklen_t addrlen);

//交互

int main()
{
int c_fd=0;

int nread=0;
int nwrite=0;

char readbuf[128]={0};
char writebuf[128]={0};

struct sockaddr_in  s_addrs;      //服务器的地址

int c_len=0;
memset(&s_addrs,0,sizeof(struct sockaddr_in)); //净化结构体空间

c_fd=socket(AF_INET,SOCK_STREAM,0);    //tcp 连接
if(c_fd==-1)
	perror("socket");

//connect 需要连接的服务器的IP地址和端口号
s_addrs.sin_family=AF_INET;       //协议族
s_addrs.sin_port=htons(8888);    //在绑定端口号之前需要先进行字节序转换，本机to网络的意思
inet_aton("192.168.2.100",&s_addrs.sin_addr);     //IP地址从字符串——网络格式，并写入结构体

if(connect(c_fd,(struct sockaddr *)&s_addrs,sizeof(struct sockaddr_in))==-1)
{
	perror("connect");
}
if(fork()==0)       //创建一个新进程负责随时写
{
	while(1)
	{
		memset(writebuf,0,sizeof(writebuf));  //每次写前先清空上一次遗留的数据

		printf("input:");
		gets(writebuf);

		nwrite=write(c_fd,writebuf,strlen(writebuf));
		if(nwrite==-1)
			perror("write");
	}
}
while(1)        //父进程负责随时接收数据
{
	memset(readbuf,0,sizeof(readbuf));  //每次读取数据前先清空上一次遗留的数据
	nread=read(c_fd,readbuf,sizeof(readbuf));
	if(nread==-1)
		perror("read");
	printf("server:%s\n",readbuf);
}
return 0;