Windows socket 编程汇总

最新推荐文章于 2023-11-21 22:37:44 发布

sharkshake

最新推荐文章于 2023-11-21 22:37:44 发布

阅读量355

点赞数

分类专栏：网络知识文章标签： socket windows

网络知识专栏收录该内容

3 篇文章 0 订阅

订阅专栏

一常用数据结构

1 SOCKET

typedef u_int SOCKET

其实就是一个无符号的整数,是一个socket描述符,我的理解就是 ,指向系统内核的”指针”,但这个”指针”要靠系统维护,我们只能获取,还要负责释放.

2 SOCKADDR_IN

struct sockaddr_in{ short sin_family; unsigned short sin_port; IN_ADDR sin_addr;

char sin_zero[8];};

用来指定本地或远程的地址,以此来进行socket连接

sin_family:指定为AF_INET

sin_port: 指定所连接的端口号,用htons将short的端口号进行转换,如htons(6000)

sin_addr:指定所连接的ip,用inet_addr装换,如inet_addr(“127.0.0.1”)

sin_zero:为了和SOCKADDR的大小相同,而进行的填充,应该将其初始化为0

二常用函数

1 WSAStartup

原型:

int WSAStartup(WORD wVersionRequested,LPWSADATA lpWSAData)

作用:

用来初始化ws2_32.lib

返回值

成功返回0

2 WSACleanup

终止ws2_32.lib

3 socket

原型:

SOCKET socket (int af, int type, int protocol );

参数说明

af:指定地址家族,AF_INET

type: SOCK_STREAM或SOCK_DGRAM,前者用于TCP,后者用于UDP

protocol:设置为0即可

作用:

创建一个SOCKET

返回值

创建失败返回INVALID_SOCKET

4 bind

原型:

int bind( SOCKET s, const struct sockaddr FAR *name,int namelen );

参数说明

s:server端已经创建好的SOCKET

name:server的SOCKADDR_IN结构,需要做强制类型转换,注意,他和SOCKADDR的大小一样

namelen:顾名思义,name的size大小,注意他和SOCKADDR的大小一样

作用

将SOCKET绑定到机器上

返回值

成功返回0,错误返回SOCKET_ERROR

5 listen

原型

int listen( SOCKET s, int backlog );

参数说明

s: 服务端未连接的SOCKET

backlog:最大可连接数

作用

设置tcp服务端

返回值

成功返回0,失败返回SOCKET_ERROR

6 accept

原型

SOCKET accept( SOCKET s, struct sockaddr FAR *addr, int FAR *addrlen);

参数说明

s:tcp服务端的SOCKET

addr:远程客户端的地址信息

addlen:addr的size

作用

从已经获得许可的连接中关联一个新的SOCKET

返回值

成功返回新的SOCKET的值,错误返回INVALID_SOCKET

7 send

原型

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

参数说明

s:对方的SOCKET

buf:要发送的缓冲区的地址

flags:通常置为0

作用

向对方发送数据

返回值

成功返回已发送的数据的字节数,错误返回SOCKET_ERROR

8 recv

原型

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

参数说明

s:对方的SOCKET

buf:要发送的缓冲区的地址

flags:通常置为0

作用

接受对方的数据

返回值

成功返回已接受的数据的字节数,错误返回SOCKET_ERROR

9 closesocket

原型

int closesocket( SOCKET s );

参数说明

s:要关闭的SOCKET

作用

关闭指定的SOCKET

返回值

成功返回0,错误返回SOCKET_ERROR

10 connect

原型

Int connect(SOCKET s,const struct sockaddr FAR *name,int namelen) );

参数说明

S:本地SOCKET

name:远程服务端地址信息

namelen:name的size

作用

远程socket连接

返回值

成功返回0,错误返回SOCKET_ERROR

11 sendto

原型

int sendto( SOCKET s, const char FAR *buf, int len, int flags, const struct sockaddr FAR *to, int tolen); );

参数说明

S:对方的SOCKET,可能是连接状态

