Linux 计算机网络编程实战

已于 2022-03-03 20:41:56 修改
阅读量354 收藏 2
点赞数 2
分类专栏： linux 文章标签： linux 运维 服务器
于 2022-03-01 22:05:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yimomrik/article/details/123198141
版权

文章目录

前言

提示：这里可以添加本文要记录的大概内容：
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

提示：以下是本篇文章正文内容，下面案例可供参考

一、TCP/UDP对比

  1. TCP面向连接（如打电话要先拨号建立连接）;UDP是无连接的，即发送数据之前 不需 要建立连接
  2. TCP提供可靠的服务。也就是说，通过TCP连接传送的数据，无差错，不丢失，不重复，且按序到达;UDP尽最大努力交付，即不保证可靠交付
  3. TCP面向字节流，实际上是TCP把数据看成一连串无结构的字节流;UDP是面向报文的
    UDP没有拥塞控制，因此网络出现拥塞不会使源主机的发送速率降低（对实时应用很有用，如IP电话，实时视频会议等）
  4. 每一条TCP连接只能是点到点的;UDP支持一对一，一对多，多对一和多对多的交互通信
  5. TCP首部开销20字节;UDP的首部开销小，只有8个字节
  6. TCP的逻辑通信信道是全双工的可靠信道，UDP则是不可靠信道

二、端口号作用

一台拥有IP地址的主机可以提供许多服务，比如Web服务、FTP服务、SMTP服务等

这些服务完全可以通过1个IP地址来实现。那么，主机是怎样区分不同的网络服务呢？显然不能只靠IP地址，因为IP 地址与网络服务的关系是一对多的关系。

实际上是通过“IP地址+端口号”来区 分不同的服务的。
端口提供了一种访问通道，
服务器一般都是通过知名端口号来识别的。例如，对于每个TCP/IP实现来说，FTP服务器的TCP端口号都是21，每个Telnet服务器的TCP端口号都是23，每个TFTP(简单文件传送协议)服务器的UDP端口号都是69。

通常用户使用的端口号在3000-9999

三、字节序

常见序

1、Little endian ;将低序字节存储在起始地址
2、Big endian ;将高序字节存储在起始地址

网络字节序 = 大端字节序

字节序转换API

#include <netinet/in.h>

uint16_t htons(uint16_t host16bitvalue);    //返回网络字节序的值
uint32_t htonl(uint32_t host32bitvalue);    //返回网络字节序的值
uint16_t ntohs(uint16_t net16bitvalue);     //返回主机字节序的值
uint32_t ntohl(uint32_t net32bitvalue);     //返回主机字节序的值

h代表host，n代表net，s代表short（两个字节），l代表long（4个字节），通过上面的4个函数可以实现主机字节序和网络字节序之间的转换。有时可以用INADDR_ANY，INADDR_ANY指定地址让操作系统自己获取

四、网络编程协议API

1、socket 函数

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

功能说明：
调用成功，返回socket文件描述符；失败，返回－1，并设置errno
参数说明：
1、domain:
指明所使用的协议族，通常为AF_INET， 表示互联网协议族（TCP/IP协议族）；
AF_INET IPv4 因特网域
AF_INET6 IPv6 因特网域
AF_UNIX Unix域
AF_ROUTE 路由套接字
AF_KEY 密钥套接字
AF_UNSPEC 未指定

2、type参数指定socket的类型：
SOCK_STREAM:
流式套接字提供可靠的、面向连接的通信流；它使用TCP协议，从而保证了数据传输正确性和顺序性
SOCK_DGRAM
数据报套接字定义了一种五连接的服，数据通过相互独立的报文进行传输，是无序的，并且不保证是可靠的、无差错的。它使用数据报协议UDP。
SOCK_RAW
允许程序使用低层协议，原始套接字允许对底层协议如IP或ICMP进行直接访问，功能强大但使用较为不便，主要用于一些协议的开发；

3、protocol
通常赋值“ 0”
0选择 type类型对应的默认协议
IPPROTO_TCP TCP传输协议
IPPROTO_UDP UDP传输协议
IPPROTO_SCTP SCTP传输协议
IPPROTO_TIPC TIPC传输协议

