精华内容
下载资源
问答
  • C语言的Socket编程例子(TCP和UDP)

    千次阅读 2016-05-20 15:20:41
    C语言的Socket编程例子(TCP和UDP)

    <TCP>

    server端:

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. #include "stdafx.h"  
    2. #include <stdio.h>  
    3. #include <winsock2.h>  
    4.   
    5. #pragma comment(lib,"ws2_32.lib")  
    6.   
    7. int main(int argc, char* argv[])  
    8. {  
    9.     //初始化WSA  
    10.     WORD sockVersion = MAKEWORD(2,2);  
    11.     WSADATA wsaData;  
    12.     if(WSAStartup(sockVersion, &wsaData)!=0)  
    13.     {  
    14.         return 0;  
    15.     }  
    16.   
    17.     //创建套接字  
    18.     SOCKET slisten = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  //此处 IPPROTO_TCP一定要注意,否则导致失败!
    19.     if(slisten == INVALID_SOCKET)  
    20.     {  
    21.         printf("socket error !");  
    22.         return 0;  
    23.     }  
    24.   
    25.     //绑定IP和端口  
    26.     sockaddr_in sin;  
    27.     sin.sin_family = AF_INET;  
    28.     sin.sin_port = htons(8888);  
    29.     sin.sin_addr.S_un.S_addr = INADDR_ANY;   
    30.     if(bind(slisten, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)  
    31.     {  
    32.         printf("bind error !");  
    33.     }  
    34.   
    35.     //开始监听  
    36.     if(listen(slisten, 5) == SOCKET_ERROR)  
    37.     {  
    38.         printf("listen error !");  
    39.         return 0;  
    40.     }  
    41.   
    42.     //循环接收数据  
    43.     SOCKET sClient;  
    44.     sockaddr_in remoteAddr;  
    45.     int nAddrlen = sizeof(remoteAddr);  
    46.     char revData[255];   
    47.     while (true)  
    48.     {  
    49.         printf("等待连接...\n");  
    50.         sClient = accept(slisten, (SOCKADDR *)&remoteAddr, &nAddrlen);  
    51.         if(sClient == INVALID_SOCKET)  
    52.         {  
    53.             printf("accept error !");  
    54.             continue;  
    55.         }  
    56.         printf("接受到一个连接:%s \r\n", inet_ntoa(remoteAddr.sin_addr));  
    57.           
    58.         //接收数据  
    59.         int ret = recv(sClient, revData, 255, 0);          
    60.         if(ret > 0)  
    61.         {  
    62.             revData[ret] = 0x00;  
    63.             printf(revData);  
    64.         }  
    65.   
    66.         //发送数据  
    67.         char * sendData = "你好,TCP客户端!\n";  
    68.         send(sClient, sendData, strlen(sendData), 0);  
    69.         closesocket(sClient);  
    70.     }  
    71.       
    72.     closesocket(slisten);  
    73.     WSACleanup();  
    74.     return 0;  
    75. }  


    client端:

     

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. #include "stdafx.h"  
    2. #include <WINSOCK2.H>  
    3. #include <STDIO.H>  
    4.   
    5. #pragma  comment(lib,"ws2_32.lib")  
    6.   
    7.   
    8. int main(int argc, char* argv[])  
    9. {  
    10.     WORD sockVersion = MAKEWORD(2,2);  
    11.     WSADATA data;   
    12.     if(WSAStartup(sockVersion, &data) != 0)  
    13.     {  
    14.         return 0;  
    15.     }  
    16.   
    17.     SOCKET sclient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);  
    18.     if(sclient == INVALID_SOCKET)  
    19.     {  
    20.         printf("invalid socket !");  
    21.         return 0;  
    22.     }  
    23.   
    24.     sockaddr_in serAddr;  
    25.     serAddr.sin_family = AF_INET;  
    26.     serAddr.sin_port = htons(8888);  
    27.     serAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");   
    28.     if (connect(sclient, (sockaddr *)&serAddr, sizeof(serAddr)) == SOCKET_ERROR)  
    29.     {  
    30.         printf("connect error !");  
    31.         closesocket(sclient);  
    32.         return 0;  
    33.     }  
    34.     char * sendData = "你好,TCP服务端,我是客户端!\n";  
    35.     send(sclient, sendData, strlen(sendData), 0);  
    36.   
    37.     char recData[255];  
    38.     int ret = recv(sclient, recData, 255, 0);  
    39.     if(ret > 0)  
    40.     {  
    41.         recData[ret] = 0x00;  
    42.         printf(recData);  
    43.     }  
    44.     closesocket(sclient);  
    45.     WSACleanup();  
    46.     return 0;  
    47. }  


     

    二. <UDP>

    SERVER 端

     

     

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. #include "stdafx.h"  
    2. #include <stdio.h>  
    3. #include <winsock2.h>  
    4.   
    5. #pragma comment(lib, "ws2_32.lib")   
    6.   
    7. int main(int argc, char* argv[])  
    8. {  
    9.     WSADATA wsaData;  
    10.     WORD sockVersion = MAKEWORD(2,2);  
    11.     if(WSAStartup(sockVersion, &wsaData) != 0)  
    12.     {  
    13.         return 0;  
    14.     }  
    15.   
    16.     SOCKET serSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);   
    17.     if(serSocket == INVALID_SOCKET)  
    18.     {  
    19.         printf("socket error !");  
    20.         return 0;  
    21.     }  
    22.   
    23.     sockaddr_in serAddr;  
    24.     serAddr.sin_family = AF_INET;  
    25.     serAddr.sin_port = htons(8888);  
    26.     serAddr.sin_addr.S_un.S_addr = INADDR_ANY;  
    27.     if(bind(serSocket, (sockaddr *)&serAddr, sizeof(serAddr)) == SOCKET_ERROR)  
    28.     {  
    29.         printf("bind error !");  
    30.         closesocket(serSocket);  
    31.         return 0;  
    32.     }  
    33.       
    34.     sockaddr_in remoteAddr;  
    35.     int nAddrLen = sizeof(remoteAddr);   
    36.     while (true)  
    37.     {  
    38.         char recvData[255];    
    39.         int ret = recvfrom(serSocket, recvData, 255, 0, (sockaddr *)&remoteAddr, &nAddrLen);  
    40.         if (ret > 0)  
    41.         {  
    42.             recvData[ret] = 0x00;  
    43.             printf("接受到一个连接:%s \r\n", inet_ntoa(remoteAddr.sin_addr));  
    44.             printf(recvData);              
    45.         }  
    46.   
    47.         char * sendData = "一个来自服务端的UDP数据包\n";  
    48.         sendto(serSocket, sendData, strlen(sendData), 0, (sockaddr *)&remoteAddr, nAddrLen);      
    49.   
    50.     }  
    51.     closesocket(serSocket);   
    52.     WSACleanup();  
    53.     return 0;  
    54. }  


    CLIENT 端

     

    [cpp] view plain copy
     在CODE上查看代码片派生到我的代码片
    1. #include "stdafx.h"  
    2. #include <stdio.h>  
    3. #include <winsock2.h>  
    4.   
    5. #pragma comment(lib, "ws2_32.lib")   
    6.   
    7. int main(int argc, char* argv[])  
    8. {  
    9.     WORD socketVersion = MAKEWORD(2,2);  
    10.     WSADATA wsaData;   
    11.     if(WSAStartup(socketVersion, &wsaData) != 0)  
    12.     {  
    13.         return 0;  
    14.     }  
    15.     SOCKET sclient = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);  
    16.       
    17.     sockaddr_in sin;  
    18.     sin.sin_family = AF_INET;  
    19.     sin.sin_port = htons(8888);  
    20.     sin.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");  
    21.     int len = sizeof(sin);  
    22.       
    23.     char * sendData = "来自客户端的数据包.\n";  
    24.     sendto(sclient, sendData, strlen(sendData), 0, (sockaddr *)&sin, len);  
    25.   
    26.     char recvData[255];       
    27.     int ret = recvfrom(sclient, recvData, 255, 0, (sockaddr *)&sin, &len);  
    28.     if(ret > 0)  
    29.     {  
    30.         recvData[ret] = 0x00;  
    31.         printf(recvData);  
    32.     }  
    33.   
    34.     closesocket(sclient);  
    35.     WSACleanup();  
    36.     return 0;  
    37. }  
    展开全文
  • Windows下C语言的Socket编程例子(TCP和UDP) 原文: Windows下C语言的Socket编程例子(TCP和UDP) 刚刚学windows编程,所以想写学习笔记,这是一个简单的Socket程序例子,开发环境是vc6: ...
    原文: Windows下C语言的Socket编程例子(TCP和UDP)

    刚刚学windows编程,所以想写学习笔记,这是一个简单的Socket程序例子,开发环境是vc6:

    首先是TCP

    server端:
    #include "stdafx.h"
    #include <stdio.h>
    #include <winsock2.h>
    
    #pragma comment(lib,"ws2_32.lib")
    
    int main(int argc, char* argv[])
    {
    	//初始化WSA
    	WORD sockVersion = MAKEWORD(2,2);
    	WSADATA wsaData;
    	if(WSAStartup(sockVersion, &wsaData)!=0)
    	{
    		return 0;
    	}
    
    	//创建套接字
    	SOCKET slisten = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    	if(slisten == INVALID_SOCKET)
    	{
    		printf("socket error !");
    		return 0;
    	}
    
    	//绑定IP和端口
    	sockaddr_in sin;
    	sin.sin_family = AF_INET;
    	sin.sin_port = htons(8888);
    	sin.sin_addr.S_un.S_addr = INADDR_ANY; 
    	if(bind(slisten, (LPSOCKADDR)&sin, sizeof(sin)) == SOCKET_ERROR)
    	{
    		printf("bind error !");
    	}
    
    	//开始监听
    	if(listen(slisten, 5) == SOCKET_ERROR)
    	{
    		printf("listen error !");
    		return 0;
    	}
    
    	//循环接收数据
    	SOCKET sClient;
    	sockaddr_in remoteAddr;
    	int nAddrlen = sizeof(remoteAddr);
    	char revData[255]; 
    	while (true)
    	{
    		printf("等待连接...\n");
    		sClient = accept(slisten, (SOCKADDR *)&remoteAddr, &nAddrlen);
    		if(sClient == INVALID_SOCKET)
    		{
    			printf("accept error !");
    			continue;
    		}
    		printf("接受到一个连接:%s \r\n", inet_ntoa(remoteAddr.sin_addr));
    		
    		//接收数据
    		int ret = recv(sClient, revData, 255, 0);		
    		if(ret > 0)
    		{
    			revData[ret] = 0x00;
    			printf(revData);
    		}
    
    		//发送数据
    		char * sendData = "你好,TCP客户端!\n";
    		send(sClient, sendData, strlen(sendData), 0);
    		closesocket(sClient);
    	}
    	
    	closesocket(slisten);
    	WSACleanup();
    	return 0;
    }
    

    client端:
    #include "stdafx.h"
    #include <WINSOCK2.H>
    #include <STDIO.H>
    
    #pragma  comment(lib,"ws2_32.lib")
    
    
    int main(int argc, char* argv[])
    {
    	WORD sockVersion = MAKEWORD(2,2);
    	WSADATA data; 
    	if(WSAStartup(sockVersion, &data) != 0)
    	{
    		return 0;
    	}
    
    	SOCKET sclient = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    	if(sclient == INVALID_SOCKET)
    	{
    		printf("invalid socket !");
    		return 0;
    	}
    
    	sockaddr_in serAddr;
    	serAddr.sin_family = AF_INET;
    	serAddr.sin_port = htons(8888);
    	serAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1"); 
    	if (connect(sclient, (sockaddr *)&serAddr, sizeof(serAddr)) == SOCKET_ERROR)
    	{
    		printf("connect error !");
    		closesocket(sclient);
    		return 0;
    	}
    	char * sendData = "你好,TCP服务端,我是客户端!\n";
    	send(sclient, sendData, strlen(sendData), 0);
    
    	char recData[255];
    	int ret = recv(sclient, recData, 255, 0);
    	if(ret > 0)
    	{
    		recData[ret] = 0x00;
    		printf(recData);
    	}
    	closesocket(sclient);
    	WSACleanup();
    	return 0;
    }
    

    然后是UDP

    server端:
    #include "stdafx.h"
    #include <stdio.h>
    #include <winsock2.h>
    
    #pragma comment(lib, "ws2_32.lib") 
    
    int main(int argc, char* argv[])
    {
    	WSADATA wsaData;
    	WORD sockVersion = MAKEWORD(2,2);
    	if(WSAStartup(sockVersion, &wsaData) != 0)
    	{
    		return 0;
    	}
    
    	SOCKET serSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); 
    	if(serSocket == INVALID_SOCKET)
    	{
    		printf("socket error !");
    		return 0;
    	}
    
    	sockaddr_in serAddr;
    	serAddr.sin_family = AF_INET;
    	serAddr.sin_port = htons(8888);
    	serAddr.sin_addr.S_un.S_addr = INADDR_ANY;
    	if(bind(serSocket, (sockaddr *)&serAddr, sizeof(serAddr)) == SOCKET_ERROR)
    	{
    		printf("bind error !");
    		closesocket(serSocket);
    		return 0;
    	}
    	
    	sockaddr_in remoteAddr;
    	int nAddrLen = sizeof(remoteAddr); 
    	while (true)
    	{
    		char recvData[255];  
    		int ret = recvfrom(serSocket, recvData, 255, 0, (sockaddr *)&remoteAddr, &nAddrLen);
    		if (ret > 0)
    		{
    			recvData[ret] = 0x00;
    			printf("接受到一个连接:%s \r\n", inet_ntoa(remoteAddr.sin_addr));
    			printf(recvData);			
    		}
    
    		char * sendData = "一个来自服务端的UDP数据包\n";
    		sendto(serSocket, sendData, strlen(sendData), 0, (sockaddr *)&remoteAddr, nAddrLen);	
    
    	}
    	closesocket(serSocket); 
    	WSACleanup();
    	return 0;
    }
    
    client端:
    #include "stdafx.h"
    #include <stdio.h>
    #include <winsock2.h>
    
    #pragma comment(lib, "ws2_32.lib") 
    
    int main(int argc, char* argv[])
    {
    	WORD socketVersion = MAKEWORD(2,2);
    	WSADATA wsaData; 
    	if(WSAStartup(socketVersion, &wsaData) != 0)
    	{
    		return 0;
    	}
    	SOCKET sclient = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
    	
    	sockaddr_in sin;
    	sin.sin_family = AF_INET;
    	sin.sin_port = htons(8888);
    	sin.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    	int len = sizeof(sin);
    	
    	char * sendData = "来自客户端的数据包.\n";
    	sendto(sclient, sendData, strlen(sendData), 0, (sockaddr *)&sin, len);
    
    	char recvData[255]; 	
    	int ret = recvfrom(sclient, recvData, 255, 0, (sockaddr *)&sin, &len);
    	if(ret > 0)
    	{
    		recvData[ret] = 0x00;
    		printf(recvData);
    	}
    
    	closesocket(sclient);
    	WSACleanup();
    	return 0;
    }
    

    测试是可以通过的,就是不知道有那些地方可以改进,那些地方是可以删除的,如果有人知道可以给我留言。
    http://shop110737039.taobao.com/
    posted on 2014-12-12 16:08 NET未来之路 阅读(...) 评论(...) 编辑 收藏

    转载于:https://www.cnblogs.com/lonelyxmas/p/4159932.html

    展开全文
  • 考虑到了关闭连接退出机制,多线程编程,以及线程参数传递,值得学习 服务端 #include #include #include #include #include #include #include #include #include #include #include #define MAXCONN 2 #...

    目录

    2. 客户/服务器模式

    2.1 服务器端:

    2.2 客户端:

    4. 套接字函数

    4.1 创建套接字──socket()

    4.2 指定本地地址──bind() 

    4.3 建立套接字连接──connect()与accept()

    4.4 监听连接──listen() 

    4.5 数据传输──send()与recv() 

    4.6 关闭套接字──close

    5 编程实例


    2. 客户/服务器模式


    在TCP/IP网络应用中,通信的两个进程间相互作用的主要模式是客户/服务器(Client/Server, C/S)模式,即客户向服务器发出服务请求,服务器接收到请求后,提供相应的服务。

    客户/服务器模式的建立基于以下两点:
    (1)首先,建立网络的起因是网络中软硬件资源、运算能力和信息不均等,需要共享,从而造就拥有众多资源的主机提供服务,资源较少的客户请求服务这一非对等作用。
    (2)其次,网间进程通信完全是异步的,相互通信的进程间既不存在父子关系,又不共享内存缓冲区,因此需要一种机制为希望通信的进程间建立联系,为二者的数据交换提供同步,这就是基于客户/服务器模式的TCP/IP。
     

    2.1 服务器端:


    其过程是首先服务器方要先启动,并根据请求提供相应服务:
    (1)打开一通信通道并告知本地主机,它愿意在某一公认地址上的某端口(如FTP的端口可能为21)接收客户请求;
    (2)等待客户请求到达该端口;
    (3)接收到客户端的服务请求时,处理该请求并发送应答信号。接收到并发服务请求,要激活一新进程来处理这个客户请求(如UNIX系统中用fork、exec)。新进程处理此客户请求,并不需要对其它请求作出应答。服务完成后,关闭此新进程与客户的通信链路,并终止。
    (4)返回第(2)步,等待另一客户请求。
    (5)关闭服务器


    2.2 客户端:


    (1)打开一通信通道,并连接到服务器所在主机的特定端口;
    (2)向服务器发服务请求报文,等待并接收应答;继续提出请求......
    (3)请求结束后关闭通信通道并终止。

    从上面所描述过程可知:
    (1)客户与服务器进程的作用是非对称的,因此代码不同。
    (2)服务器进程一般是先启动的。只要系统运行,该服务进程一直存在,直到正常或强迫终止。
    3. 基本TCP套接字编程
    基于 TCP 的套接字编程的所有客户端和服务器端都是从调用socket 开始,它返回一个套接字描述符。客户端随后调用connect 函数,服务器端则调用 bind、listen 和accept 函数。套接字通常使用标准的close 函数关闭,但是也可以使用 shutdown 函数关闭套接字。

    下图为TCP套接字编程流程图:

    4. 套接字函数


    4.1 创建套接字──socket()


    应用程序在使用套接字前,首先必须拥有一个套接字,系统调用socket()向应用程序提供创建套接字的手段,

    其调用格式如下:
    SOCKET PASCAL FAR socket(int af, int type, int protocol);

    该调用要接收三个参数:af、type、protocol。参数af指定通信发生的区域:AF_UNIX、AF_INET、AF_NS等,而DOS、WINDOWS中仅支持AF_INET,它是网际网区域。因此,地址族与协议族相同。参数type 描述要建立的套接字的类型。

    这里分三种:
    (1)一是TCP流式套接字(SOCK_STREAM)提供了一个面向连接、可靠的数据传输服务,数据无差错、无重复地发送,且按发送顺序接收。内设流量控制,避免数据流超限;数据被看作是字节流,无长度限制。文件传送协议(FTP)即使用流式套接字。
    (2)二是数据报式套接字(SOCK_DGRAM)提供了一个无连接服务。数据包以独立包形式被发送,不提供无错保证,数据可能丢失或重复,并且接收顺序混乱。网络文件系统(NFS)使用数据报式套接字。
    (3)三是原始式套接字(SOCK_RAW)该接口允许对较低层协议,如IP、ICMP直接访问。常用于检验新的协议实现或访问现有服务中配置的新设备。
    参数protocol说明该套接字使用的特定协议,如果调用者不希望特别指定使用的协议,则置为0,使用默认的连接模式。根据这三个参数建立一个套接字,并将相应的资源分配给它,同时返回一个整型套接字号。因此,socket()系统调用实际上指定了相关五元组中的“协议”这一元。


    4.2 指定本地地址──bind() 


    当一个套接字用socket()创建后,存在一个名字空间(地址族),但它没有被命名。bind()将套接字地址(包括本地主机地址和本地端口地址)与所创建的套接字号联系起来,即将名字赋予套接字,以指定本地半相关。

    其调用格式如下:
    int PASCAL FAR bind(SOCKET s, const struct sockaddr FAR * name, int namelen);

    参数s是由socket()调用返回的并且未作连接的套接字描述符(套接字号)。参数name 是赋给套接字s的本地地址(名字),其长度可变,结构随通信域的不同而不同。namelen表明了name的长度。如果没有错误发生,bind()返回0。否则返回SOCKET_ERROR。

    4.3 建立套接字连接──connect()与accept()


    这两个系统调用用于完成一个完整相关的建立,其中connect()用于建立连接。accept()用于使服务器等待来自某客户进程的实际连接。

    connect()的调用格式如下:
    int PASCAL FAR connect(SOCKET s, const struct sockaddr FAR * name, int namelen);

    参数s是欲建立连接的本地套接字描述符。参数name指出说明对方套接字地址结构的指针。对方套接字地址长度由namelen说明。
    如果没有错误发生,connect()返回0。否则返回值SOCKET_ERROR。在面向连接的协议中,该调用导致本地系统和外部系统之间连接实际建立。
    由于地址族总被包含在套接字地址结构的前两个字节中,并通过socket()调用与某个协议族相关。因此bind()和connect()无须协议作为参数。

    accept()的调用格式如下:
    SOCKET PASCAL FAR accept(SOCKET s, struct sockaddr FAR* addr, int FAR* addrlen);

    参数s为本地套接字描述符,在用做accept()调用的参数前应该先调用过listen()。addr 指向客户方套接字地址结构的指针,用来接收连接实体的地址。addr的确切格式由套接字创建时建立的地址族决定。addrlen 为客户方套接字地址的长度(字节数)。如果没有错误发生,accept()返回一个SOCKET类型的值,表示接收到的套接字的描述符。否则返回值INVALID_SOCKET。

    accept()用于面向连接服务器。参数addr和addrlen存放客户方的地址信息。调用前,参数addr 指向一个初始值为空的地址结构,而addrlen 的初始值为0;调用accept()后,服务器等待从编号为s的套接字上接受客户连接请求,而连接请求是由客户方的connect()调用发出的。当有连接请求到达时,accept()调用将请求连接队列上的第一个客户方套接字地址及长度放入addr 和addrlen,并创建一个与s有相同特性的新套接字号。新的套接字可用于处理服务器并发请求。

    四个套接字系统调用,socket()、bind()、connect()、accept(),可以完成一个完全五元相关的建立。socket()指定五元组中的协议元,它的用法与是否为客户或服务器、是否面向连接无关。bind()指定五元组中的本地二元,即本地主机地址和端口号,其用法与是否面向连接有关:在服务器方,无论是否面向连接,均要调用bind(),若采用面向连接,则可以不调用bind(),而通过connect()自动完成。若采用无连接,客户方必须使用bind()以获得一个唯一的地址。


    4.4 监听连接──listen() 


    此调用用于面向连接服务器,表明它愿意接收连接。listen()需在accept()之前调用,

    其调用格式如下:
    int PASCAL FAR listen(SOCKET s, int backlog);

    参数s标识一个本地已建立、尚未连接的套接字号,服务器愿意从它上面接收请求。backlog表示请求连接队列的最大长度,用于限制排队请求的个数,目前允许的最大值为5。如果没有错误发生,listen()返回0。否则它返回SOCKET_ERROR。
    listen()在执行调用过程中可为没有调用过bind()的套接字s完成所必须的连接,并建立长度为backlog的请求连接队列。
    调用listen()是服务器接收一个连接请求的四个步骤中的第三步。它在调用socket()分配一个流套接字,且调用bind()给s赋于一个名字之后调用,而且一定要在accept()之前调用。

    4.5 数据传输──send()与recv() 


    当一个连接建立以后,就可以传输数据了。常用的系统调用有send()和recv()。
    send()调用用于s指定的已连接的数据报或流套接字上发送输出数据,格式如下:

    int PASCAL FAR send(SOCKET s, const char FAR *buf, int len, int flags);

    参数s为已连接的本地套接字描述符。buf 指向存有发送数据的缓冲区的指针,其长度由len 指定。flags 指定传输控制方式,如是否发送带外数据等。如果没有错误发生,send()返回总共发送的字节数。否则它返回SOCKET_ERROR。

    recv()调用用于s指定的已连接的数据报或流套接字上接收输入数据,格式如下:

    int PASCAL FAR recv(SOCKET s, char FAR *buf, int len, int flags);

    参数s 为已连接的套接字描述符。buf指向接收输入数据缓冲区的指针,其长度由len 指定。flags 指定传输控制方式,如是否接收带外数据等。如果没有错误发生,recv()返回总共接收的字节数。如果连接被关闭,返回0。否则它返回SOCKET_ERROR。

     

    4.6 关闭套接字──close


    close()关闭套接字s,并释放分配给该套接字的资源;如果s涉及一个打开的TCP连接,则该连接被释放。

    4.6 recv和read|send和write的区别

    int recv(int sockfd,void *buf,int len,int flags) 

    recv 比read 的功能强大点,体现在recv提供的flags参数上,
    recv最终的实现还是要调用read。

    recv和read都可以操作阻塞或非阻塞,阻塞非阻塞与recv和read没关系,它是socket的属性,函数fcntl可以设置。

    https://www.xuebuyuan.com/1794019.html

     

    5 编程实例

     
    考虑到了关闭连接退出机制,多线程编程,以及线程参数的传递,值得学习
     

    服务端

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <netinet/ip.h>
    #include <arpa/inet.h>
    #include<unistd.h>
    #include<errno.h>
    #include<pthread.h>
    #define MAXCONN 2
    #define ERRORCODE -1
    #define BUFFSIZE 1024
    int count_connect = 0;
    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
    struct pthread_socket
    {
    	int socket_d;
    	pthread_t thrd;
    };
    static void *thread_send(void *arg)
    {
    	char buf[BUFFSIZE];
    	int sd = *(int *) arg;
    	memset(buf, 0, sizeof(buf));
    	strcpy(buf, "hello,welcome to you! \n");
    	if (send(sd, buf, strlen(buf), 0) == -1)
    	{
    		printf("send error:%s \n", strerror(errno));
    		return NULL;
    	}
    	while (1)
    	{
    		memset(buf, 0, sizeof(buf));
    		read(STDIN_FILENO, buf, sizeof(buf));
    		if (send(sd, buf, strlen(buf), 0) == -1)
    		{
    			printf("send error:%s \n", strerror(errno));
    			break;
    		}
    	}
    	return NULL;
    }
    static void* thread_recv(void *arg)
    {
    	char buf[BUFFSIZE];
    	struct pthread_socket *pt = (struct pthread_socket *) arg;
    	int sd = pt->socket_d;
    	pthread_t thrd = pt->thrd;
    	while (1)
    	{
    		memset(buf, 0, sizeof(buf));
    		int rv = recv(sd, buf, sizeof(buf), 0); //是阻塞的
    		if (rv < 0)
    		{
    			printf("recv error:%s \n", strerror(errno));
    			break;
            	}
            	if (rv == 0) // 这种情况说明client已经关闭socket连接
            	{
                		break;
            	}
            	printf("%s", buf); //输出接受到内容
        	}
        	pthread_cancel(thrd);
        	pthread_mutex_lock(&mutex);
        	count_connect--;
        	pthread_mutex_unlock(&mutex);
        	close(sd);
        	return NULL;
    }
     
    static int create_listen(int port)
    {
     
        	int listen_st;
        	struct sockaddr_in sockaddr; //定义IP地址结构
        	int on = 1;
        	listen_st = socket(AF_INET, SOCK_STREAM, 0); //初始化socket
        	if (listen_st == -1)
        	{
            	printf("socket create error:%s \n", strerror(errno));
            	return ERRORCODE;
        	}
        	if (setsockopt(listen_st, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) == -1) //设置ip地址可重用
        	{
            	printf("setsockopt error:%s \n", strerror(errno));
            	return ERRORCODE;
        	}
        	sockaddr.sin_port = htons(port); //指定一个端口号并将hosts字节型传化成Inet型字节型(大端或或者小端问题)
        	sockaddr.sin_family = AF_INET;    //设置结构类型为TCP/IP
        	sockaddr.sin_addr.s_addr = htonl(INADDR_ANY);    //服务端是等待别人来连,不需要找谁的ip
        	//这里写一个长量INADDR_ANY表示server上所有ip,这个一个server可能有多个ip地址,因为可能有多块网卡
        	if (bind(listen_st, (struct sockaddr *) &sockaddr, sizeof(sockaddr)) == -1)
        	{
           		printf("bind error:%s \n", strerror(errno));
            	return ERRORCODE;
        	}
     
        	if (listen(listen_st, 5) == -1) //     服务端开始监听
        	{
            	printf("listen error:%s \n", strerror(errno));
            	return ERRORCODE;
        	}
        	return listen_st;
    }
     
    int accept_socket(int listen_st)
    {
        	int accept_st;
        	struct sockaddr_in accept_sockaddr; //定义accept IP地址结构
        	socklen_t addrlen = sizeof(accept_sockaddr);
        	memset(&accept_sockaddr, 0, addrlen);
        	accept_st = accept(listen_st, (struct sockaddr*) &accept_sockaddr,&addrlen);
        	//accept 会阻塞直到客户端连接连过来 服务端这个socket只负责listen 是不是有客服端连接过来了
        	//是通过accept返回socket通信的
        	if (accept_st == -1)
        	{
            	printf("accept error:%s \n", strerror(errno));
            	return ERRORCODE;
        	}
       	printf("accpet ip:%s \n", inet_ntoa(accept_sockaddr.sin_addr));
        	return accept_st;
    }
    int run_server(int port)
    {
        	int listen_st = create_listen(port);    //创建监听socket
        	pthread_t send_thrd, recv_thrd;
        	struct pthread_socket ps;
        	int accept_st;
        	if (listen_st == -1)
        	{
            	return ERRORCODE;
        	}
        	printf("server start \n");
        	while (1)
        	{
            	accept_st = accept_socket(listen_st); //获取连接的的socket
            	if (accept_st == -1)
            	{
                		return ERRORCODE;
            	}
            	if (count_connect >= MAXCONN)
            	{
                		printf("connect have already be full! \n");
                		close(accept_st);
                		continue;
            	}
            	pthread_mutex_lock(&mutex);
            	count_connect++;
            	pthread_mutex_unlock(&mutex);
            	if (pthread_create(&send_thrd, NULL, thread_send, &accept_st) != 0) //创建发送信息线程
            	{
                		printf("create thread error:%s \n", strerror(errno));
                		break;
     
            	}
            	pthread_detach(send_thrd);        //设置线程可分离性,这样的话主线程就不用join
            	ps.socket_d = accept_st;
            	ps.thrd = send_thrd;
            	if (pthread_create(&recv_thrd, NULL, thread_recv, &ps) != 0)//创建接收信息线程
            	{
                		printf("create thread error:%s \n", strerror(errno));
                		break;
            	}
            	pthread_detach(recv_thrd); //设置线程为可分离,这样的话,就不用pthread_join
        	}
        close(accept_st);
        close(listen_st);
        return 0;
    }
    //server main
    int main(int argc, char *argv[])
    {
        	if (argc < 2)
        	{
            	printf("Usage:port,example:8080 \n");
            	return -1;
        	}
        	int port = atoi(argv[1]);
        	if (port == 0)
        	{
            	printf("port error! \n");
        	} 
    	else
        	{
            	run_server(port);
        	}
        return 0;
    }
     
     
    客户端:
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include <sys/types.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <netinet/ip.h>
    #include <arpa/inet.h>
    #include<unistd.h>
    #include<errno.h>
    #include<pthread.h>
     
    #define BUFFSIZE 1024
    #define ERRORCODE -1
     
    static void *thread_send(void *arg)
    {
    	char buf[BUFFSIZE];
    	int sd = *(int *) arg;
    	while (1)
    	{
    		memset(buf, 0, sizeof(buf));
    		read(STDIN_FILENO, buf, sizeof(buf));
    		if (send(sd, buf, strlen(buf), 0) == -1)
    		{
    			printf("send error:%s \n", strerror(errno));
    			break;
    		}
    	}
    	return NULL;
    }
    static void *thread_recv(void *arg)
    {
    	char buf[BUFFSIZE];
    	int sd = *(int *) arg;
    	while (1)
    	{
    		memset(buf, 0, sizeof(buf));
    		int rv = recv(sd, buf, sizeof(buf), 0);
    		if (rv <= 0)
    		{
    			if(rv == 0) //server socket关闭情况
    			{
    				printf("server have already full !\n");
    				exit(0);//退出整个客服端
    			}
    		printf("recv error:%s \n", strerror(errno));
    		break;
    		}
    		printf("%s", buf);//输出接收到的内容
    	}	
    	return NULL;
    }
    int run_client(char *ip_str, int port)
    {
    	int client_sd;
    	int con_rv;
    	pthread_t thrd1, thrd2;
    	struct sockaddr_in client_sockaddr; //定义IP地址结构
    	client_sd = socket(AF_INET, SOCK_STREAM, 0);
    	if (client_sd == -1)
    	{
    		printf("socket create error:%s \n", strerror(errno));
    		return ERRORCODE;
    	}
    	memset(&client_sockaddr, 0, sizeof(client_sockaddr));
    	client_sockaddr.sin_port = htons(port); //指定一个端口号并将hosts字节型传化成Inet型字节型(大端或或者小端问题)
    	client_sockaddr.sin_family = AF_INET; //设置结构类型为TCP/IP
    	client_sockaddr.sin_addr.s_addr = inet_addr(ip_str);//将字符串的ip地址转换成int型,客服端要连接的ip地址
    	con_rv = connect(client_sd, (struct sockaddr*) &client_sockaddr,
    	sizeof(client_sockaddr));
    	//调用connect连接到指定的ip地址和端口号,建立连接后通过socket描述符通信
    	if (con_rv == -1)
    	{
    		printf("connect error:%s \n", strerror(errno));
    		return ERRORCODE;
    	}
    	if (pthread_create(&thrd1, NULL, thread_send, &client_sd) != 0)
    	{
    		printf("thread error:%s \n", strerror(errno));
    		return ERRORCODE;
    	}
    	if (pthread_create(&thrd2, NULL, thread_recv, &client_sd) != 0)
    	{
    		printf("thread error:%s \n", strerror(errno));
    		return ERRORCODE;
    	}
    	pthread_join(thrd2, NULL);// 等待线程退出
    	pthread_join(thrd1, NULL);
    	close(client_sd);
    	return 0;
    }
    int main(int argc, char *argv[])
    {
    	if (argc < 3)
    	{
    		printf("Usage:ip port,example:127.0.0.1 8080 \n");
    		return ERRORCODE;
    	}
    	int port = atoi(argv[2]);
    	char *ip_str = argv[1];
    	run_client(ip_str,port);
    	return 0;
    }

     g++ -pthread socket.c -o socketTest 

    转自:https://blog.csdn.net/cike44/article/details/52756900/
     
     

    字节流套接口(如tcp套接口)上的read和write函数所表现的行为不同于通常的文件IO。字节流套接口上的读或写输入或输出的字节数可能比要求的数量少,但这不是错误状况,原因是内核中套接口的缓冲区可能已达到了极限。此时所需的是调用者再次调用read或write函数,以输入或输出剩余的字节。 

    可以使用readn函数来实现循环读取以解决这个问题:

     
    ssize_t      /* Read "n" bytes from a descriptor. */
    readn(int fd, void *vptr, size_t n)
    {
        size_t nleft;
        ssize_t nread;
        char *ptr;
        
        ptr = vptr;
        nleft = n;
     
        while (nleft > 0) {
            if ( (nread = read(fd, ptr, nleft)) < 0) {
                if (errno == EINTR)
                    nread = 0;  /* and call read() again */
                else
                    return(-1);
            } else if (nread == 0)
       
            break;    /* EOF */
     
            nleft -= nread;
            ptr += nread;
        }
        
        return(n - nleft);  /* return >= 0 */
    }

    https://blog.csdn.net/hhhlizhao/article/details/73912578

     
     
     
    展开全文
  • 套接字是一种进程间通信方法,不同于以往介绍进程间通信方法是,它并不局限于同一台计算机资源,例如文件系统空间,共享内存或者消息队列。套接字可以认为是对管道概念扩展——一台机器上进程可以使用...

         套接字是一种进程间的通信的方法,不同于以往介绍的进程间通信方法的是,它并不局限于同一台计算机的资源,例如文件系统空间,共享内存或者消息队列。套接字可以认为是对管道概念的扩展——一台机器上的进程可以使用套接字与另一台机器上的进程通信。因此客户与服务器可以分散在网络中。同一台机器上的进程间也可以用套接字通信。套接字是一种通信机制,客户/服务器系统既可以在本地单机上运行,也可以在网络中运行。套接字与管道的区别:它明确区分客户与服务器,可以实现将多个客户连接到一个服务器。

         套接字的工作过程(服务器端):首先,服务器应用程序通过socket系统调用创建一个套接字,它是系统分配给该服务器进程的类似文件描述符的资源,不能与其他进程共享。其次,服务器进程使用bind系统调用给套接字命名。本地套接字的名字是linux文件系统的文件名,一般放在/tmp或者/usr/tmp 目录下。网络套接字的名字是与客户相连接的特定网络有关的服务标识符。此标识符允许linux将进入的针对特定端口号的连接转到正确的服务器进程。接下来,服务器进程开始等待客户连接到这个命名套接字,调用listen创建一个等待队列以便存放来自客户的进入连接。最后,服务器通过accept系统调用来接受客户的连接。此时,会产生一个与原有的命名套接字不同的新套接字,它仅用于与这个特定的客户通信,而命名套接字则被保留下来继续处理来自其他客户的连接。  

         套接字的工作过程客户端):调用socket创建一个未命名套接字,将服务器的命名套接字作为一个地址来调用connect与服务器建立连接。一旦建立了连接,就可以像使用底层文件描述符那样来用套接字进行双向的数据通信。

    一、Linux Socket

    1、TCP协议:

    服务器端:tcp_server.c

    1. #include <stdio.h>  
    2. #include <sys/types.h>  
    3. #include <sys/socket.h>  
    4. #include <netinet/in.h>  
    5. #include <arpa/inet.h>  
    6.   
    7. int main(int argc, char *argv[])  
    8. {  
    9.     int server_sockfd;//服务器端套接字  
    10.     int client_sockfd;//客户端套接字  
    11.     int len;  
    12.     struct sockaddr_in my_addr;   //服务器网络地址结构体  
    13.     struct sockaddr_in remote_addr; //客户端网络地址结构体  
    14.     int sin_size;  
    15.     char buf[BUFSIZ];  //数据传送的缓冲区  
    16.     memset(&my_addr,0,sizeof(my_addr)); //数据初始化--清零  
    17.     my_addr.sin_family=AF_INET; //设置为IP通信  
    18.     my_addr.sin_addr.s_addr=INADDR_ANY;//服务器IP地址--允许连接到所有本地地址上  
    19.     my_addr.sin_port=htons(8000); //服务器端口号  
    20.       
    21.     /*创建服务器端套接字--IPv4协议,面向连接通信,TCP协议*/  
    22.     if((server_sockfd=socket(PF_INET,SOCK_STREAM,0))<0)  
    23.     {    
    24.         perror("socket");  
    25.         return 1;  
    26.     }  
    27.    
    28.         /*将套接字绑定到服务器的网络地址上*/  
    29.     if (bind(server_sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))<0)  
    30.     {  
    31.         perror("bind");  
    32.         return 1;  
    33.     }  
    34.       
    35.     /*监听连接请求--监听队列长度为5*/  
    36.     listen(server_sockfd,5);  
    37.       
    38.     sin_size=sizeof(struct sockaddr_in);  
    39.       
    40.     /*等待客户端连接请求到达*/  
    41.     if((client_sockfd=accept(server_sockfd,(struct sockaddr *)&remote_addr,&sin_size))<0)  
    42.     {  
    43.         perror("accept");  
    44.         return 1;  
    45.     }  
    46.     printf("accept client %s\n",inet_ntoa(remote_addr.sin_addr));  
    47.     len=send(client_sockfd,"Welcome to my server\n",21,0);//发送欢迎信息  
    48.       
    49.     /*接收客户端的数据并将其发送给客户端--recv返回接收到的字节数,send返回发送的字节数*/  
    50.     while((len=recv(client_sockfd,buf,BUFSIZ,0))>0)  
    51.     {  
    52.         buf[len]='\0';  
    53.         printf("%s\n",buf);  
    54.         if(send(client_sockfd,buf,len,0)<0)  
    55.         {  
    56.             perror("write");  
    57.             return 1;  
    58.         }  
    59.     }  
    60.     close(client_sockfd);  
    61.     close(server_sockfd);  
    62.         return 0;  
    63. }  

    客户端:tcp_client.c

    1. #include <stdio.h>  
    2. #include <sys/types.h>  
    3. #include <sys/socket.h>  
    4. #include <netinet/in.h>  
    5. #include <arpa/inet.h>  
    6.   
    7. int main(int argc, char *argv[])  
    8. {  
    9.     int client_sockfd;  
    10.     int len;  
    11.     struct sockaddr_in remote_addr; //服务器端网络地址结构体  
    12.     char buf[BUFSIZ];  //数据传送的缓冲区  
    13.     memset(&remote_addr,0,sizeof(remote_addr)); //数据初始化--清零  
    14.     remote_addr.sin_family=AF_INET; //设置为IP通信  
    15.     remote_addr.sin_addr.s_addr=inet_addr("127.0.0.1");//服务器IP地址  
    16.     remote_addr.sin_port=htons(8000); //服务器端口号  
    17.       
    18.     /*创建客户端套接字--IPv4协议,面向连接通信,TCP协议*/  
    19.     if((client_sockfd=socket(PF_INET,SOCK_STREAM,0))<0)  
    20.     {  
    21.         perror("socket");  
    22.         return 1;  
    23.     }  
    24.       
    25.     /*将套接字绑定到服务器的网络地址上*/  
    26.     if(connect(client_sockfd,(struct sockaddr *)&remote_addr,sizeof(struct sockaddr))<0)  
    27.     {  
    28.         perror("connect");  
    29.         return 1;  
    30.     }  
    31.     printf("connected to server\n");  
    32.     len=recv(client_sockfd,buf,BUFSIZ,0);//接收服务器端信息  
    33.          buf[len]='\0';  
    34.     printf("%s",buf); //打印服务器端信息  
    35.       
    36.     /*循环的发送接收信息并打印接收信息--recv返回接收到的字节数,send返回发送的字节数*/  
    37.     while(1)  
    38.     {  
    39.         printf("Enter string to send:");  
    40.         scanf("%s",buf);  
    41.         if(!strcmp(buf,"quit"))  
    42.             break;  
    43.         len=send(client_sockfd,buf,strlen(buf),0);  
    44.         len=recv(client_sockfd,buf,BUFSIZ,0);  
    45.         buf[len]='\0';  
    46.         printf("received:%s\n",buf);  
    47.     }  
    48.     close(client_sockfd);//关闭套接字  
    49.         return 0;  
    50. }  

    2、UDP协议:

    服务器端:udp_server.c

    1. #include <stdio.h>  
    2. #include <sys/types.h>  
    3. #include <sys/socket.h>  
    4. #include <netinet/in.h>  
    5. #include <arpa/inet.h>  
    6.   
    7. int main(int argc, char *argv[])  
    8. {  
    9.     int server_sockfd;  
    10.     int len;  
    11.     struct sockaddr_in my_addr;   //服务器网络地址结构体  
    12.     struct sockaddr_in remote_addr; //客户端网络地址结构体  
    13.     int sin_size;  
    14.     char buf[BUFSIZ];  //数据传送的缓冲区  
    15.     memset(&my_addr,0,sizeof(my_addr)); //数据初始化--清零  
    16.     my_addr.sin_family=AF_INET; //设置为IP通信  
    17.     my_addr.sin_addr.s_addr=INADDR_ANY;//服务器IP地址--允许连接到所有本地地址上  
    18.     my_addr.sin_port=htons(8000); //服务器端口号  
    19.       
    20.     /*创建服务器端套接字--IPv4协议,面向无连接通信,UDP协议*/  
    21.     if((server_sockfd=socket(PF_INET,SOCK_DGRAM,0))<0)  
    22.     {    
    23.         perror("socket");  
    24.         return 1;  
    25.     }  
    26.    
    27.     /*将套接字绑定到服务器的网络地址上*/  
    28.     if (bind(server_sockfd,(struct sockaddr *)&my_addr,sizeof(struct sockaddr))<0)  
    29.     {  
    30.         perror("bind");  
    31.         return 1;  
    32.     }  
    33.     sin_size=sizeof(struct sockaddr_in);  
    34.     printf("waiting for a packet...\n");  
    35.       
    36.     /*接收客户端的数据并将其发送给客户端--recvfrom是无连接的*/  
    37.     if((len=recvfrom(server_sockfd,buf,BUFSIZ,0,(struct sockaddr *)&remote_addr,&sin_size))<0)  
    38.     {  
    39.         perror("recvfrom");  
    40.         return 1;  
    41.     }  
    42.     printf("received packet from %s:\n",inet_ntoa(remote_addr.sin_addr));  
    43.     buf[len]='\0';  
    44.     printf("contents: %s\n",buf);  
    45.     close(server_sockfd);  
    46.     return 0;  
    47. }  

    客户端:udp_client.c

    1. #include <stdio.h>  
    2. #include <sys/types.h>  
    3. #include <sys/socket.h>  
    4. #include <netinet/in.h>  
    5. #include <arpa/inet.h>  
    6.   
    7. int main(int argc, char *argv[])  
    8. {  
    9.     int client_sockfd;  
    10.     int len;  
    11.         struct sockaddr_in remote_addr; //服务器端网络地址结构体  
    12.     int sin_size;  
    13.     char buf[BUFSIZ];  //数据传送的缓冲区  
    14.     memset(&remote_addr,0,sizeof(remote_addr)); //数据初始化--清零  
    15.     remote_addr.sin_family=AF_INET; //设置为IP通信  
    16.     remote_addr.sin_addr.s_addr=inet_addr("127.0.0.1");//服务器IP地址  
    17.     remote_addr.sin_port=htons(8000); //服务器端口号  
    18.   
    19.         /*创建客户端套接字--IPv4协议,面向无连接通信,UDP协议*/  
    20.     if((client_sockfd=socket(PF_INET,SOCK_DGRAM,0))<0)  
    21.     {    
    22.         perror("socket");  
    23.         return 1;  
    24.     }  
    25.     strcpy(buf,"This is a test message");  
    26.     printf("sending: '%s'\n",buf);  
    27.     sin_size=sizeof(struct sockaddr_in);  
    28.       
    29.     /*向服务器发送数据包*/  
    30.     if((len=sendto(client_sockfd,buf,strlen(buf),0,(struct sockaddr *)&remote_addr,sizeof(struct sockaddr)))<0)  
    31.     {  
    32.         perror("recvfrom");   
    33.         return 1;  
    34.     }  
    35.     close(client_sockfd);  
    36.     return 0;  
    37. }  

    socket函数API.cpp

    htons();//将short类型的值从主机字节序转换为网络字节序
    inet_addr();//将IP地址字符串转换为long类型的网络字节序
    gethostbyname();//获得与该域名对应的IP地址
    inet_ntoa();//将long类型的网络字节序转换成IP地址字符串

    展开全文
  • TCP服务端通信常规步骤: 使用 socket() 创建 TCP 套接字(socket) 将创建套接字绑定到一个本地地址和端口上(Bind) 将套接字设为监听模式,准备接收客户端请求(listen) 等待客户请求到来: 当请求到来后,...
  • 15 } 16 17 //创建套接字 18 SOCKET slisten = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); 19 if(slisten == INVALID_SOCKET) 20 { 21 printf("socket error !"); 22 return 0; 23 } 24 25 //绑定IP和端口 26 ...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 125
精华内容 50
关键字:

c语言的socket编程例子

c语言 订阅