buf:要发送的信息地址

len:信息的大小

flags:通常置为0

to:远程地址信息

tolen:to的size

作用

用于UDP,数据的发送

返回值

成功返回已发送的数据的字节数,错误返回SOCKET_ERROR

12 recvfrom

原型

int recvfrom( SOCKET s, char FAR* buf, int len, int flags, struct sockaddr FAR *from, int FAR *fromlen );

参数说明

S:对方的SOCKET,可能是连接状态

buf:用于接收的缓冲区地址

len:信息的大小

flags:通常置为0

from:接收远程地址信息

fromlen:to的size

作用

用于UDP,数据的接收

返回值

成功返回已接收的数据的字节数,错误返回SOCKET_ERROR

15 WSAGetLastError

原型: int WSAGetLastError (void);

作用:返回最后一次的错误代码

错误代码在WINSOCK2.H中定义

14 一些转换函数

ntohs:”network to host short”

ntohl:”network to host long”

htons:”host to network short”

htonl:”host to network long”

inet_addr:将字符串的IP转换为网络IP

三正式编程

以下程序在vc6.0 下编译

1 tcp编程

TCP Server:

[cpp]view plaincopy 
   
 /************************************************************************/  
 /* 
 准备步骤 
 #include <WINSOCK2.H> 
 #pragma     comment(lib, "ws2_32.lib ") 
  
 服务器端编程的步骤： 
 0：加载套接字库(WSAStartup()) 
  
 1：创建套接字(socket())； 
    
 2：绑定套接字到一个IP地址和一个端口上(bind())； 
      
 3：将套接字设置为监听模式等待连接请求(listen())； 
        
 4：请求到来后，接受连接请求，返回一个新的对应于此次连接的套接字(accept())； 
          
 5：用返回的套接字和客户端进行通信(send()/recv())； 
            
 6：返回，等待另一连接请求； 
              
 7：关闭套接字(closesocket()) 
  
 8:关闭加载的套接字库(WSACleanup())。 
  
                                                                         */  
 /************************************************************************/  
 #include <WINSOCK2.H>  
 #include <windows.h>  
 #include <iostream>  
 #include <string>  
 using namespace std;  
 #pragma     comment(lib, "ws2_32.lib ")  
   
   
 //0   
 bool LoadWSA();  
 //1  
 bool CreateSocket(SOCKET& sock,int type=SOCK_STREAM);  
 //2  
 bool BindSocket(SOCKET& sock,short port ,const char* strIp);  
 //3  
 bool SetListen(SOCKET& sock,int number);  
 //4,5,6  
 bool Communicate(SOCKET& srverSock);  
 //7  
 bool CloseSocket(SOCKET& sock);  
 //8  
 void CloseWSA();  
   
 void ExitWithErrorMessage(const string& errMsg);  
   
 DWORD WINAPI ClientThread(LPVOID sockCliet);  
    
 void main()  
 {  
     cout<<"start server.\n";  
   
     if(!LoadWSA() )  
         ExitWithErrorMessage("LoadWSA  failed.");  
     cout<<"LoadWAS success.\n";  
   
     SOCKET serSock;  
   
     if(!CreateSocket(serSock) )  
         ExitWithErrorMessage("create server socket failed.");  
     cout<<"CreateSocket success.\n";  
   
     if(!BindSocket(serSock,6000,"127.0.0.1") )  
         ExitWithErrorMessage("BindSocket failed.");  
     cout<<"BindSocket success.\n";  
   
     if(!SetListen(serSock,10) )  
         ExitWithErrorMessage("SetListen failed.");  
     cout<<"SetListen success.\n";  
       
     if(!Communicate(serSock) )  
         ExitWithErrorMessage("Communicate failed.");  
     cout<<"Communicate success.\n";  
   
     if(! CloseSocket(serSock) )  
         ExitWithErrorMessage("CloseSocket failed.");  
     cout<<"CloseSocket success.\n";  
   
     CloseWSA();  
     cout<<"CloseWSA success.\n";  
 }  
   
   
 bool LoadWSA()  
 {  
     WSAData wsaData;  
   
     if( 0 == WSAStartup(MAKEWORD(2,2),&wsaData) )  
     {  
         return true;  
     }  
   
     return false;  
 }  
   
 void CloseWSA()  
 {  
     WSACleanup();  
 }  
   
 bool CreateSocket(SOCKET& sock,int type/* =SOCK_STREAM */)  
 {  
     sock=socket(AF_INET,type,0);  
   
     if(INVALID_SOCKET == sock)  
     {  
         return false;  
     }  
   
     return true;  
 }  
   
 bool BindSocket(SOCKET& sock,short port ,const char* strIp)  
 {  
     SOCKADDR_IN address;  
       
     address.sin_family=AF_INET;       
     address.sin_addr.s_addr =inet_addr(strIp);  
     address.sin_port=htons(port);  
     memset(address.sin_zero,0,sizeof(address.sin_zero));  
   
     if(SOCKET_ERROR == bind(sock,(const struct sockaddr*)&address,sizeof(struct sockaddr)) )  
     {  
         return false;  
     }  
   
     return true;  
 }  
   
 bool SetListen(SOCKET& sock,int number)  
 {  
     if(SOCKET_ERROR == listen(sock,number) )  
     {  
         return false;  
     }  
   
     return true;  
 }  
   
 bool Communicate(SOCKET& srverSock)  
 {  
     SOCKADDR_IN addrClient;  
     SOCKET      newSock;  
     HANDLE  hThread=NULL;  
     int n=sizeof(struct sockaddr);  
     bool flag=true;  
       
     while(true)  
     {  
         newSock=accept(srverSock,( struct sockaddr*)&addrClient,&n);      
           
         if(newSock == INVALID_SOCKET)  
         {  
             cout<<"accept failed.\n";  
             flag=false;  
             break;  
         }  
       
         cout<<"client from "<<inet_ntoa(addrClient.sin_addr)<<":"<<ntohs(addrClient.sin_port)<<endl;  
   
         hThread=CreateThread(NULL,0,ClientThread,(LPVOID)newSock,0,NULL);  
   
         if(hThread==NULL)  
         {  
             cout<<"CreateThread failed.\n";  
             flag=false;  
             break;  
         }  
   
         CloseHandle(hThread);  
     }  
   
     closesocket(newSock);  
   
     return flag;  
 }  
   
   
 bool CloseSocket(SOCKET& sock)  
 {  
     if( closesocket(sock) == SOCKET_ERROR)   
         return false;  
     return true;  
 }  
   
 void ExitWithErrorMessage(const string& errMsg)  
 {  
     cout<<errMsg<<endl;  
     system("pause");  
     exit(1);  
 }  
   
 DWORD WINAPI ClientThread(LPVOID sockCliet)  
 {  
     SOCKET sock=(SOCKET)sockCliet;  
     char buffer[100]={0};  
     int errCode;  
   
     while(true)  
     {  
         memset(buffer,0,100);  
         errCode=recv(sock,buffer,100,0);  
   
         if(errCode==0 || errCode==SOCKET_ERROR)  
         {  
             cout<<"client exit.\n";  
             break;  
         }  
           
         cout<<"message from client: "<<buffer<<endl;  
           
         send(sock,"welcome.",strlen("welcome."),0);  
     }  
   
     return 0;  
 }  

