用Socket在局域网内进行广播

悠悠 2022-06-12 12:18 2017阅读 0赞

服务器和客户机采用Socket编程。  
问题1:服务器进入侦听状态，但是此时客户端并不知道服务器的地址。我该如何做？  
  
问题2:我想使客户端先发出一个广播，服务器接受广播后给客户机发送自己的Ip等信息。  
接着再建立Socket通讯。这样对吗？  
  
问题3:是不是进行广播必须是数据报SOCK\_DGRAM  
  
问题4:是不是通讯的双方必须都是数据流或数据报？如果服务器是数据流SOCK\_STREAM套接字，而客户机是数据报套接字就不能够通讯？  
  
1、用广播（或组播）方式，客户端不需道服务器的地址，初始化时用程序建立一个新的广播地址。  
2、用广播（或组播）方式，可直接收发数据。不用侦听。  
3、是；  
4、只要是数据就行。  
例子：

//   MSGSocket.cpp   :   implementation   file 
    // 
    
    #include   "stdafx.h " 
    //#include   "AV8Rcvr.h " 
    #include   "MSGSocket.h " 
    
    #ifdef   _DEBUG 
    #define   new   DEBUG_NEW 
    #undef   THIS_FILE 
    static   char   THIS_FILE[]   =   __FILE__; 
    #endif 
    
    / 
    //   CMSGSocket 
    
    CMSGSocket::CMSGSocket() 
    { 
    bForceNoLoopback   =   FALSE; 
    bDataReceived   =   false; /*   Variable   defined   for   this   project.   Not   necessarily   part   of   CMsocket   */ 
    number=0; 
    for(int   i=0;i <40;i++) 
    { 
    ready[i]=false; 
    } 
    number=0; 
    newfile=false; 
    receivenumber=0; 
    filename= " "; 
    
    
    } 
    
    CMSGSocket::~CMSGSocket() 
    { 
    } 
    
    
    //   Do   not   edit   the   following   lines,   which   are   needed   by   ClassWizard. 
    #if   0 
    BEGIN_MESSAGE_MAP(CMSGSocket,   CSocket) 
    //{
       {AFX_MSG_MAP(CMSGSocket) 
    //}}AFX_MSG_MAP 
    END_MESSAGE_MAP() 
    #endif //   0 
    
    / 
    //   CMSGSocket   member   functions 
    BOOL   CMSGSocket::CreateSocket(LPCTSTR   strGroupIP,   UINT   nGroupPort) 
    { 
    /*   Create   socket   for   receiving   packets   from   multicast   group   */ 
    LeaveGroup(); 
    //if(!Create(nGroupPort,   SOCK_DGRAM,   FD_READ|FD_WRITE))     //CAsyncSocket 
    if(!Create(nGroupPort,   SOCK_DGRAM,   NULL))     //CSocket 
    { 
    AfxMessageBox( "建立连接时出错，检查该频道是否已被别的窗口占用！ "); 
    return   FALSE; 
    } 
    
    BOOL   bMultipleApps   =   TRUE; /*   allow   reuse   of   local   port   if   needed   */ 
    SetSockOpt(SO_REUSEADDR,   (void*)&bMultipleApps,   sizeof(BOOL),   SOL_SOCKET); 
    
    /*   Fill   m_saHostGroup_in   for   sending   datagrams   */ 
    memset(&m_saHostGroup,   0,   sizeof(m_saHostGroup)); 
    m_saHostGroup.sin_family   =   AF_INET; 
    m_saHostGroup.sin_addr.s_addr   =   inet_addr(strGroupIP); 
    m_saHostGroup.sin_port   =   htons((USHORT)nGroupPort); 
    
    /*   Join   the   multicast   group   */ 
    m_mrMReq.imr_multiaddr.s_addr   =   inet_addr(strGroupIP); /*   group   addr   */  
     m_mrMReq.imr_interface.s_addr   =   htons(INADDR_ANY); /*   use   default   */   
    if(setsockopt(m_hSocket,   IPPROTO_IP,   IP_ADD_MEMBERSHIP,   (char   FAR   *)&m_mrMReq,   sizeof(m_mrMReq))   <   0) 
    { 
    AfxMessageBox( "CreateReceivingSocket   failed "); 
    return   FALSE; 
    } 
    
    return   TRUE; 
    } 
    
    void   CMSGSocket::OnReceive(int   nErrorCode) 
    { 
    ::SetActiveWindow(AfxGetApp()-> m_pMainWnd-> m_hWnd); 
    //AfxMessageBox( "MSG收到数据! "); 
    //return; 
    int   nError   =   ReceiveFrom   (&msg_commanddata,sizeof(csock_data),   m_strSendersIP,   m_nSendersPort); 
    
    if(nError   ==   SOCKET_ERROR) 
    AfxMessageBox( "Error   receiving   data   from   the   host   group "); 
    else 
    { 
    if   (!bForceNoLoopback   ||   (bForceNoLoopback   &&   !(m_strSendersIP   ==   m_strLocalIP   &&   m_nSendersPort   ==   m_nLocalPort))) 
    { 
    //lyksetdata1(3); 
    //AfxMessageBox( "MSG收到数据! "); 
    ::PostMessage(GetActiveWindow(   ),WM_COMMAND,WM_RECEIVEMSG,(LPARAM)0); 
    } 
    } 
    CSocket::OnReceive(nErrorCode);   
    } 
    
    
    BOOL   CMSGSocket::LeaveGroup() 
    { 
    if(setsockopt   (m_hSocket,   IPPROTO_IP,   IP_DROP_MEMBERSHIP,   (char   FAR   *)&m_mrMReq,   sizeof(m_mrMReq))   <   0) 
    return   FALSE; 
    
    Close(); //   Close   receving   socket 
    return   TRUE; 
    } 
    
    /* 
    BOOL   CMSGSocket::Send(const   void*   strMessage,   int   nSize) 
    { 
    //CString   str=strMessage; 
    //AfxMessageBox(str); 
    
    if(SendTo(strMessage,   nSize,   (SOCKADDR*)&m_saHostGroup,   sizeof(SOCKADDR),   0)   ==   SOCKET_ERROR) 
    return   FALSE; 
    else 
    return   TRUE; 
    } 
    */ 
    BOOL   CMSGSocket::Send(csock_data   m_data1) 
    { 
    
    if(SendTo(&m_data1,   sizeof(csock_data),   (SOCKADDR*)&m_saHostGroup,   sizeof(SOCKADDR),   0)   ==   SOCKET_ERROR) 
    { 
            return   FALSE; 
    } 
    else 
    { 
    //AfxMessageBox( "MSGSend! "); 
    return   TRUE; 
    } 
    } 
    
    BOOL   CMSGSocket::TextSend(CString   str) 
    { 
    CString   st=str; 
    st+= "/@&/ "; 
    //BOOL   bo=Send(st,   st.GetLength()+1); 
    return   0; 
    } 
    
    BOOL   CMSGSocket::GetMaker(void) 
    { 
    return   bDataReceived; 
    } 
    
    void   CMSGSocket::SetMaker(BOOL   da) 
    { 
    bDataReceived=da; 
    //ready[number]==da; 
    } 
    
    void   CMSGSocket::Init(void) 
    { 
    bForceNoLoopback   =   FALSE; 
    bDataReceived   =   false; /*   Variable   defined   for   this   project.   Not   necessarily   part   of   CMSGSocket   */ 
    number=0; 
    for(int   i=0;i <40;i++) 
    { 
    ready[i]=false; 
    } 
    } 
    
    
    BOOL   CMSGSocket::SendFile(CString   filename) 
    { 
    return   0; 
    } 
    
    void   CMSGSocket::ReadFile() 
    { 
    
    } 
    
    BOOL   CMSGSocket::SendData(SOCKET_STREAM_FILE_INFO   m_data1) 
    { 
    //AfxMessageBox( "send........ "); 
    if(SendTo(&m_data1,   sizeof(SOCKET_STREAM_FILE_INFO),   (SOCKADDR*)&m_saHostGroup,   sizeof(SOCKADDR),   0)   ==   SOCKET_ERROR) 
    { 
    //AfxMessageBox( "send   false "); 
            return   FALSE; 
    } 
    else 
    { 
    //AfxMessageBox( "send   ok "); 
    return   TRUE; 
    } 
    }

#if   !defined(AFX_MSGSocket_H__257F140C_C139_4112_BACA_2C16C0F155B8__INCLUDED_) 
    #define   AFX_MSGSocket_H__257F140C_C139_4112_BACA_2C16C0F155B8__INCLUDED_ 
    
    #if   _MSC_VER   >   1000 
    #pragma   once 
    #endif   //   _MSC_VER   >   1000 
    //   MSGSocket.h   :   header   file 
    // 
    
    / 
    //   CMSGSocket   command   target 
    
    class   CMSGSocket   :   public   CSocket 
    { 
    //   Attributes 
    public: 
    char   m_strBuffer[32768]; 
    char   m_strBuffer1[32768]; 
    char   m_strBuffer2[32768]; //   Receiving   buffer   for   the   packet   that   has   arrived 
    SOCKADDR_IN   m_saHostGroup; //   SOCKADDR   structure   to   hold   IP/Port   of   the   Host   group   to   send   data   to   it 
    ip_mreq   m_mrMReq; //   Contains   IP   and   interface   of   the   host   group 
    UINT   m_nSendersPort; //   Holds   Port   No.   of   the   socket   from   which   last   packet   was   received 
    CString   m_strSendersIP; //   Hold   IP   of   the   socket   from   which   the   last   packet   was   received 
    UINT   m_nLocalPort; //   Ephemeral   port   number   of   the   sending   port 
    CString   m_strLocalIP; //   IP   Address   of   the   local   host   or   your   machine 
    BOOL   bForceNoLoopback; //   If   interface   does   not   support   lopback   and   the   service   is   required,   the   bool   is   set   to   true 
    
    BOOL   bDataReceived; 
    BOOL   LeaveGroup(); 
    //BOOL   Send(const   void*,   int); 
    BOOL   Send(csock_data   m_data1); 
    BOOL   CreateSocket(LPCTSTR,   UINT); 
    BOOL   ready[40]; 
    int   number; 
    CString   text; 
    
     
    csock_data   msg_commanddata; 
    
    BOOL   newfile; 
    DWORD   fileID; 
    DWORD     receivenumber; 
    CString   filename; 
    
    BOOL   GetMaker(void); 
    void   SetMaker(BOOL   da); 
    void   ReadFrom(void); 
    void   Init(void); 
    BOOL   TextSend(CString   text); 
    
    BOOL   SendFile(CString   filename); 
    void   ReadFile(void); 
    BOOL   SendData(SOCKET_STREAM_FILE_INFO   m_data1); 
    
    
    / 
     
    HINSTANCE   glib; 
    LYKGETDATA   lykgetdata1; 
    LYKSETDATA   lyksetdata1; 
    
    
    //   Operations 
    public: 
    CMSGSocket(); 
    virtual   ~CMSGSocket(); 
    
    //   Overrides 
    public: 
    //   ClassWizard   generated   virtual   function   overrides 
    //{
       {AFX_VIRTUAL(CMSGSocket) 
    public: 
    virtual   void   OnReceive(int   nErrorCode); 
    //}}AFX_VIRTUAL 
    
    //   Generated   message   map   functions 
    //{
       {AFX_MSG(CMSGSocket) 
    //   NOTE   -   the   ClassWizard   will   add   and   remove   member   functions   here. 
    //}}AFX_MSG 
    
    //   Implementation 
    protected: 
    }; 
    
    / 
    
    //{
       {AFX_INSERT_LOCATION}} 
    //   Microsoft   Visual   C++   will   insert   additional   declarations   immediately   before   the   previous   line. 
    
    #endif   //   !defined(AFX_MSGSocket_H__257F140C_C139_4112_BACA_2C16C0F155B8__INCLUDED_) 
    
    
    用法是： 
    
    void   CMainFrame::SendMSG(int   pcommand,int   pmsg) 
    { 
    if(!MSG_Socket.CreateSocket( "234.5.6.7 ",   206)) 
    AfxMessageBox( "建立网络连接出错！ "); 
    
    //AfxMessageBox( "SendMSG "); 
    //return; 
    //AfxMessageBox( "aa "); 
    ::memset(&msg_commanddata,0,sizeof(csock_data)); 
    msg_commanddata.command=pcommand; 
    msg_commanddata.serial=pmsg; 
    POINT   pt; 
    GetCursorPos(&pt); 
    msg_commanddata.mousex=pt.x; 
    msg_commanddata.mousey=pt.y; 
    // 
    char   ch[128]; 
            ::gethostname(ch,100); 
    hostent*   tent=::gethostbyname(ch); 
    msg_commanddata.IP[0][0]=(byte)tent-> h_addr[0]; 
    msg_commanddata.IP[0][1]=(byte)tent-> h_addr[1]; 
    msg_commanddata.IP[0][2]=(byte)tent-> h_addr[2]; 
    msg_commanddata.IP[0][3]=(byte)tent-> h_addr[3]; 
    
    /// 
    if(!MSG_Socket.Send(msg_commanddata)) 
    { 
    // 
    for(int   i=0;i <3;i++) 
    { 
    //Sleep(100); 
    if(!MSG_Socket.Send(msg_commanddata)) 
    { 
    //AfxMessageBox( "send   data   failed "); 
                            //return; 
    } 
    else 
    { 
                                      //AfxMessageBox( "send   data   failed "); 
    } 
    } 
    } 
    else 
    { 
    } 
    //AfxMessageBox( "send   end "); 
    //return; 
    }

//发送端程序
    
    
    
    #include <stdio.h>
    #include <winsock.h>
    
    
    
    int main(int argc, char* argv[])
    {
        WSADATA wsaData;          //指向WinSocket信息结构的指针
        SOCKET sockListener;
        SOCKADDR_IN sin,saUdpServ;
        BOOL fBroadcast = TRUE;
        char sendBuff[1024];
        int nSize;
        int ncount=0;
     // 初始化winsock库，使用socket的前提
        if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//进行WinSocket的初始化
        {
            printf("Can't initiates windows socket!Program stop.\n");//初始化失败返回-1
            return -1;
        }
     // 创建socket
        sockListener=socket(PF_INET,SOCK_DGRAM,0);
     // 打开广播选项，是socket可以广播消息
        setsockopt ( sockListener,SOL_SOCKET,SO_BROADCAST, (CHAR *)&fBroadcast,sizeof ( BOOL ));
     // 将socket绑定到本地端口
        sin.sin_family = AF_INET;
        sin.sin_port = htons(0);
        sin.sin_addr.s_addr = htonl(INADDR_ANY);
        if(bind( sockListener, (SOCKADDR *)&sin, sizeof(sin))!=0)
        {
            printf("Can't bind socket to local port!Program stop.\n");//初始化失败返回-1
            return -1;
        }
     // 设定广播的目的端口
        saUdpServ.sin_family = AF_INET;
        saUdpServ.sin_addr.s_addr = htonl ( INADDR_BROADCAST );
        saUdpServ.sin_port = htons (7001);//发送用的端口，可以根据需要更改
        nSize = sizeof ( SOCKADDR_IN );
        while(1)
        {
      // 广播消息
            sprintf(sendBuff,"Message %d",ncount++);
            sendto ( sockListener,sendBuff,
                lstrlen (sendBuff),
                0,
                (SOCKADDR *) &saUdpServ,
                sizeof ( SOCKADDR_IN ));
            printf("%s\n",sendBuff);
        }
     return 0;
    }
    
    
    //接收
    #include <stdio.h>
    #include <winsock.h>
    #include <conio.h>
    
    int main(int argc, char* argv[])
    {
        WSADATA wsaData;          //指向WinSocket信息结构的指针
        SOCKET sockListener;
        SOCKADDR_IN sin,saClient;
        char cRecvBuff[1024];
        int nSize,nbSize;
        int iAddrLen=sizeof(saClient);
        if(WSAStartup(MAKEWORD( 1, 1 ), &wsaData )!=0)//进行WinSocket的初始化
        {
            printf("Can't initiates windows socket!Program stop.\n");//初始化失败返回-1
            return -1;
        }
     // 绑定到7001端口，以监听来自网络的数据
        sockListener=socket(AF_INET, SOCK_DGRAM,0);
        sin.sin_family = AF_INET;
        sin.sin_port = htons(7001);//发送端使用的发送端口，可以根据需要更改
        sin.sin_addr.s_addr = htonl(INADDR_ANY);
        if(bind( sockListener, (SOCKADDR FAR *)&sin, sizeof(sin))!=0)
        {
            printf("Can't bind socket to local port!Program stop.\n");//初始化失败返回-1
            return -1;
        }
        while(1)
        {
            nSize = sizeof ( SOCKADDR_IN );
      // 接受消息
            if((nbSize=recvfrom (sockListener,cRecvBuff,1024,0,(SOCKADDR FAR *) &saClient,&nSize))==SOCKET_ERROR)
            {
                printf("Recive Error");
                break;
            }
            cRecvBuff[nbSize] = '\0';
            printf("%s\n",cRecvBuff);
      
      
      
        }
        return 0;
    }

**广播**

广播是指在一个局域网中向所有的网上节点发送信息。这是UDP连接的一种

广播有一个广播组，即只有一个广播组内的节点才能收到发往这个广播组的信息。什么决定了一个广播组呢，就是端口号，局域网内一个节点，如果设置了广播属性并监听了端口号A后，那么他就加入了A组广播，这个局域网内所有发往广播端口A的信息他都收的到。在广播的实现中，如果一个节点想接受A组广播信息，那么就要先将他绑定给地址和端口A，然后设置这个socket的属性为广播属性。如果一个节点不想接受广播信息，而只想发送广播信息，那么不用绑定端口，只需要先为socket设置广播属性后，向广播地址INADDR\_BROADCAST的A端口发送udp信息即可。详细的程序实现如下：

1.初始化

WSAStartup(MAKEWORD(2,2),&wsad);

2.创建一个UDP的socket  
s=socket(AF\_INET,SOCK\_DGRAM,0);

3.如果这个socket希望收到信息，则需要绑定地址和这组广播的端口号，如果只是希望发送广播信息，则不需要这步

SOCKADDR\_IN udpAdress,sender;  
int senferAddSize=sizeof(sender);  
udpAdress.sin\_family=AF\_INET;  
udpAdress.sin\_port=htons(11114);  
udpAdress.sin\_addr.s\_addr=inet\_addr("10.11.131.32");  
bind(s,(SOCKADDR\*)&udpAdress,sizeof(udpAdress));

//这样这个节点即可收到局域网内所有发往端口11114的广播信息

4.设置socket的属性为广播  
bool optval=true;  
setsockopt(s,SOL\_SOCKET,SO\_BROADCAST,(char\*)&optval,sizeof(bool));

5.下面就可以使用recvfrom或sendto来收发广播信息了

这里是接受，这是一个阻塞操作  
ret=recvfrom(s,data,1000,0,(SOCKADDR\*)&sender,&senferAddSize);

这里是像该广播组发送信息，注意发送的地址为广播地址INADDR\_BROADCAST，端口号为改组广播的端口号11114

SOCKADDR\_IN dstAdd;  
dstAdd.sin\_family=AF\_INET;  
dstAdd.sin\_port=htons(11114);  
dstAdd.sin\_addr.s\_addr=INADDR\_BROADCAST;  
sendto(s,data(),totalbyte,0,(SOCKADDR\*)&dstAdd,sizeof(SOCKADDR));

多播

多播与广播不同，多播是指一条信息向局域网内有限几个节点传递，而广播是不管某个节点是否在制定组内，都会向这个节点发送广播信息，容易造成网络负担严重。

多播的实现是靠多播组，在局域网内，一个多播地址唯一的定义了一个多播组（端口号任意），可以使用的多播地址是有规定的，从224.0.0.0—239.255.255.255之间，但是其中的一些地址不能用，是用作特殊用途的：224.0.0.0 –224.0.0.2 224.0.1.1 224.0.0.9 224.0.1.24。一个节点如果想接受自某个多播组或向某个多播组发送信息，必须首先加入多播组，然后给予UDP发送。下面是详细的代码实现。

1.初始化

WSAStartup(MAKEWORD(2,2),&wsad);

2.这里传建一个用于多播通信的socket，注意这个socket的参数为设置成多播  
s=WSASocket(AF\_INET,SOCK\_DGRAM,0,NULL,0,WSA\_FLAG\_MULTIPOINT\_C\_LEAF|WSA\_FLAG\_MULTIPOINT\_D\_LEAF|WSA\_FLAG\_OVERLAPPED);

3.将socket绑定到一个本地地址、端口，和广播不同，在多播中，无论是发送还是接收端都必须绑定一个本地地址，这个地址就是多播通信时处理信息的端口  
udpAdress.sin\_family=AF\_INET;  
udpAdress.sin\_port=htons(22222);  
udpAdress.sin\_addr.s\_addr=inet\_addr("10.11.131.32");  
bind(s,(SOCKADDR\*)&udpAdress,sizeof(udpAdress));

4.定义多播组的地址  
multiCastGroup.sin\_family=AF\_INET;  
multiCastGroup.sin\_port=htons(1111);此处端口任意，每个节点的可以设置成不同的  
multiCastGroup.sin\_addr.s\_addr=inet\_addr("224.0.0.3"); 此处需使用上面规定地址段内的多播地址

5.加入这个多播组。注意这里的函数返回了一个socket，这个socket不负责通信，只是在脱离多播组时使用

SOCKET sockM=WSAJoinLeaf(s,(SOCKADDR\*)&multiCastGroup,sizeof(multiCastGroup),NULL,NULL,NULL,NULL,JL\_BOTH);

6.下面使用recvfrom接受多播信息，或者使用sendto发送多播信息

ret=recvfrom(s,data,1000,0,(SOCKADDR\*)&sender,&senferAddSize);

sendto(s,data(),totalbyte,0,(SOCKADDR\*)&multiCastGroup,sizeof(multiCastGroup));

7.最后关闭清理  
closesocket(sockM);  
closesocket(s);  
WSACleanup();

其他：

1）在多播组中，默认情况下一个发出多播信息的节点也会收到自己发送的信息，这称为多播回环，可以关闭多播回环：

bool val=false;

setsocket（s,IPPROTO\_IP,IP\_MULTICAST\_LOOP,(char\*)val,sizeof(val));

2)在多播时，通常要设置适当的TTL（TTL的值是多少，那么多播信息就可以经过多少路由器，每经过一个路由器，TTl的值自动减1）：

