linux下TCP和UTP

最新推荐文章于 2024-04-02 15:03:05 发布
最新推荐文章于 2024-04-02 15:03:05 发布
阅读量404 收藏
点赞数
分类专栏： Linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tyeat/article/details/104277299
版权

1-Tcp服务器.c

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

int main()
{	
	//创建socket
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);   //ipv4协议  流式套接字   具体的协议类型
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	int opt = 1; 
	setsockopt(sockfd,SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));   //地址可以被重复绑定

	struct sockaddr_in server_addr;    //保存服务器的信息

	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //127.0.0.1回环ip 表示本机 测试时候可以用 
	//绑定信息
	int ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret)
	{
		perror("bind");
		exit(1);
	}

	//设置监听队列
	ret = listen(sockfd, 10);
	if (-1 == ret)
	{
		perror("listen");
		exit(1);
	}

	printf("等待客户端的连接...\n");
	struct sockaddr_in client_addr;   //用于保存客户端的信息
	int length = sizeof(client_addr);
	//接受连接（建立TCP连接）
	int fd = accept(sockfd, (struct sockaddr *)&client_addr, &length);
	if (-1 == fd)
	{
		perror("accept");
		exit(1);
	}
	printf("接受客户端的连接 %d\n", fd);

	char buf[32] = {0};
	while (1)
	{
		//从fd接收消息，TCP连接相当于一个文件，fd就是文件描述符，从fd读取数据，就是从TCP连接接收数据
		ret = recv(fd, buf, sizeof(buf), 0);
		if (-1 == ret)
		{
			perror("recv");
			exit(1);
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}
		printf("%s\n", buf);

		memset(buf, 0, sizeof(buf));
	}

	close(fd);
	close(sockfd);

	return 0;
}

2-Tcp客户端.c

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

int main()
{
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	//向服务器发起连接
	int ret = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret)
	{
		perror("connect");
		exit(1);
	}

	char buf[32] = {0};
	while (1)
	{
		scanf("%s", buf);
		ret = send(sockfd, buf, strlen(buf), 0);
		if (-1 == ret)
		{
			perror("send");
			exit(1);
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}

		memset(buf, 0, sizeof(buf));
	}

	close(sockfd);

	return 0;
}

3-Tcp并发服务器.c

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

void *ClientHandler(void *arg)
{
	int ret;
	int fd = *(int *)arg;
	char buf[32] = {0};

	pthread_detach(pthread_self());    //线程结束，自动释放资源

	while (1)
	{
		//从fd接收消息，TCP连接相当于一个文件，fd就是文件描述符，从fd读取数据，就是从TCP连接接收数据
		ret = recv(fd, buf, sizeof(buf), 0);
		if (-1 == ret)
		{
			perror("recv");
			exit(1);
		}
		else if (0 == ret)    //客户端异常退出
		{
			break;
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}
		printf("接收%d客户端%s\n", fd, buf);

		memset(buf, 0, sizeof(buf));
	}

	printf("%d 客户端退出!\n", fd);
	close(fd);
}

int main()
{	
	//创建socket
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);   //ipv4协议  流式套接字   具体的协议类型
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	int opt = 1; 
	setsockopt(sockfd,SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));   //地址可以被重复绑定

	struct sockaddr_in server_addr;    //保存服务器的信息

	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //127.0.0.1回环ip 表示本机 测试时候可以用 
	//绑定信息
	int ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret)
	{
		perror("bind");
		exit(1);
	}

	//设置监听队列
	ret = listen(sockfd, 10);
	if (-1 == ret)
	{
		perror("listen");
		exit(1);
	}

	printf("等待客户端的连接...\n");
	struct sockaddr_in client_addr;   //用于保存客户端的信息
	int length = sizeof(client_addr);
	while (1)
	{
		//接受连接（建立TCP连接）
		int fd = accept(sockfd, (struct sockaddr *)&client_addr, &length);
		if (-1 == fd)
		{
			perror("accept");
			exit(1);
		}
		printf("接受客户端的连接 %d\n", fd);

		//为每一个客户端创建新的线程
		pthread_t tid;
		ret = pthread_create(&tid, NULL, ClientHandler, &fd);
		if (ret != 0)
		{
			perror("pthread_create");
			exit(1);
		}
		usleep(10000);
	}

	close(sockfd);

	return 0;
}