TCP Client

[cpp]view plaincopy 
   
 /************************************************************************/  
 /*  
 准备步骤 
 #include <WINSOCK2.H> 
 #pragma     comment(lib, "ws2_32.lib ") 
  
 0:加载套接字库(WSAStartup()) 
  
 1：创建套接字(socket())； 
    
 2：向服务器发出连接请求(connect())； 
      
 3：和服务器端进行通信(send()/recv())； 
        
 4：关闭套接字(closesocket()) 
  
 5: 关闭加载的套接字库(WSACleanup())。 
  
                                                                      */  
 /************************************************************************/  
   
 #include <WINSOCK2.H>  
 #include <windows.h>  
 #include <iostream>  
 #include <string>  
 using namespace std;  
 #pragma     comment(lib, "ws2_32.lib ")  
   
   
 //0   
 bool LoadWSA();  
 //1  
 bool CreateSocket(SOCKET& sock,int type=SOCK_STREAM);  
 //2  
 bool ConnectToServer(SOCKET& sock,short port ,const char* strIp);  
 //3  
 bool Communicate(SOCKET& sock);  
 //4  
 bool CloseSocket(SOCKET& sock);  
 //5  
 void CloseWSA();  
   
 void ExitWithErrorMessage(const string& errMsg);  
   
   
 void main()  
 {  
     cout<<"Start Client.\n";  
     if(!LoadWSA() )  
         ExitWithErrorMessage("LoadWSA  failed.");  
     cout<<"LoadWSA Success.\n";  
       
     SOCKET clietSock;  
       
     if(!CreateSocket(clietSock) )  
         ExitWithErrorMessage("create server socket failed.");  
     cout<<"CreateSocket Success.\n";  
   
     if(!ConnectToServer(clietSock,6000,"127.0.0.1") )  
         ExitWithErrorMessage("ConnectToServer failed.");  
     cout<<"ConnectToServer Success.\n";  
   
     if(!Communicate(clietSock) )  
         ExitWithErrorMessage("Communicate failed.");  
     cout<<"Communicate Success.\n";  
   
     if(! CloseSocket(clietSock) )  
         ExitWithErrorMessage("CloseSocket failed.");  
     cout<<"CloseSocket Success.\n";  
   
     CloseWSA();  
     cout<<"CloseWSA Success.\n";  
   
   
 }  
   
 bool LoadWSA()  
 {  
     WSAData wsaData;  
       
     if( 0 == WSAStartup(MAKEWORD(2,2),&wsaData) )  
     {  
         return true;  
     }  
       
     return false;  
 }  
   
 void CloseWSA()  
 {  
     WSACleanup();  
 }  
   
 bool CreateSocket(SOCKET& sock,int type/* =SOCK_STREAM */)  
 {  
     sock=socket(AF_INET,type,0);  
       
     if(INVALID_SOCKET == sock)  
     {  
         return false;  
     }  
       
     return true;  
 }  
   
 bool ConnectToServer(SOCKET& sock,short port ,const char* strIp)  
 {  
     SOCKADDR_IN address;  
       
     address.sin_family=AF_INET;       
     address.sin_addr.s_addr=inet_addr(strIp);  
     address.sin_port=htons(port);  
     memset(address.sin_zero,0,sizeof(address.sin_zero));  
   
     if(SOCKET_ERROR == connect(sock,(const struct sockaddr*)&address,sizeof(struct sockaddr)) )  
     {  
         return false;  
     }  
       
     return true;  
 }  
   
 bool Communicate(SOCKET& sock)  
 {  
     bool flag=true;  
     int errCode;  
     char buffer[100]={0};  
   
     while(true)  
     {  
         memset(buffer,0,100);  
         cin.getline(buffer,100);  
         errCode=send(sock,buffer,strlen(buffer),0);  
   
         if(errCode==SOCKET_ERROR)  
         {  
             cout<<"send message error.\n";  
             flag=false;  
             break;  
         }  
       
         memset(buffer,0,100);  
         recv(sock,buffer,100,0);  
         cout<<buffer<<endl;  
     }  
   
     return flag;  
 }  
   
   
   
 void ExitWithErrorMessage(const string& errMsg)  
 {  
     cout<<errMsg<<endl;  
     system("pause");  
     exit(1);  
 }  
   
 bool CloseSocket(SOCKET& sock)  
 {  
     if( closesocket(sock)==SOCKET_ERROR )  
         return false;  
   
     return true;  
 }  