int val=3;

setsocket（s，IPPROTO\_IP,IP\_MULTICAST\_TTL，(char\*)val,sizeof(int));

//
    	// UDPServer.cpp 
    #include <stdio.h>
    #include <WINSOCK2.H> 
    #pragma comment(lib,"WS2_32.lib")
    #define BUF_SIZE    64 
    	int main(void)
    	{    
    		WSADATA wsd;    
    		SOCKET  s;    
    		int     nRet;     
    		// 初始化套接字动态库    
    		if(WSAStartup(MAKEWORD(2,2),&wsd) != 0)    
    		{        
    			printf("WSAStartup failed !\n");        
    			return 1;    
    		}     
    		// 创建套接字    
    		s = socket(AF_INET,SOCK_DGRAM,0);    
    		if(s == INVALID_SOCKET)    
    		{        
    			printf("socket() failed ,Error Code:%d\n",WSAGetLastError());        
    			WSACleanup();        
    			return 1;    
    		}     
    		SOCKET      socketSrv = socket(AF_INET,SOCK_DGRAM,0);    
    		SOCKADDR_IN addrSrv;    
    		SOCKADDR_IN addrClient;    
    		char        buf[BUF_SIZE];    
    		int         len = sizeof(SOCKADDR);     
    		// 设置服务器地址    
    		ZeroMemory(buf,BUF_SIZE);    
    		addrSrv.sin_addr.S_un.S_addr = htonl(INADDR_ANY);    
    		addrSrv.sin_family = AF_INET;    
    		addrSrv.sin_port = htons(5000);     
    		// 绑定套接字    
    		nRet = bind(socketSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));    
    		if(SOCKET_ERROR == nRet)       
    		{           
    			printf("bind failed !\n");           
    			closesocket(s);           
    			WSACleanup();           
    			return -1;       
    		}    
    		// 从客户端接收数据    
    		nRet = recvfrom(socketSrv,buf,BUF_SIZE,0,(SOCKADDR*)&addrClient,&len);    
    		if(SOCKET_ERROR == nRet)       
    		{           
    			printf("recvfrom failed !\n");           
    			closesocket(s);           
    			WSACleanup();           
    			return -1;       
    		}    
    		// 打印来自客户端发送来的数据    
    		printf("Recv From Client:%s\n",buf);     
    		// 向客户端发送数据    
    		sendto(socketSrv,"UDP Hello World !",sizeof("UDP Hello World !"),0,(SOCKADDR*)&addrClient,len);    
    		closesocket(s);    
    		WSACleanup();    
    		return 0;
    	}