4-Tcp客户端.c

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

int main()
{
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	//向服务器发起连接
	int ret = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret)
	{
		perror("connect");
		exit(1);
	}

	char buf[32] = {0};
	while (1)
	{
		scanf("%s", buf);
		ret = send(sockfd, buf, strlen(buf), 0);
		if (-1 == ret)
		{
			perror("send");
			exit(1);
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}

		memset(buf, 0, sizeof(buf));
	}

	close(sockfd);

	return 0;
}

5-Udp服务器.c

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

int main()
{
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);    //IPV4协议   数据包套接字
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	//绑定信息
	int ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret)
	{
		perror("bind");
		exit(1);
	}

	char buf[32] = {0};
	struct sockaddr_in client_addr;    //用于保存客户端的信息
	int length = sizeof(client_addr);
	while (1)
	{
		ret = recvfrom(sockfd, buf, sizeof(buf), 0, (struct sockaddr *)&client_addr, &length);
		if (-1 == ret)
		{
			perror("recvfrom");
			exit(1);
		}

		printf("接收%d : %s\n", client_addr.sin_port, buf);

		memset(buf, 0, sizeof(buf));
	}

	return 0;
}

6-Udp客户端.c

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

int main()
{
	int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	char buf[32] = {0};
	int ret;
	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");

	while (1)
	{
		scanf("%s", buf);

		ret = sendto(sockfd, buf, strlen(buf), 0, (struct sockaddr *)&server_addr, sizeof(server_addr));
		if (-1 == ret)
		{
			perror("sendto");
			exit(1);
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}
			
		memset(buf, 0, sizeof(buf));
	}

	close(sockfd);

	return 0;
}

7-select服务器.c

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

int main()
{	
	int fd[1024] = {0};
	//创建socket
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);   //ipv4协议  流式套接字   具体的协议类型
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	int opt = 1; 
	setsockopt(sockfd,SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));   //地址可以被重复绑定

	struct sockaddr_in server_addr;    //保存服务器的信息

	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //127.0.0.1回环ip 表示本机 测试时候可以用 
	//绑定信息
	int ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret)
	{
		perror("bind");
		exit(1);
	}

	//设置监听队列
	ret = listen(sockfd, 10);
	if (-1 == ret)
	{
		perror("listen");
		exit(1);
	}

	fd_set readfd, tmpfd;         //定义集合
	FD_ZERO(&readfd);             //清空集合
	FD_SET(sockfd, &readfd);      //添加到集合
	int maxfd = sockfd, i = 0;
	struct sockaddr_in client_addr;   //用于保存客户端的信息
	int length = sizeof(client_addr);
	char buf[32] = {0};

	while (1)                     //循环服务器
	{
		tmpfd = readfd;
		ret = select(maxfd + 1, &tmpfd, NULL, NULL, NULL);   //监听集合是否可读  最后一个NULL表示阻塞
		if (-1 == ret)
		{	
			perror("select");
			exit(1);
		}
		//有文件描述符可读
		if (FD_ISSET(sockfd, &tmpfd))      //判断sockfd是否还留在集合里面  判断是否有客户端发起连接
		{
			for (i = 0; i < 1024; i++)    //选择合适的i
			{
				if (fd[i] == 0)
				{
					break;
				}
			}
			fd[i] = accept(sockfd, (struct sockaddr *)&client_addr, &length);
			if (-1 == fd[i])
			{
				perror("accept");
				exit(1);
			}

			printf("接受来自%s的客户端的连接 fd = %d\n", inet_ntoa(client_addr.sin_addr), fd[i]);

			FD_SET(fd[i], &readfd);       //新的文件描述符加入到集合中
			if (maxfd < fd[i])
			{
				maxfd = fd[i];
			}
		}
		else                               //有客户端发消息
		{
			for (i = 0; i < 1024; i++)
			{
				if (FD_ISSET(fd[i], &tmpfd))    //判断是哪个fd可读
				{
					ret = recv(fd[i], buf, sizeof(buf), 0);
					if (-1 == ret)
					{	
						perror("recv");
					}
					else if (0 == ret)  
					{	
						close(fd[i]);    //关闭TCP连接
						FD_CLR(fd[i], &readfd);    //从集合中清除掉
						printf("客户端%d下线!\n", fd[i]);
						fd[i] = 0;
					}
					else 
					{
						printf("收到%d客户端的消息%s\n", fd[i], buf);
					}
					memset(buf, 0, sizeof(buf));
					break;		
				}
			}
		}
	}
	
	return 0;
}