2、bind函数：IP号端口号与相应描述字赋值函数

#include<sys/types.h>
#include<sys/socket.h>
int bind(int sockfd ,const struct sockaddr *addr , socklen_t addrlen);

功能说明：
将套接字和指定的端口相连。成功返回0，否则，返回－1，并置errno.

函数的三个参数分别为：

1、sockfd：即socket描述字，它是通过socket()函数创建了，唯一标识一个socket。bind()函数就是将给这个描述字绑定一个名字。

2、addr：一个const struct sockaddr *指针，指向要绑定给sockfd的协议地址。这个地址结构根据地址创建socket时的地址协议族的不同而不同，如ipv4对应的是：

struct sockaddr{
    unsigned short as_family  ; /* address family: AF_INET */
     char      sa_data[14]  ;   /* port in network byte order */
    ;   /* internet address */
};

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 */
    unsigned char sin_zero[8]
};

简单描述如何在Linux中寻找结构体头文件和结构体具体位置

以struct sockaddr_in为例 如下：

 cd /usr/include/
 ls
 grep "struct sockaddr_in {" * -nir
vi linux/in.h +184

地址转换API

int inet_aton(const char* straddr,struct in_addr *addrp);
把字符串形式的“192.168.1.123”转为网络能识别的格式

char* inet_ntoa(struct in_addr inaddr); 
把网络格式的ip地址转为字符串形式

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服务器的连接。

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); //返回连接connect_fd

参数sockfd
参数sockfd就是上面解释中的监听套接字，这个套接字用来监听一个端口，当有一个客户与服务器连接时，它使用这个一个端口号，而此时这个端口号正与这个套接字关联。当然客户不知道套接字这些细节，它只知道一个地址和一个端口号。
参数addr
这是一个结果参数，它用来接受一个返回值，这返回值指定客户端的地址，当然这个地址是通过某个地址结构来描述的，用户应该知道这一个什么样的地址结构。如果对客户的地址不感兴趣，那么可以把这个值设置为NULL。
参数len
如同大家所认为的，它也是结果的参数，用来接受上述addr的结构的大小的，它指明addr结构所占有的字节个数。同样的，它也可以被设置为NULL。
如果accept成功返回，则服务器与客户已经正确建立连接了，此时服务器通过accept返回的套接字来完成与客户的通信。

注意：

  accept默认会阻塞进程，直到有一个客户连接建立后返回，它返回的是一个新可用的套接字，这个套接字是连接套接字。

此时我们需要区分两种套接字，

   监听套接字: 监听套接字正如accept的参数sockfd，它是监听套接字，在调用listen函数之后，是服务器开始调用socket()函数生成的，称为监听socket描述字(监听套接字)

   连接套接字：一个套接字会从主动连接的套接字变身为一个监听套接字；而accept函数返回的是已连接socket描述字(一个连接套接字)，它代表着一个网络已经存在的点点连接。

    一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。

    自然要问的是：为什么要有两种套接字？原因很简单，如果使用一个描述字的话，那么它的功能太多，使得使用很不直观，同时在内核确实产生了一个这样的新的描述字。

连接套接字socketfd_new 并没有占用新的端口与客户端通信，依然使用的是与监听套接字socketfd一样的端口号

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