//
    	// UDPClient.cpp 
    #include <stdio.h>
    #include <WINSOCK2.H> 
    #pragma comment(lib,"WS2_32.lib")
    #define BUF_SIZE    64 
    	int main(void)
    	{    
    		WSADATA wsd;        
    		SOCKET  s;     
    		// 初始化套接字动态库    
    		if(WSAStartup(MAKEWORD(2,2),&wsd) != 0)    
    		{        
    			printf("WSAStartup failed !\n");        
    			return 1;    
    		}     
    		// 创建套接字    
    		s = socket(AF_INET,SOCK_DGRAM,0);    
    		if(s == INVALID_SOCKET)    
    		{        
    			printf("socket() failed, Error Code:%d\n",WSAGetLastError());        
    			WSACleanup();        
    			return 1;    
    		}     
    		char        buf[BUF_SIZE];  
    		// 接受数据    
    		SOCKADDR_IN servAddr;       
    		// 服务器套接字地址    
    		SOCKET      sockClient = socket(AF_INET,SOCK_DGRAM,0);    
    		int         nRet;     ZeroMemory(buf,BUF_SIZE);    
    		strcpy(buf,"UDP Hello World !");     
    		// 设置服务器地址    
    		servAddr.sin_family = AF_INET;    
    		servAddr.sin_addr.S_un.S_addr = inet_addr("192.168.1.254");    
    		servAddr.sin_port = htons(5000);     
    		// 向服务器发送数据    
    		int nServAddLen = sizeof(servAddr);    
    		if(sendto(sockClient,buf,BUF_SIZE,0,(sockaddr *)&servAddr,nServAddLen) == SOCKET_ERROR)    
    		{        
    			printf("recvfrom() failed:%d\n",WSAGetLastError());        
    			closesocket(s);        
    			WSACleanup();        
    			return 1;    
    		}    
    		nRet = recvfrom(sockClient,buf,BUF_SIZE,0,(sockaddr *)&servAddr,&nServAddLen);    
    		if(SOCKET_ERROR == nRet)       
    		{           
    			printf("recvfrom failed !\n");           
    			closesocket(s);           
    			WSACleanup();           
    			return -1;       
    		}     
    		// 打印来自服务端发送来的数据    
    		printf("Recv From Server:%s\n",buf);    
    		closesocket(s);    
    		WSACleanup();    
    		return 0;
    	}