8-客户端.c

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

int main()
{
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	//向服务器发起连接
	int ret = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret)
	{
		perror("connect");
		exit(1);
	}

	char buf[32] = {0};
	while (1)
	{
		scanf("%s", buf);
		ret = send(sockfd, buf, strlen(buf), 0);
		if (-1 == ret)
		{
			perror("send");
			exit(1);
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}

		memset(buf, 0, sizeof(buf));
	}

	close(sockfd);

	return 0;
}

9-epoll服务器.c

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

#define MAXSIZE     256

int main()
{	
	//创建socket
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);   //ipv4协议  流式套接字   具体的协议类型
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	int opt = 1; 
	setsockopt(sockfd,SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));   //地址可以被重复绑定

	struct sockaddr_in server_addr;    //保存服务器的信息

	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");  //127.0.0.1回环ip 表示本机 测试时候可以用 
	//绑定信息
	int ret = bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret)
	{
		perror("bind");
		exit(1);
	}

	//设置监听队列
	ret = listen(sockfd, 10);
	if (-1 == ret)
	{
		perror("listen");
		exit(1);
	}

	int epfd = epoll_create(MAXSIZE);   //创建epoll对象
	if (-1 == epfd)
	{
		perror("epoll_create");
		exit(1);
	}

	struct epoll_event ev, events[MAXSIZE] = {0};
	ev.events = EPOLLIN;       //监听sockfd可读
	ev.data.fd = sockfd;   
	ret = epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &ev);
	if (-1 == ret)
	{
		perror("epoll_ctl");
		exit(1);
	}

	struct sockaddr_in client_addr;   //用于保存客户端的信息
	int length = sizeof(client_addr), i;
	char buf[32] = {0};
	
	while (1)
	{
		int num = epoll_wait(epfd, events, MAXSIZE, -1);   //-1表示阻塞 
		if (-1 == num)
		{
			perror("epoll_wait");
			exit(1);
		}

		for (i = 0; i < num; i++)
		{
			if (events[i].data.fd == sockfd)    //有客户端发起连接
			{
				int fd = accept(sockfd, (struct sockaddr *)&client_addr, &length);
				if (-1 == fd)
				{
					perror("accept");
					exit(1);
				}

				printf("接受来自%s的连接fd=%d\n", inet_ntoa(client_addr.sin_addr), fd);

				//为新的文件描述符注册事件
				ev.data.fd = fd;
				ev.events = EPOLLIN;
				ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
				if (-1 == ret)
				{
					perror("epoll_ctl");
				}
			}
			else
			{
				if (events[i].events & EPOLLIN)   //如果事件是可读的
				{
					ret = recv(events[i].data.fd, buf, sizeof(buf), 0);
					if (-1 == ret)
					{
						perror("recv");
					}
					else if (0 == ret)
					{
						ev.data.fd = events[i].data.fd;
						ev.events = EPOLLIN;
						epoll_ctl(epfd, EPOLL_CTL_DEL, events[i].data.fd, &ev);   //客户端退出，注销事件
						close(events[i].data.fd);
					}
					else
					{
						printf("收到%d客户端的消息%s\n", events[i].data.fd, buf);
					}
					memset(buf, 0, sizeof(buf));
				}
			}
		}
	}

	return 0;
}


10-客户端.c

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

