- 1我的书签菜单_聚bt网址
- 2SLA（服务等级协议）_服务可用性sla
- 3Baidu Comate——基于AI的智能代码生成让你的编码更快、更好、更简单！_指新用户在ide中安装comate插件,并在问答区有技术类的提问,或者在编码区有采纳行
- 4Java｜IDEA 运行和打包报错解决_java: java.lang.nosuchfielderror: class com.sun.to
- 5Github 2024-05-21 开源项目日报 Top10
- 6Android Studio Gradle
- 7Openlayers的交互功能（六）——编辑图斑_openlayer modify
- 8CSDN上传付费资源需要创作者等级Lv3,我的升级之路_csdn 的 综合贡献分
- 9Endnote 保姆级攻略：参考文献插入与删除、Style修改、文档格式转化（转载）_endnote插入引文 参考文献格式
- 10人工智能 ai java_人工智能需要java吗
Linux网络编程_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网络编程实质上由内核完成，调用相应的接口函数，支配内核干活。
(blocks until connection from client 译为：阻塞直到收到来自客户端的连接)
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; }
- 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