本文讲述了SOCKADDR 与 SOCKADDR\_IN 的区别与联系。已经里面涉及的结构体 联合体 等的一些细节问题。这个是一个很基础的问题，但是很多人都是似是而非的理解着！下面详解了这个谜团！

\-----------------------------------------------------------------------------------------------------------------------

**struct sockaddr** \{  
unsigned short sa\_family; // 地址族, AF\_xxx AF\_INET 不涉及转序的问题  
char sa\_data\[14\]; // 14字节的协议地址 网络字节顺序的  
\};  
  
上面是通用的socket地址，共16个字节！

具体到Internet socket，用下面的结构，二者可以进行类型转换  
  
**struct sockaddr\_in** \{  
short int sin\_family; /\* 地址族 \*/  
unsigned short int sin\_port; /\* 端口号 \*/  
**struct in\_addr** sin\_addr; /\* Internet地址 \*/  
unsigned char sin\_zero\[8\]; /\* 与struct sockaddr一样的长度 \*/ 16个字节  
\};  
  
\---------------------------**struct in\_addr** 就是32位IP地址---------------------------------  
第一种表示方式：  
 **struct in\_addr** \{  
unsigned long s\_addr;  
\};

第二种表示方式：  
**struct in\_addr**  
\{  
**union**  
\{  
struct \{ u\_char s\_b1,s\_b2,s\_b3,s\_b4;\} S\_un\_b;  
struct \{ u\_short s\_w1,s\_w2;\} S\_un\_w;  
u\_long S\_addr;  
\} S\_un;  
\};  
  