2 upd编程

UDP Server

[cpp]view plaincopy 
   
 /************************************************************************/  
 /*  
 准备步骤 
 #include <WINSOCK2.H> 
 #pragma     comment(lib, "ws2_32.lib ") 
  
 0: 加载套接字库(WSAStartup()); 
  
 1：创建套接字(socket())； 
    
 2：绑定套接字到一个IP地址和一个端口上(bind())； 
      
 3：等待和接收数据(sendto()/recvfrom())； 
        
 4：关闭套接字(closesocket()); 
          
 5: 关闭加载的套接字库(WSACleanup()). 
                                                                      */  
 /************************************************************************/  
   
 #include <WINSOCK2.H>  
 #include <windows.h>  
 #include <iostream>  
 #include <string>  
 using namespace std;  
 #pragma     comment(lib, "ws2_32.lib ")  
   
   
 //0   
 bool LoadWSA();  
 //1  
 bool CreateSocket(SOCKET& sock,int type=SOCK_DGRAM);  
 //2  
 bool BindSocket(SOCKET& sock,short port ,const char* strIp);  
 //4  
 bool Communicate(SOCKET& srverSock);  
 //5  
 bool CloseSocket(SOCKET& sock);  
 //6  
 void CloseWSA();  
   
 void ExitWithErrorMessage(const string& errMsg);  
   
   
 void main()  
 {  
     if(! LoadWSA() )  
         ExitWithErrorMessage("LoadWSA falid.");  
     cout<<"LoadWSA success.\n";  
   
     SOCKET serSocket;  
     if(! CreateSocket(serSocket) )  
         ExitWithErrorMessage("CreateSocket falid.");  
     cout<<"CreateSocket success.\n";  
   
     if(! BindSocket(serSocket,6000,"127.0.0.1") )  
         ExitWithErrorMessage("BindSocket falid.");  
     cout<<"BindSocket success.\n";  
       
     while(! Communicate(serSocket) );  
     cout<<"Communicate success.\n";  
   
     if(! CloseSocket(serSocket) )  
         ExitWithErrorMessage("CloseSocket falid.");  
     cout<<"CloseSocket success.\n";  
   
     CloseWSA();  
 }   
   
   
 bool LoadWSA()  
 {  
     WSAData wsaData;  
       
     if( 0 == WSAStartup(MAKEWORD(2,2),&wsaData) )  
     {  
         return true;  
     }  
       
     return false;  
 }  
   
 void CloseWSA()  
 {  
     WSACleanup();  
 }  
   
 bool CreateSocket(SOCKET& sock,int type)  
 {  
     sock=socket(AF_INET,type,0);  
       
     if(INVALID_SOCKET == sock)  
     {  
         return false;  
     }  
       
     return true;  
 }  
   
 bool BindSocket(SOCKET& sock,short port ,const char* strIp)  
 {  
     SOCKADDR_IN address;  
       
     address.sin_family=AF_INET;       
     address.sin_addr.s_addr =inet_addr(strIp);  
     address.sin_port=htons(port);  
     memset(address.sin_zero,0,sizeof(address.sin_zero));  
       
     if(SOCKET_ERROR == bind(sock,(const struct sockaddr*)&address,sizeof(struct sockaddr)) )  
     {  
         return false;  
     }  
       
     return true;  
 }  
   
 bool Communicate(SOCKET& srverSock)  
 {  
     bool flag =true;  
     SOCKADDR_IN address;  
     int n=sizeof(struct sockaddr);  
     char buffer[100] = {0};  
   
     if(recvfrom(srverSock,buffer, 100,0,(struct sockaddr*)&address,&n) ==SOCKET_ERROR )  
         flag =false;  
   
     if(flag)  
         cout<<buffer;  
   
     return flag;  
 }  
   
 void ExitWithErrorMessage(const string& errMsg)  
 {  
     cout<<errMsg<<endl;  
     system("pause");  
     exit(1);  
 }  
   
 bool CloseSocket(SOCKET& sock)  
 {  
     if( closesocket(sock)==SOCKET_ERROR )  
         return false;  
       
     return true;  
 }  