万事具备只欠东风，至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写操作了，即实现了网咯中不同进程之间的通信！网络I/O操作有下面几组：
read()/write()
recv()/send()
readv()/writev()
recvmsg()/sendmsg()
recvfrom()/sendto()
我推荐使用recvmsg()/sendmsg()函数，这两个函数是最通用的I/O函数，实际上可以把上面的其它函数都替换成这两个函数。它们的声明如下：

   ssize_t <span>read</span>(<span>int</span> fd, <span>void</span> *buf, size_t count);
   ssize_t <span>write</span>(<span>int</span> fd, <span>const</span> <span>void</span> *buf, size_t count);

   #include &lt;sys/types.h&gt;
   #include &lt;sys/socket.h&gt;

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

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

   ssize_t sendmsg(<span>int</span> sockfd, <span>const</span> <span>struct</span> msghdr *msg, <span>int</span> flags);
   ssize_t recvmsg(<span>int</span> sockfd, <span>struct</span> msghdr *msg, <span>int</span> 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。

6、close()函数

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

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

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

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

五、 Socket中TCP的建立（三次握手）

TCP协议通过三个报文段完成连接的建立，这个过程称为三次握手(three-way handshake)，过程如下图所示。
第一次握手：建立连接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；SYN：同步序列编号(Synchronize Sequence Numbers)。

第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时自己也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态；
第三次握手：客户端收到服务器的SYN+ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。
一个完整的三次握手也就是： 请求—应答—再次确认。

对应的函数接口：
请添加图片描述
从图中可以看出，当客户端调用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返回，至此三次握手完毕，连接建立。

我们可以通过网络抓包的查看具体的流程：
比如我们服务器开启9502的端口。使用tcpdump来抓包：
tcpdump -iany tcp port 9502
然后我们使用telnet 127.0.0.1 9502开连接.:
telnet 127.0.0.1 9502

14:12:45.104687 IP localhost.39870 > localhost.9502: Flags [S], seq 2927179378, win 32792, options [mss 16396,sackOK,TS val 255474104 ecr 0,nop,wscale 3], length 0（1）
14:12:45.104701 IP localhost.9502 > localhost.39870: Flags [S.], seq 1721825043, ack 2927179379, win 32768, options [mss 16396,sackOK,TS val 255474104 ecr 255474104,nop,wscale 3], length 0 （2）
14:12:45.104711 IP localhost.39870 > localhost.9502: Flags [.], ack 1, win 4099, options [nop,nop,TS val 255474104 ecr 255474104], length 0 （3）

14:13:01.415407 IP localhost.39870 > localhost.9502: Flags [P.], seq 1:8, ack 1, win 4099, options [nop,nop,TS val 255478182 ecr 255474104], length 7
14:13:01.415432 IP localhost.9502 > localhost.39870: Flags [.], ack 8, win 4096, options [nop,nop,TS val 255478182 ecr 255478182], length 0
14:13:01.415747 IP localhost.9502 > localhost.39870: Flags [P.], seq 1:19, ack 8, win 4096, options [nop,nop,TS val 255478182 ecr 255478182], length 18
14:13:01.415757 IP localhost.39870 > localhost.9502: Flags [.], ack 19, win 4097, options [nop,nop,TS val 255478182 ecr 255478182], length 0

六、客户端代码

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h> 
#include <string.h>

int main(int argc, char const *argv[])
{
	//1、socket
	//int socket(int domain, int type, int protocol);
	int s_fd;
	int n_read;
	char readBuff[128];
	char writeBuff[1024] = {0};
	int c_fd;

	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;	

	if (argc != 3)
	{
		printf("param not enough!\n");
		exit(-1);
	}


	memset(&s_addr, 0 ,sizeof(struct sockaddr_in));
	memset(&c_addr, 0 ,sizeof(struct sockaddr_in));


	s_fd = socket(AF_INET,SOCK_STREAM,0);

	if (s_fd == -1)
	{
		perror("socket");
		exit(-1);
	}
	//2、bind
 	//int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
//  	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 */
//     unsigned char sin_zero[8]
// };

	s_addr.sin_family = AF_INET; 
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);
	bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

	//3、listen
	listen(s_fd,10);

	//4、accept
	int clen = sizeof(struct sockaddr_in);
	while(1){
		c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);
	 	if(c_fd == -1){
	 		perror("accept");
	 	}
	 	printf("connect\n");
	 	printf("get connect : %s\n",inet_ntoa(c_addr.sin_addr));
 
	 	if(fork() == 0){
		 		//5、read	 		
	 			if(fork() == 0){
	 				while(1){
	 					//6、write
	 					memset(writeBuff,0,sizeof(writeBuff));
						printf("input : ");
						gets(writeBuff);
						write(c_fd,writeBuff,strlen(writeBuff));
	 				}
	 			}
	 		while(1){
	 			memset(readBuff,0,sizeof(readBuff));
			 	n_read = read(c_fd,readBuff,128);
			 	if(n_read  == -1){
			 		perror("read");
			 	}else{
			 		printf("get message:%d,%s\n",n_read,readBuff);
		 	}
	 		}

	 		}
		
		}
 	
 	
	return 0;
}