利用u\_long htonl(u\_long hostlong);将主机字节序转换为TCP/IP网络字节序.  
利用u\_short htons(u\_short hostshort);将主机字节序转换为TCP/IP网络字节序.  
  
inet\_addr()是将一个点分制的IP地址(如192.168.0.1)转换为上述结构中需要的32位IP地址(0xC0A80001)。

通常的用法是：  
SOCKET sockfd;  
struct sockaddr\_in my\_addr; //SOCKETADDR\_IN my\_addr;  
sockfd = socket(AF\_INET, SOCK\_STREAM, 0); /\* 做一些错误检查! \*/  
  
my\_addr.sin\_family = AF\_INET; /\* 主机字节序 \*/  
my\_addr.sin\_port = htons(MYPORT); /\* short, 网络字节序 \*/

//有两种方式 对应上面 in\_addr 的两种方式  
my\_addr.sin\_addr.s\_addr = inet\_addr("192.168.0.1");  
//my\_addr.sin\_addr.S\_un.s\_addr = inet\_addr("192.168.0.1");  
  
bzero(&(my\_addr.sin\_zero), 8); /\* zero the rest of the struct \*/  
/\* 不要忘了为bind()做错误检查: \*/  
bind(sockfd, (struct sockaddr \*)&my\_addr, sizeof(struct sockaddr));