TCP Client

[cpp]view plaincopy 
   
 /************************************************************************/  
 /*  
 准备步骤 
 #include <WINSOCK2.H> 
 #pragma     comment(lib, "ws2_32.lib ") 
  
 0: 加载套接字库(WSAStartup()); 
  
 1：创建套接字(socket())； 
  
 2：等待和接收数据(sendto()/recvfrom())； 
        
 3：关闭套接字(closesocket()); 
          
 4: ，关闭加载的套接字库(WSACleanup()). 
                                                                      */  
 /************************************************************************/  
   
 #include <WINSOCK2.H>  
 #include <windows.h>  
 #include <iostream>  
 #include <string>  
 using namespace std;  
 #pragma     comment(lib, "ws2_32.lib ")  
   
   
 //0   
 bool LoadWSA();  
 //1  
 bool CreateSocket(SOCKET& sock,int type=SOCK_DGRAM);  
 //2  
 bool Communicate(SOCKET& clientSock,short port ,const char* strIp);  
 //3  
 bool CloseSocket(SOCKET& sock);  
 //4  
 void CloseWSA();  
   
 void ExitWithErrorMessage(const string& errMsg);  
   
   
 void main()  
 {  
     if(! LoadWSA() )  
         ExitWithErrorMessage("LoadWSA falid.");  
     cout<<"LoadWSA success.\n";  
   
     SOCKET clientSocket;  
     if(! CreateSocket( clientSocket) )  
         ExitWithErrorMessage("CreateSocket falid.");  
     cout<<"CreateSocket success.\n";  
   
     if(! Communicate( clientSocket,6000,"127.0.0.1") )  
         ExitWithErrorMessage("Communicate falid.");  
     cout<<"Communicate success.\n";  
   
     if(! CloseSocket( clientSocket) )  
         ExitWithErrorMessage("CloseSocket falid.");  
     cout<<"CloseSocket success.\n";  
   
     CloseWSA();  
 }   
   
   
 bool LoadWSA()  
 {  
     WSAData wsaData;  
       
     if( 0 == WSAStartup(MAKEWORD(2,2),&wsaData) )  
     {  
         return true;  
     }  
       
     return false;  
 }  
   
 void CloseWSA()  
 {  
     WSACleanup();  
 }  
   
 bool CreateSocket(SOCKET& sock,int type)  
 {  
     sock=socket(AF_INET,type,0);  
       
     if(INVALID_SOCKET == sock)  
     {  
         return false;  
     }  
       
     return true;  
 }  
   
   
 bool Communicate(SOCKET& clientSock,short port ,const char* strIp)  
 {  
     bool flag =true;  
     SOCKADDR_IN address;  
     int n=sizeof(struct sockaddr);  
   
     address.sin_family=AF_INET;       
     address.sin_addr.s_addr=inet_addr(strIp);  
     address.sin_port=htons(port);  
     memset(address.sin_zero,0,sizeof(address.sin_zero));  
   
     if( sendto(clientSock,"hello , I am from client message.", sizeof("hello , I am from server message."),  
         0,(const struct sockaddr*)&address,sizeof(struct sockaddr) ) ==SOCKET_ERROR )  
            flag =false;  
   
     return flag;  
 }  
   
 void ExitWithErrorMessage(const string& errMsg)  
 {  
     cout<<errMsg<<endl;  
     system("pause");  
     exit(1);  
 }  
   
 bool CloseSocket(SOCKET& sock)  
 {  
     if( closesocket(sock)==SOCKET_ERROR )  
         return false;  
       
     return true;  
 }  

sharkshake

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Windows socket 编程汇总

一常用数据结构1 SOCKETtypedef u_int SOCKET其实就是一个无符号的整数,是一个socket描述符,我的理解就是 ,指向系统内核的”指针”,但这个”指针”要靠系统维护,我们只能获取,还要负责释放. 2 SOCKADDR_INstruct sockaddr_in{ short sin_family; unsig
复制链接

扫一扫