int main()
{
	int sockfd = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sockfd)
	{
		perror("socket");
		exit(1);
	}

	struct sockaddr_in server_addr;
	memset(&server_addr, 0, sizeof(server_addr));
	server_addr.sin_family = AF_INET;
	server_addr.sin_port = 8000;
	server_addr.sin_addr.s_addr = inet_addr("127.0.0.1");
	//向服务器发起连接
	int ret = connect(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret)
	{
		perror("connect");
		exit(1);
	}

	char buf[32] = {0};
	while (1)
	{
		scanf("%s", buf);
		ret = send(sockfd, buf, strlen(buf), 0);
		if (-1 == ret)
		{
			perror("send");
			exit(1);
		}
		if (!strcmp(buf, "bye"))
		{
			break;
		}

		memset(buf, 0, sizeof(buf));
	}

	close(sockfd);

	return 0;
}
鸭鸭屁股翘
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux下的udp通信
12-08
Linux下udp通信程序，含客户端和服务器以及Makefile
2012年下半年 网络工程师下午试题
03-31
### 知识点4：Linux下的文件传输服务配置 #### 核心内容 - 使用Linux系统作为文件服务器，提供文件传输服务。 - 使用vsftpd作为FTP服务软件。 #### 解析 - **服务配置**: - vsftpd使用TCP协议（应用层协议），...
linux下查询utp命令,Linux wget命令实例讲解
weixin_36440677的博客
05-02 113
Wget是一个有用的GNU命令行工具，用于从互联网上下载文件。 该实用程序可以使用常用协议(如HTTP，HTTPS和FTP)从服务器下载文件。 它运行在后台(非交互式)，因此可用于脚本和cron作业。 GNU Wget由HrvojeNikšić撰写，目前在TimRühsen，Darshit Shah和Giuseppe Scrivano。在本文中，让我们看看使用wget实用程序的有用示例。从网站下载...
linux socket utp
qq_46534428的博客
06-19 113
一种简单的基于utp通信
linux下查询utp命令,Linux基本命令
weixin_33989001的博客
05-02 197
总结一些Linux命令，便于记忆三人行，必有我师Ctrl+Alt+F1到F6：桌面切换到相应终端Alt+ F1到F6：终端中互相切换Alt+F7：终端切换到桌面Ctrl+空格：切换输入法Ctrl+Alt+T：打开桌面模拟终端Ubuntu—模拟终端中：切换用户su -用户名切换为相应用户sudo -i切换为root用户sudopasswd root设置root用户的密码exit：退出当前用户Unam...
嵌入式系统设计人员的 TCP/IP 简介、英文原版
04-27
- **双绞线**：是最常见的类型，包括UTP（非屏蔽双绞线）和STP（屏蔽双绞线）。 - **光纤**：用于长距离传输，具有更高的带宽和更低的信号衰减。 - **同轴电缆**：早期的以太网中常用，现在较少使用。 ##### 2.3 帧...
计算机网络试题和答案.docx
最新发布
06-07
计算机网络是指通过通信设备和线路将地理位置不同、功能独立的多个计算机系统互相连接起来，在网络软件的支持下实现彼此之间的数据通信和资源共享的系统。 #### 二、计算机网络系统构成 - **网络通信系统**：包括...
局域网技术（包括计算机网络的基础知识和局域网技术）
06-25
- **分类**：分为非屏蔽双绞线（UTP）和屏蔽双绞线（STP）。 - **选择**：应考虑网络性能需求和预算限制。 - **RJ-45接头的制作**：正确连接双绞线至RJ-45接头对于确保网络连接的稳定性至关重要。 **3.3 网卡** - ...
开源项目-anacrolix-torrent.zip
10-12
5. **跨平台**：由于是开源项目，anacrolix-torrent可以在多种操作系统上运行，包括Windows、Mac OS X和Linux等。 6. **自定义设置**：为满足不同用户需求，它提供了丰富的自定义选项，包括连接数、上传下载速度限制...
能在linux(epoll)运行基于C# .net standard2.0 写的socket框架，可使用于dotnet core程序集
11-16
能在linux(epoll)运行基于C# .net standard2.0 写的socket框架，可使用dotnet core程序集 安装NuGet: https://www.nuget.org/packages/socket.core/ Package Manager: Install-Package socket.core .Net CLI :dotnet add package socket.core Paket CLI:paket add socket.core 一：TCP模块介绍 服务端所在socket.core.Server命名空间下，分别为三种模式 push/pull/pack 客户端所在socket.core.Client命名空间下，分别为三种模式 push/pull/pack 主要流程与对应的方法和事件介绍. 注:connectId(int)代表着一个连接对象,data(byte[]),success(bool)
可靠连接utp实现网络通讯enet1.3
03-05
enet封装了网络通讯的socket的udp协议，实现可靠连接有序的网络高速传输，请大家测试使用。
PHY芯片UTP接口直连设计
07-11
PHY芯片直连
linux下查询utp命令,Linux后台下载工具（器）transmission 使用详解
weixin_34739646的博客
05-02 675
transmission简述Linux后台下载工具(器)transmission 使用详解,transmission 是一款支持绝大多数Linux系统的下载工具，采用web进行管理。可以通过web添加bt下载文件下载任务也可以直接指定下载url进行下载，一切皆在web中完成，这对Linux来说简直是一个下载神器啊。另一个角度来说Linux中的transmission就相当于windows系统中的迅...
linux下tcp #c编程
weixin_43673603的博客
07-08 105
** 一、工具准备 ** windows下linux子系统(在我的博客里面有相关搭建教程) vscode（自行下载安装） 二、创建文件和文件夹 选择你想要放代码的地方然后 mkdir classpro #创建文件夹 cd classpro #进入文件夹 touch tcpclient.c #创建tcp客户端 touch tcpserver.c #创建tcp服务端 三、编程 tcp客户端： #include <stdio.h> #include <un
Linux网络编程一(协议、TCP、UDP、socket编程、TCP服务器端及客户端)
DZJ_Nirvana
04-02 1146
(User Datagram Protocol)，IP负责把数据包送到正确的计算机中，UDP负责把数据包送到正确的程序，UDP不提供数据修复和重发的机制，且无法知道数据包是否送达，数据的确实不重要但是快！16位：目的端口号，如：微信端口号是8080，则送入到微信程序中。)，它位于网络协议栈的传输层，负责在通信的两个应用程序之间提供可靠的、面向连接的数据传输服务。②注册端口：1024~49151，随意使用，用于松散的绑定一些程序/服务。4、目的IP：32位对应4字节，Ip地址共4字节，每个字段上限255。
Linux下TCP网络编程与基于Windows下C#Socket编程间通信
轮子工厂
04-16 2002
一、Linux下TCP网络编程基础，需要了解相关函数 Socket（）：用于套接字初始化。 Bind():将 socket 与本机上的一个端口绑定，就可以在该端口监听服务请求。 Listen():使socket处于被动的监听模式，并为该  socket  建立一个输入数据队列，将到达的服务器， 请求保存在此队列中，直到程序处理他们。 Accept():让服务器接收客户的连接请求。 C
BT协议学习笔记4--uTP
山鸡哥的专栏
07-27 7100
这是一个对于uTorrent建立在UDP之上的传输层协议。可以和目的就是为了改善TCP的一些特性，可以和TCP作一些对比学习。 所以我想专门对这个拓展，记录一章。 BEP：uTorrent transport protocol 作用：在DSL 和 cable modems中，会有一个send buffer由于TCP connection采用的是平均分配带宽的方式。 在所有的服务中，
简单介绍TCP 和UTP 的区别
xiangminqin的博客
10-25 4632
TCP 和UTP 的区别 最近即将面试，特意来复习来这个知识点 首先先来说TCP,翻译叫做传输控制协议。客户端与服务器需要通过三次握手建立连接，由于通过三次握手，能保证传输可靠。一般应用于数据要求完整性较高的传输（文件传输，邮件等）但是挥手也需要付出时间代价所以消耗资源较高，传输效率慢，数据传输单位为字节流。 UTP翻译为用户数据报协议。客户端与服务器不需要建立连接就可以通信，数据传输不可靠传输效率快所需资源少，传输单位为数据报文段。 ...
tcp和utp的区别
02-28
TCP（传输控制协议）和UDP（用户数据报协议）是两种常见的传输层协议，用于在计算机网络中传输数据。它们有以下几个主要区别： 1. 可靠性：TCP是一种可靠的协议，它通过使用确认、重传和流量控制等机制来确保数据的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值