七、服务端代码

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h> 
#include <string.h>

int main(int argc, char const *argv[])
{
	//1、socket
	//int socket(int domain, int type, int protocol);
	int c_fd;
	int n_read;
	char readBuff[128];
	char writeBuff[1024] = {0} ;


	struct sockaddr_in c_addr;	

	if (argc != 3)
	{
		printf("param not enough!\n");
		exit(-1);
	}


	memset(&c_addr, 0 ,sizeof(struct sockaddr_in));


	c_fd = socket(AF_INET,SOCK_STREAM,0);

	if (c_fd == -1)
	{
		perror("socket");
		exit(-1);
	}
	//2、bind
 	//int bind(int sockfd, const struct sockaddr *addr,socklen_t addrlen);
//  	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 */
//     unsigned char sin_zero[8]
// };

	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);



	int c_cnet;
	//2、connect
	c_cnet = connect(c_fd,(struct sockaddr*)&c_addr,sizeof(struct sockaddr));
	if(c_cnet == -1){
		perror("connect");
		exit(-1);
	}else{
		printf("connect success !\n");
	}

	while(1){
		if(fork() == 0){
				while(1){
				//3、send
				memset(writeBuff,0,sizeof(writeBuff));
				printf("input : ");
				gets(writeBuff);
				write(c_fd,writeBuff,strlen(writeBuff));
				}	
			
	 	}
	 	while(1){
	 				//4、read
	 		memset(readBuff,0,sizeof(readBuff));
		 	n_read = read(c_fd,readBuff,128);
		 	if(n_read  == -1){
		 		perror("read");
		 	}else{
		 		printf("get message:%d,%s\n",n_read,readBuff);
	 	}
	 	}


	}

	return 0;
}
会吃茶叶蛋的小羊
关注
专栏目录
Linux操作系统之网络实战1
yiweii的博客
08-12 926
一、osi简介 1、osi Open System Interconnection 开放系统互联模型， 2、开放式系统互联 ① 国际标准化组织（ISO）制定 ② 定义了不同计算机互联的标准 ③ 设计和描述，计算机网络通信的框架 全世界网络通信的工作分为7层 应用层 表示层 会话层 传输层 网络层 数据链路层 物理层 制定O...
头歌Linux系统编程之c编程入门
11-20
9. **Linux网络编程**：分为TCP和UDP两部分，包括套接字创建、端口绑定、监听、连接建立与终止、数据传输等内容，这些都是网络服务开发的基础。 10. **交叉编译和BusyBox**：介绍了如何在宿主机上为嵌入式设备进行...
socket通信
abcdefg的专栏
07-22 405
我们深谙信息交流的价值，那网络中进程之间如何通信，如我们每天打开浏览器浏览网页时，浏览器的进程怎么与web服务器通信的？当你用QQ聊天时，QQ进程怎么与服务器或你好友所在的QQ进程通信？这些都得靠socket？那什么是socket？socket的类型有哪些？还有socket的基本函数，这些都是本文想介绍的。本文的主要内容如下： 1、网络中进程之间如何通信？ 2、Socket是什么？
linux网络编程2
最新发布
qq_65818377的博客
09-18 728
常用于语音和视频通话相较于TCP速度稍快些简单的请求、应答应用程序可以使用UDP对于海量数据传输不应该使用UDP广播和多播应用必须使用UDP。
Linux网络编程简单示例
imxiangzi的专栏
12-07 487
参考博文：http://www.cnblogs.com/luxiaoxun/archive/2012/10/16/2725760.html 示例程序是国嵌的 linux 网络编程是通过socket(套接字)接口实现，Socket是一种文件描述符，socket起源于UNIX，在Unix一切皆文件哲学的思想下，socket是一种"打开—读/写—关闭"模式的实现，服务器和客户端各自维
Linux环境下的网络编程
07-14 3972
xuyb                 Email:bai_xy@21cn.com    　　本文介绍了在Linux环境下的socket编程常用函数用法及socket编程的一般规则和客户/服务器模型的编程应注意的事项和常遇问题的解决方法，并举了具体代  码实例。要理解本文所谈的技术问题需要读者具有一定C语言的编程经验和TCP/IP方面的基本知识。要实习本文的示例，需要Linux下的gcc编译平台
《8.实现双方聊天》
weixin_49866713的博客
11-30 146
这是服务端 #include <stdio.h> #include <sys/types.h> #include <sys/socket.h> #include <arpa/inet.h> #include <netinet/in.h> #include <stdlib.h> #include <string.h> int main(int argc,char** argv) { int s_fd; int c_fd;
Linux C编程实战代码（可运行在ZYNQ7010开发板）.zip
02-10
在本文中，我们将深入探讨与"Linux C编程实战代码（可运行在ZYNQ7010开发板）"相关的嵌入式Linux开发知识。ZYNQ7010是一款基于Xilinx公司的System on Chip (SoC) FPGA平台，它集成了ARM Cortex-A9双核处理器，适用于...
Linux系统下的网络编程实战：C++，Python，Go语言解析
"网络编程实战视频陈硕 - 通过Linux平台，C++，Python，Go语言讲解服务端网络编程核心机制与实践" 本课程是针对网络编程的深度学习资源，由经验丰富的专家陈硕主讲，他在美国Google硅谷总部从事大规模分布式系统...
Linux C编程实战源码实现.zip
08-09
【本人专注计算机领域】： 有任何使用问题欢迎随时与我联系，我会及时解答，第一时间为你提供帮助，CSDN博客端可私信，为你解惑，欢迎交流。 【适合场景】： 相关项目设计中，皆可应用在项目开发、毕业设计、课程...
linux下C 网络编程实例
10-31
以时间程序为例介绍了linux下C网络编程的TCP/UDP，服务器端/客户端的基本用法，socket，inet-ptoh，hton，bind，listen，acceept，connect，read，write，快速入门，超实用
linux——网络编程实战
weixin_59622415的博客
01-26 412
h代表host，n代表net，s代表short（两个字节），l代表long（4个字节），通过上面的4个函数可以实现主机字节序和网络字节序之间的转换。有时可以用INADDR_ANY，INADDR_ANY指定地址让操作系统自己获取。显而易见，相比服务端，客户端少了几个API，多了一个connet。需要先把字节序给调整一下，把主机的字节序调整为网络字节序。需要将主机的字符串型ip地址转换为网络的地址。
linux网络编程实践
1
05-07 1253
《朱老师物联网大讲堂》学习笔记 学习地址：www.zhulaoshi.org (1). linux网络编程框架， 网络是分层的，OSI是7层的，这种分层是理论的， 实际应用只有4层，TCP/IP, 处理问题时，一定要知道你自己在哪一层，我们目前关注的是应用层， 因为网络是目前最复杂的通信体系， 曾经有很多类似tcp/ip的协议， CS，client
【LINUX网络编程】Socket网络编程实战
yy197696的博客
02-09 504
网络套接字函数 最简单的socket的程序 sever #include <stdio.h> #include <stdlib.h> #include <string.h> #include <unistd.h> #include <sys/socket.h> #include <netinet/in.h> #include ...
Linux网络编程实战一
weixin_52248748的博客
03-07 193
Linux网络编程实践
小嵌同学的博客
09-05 1200
目录一、Linux网络编程框架1、网络是分层的2、TCP/IP协议引入3、BS和CS二、TCP协议的学习1、关于TCP理解的重点2、TCP如何保证可靠传输3、TCP的三次握手4、TCP的四次握手5、基于TCP通信的服务模式6、常见的使用了TCP协议的网络应用三、socket编程接口介绍1、建立连接2、发送和接收3、辅助性函数：主要用于进行IP地址的转换，点分十进制与二进制方式4、表示IP地址相关数据结构四、IP地址格式转换函数实践1、网络通信中使用网络字节序，即大端模式2、ipv4和ipv6的区别：3、把i
Linux 网络编程 简单实例
linux/unix
12-16 4979
一、编写Linux下socket协议TCP的ClientServer程序//客户端,client: #include #include #include #include #include #include #define MAXBUF 256 int main() {     int ssock;     int clen;     struct sockaddr_in server_addr
Linux 网络实战
benziwu的博客
04-17 1137
进制
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值