久久伊人精品一区二区三区,午夜精品久久久久久久无码,综合久久一区二区三区

用Winsock实现语音全双工通信使用

�? — Wed, 31 Jan 2007 03:47:00 GMT

　　摘要�Q�在Windows 95环境下，��Z��TCP/IP协议�Q�用Winsock完成了话音的端到端传输。采用双套接字技术，阐述了主要函数的使用要点�Q�以及基于异步选择机制的应用方法。同�Ӟ��l�出了相应的实例�E�序�?br />
　　一、引�a��?br />
　　Windows 95作�ؓ微机的操作系�l�，已经完全融入了网�l�与通信功能�Q�不仅可以徏立纯Windows 95环境下的“对�{�网�l�”，而且支持多种协议�Q�如TCP/IP、IPX/SPX、NETBUI�{�。在TCP/IP协议�l�中�Q�TPC是一�U�面向连接的协义�Q��ؓ用户提供可靠的、全双工的字节流服务�Q�具有确认、流控制、多路复用和同步�{�功能，适于数据传输。UDP协议则是无连接的�Q�每个分�l�都携带完整的目的地址�Q�各分组在系�l�中独立传送。它不能保证分组的先后顺序，不进行分�l�出错的恢复与重传，因此不保证传输的可靠性，但是�Q�它提供高传输效率的数据报服务，适于实时的语韟뀁图像传输、广播消息等�|�络传输�?br />
　　Winsock接口��E�间通信提供了一�U�新的手�D�，它不但能用于同一机器中的�q�程之间通信�Q�而且支持�|�络通信功能。随着Windows 95的推出。Winsock已经被正式集成到了Windows�pȝ��中，同时包括�?6位和32位的�~�程接口。而Winsock的开发工具也可以在Borland C++4.0、Visual C++2.0�q�些C�~�译器中扑ֈ��Q�主要由一个名为winsock.h的头文�g和动态连接库winsock.dll或wsodk32.dll�l�成�Q�这两种动态连接库分别用于Win16和Win32的应用程序。�?br />
　　本文针对话音的全双工传输要求�Q�采用UDP协议实现了实时网�l�通信。��用VisualC++2.0�~�译环境�Q�其动态连接库名�ؓwsock32.dll。�?

　　二、主要函数的使用要点�?/b>

　　通过建立双套接字�Q�可以很方便地实现全双工�|�络通信。�?br />
　　1.套接字徏立函敎ͼ��?br />
SOCKET socket(int family,int type,int protocol)�?

　　对于UDP协议�Q�写为：�?br />
SOCKRET s;�?br />s=socket(AF_INET,SOCK_DGRAM,0);�?br />或s=socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP)�?/td>

　　��Z��建立两个套接字，必须实现地址的重复绑定，卻I��当一个套接字已经�l�定到某本地地址后，��Z��让另一个套接字重复使用该地址�Q�必��Mؓ调用bind()函数�l�定�W�二个套接字之前�Q�通过函数setsockopt()��套接字设�|�SO_REUSEADDR套接字选项。通过函数getsockopt()可获得套接字选项讄��状态。需要注意的是，两个套接字所对应的端口号不能相同。此外，�q�涉及到套接字缓冲区的设�|�问题，按规定，每个区的讄��范围是：不小�?12个字节，大大�?k字节�Q�根据需要，文中选用�?k字节。�?br />
　　2.套接字绑定函数�?br />
int bind(SOCKET s,struct sockaddr_in*name,int namelen)�?/td>

　　s是刚才创建好的套接字�Q�name指向描述通讯对象的结构体的指针，namelen是该�l�构体的长度。该�l�构体中的分量包括：IP地址(对应name.sin_addr.s_addr)、端口号(name.sin_port)、地址�c�d��(name.sin_family�Q�一般都赋成AF_INET�Q�表�C�是internet地址)。�?br />
　　(1)IP地址的填写方法：在全双工通信中，要把用户名对应的点分表示法地址转换�?2位长整数格式的IP地址�Q��用inet_addr()函数。�?br />
　　(2)端口��h��用于表示同一台计��机不同的进�E?应用�E�序)�Q�其分配�Ҏ��有两�U�：1)�q�程可以让系�l��ؓ套接字自动分配一端口��P��只要在调用bind前将端口��h��定�ؓ0卛_��。由�pȝ��自动分配的端口号位于1024~5000之间�Q��?~1023之间的�Q一TCP或UDP端口都是保留的，�pȝ��不允�怓Q一�q�程使用保留端口�Q�除非其有效用户ID是零(��用户)。�?br />
　　2)�q�程可�ؓ套接字指定一特定端口。这对于需要给套接字分配一众所端口的服务器是很有用的。指定范围�ؓ1024�?5536之间。可��L��指定。�?br />
　　在本�E�序中，对两个套接字的端口号规定�?000�?001�Q�前者对应发送套接字�Q�后者对应接收套接字�?br />
　　端口可��从一�?6位无�W�号�?u_short�c�d��?从主机字节顺序�{换成�|�络字节��序�Q��用htons()函数。�?br />
　　�Ҏ��以上两个函数�Q�可以给出双套接字徏立与�l�定的程序片断�?br />
//讄��有关的全局变量�?br />SOCKET sr,ss;�?br />HPSTR sockBufferS,sockBufferR;�?br />HANDLE hSendData,hReceiveData;�?br />DWROD dwDataSize=1024*4;�?br />struct sockaddr_in therel.there2;�?br />#DEFINE LOCAL_HOST_ADDR 200.200.200.201�?br />#DEFINE REMOTE_HOST-ADDR 200.200.200.202�?br />#DEFINE LOCAL_HOST_PORT 2000�?br />#DEFINE LOCAL_HOST_PORT 2001�?br />//套接字徏立函数�?
BOOL make_skt(HWND hwnd)�?br />{�?br />struct sockaddr_in here,here1;�?br />ss=socket(AF_INET,SOCK_DGRAM,0);�?br />sr=socket(AF_INET,SOCK_DGRAM,0);�?br />if((ss==INVALID_SOCKET)||(sr==INVALID_SOCKET))�?br />{�?br />MessageBox(hwnd,“套接字建立��p�|!”，“�?MB_OK);�?br />return(FALSE);�?br />}�?br />here.sin_family=AF_INET;�?br />here.sin_addr.s_addr=inet_addr(LOCAL_HOST_ADDR);�?br />here.sin_port=htons(LICAL_HOST_PORT);�?br />//another socket�?br />herel.sin_family=AF_INET;�?br />herel.sin_addr.s_addr(LOCAL_HOST_ADDR);�?br />herel.sin_port=htons(LOCAL_HOST_PORT1);�?br />SocketBuffer();//套接字缓冲区的锁定设�|��?br />setsockopt(ss,SOL_SOCKET,SO_SNDBUF,(char FAR*)sockBufferS,dwDataSize);
if(bind(ss,(LPSOCKADDR)&here,sizeof(here)))
{
MessageBox(hwnd,“发送套接字�l�定��p�|!”，“”，MB_OK);
return(FALSE);
}
setsockopt(sr SQL_SOCKET,SO_RCVBUF|SO_REUSEADDR,(char FAR*)
sockBufferR,dwDataSize);
if(bind(sr,(LPSOCKADDR)&here1,sizeof(here1)))
{
MessageBox(hwnd,“接收套接字�l�定��p�|!”，“”，MB_OK);
return(FALSE);
}
return(TRUE);
}
//套接字缓冲区讄��
void sockBuffer(void)
{
hSendData=GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE,dwDataSize);
if(!hSendData)
{
MessageBox(hwnd,“发送套接字�~�冲区定位失�?”，NULL,
MB_OK|MB_ICONEXCLAMATION);
return;
}
if((sockBufferS=GlobalLock(hSendData)==NULL)
{
MessageBox(hwnd,“发送套接字�~�冲区锁定失�?”，NULL,
MB_OK|MB_ICONEXCLAMATION);
GlobalFree(hRecordData[0];
return;
}
hReceiveData=globalAlloc(GMEM_MOVEABLE|GMEM_SHARE,dwDataSize);
if(!hReceiveData)
{
MessageBox(hwnd,"“接收套接字�~�冲区定位��|!”，NULL
MB_OK|MB_ICONEXCLAMATION);
return;
}
if((sockBufferT=Globallock(hReceiveData))=NULL)
MessageBox(hwnd,"发送套接字�~�冲区锁定失�?”，NULL,
MB_OK|MB_ICONEXCLAMATION);
GlobalFree(hRecordData[0]);
return;
}
{

　　3.数据发送与接收函数�Q��?br />
int sendto(SOCKET s.char*buf,int len,int flags,struct sockaddr_in to,int
tolen);�?br />int recvfrom(SOCKET s.char*buf,int len,int flags,struct sockaddr_in
fron,int*fromlen)

　　其中�Q�参数flags一般取0。�?br />
　　recvfrom()函数实际上是��d��sendto()函数发过来的一个数据包�Q�当��d��的数据字节少于规定接收的数目�Ӟ��把数据全部接收�Q��ƈ�q�回实际接收到的字节敎ͼ�当读到的数据多于规定值时�Q�在数据报文方式下，多余的数据将被丢弃。而在��方式下�Q�剩余的数据�׃��recvfrom()��d��。�ؓ了发送和接收数据�Q�必��d��立数据发送缓冲区和数据接收缓冲区。规定：IP层的一个数据报最大不��过64K(含数据报�?。当�~�冲��|�得�q�多、过大时�Q�常因内存不够而导致套接字建立��p�|。在减小�~�冲区后�Q�该错误消失。经�q�实验，文中选用�?K字节。�?br />
　　此外�Q�还应注意这两个函数中最后参数的写法�Q�给sendto()的最后参数是一个整数��|��而recvfrom()的则是指向一整数值的指针。�?br />
　　4.套接字关闭函敎ͼ�closesocket(SOCKET s)�?br />
　　通讯�l�束�Ӟ��应关闭指定的套接字，以释与之相关的资源。�?br />
　　在关闭套接字�Ӟ��应先寚w��定的各种�~�冲区加以释放。其�E�序片断为：�?br />
void CloseSocket(void)�?br />{�?br />GlobalUnlock(hSendData);�?br />GlobalFree(hSenddata);�?br />GlobalUnlock(hReceiveData);�?br />GlobalFree(hReceiveDava);�?br />if(WSAAysncSelect(ss,hwnd,0,0)=SOCKET_ERROR)�?br />{�?br />MessageBos(hwnd,“发送套接字关闭��p�|!”，“”，MB_OK);�?br />return;�?br />}�?br />if(WSAAysncSelect(sr,hwnd,0,0)==SOCKET_ERROR)�?br />{�?
MessageBox(hwnd,“接收套接字关闭��p�|!”，“”，MB_OK);�?br />return;�?br />}�?br />WSACleanup();�?br />closesockent(ss);�?br />closesockent(sr);�?br />return;�?br />}�?/td>

　　三、Winsock的编�E�特点与异步选择机制�?/b>

　　1 ��d��及其处理方式�?br />
　　在网�l�通讯中，�׃��|�络拥挤或一�ơ发送的数据量过大等原因�Q�经�怼�发生交换的数据在短时间内不能传送完�Q�收发数据的函数因此不能�q�回�Q�这�U�现象叫做阻塞。Winsock�Ҏ��可能��d��的函数提供了两种处理方式�Q�阻塞和非阻塞方式。在��d��方式下，收发数据的函数在被调用后一直要��C��送完毕或者出错才能返回。在��d��期间�Q�被�ȝ��函数不会断调用系�l�函数GetMessage()来保持消息��@环的正常�q�行。对于非��d��方式�Q�函数被调用后立卌��回，当传送完成后由Winsock�l�程序发一个事先约定好的消息。�?br />
　　在编�E�时�Q�应��量使用非阻塞方式。因为在��d��方式下，用户可能会长旉��的等待过�E�中试图关闭�E�序�Q�因为消息��@环还在�v作用�Q�所以程序的�H�口可能被关闭，�q�样当函��C��Winsock的动态连接库中返回时�Q�主�E�序已经从内存中删除�Q�这昄��是极其危险的。�?br />
　　2 异步选择函数WSAAsyncSelect()的��用�?br />
　　Winsock通过WSAAsyncSelect()自动地设�|�套接字处于非阻塞方式。��用WindowsSockets实现Windows�|�络�E�序设计的关键就是它提供了对�|�络事�g��Z��消息的异步存取，用于注册应用�E�序感兴��的�|�络事�g。它��h��Windows Sockets DLL在检��到套接字上发生的网�l�事件时�Q�向�H�口发送一个消息。对UDP协议�Q�这些网�l�事件主要�ؓ�Q��?br />
　　FD_READ 期望在套接字收到数据(卌��准备�?时接攉��知�Q��?br />
　　FD_WRITE 期望在套接字可发送数(卛_��准备�?时接攉��知�Q��?br />
　　FD_CLOSE 期望在套接字关闭时接电通知�?br />
　　消息变量wParam指示发生�|�络事�g的套接字�Q�变�?Param的低字节描述发生的网�l�事�Ӟ��高字包含错误码。如在窗口函数的消息循环中均加一个分支：�?br />
int ok=sizeof(SOCKADDR);�?br />case wMsg;�?br />switch(1Param)�?br />{�?br />case FD_READ:�?br />//套接字上��L��据�?br />if(recvfrom(sr.lpPlayData[j],dwDataSize,0,(struct sockaddr FAR*)&there1,
�?br />(int FAR*)&ok)==SOCKET_ERROR0�?br />{�?br />MessageBox)hwnd,“数据接收失�?”，“”，MB_OK);�?br />return(FALSE);�?br />}�?br />case FD_WRITE:�?br />//套接字上写数据�?br />}�?br />break�Q��?/td>

　　在程序的�~�制中，应根据需要灵�z�d��WSAAsyncSelect()函灵敏放在相应的消息循环之中�Q�其它说明可参见文献[1]。此外，应该指出的是�Q�以上程序片断中的消息框主要是�ؓ�E�序调试方便而设�|�的�Q�而在正式产品中不再出现。同�Ӟ��按照�E�序定w��误设计，应徏立一个专门的定w��处理函数。程序中可能出现的各�U�错误都��由该函数进行处理，依据错误的危害程度不同，建立几种不同的处理措施。这��P��才能保证双方通话的顺利和可靠。�?br />
　　四、结论�?/b>

　　本文是多媒体�|�络传输��目的重要内容之一�Q�目前，�l�合��g全双工语韛_��{�设备，已经成功地实��C��话音的全双工的通信。有��x��个多媒体传输�pȝ��设计的内容，��有另文叙述�?

�? 2007-01-31 11:47 发表评论

用VC++6.0的Sockets API实现一个聊天室�E�序

�? — Wed, 31 Jan 2007 03:34:00 GMT
　　1.VC++�|�络�~�程及Windows Sockets API��?/font>

　　VC++对网�l�编�E�的支持有socket支持�Q�WinInet支持�Q�MAPI和ISAPI支持�{�。其中，Windows Sockets API是TCP/IP�|�络环境里，也是Internet上进行开发最为通用的API。最早美国加州大学Berkeley分校在UNIX下�ؓTCP/IP协议开发了一个API�Q�这个API��是著名的Berkeley Socket接口(套接�?。在桌面操作�pȝ��q�入Windows时代后，仍然�l�承了Socket�Ҏ��。在TCP/IP�|�络通信环境下，Socket数据传输是一�U�特�D�的I/O�Q�它也相当于一�U�文件描�q�符�Q�具有一个类��g��打开文�g的函数调�?socket()。可以这��L��解：Socket实际上是一个通信端点�Q�通过它，用户的Socket�E�序可以通过�|�络和其他的Socket应用�E�序通信。Socket存在于一�?通信�?(为描�q�C��般的�U�程如何通过Socket�q�行通信而引入的一�U�抽象概�?里，�q�且与另一个域的Socket交换数据。Socket有三�c�R��第一�U�是SOCK_STREAM(��式)�Q�提供面向连接的可靠的通信服务�Q�比如telnet,http。第二种是SOCK_DGRAM(数据�?�Q�提供无�q�接不可靠的通信�Q�比如UDP。第三种是SOCK_RAW(原始)�Q�主要用于协议的开发和��试�Q�支持通信底层操作�Q�比如对IP和ICMP的直接访问�?br />
　　2.Windows Socket机制分析

　　2.1一些基本的Socket�pȝ��调用

　　主要的系�l�调用包括：socket()-创徏Socket�Q�bind()-��创建的Socket与本地端口绑定；connect()与accept()-建立Socket�q�接�Q�listen()-服务器监听是否有�q�接��h��Q�send()-数据的可控缓冲发送；recv()-可控�~�冲接收�Q�closesocket()-关闭Socket�?br />
　　2.2Windows Socket的启动与�l�止

　　启动函数WSAStartup()建立与Windows Sockets DLL的连接，�l�止函数WSAClearup()�l�止使用该DLL�Q�这两个函数必须成对使用�?br />
　　2.3异步选择机制

　　Windows是一个非抢占式的操作�pȝ��Q�而不采取UNIX的阻塞机制。当一个通信事�g产生�Ӟ��操作�pȝ��要根据设�|�选择是否对该事�g加以处理�Q�WSAAsyncSelect()函数��是用来选择�pȝ��所要处理的相应事�g。当Socket收到讑֮�的网�l�事件中的一个时�Q�会�l�程序窗口一个消息，�q�个消息里会指定产生�|�络事�g的Socket�Q�发生的事�g�c�d��和错误码�?br />
　　2.4异步数据传输机制

　　WSAAsyncSelect()讑֮�了Socket上的��d��应通信事�g后，每发生一个这��L��事�g��׃��产生一个WM_SOCKET消息传给�H�口。而在�H�口的回调函��C��应该添加相应的数据传输处理代码�?br />
　　3.聊天室程序的设计说明

　　3.1实现思想

　　在Internet上的聊天室程序一般都是以服务器提供服务端�q�接响应�Q��用者通过客户端程序登录到服务器，��可以与��d��在同一服务器上的用户交谈，�q�是一个面向连接的通信�q�程。因此，�E�序要在TCP/IP环境下，实现服务器端和客��L��两部分程序�?br />
　　3.2服务器端工作��程

　　服务器端通过socket()�pȝ��调用创徏一个Socket数组�?卌��定了接受�q�接客户的最大数�?�Q�与指定的本地端口绑定bind()�Q�就可以在端口进行侦听listen()。如果有客户端连接请求，则在数组中选择一个空Socket�Q�将客户端地址赋给�q�个Socket。然后登录成功的客户��可以在服务器上聊天了�?br />
　　3.3客户端工作流�E?br />
　　客户端程序相对简单，只需要徏立一个Socket与服务器端连接，成功后通过�q�个Socket来发送和接收数据��可以了�?br />
　　4.核心代码分析

　　限于��幅�Q�这里仅�l�出与网�l�编�E�相关的核心代码�Q�其他的诸如聊天文字的服务器和客��L��昄��读者可以自行添加�?br />
　　4.1服务器端代码

　　开启服务器功能:

void OnServerOpen() //开启服务器功能
{
　WSADATA wsaData;
　int iErrorCode;
　char chInfo[64];
　if (WSAStartup(WINSOCK_VERSION, &wsaData)) //调用Windows Sockets DLL
　　{ MessageBeep(MB_ICONSTOP);
　　　MessageBox("Winsock无法初始�?", AfxGetAppName(), MB_OK|MB_ICONSTOP);
　　　WSACleanup();
　　　return; }
　else
　　WSACleanup();
　　if (gethostname(chInfo, sizeof(chInfo)))
　　{ ReportWinsockErr("\n无法获取��L��!\n ");
　　　return; }
　　CString csWinsockID = "\n==>>服务器功能开启在端口�Q�No. ";
　　csWinsockID += itoa(m_pDoc->m_nServerPort, chInfo, 10);
　　csWinsockID += "\n";
　　PrintString(csWinsockID); //在程序视图显�C�提�C�Z��息的函数�Q�读者可自行创徏
　　m_pDoc->m_hServerSocket=socket(PF_INET, SOCK_STREAM, DEFAULT_PROTOCOL);
　　//创徏服务器端Socket�Q�类型�ؓSOCK_STREAM�Q�面向连接的通信
　　if (m_pDoc->m_hServerSocket == INVALID_SOCKET)
　　{ ReportWinsockErr("无法创徏服务器socket!");
　　　return;}
　　m_pDoc->m_sockServerAddr.sin_family = AF_INET;
　　m_pDoc->m_sockServerAddr.sin_addr.s_addr = INADDR_ANY;
　　m_pDoc->m_sockServerAddr.sin_port = htons(m_pDoc->m_nServerPort);
　　if (bind(m_pDoc->m_hServerSocket, (LPSOCKADDR)&m_pDoc->m_sockServerAddr, 　　
　　　　 sizeof(m_pDoc->m_sockServerAddr)) == SOCKET_ERROR) //与选定的端口绑�?br />　　　{ReportWinsockErr("无法�l�定服务器socket!");
　　　　return;}
　　　iErrorCode=WSAAsyncSelect(m_pDoc->m_hServerSocket,m_hWnd,
　　　WM_SERVER_ACCEPT, FD_ACCEPT);
　　　//讑֮�服务器相应的�|�络事�g为FD_ACCEPT�Q�即�q�接��h��Q?br />　　　// 产生相应传递给�H�口的消息�ؓWM_SERVER_ACCEPT
　　if (iErrorCode == SOCKET_ERROR)
　　　{ ReportWinsockErr("WSAAsyncSelect讑֮��p�|!");
　　　　return;}
　　if (listen(m_pDoc->m_hServerSocket, QUEUE_SIZE) == SOCKET_ERROR) //开始监听客戯��接请�?br />　　　{ReportWinsockErr("服务器socket监听��p�|!");
　　　　m_pParentMenu->EnableMenuItem(ID_SERVER_OPEN, MF_ENABLED);
　　　　return;}
　　m_bServerIsOpen = TRUE; //监视服务器是否打开的变�?br />　return;
}

　　响应客户发送聊天文字到服务器：ON_MESSAGE(WM_CLIENT_READ, OnClientRead)

LRESULT OnClientRead(WPARAM wParam, LPARAM lParam)
{
　int iRead;
　int iBufferLength;
　int iEnd;
　int iRemainSpace;
　char chInBuffer[1024];
　int i;
　for(i=0;(i
　　//MAXClient是服务器可响应连接的最大数�?br />　　{}
　if(i==MAXClient) return 0L;
　　iBufferLength = iRemainSpace = sizeof(chInBuffer);
　　iEnd = 0;
　　iRemainSpace -= iEnd;
　　iBytesRead = recv(m_aClientSocket[i], (LPSTR)(chInBuffer+iEnd), iSpaceRemaining, NO_FLAGS); 　　//用可控缓冲接收函数recv()来接收字�W?br />　　iEnd+=iRead;
　if (iBytesRead == SOCKET_ERROR)
　　ReportWinsockErr("recv出错!");
　　chInBuffer[iEnd] = '\0';
　if (lstrlen(chInBuffer) != 0)
　　{PrintString(chInBuffer); //服务器端文字昄��
　　　OnServerBroadcast(chInBuffer); //自己�~�写的函敎ͼ�向所有连接的客户�q�播�q�个客户的聊天文�?br />　　}
　return(0L);
}

　　对于客户断开�q�接�Q�会产生一个FD_CLOSE消息�Q�只��ȝ��应地用closesocket()关闭相应的Socket卛_��Q�这个处理比较简单�?br />
　　4.2客户端代�?br />
　　�q�接到服务器�Q?br />
void OnSocketConnect()
{ WSADATA wsaData;
　DWORD dwIPAddr;
　SOCKADDR_IN sockAddr;
　if(WSAStartup(WINSOCK_VERSION,&wsaData)) //调用Windows Sockets DLL
　{MessageBox("Winsock无法初始�?",NULL,MB_OK);
　　return;
　}
　m_hSocket=socket(PF_INET,SOCK_STREAM,0); //创徏面向�q�接的socket
　sockAddr.sin_family=AF_INET; //使用TCP/IP协议
　sockAddr.sin_port=m_iPort; //客户端指定的IP地址
　sockAddr.sin_addr.S_un.S_addr=dwIPAddr;
　int nConnect=connect(m_hSocket,(LPSOCKADDR)&sockAddr,sizeof(sockAddr)); //��h��q�接
　if(nConnect)
　　ReportWinsockErr("�q�接��p�|!");
　else
　　MessageBox("�q�接成功!",NULL,MB_OK);
　　int iErrorCode=WSAAsyncSelect(m_hSocket,m_hWnd,WM_SOCKET_READ,FD_READ);
　　//指定响应的事�Ӟ��为服务器发送来字符
　if(iErrorCode==SOCKET_ERROR)
　MessageBox("WSAAsyncSelect讑֮��p�|!");
}

　　接收服务器端发送的字符也��用可控缓冲接收函数recv()�Q�客��L��聊天的字�W�发送��用数据可控缓冲发送函数send()�Q�这两个�q�程比较��单，在此��׃��加赘�q�C��?br />
　　5.��结

　　通过聊天室程序的�~�写�Q�可以基本了解Windows Sockets API�~�程的基本过�E�和�_�要之处。本�E�序在VC++6.0下编译通过�Q�在使用windows 98/NT的局域网里运行良好�?br />

�? 2007-01-31 11:34 发表评论

Windows Sockets API实现�|�络异步通讯

�? — Wed, 31 Jan 2007 03:32:00 GMT
摘要�Q?/strong>本文对如何��用面向连接的��式套接字实现对�|�卡的编�E�以及如何实现异步网�l�通讯�{�问题进行了讨论与阐�q��?

　　一�?引言

　　�?0�q�代初，��国加利��尼亚大学伯克利分校的研�I��h员�ؓTCP/IP�|�络通信开发了一个专门用于网�l�通讯开发的API。这个API��是Socket接口�Q�套接字�Q?-当今在TCP/IP�|�络最为通用的一�U�API�Q�也是在互联�|�上�q�行应用开发最为通用的一�U�API。在微��Y联合其它几家公司共同制定了一套Windows下的�|�络�~�程接口Windows Sockets规范后，�׃��在其规范中引入了一些异步函敎ͼ�增加了对�|�络事�g异步选择机制�Q�因此更加符合Windows的消息驱动特性，使网�l�开发�h员可以更加方便的�q�行高性能�|�络通讯�E�序的设计。本文接下来��针对Windows Sockets API�q�行面向�q�接的流式套接字�~�程以及对异步网�l�通讯的编�E�实现等问题展开讨论�?br />
　　二�?面向�q�接的流式套接字�~�程模型的设�?/b>

　　本文在方案选择上采用了在网�l�编�E�中最常用的一�U�模�?-客户�?服务器模型。这�U�客�?服务器模型是一�U�非对称式编�E�模式。该模式的基本思想是把集中在一��L��应用划分成�ؓ功能不同的两个部分，分别在不同的计算��Z��q�行�Q�通过它们之间的分工合作来实现一个完整的功能。对于这�U�模式而言其中一部分需要作为服务器�Q�用来响应�ƈ为客��h��供固定的服务�Q�另一部分则作为客��h��E�序用来向服务器提出��h��或要求某�U�服务�?br />
　　本文选取了基于TCP/IP的客��h��/服务器模型和面向�q�接的流式套接字。其通信原理为：服务器端和客��L��都必��d��立通信套接字，而且服务器端应先�q�入监听状态，然后客户端套接字发出�q�接��h��Q�服务器端收到请求后�Q�徏立另一个套接字�q�行通信�Q�原来负责监听的套接字仍�q�行监听�Q�如果有其它客户发来�q�接��h��Q�则再徏立一个套接字。默认状态下最多可同时接收5个客��L��q�接��h��Q��ƈ与之建立通信关系。因此本�E�序的设计流�E�应当由服务器首先启动，然后在某一时刻启动客户机�ƈ使其与服务器建立�q�接。服务器与客��h��开始都必须调用Windows Sockets API函数socket()建立一个套接字sockets,然后服务器方调用bind()��套接字与一个本地网�l�地址捆扎在一��P��再调用listen()使套接字处于一�U�被动的准备接收状态，同时规定它的��h��队列长度。在此之后服务器��可以通过调用accept()来接收客��h��的连接�?br />
　　相对于服务器�Q�客��L��的工作就昑־�比较��单了�Q�当客户端打开套接字之后，便可通过调用connect()和服务器建立�q�接。连接徏立之后，客户和服务器之间��可以通过�q�接发送和接收资料。最后资料传送结束，双方调用closesocket()关闭套接字来�l�束�q�次通讯。整个通讯�q�程的具体流�E�框囑֏�大致用下面的��程图来表示�Q?br />

　　　　　　　　面向�q�接的流式套接字�~�程��程�C�意�?

三�?软�g设计要点以及异步通讯的实�?br />
　　�Ҏ��前面设计的程序流�E�，可将�E�序划分��Z��部分�Q�服务器端和客户端。而且整个实现�q�程可以大致用以下几个非常关键的Windows Sockets API函数��其惯穿下来�Q?br />
　　服务器方�Q?br />
socket()->bind()->listen->accept()->recv()/send()->closesocket()

　　客户机方�Q?br />
socket()->connect()->send()/recv()->closesocket()

　　有鉴于以上几个函数在整个�|�络�~�程中的重要性，有必要结合程序实例对其做较深入的剖析。服务器端应用程序在使用套接字之前，首先必须拥有一个Socket�Q�系�l�调用socket()函数向应用程序提供创建套接字的手�D�c��该套接字实际上是在计算��Z��提供了一个通信埠，可以通过�q�个埠与��M��一个具有套接字接口的计��机通信。应用程序在�|�络上传输、接收的信息都通过�q�个套接字接口来实现的。在应用开发中如同使用文�g句柄一��P��可以对套接字句柄�q�行��d��操作�Q?br />
sock=socket(AF_INET,SOCK_STREAM,0);

　　函数的第一个参数用于指定地址族，在Windows下仅支持AF_INET(TCP/IP地址)�Q�第二个参数用于描述套接字的�c�d��Q�对于流式套接字提供有SOCK_STREAM�Q�最后一个参数指定套接字使用的协议，一般�ؓ0。该函数的返回��g��存了新套接字的句柄，在程序退出前可以�?closesocket(sock);函数来将光��放。服务器方一旦获取了一个新的套接字后应通过bind()��该套接字与本机上的一个端口相兌��Q?br />
sockin.sin_family=AF_INET;
sockin.sin_addr.s_addr=0;
sockin.sin_port=htons(USERPORT);
bind(sock,(LPSOCKADDR)&sockin,sizeof(sockin)));

　　该函数的�W�二个参数是一个指向包含有本机IP地址和端口信息的sockaddr_in�l�构�c�d��的指针，其成员描�q�C��本地端口号和本地��L��地址�Q�经�q�bind()��服务器�q�程在网�l�上标识出来。需要注意的是由�?024以内的埠号都是保留的埠号因此如无特别需要一般不能将sockin.sin_port的埠可��|��ؓ1024以内的倹{��然后调用listen()函数开始侦听，再通过accept()调用�{�待接收�q�接以完成连接的建立�Q?br />
//�q�接��h��队列长度�?�Q�即只允许有一个请�?若有多个��h��,
//则出现错误，�l�出错误代码WSAECONNREFUSED�?br />listen(sock,1);
//开启线�E�避免主�E�序的阻�?br />AfxBeginThread(Server,NULL);
…�?br />UINT Server(LPVOID lpVoid)
{
…�?br />int nLen=sizeof(SOCKADDR);
pView->newskt=accept(pView->sock,(LPSOCKADDR)& pView->sockin,(LPINT)& nLen);
…�?
WSAAsyncSelect(pView->newskt,pView->m_hWnd,WM_SOCKET_MSG,FD_READ|FD_CLOSE);
return 1;
}

　　�q�里之所以把accept()攑ֈ�一个线�E�中��L��因�ؓ在执行到该函数时如没有客戯��接服务器的请求到来，服务器就会停在accept语句上等待连接请求的到来�Q�这势必会引��L��序的��d��Q�虽然也可以通过讄��套接字�ؓ非阻塞方式��在没有客��L��待时可以使accept�Q�）函数调用立即�q�回�Q�但�q�种轮询套接字的方式会��CPU处于忙等待方式，从而降低程序的�q�行效率大大��费�pȝ��资源。考虑到这�U�情况，��套接字讄��为阻塞工作方式，�q��ؓ其单独开辟一个子�U�程�Q�将光��塞控制在子线�E�范围内而不会造成整个应用�E�序的阻塞。对于网�l�事件的响应昄��要采取异步选择机制�Q�只有采取这�U�方式才可以在由�|�络�Ҏ��所引�v的不可预知的�|�络事�g发生时能马上在进�E�中做出及时的响应处理，而在没有�|�络事�g到达时则可以处理其他事�g�Q�这�U�效率是很高的，而且完全�W�合Windows所标榜的消息触发原则。前面那�D�代码中的WSAAsyncSelect()函数便是实现�|�络事�g异步选择的核心函数�?br />
　　通过�W�四个参数注册应用程序感兴取的网�l�事�Ӟ��在这里通过FD_READ|FD_CLOSE指定了网�l�读和网�l�断开两种事�g�Q�当�q�种事�g发生时变会发出由�W�三个参数指定的自定义消息WM_SOCKET_MSG�Q�接收该消息的窗口通过�W�二个参数指定其句柄。在消息处理函数中可以通过�Ҏ��息参��C��字节�q�行判断而区别出发生的是何种�|�络事�g�Q?br />
void CNetServerView::OnSocket(WPARAM wParam,LPARAM lParam)
{
int iReadLen=0;
int message=lParam & 0x0000FFFF;
switch(message)
{
case FD_READ://��M��件发生。此时有字符到达�Q�需要进行接收处�?br />char cDataBuffer[MTU*10];
//通过套接字接收信�?br />iReadLen = recv(newskt,cDataBuffer,MTU*10,0);
//��信息保存到文�g
if(!file.Open("ServerFile.txt",CFile::modeReadWrite))
file.Open("E:ServerFile.txt",CFile::modeCreate|CFile::modeReadWrite);
file.SeekToEnd();
file.Write(cDataBuffer,iReadLen);
file.Close();
break;
case FD_CLOSE://�|�络断开事�g发生。此时客��h��关闭或退出�?br />…�?/�q�行相应的处�?br />break;
default:
break;
}
}

　　在这里需要实现对自定义消息WM_SOCKET_MSG的响应，需要在头文件和实现文�g中分别添加其消息映射关系�Q?br />
　　头文�Ӟ��

//{{AFX_MSG(CNetServerView)
//}}AFX_MSG
void OnSocket(WPARAM wParam,LPARAM lParam);
DECLARE_MESSAGE_MAP()

　　实现文�g�Q?br />
BEGIN_MESSAGE_MAP(CNetServerView, CView)
//{{AFX_MSG_MAP(CNetServerView)
//}}AFX_MSG_MAP
ON_MESSAGE(WM_SOCKET_MSG,OnSocket)
END_MESSAGE_MAP()

　　在进行异步选择使用WSAAsyncSelect()函数�Ӟ��有以下几炚w��要引��L��别的注意�Q?br />
　　1�Q?�q�箋使用两次WSAAsyncSelect()函数�Ӟ��只有�W�二�ơ设�|�的事�g有效�Q�如�Q?br />
WSAAsyncSelect(s,hwnd,wMsg1,FD_READ);
WSAAsyncSelect(s,hwnd,wMsg2,FD_CLOSE);

　　�q�样只有当FD_CLOSE事�g发生时才会发送wMsg2消息�?br />
　　2�Q�可以在讄��q�异步选择后通过再次调用WSAAsyncSelect(s,hwnd,0,0);的�Ş式取消在套接字上所讄��的异步事件�?br />
　　3�Q�Windows Sockets DLL在一个网�l�事件发生后�Q�通常只会�l�相应的应用�E�序发送一个消息，而不能发送多个消息。但通过使用一些函数隐式地允许重发此事件的消息�Q�这样就可能再次接收到相应的消息�?br />
　　4�Q�在调用�q�closesocket()函数关闭套接字之后不会再发生FD_CLOSE事�g�?br />
　　以上基本完成了服务器方的�E�序设计�Q�下面对于客��L��的实现则要简单多了，在用socket()创徏完套接字之后只需通过调用connect()完成同服务器的连接即可，剩下的工作同服务器完全一��P��用send()/recv()发�?接收收据�Q�用closesocket()关闭套接字：

sockin.sin_family=AF_INET; //地址�?br />sockin.sin_addr.S_un.S_addr=IPaddr; //指定服务器的IP地址
sockin.sin_port=m_Port; //指定�q�接的端口号
int nConnect=connect(sock,(LPSOCKADDR)&sockin,sizeof(sockin));

　　本文采取的是可靠的面向连接的��式套接字。在数据发送上有write()、writev()和send()�{�三个函数可供选择�Q�其中前两种分别用于�~�冲发送和集中发送，而send()则�ؓ可控�~�冲发送，�q�且�q�可以指定传输控制标志�ؓMSG_OOB�q�行带外数据的发送或是�ؓMSG_DONTROUTE��d��控制选项。在信宿地址的网�l�号部分指定数据发送需要经�q�的�|�络接口�Q��其可以不�l�过本地��d��机制直接发送出厅R��这也是其同write()函数的真正区别所在。由于接收数据系�l�调用和发送数据系�l�调用是一一对应的，因此对于数据的接�Ӟ��在此不再赘述�Q�相应的三个接收函数分别为：read()、readv()和recv()。由于后者功能上的全面，本文在实��C��选择了send()-recv()函数对，在具体编�E�中应当视具体情�늚�不同灉|��选择适当的发�?接收函数寏V�?br />
　　��结�Q?/b>TCP/IP协议是目前各�|�络操作�pȝ��主要的通讯协议�Q�也�?Internet的通讯协议�Q�本文通过Windows Sockets API实现了对��Z��TCP/IP协议的面向连接的��式套接字网�l�通讯�E�序的设计，�q��过异步通讯和多�U�程�{�手�D�|��高了�E�序的运行效率，避免了阻塞的发生�?br />

�? 2007-01-31 11:32 发表评论

TCP/IP Winsock�~�程要点

�? — Wed, 31 Jan 2007 02:53:00 GMT
利用Winsock�~�程由同步和异步方式�Q�同步方式逻辑清晰�Q�编�E�专注于应用�Q�在抢先式的多�Q务操作系�l�中(WinNt、Win2K)采用多线�E�方式效率基本达到异步方式的水��^�Q�应此以下�ؓ同步方式�~�程要点�?

　　1、快速通信

　　Winsock的Nagle��法��降低小数据报的发送速度�Q�而系�l�默认是使用Nagle��法,使用

int setsockopt(

SOCKET s,

int level,

int optname,

const char FAR *optval,

int optlen

);函数关闭�?

　　例子�Q?

SOCKET sConnect;

sConnect=::socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

int bNodelay = 1;

int err;

err = setsockopt(

sConnect,

IPPROTO_TCP,

TCP_NODELAY,

(char *)&bNodelay,

sizoeof(bNodelay));//不采用�g时算�?

if (err != NO_ERROR)

TRACE ("setsockopt failed for some reason\n");;

　　2、SOCKET的SegMentSize和收发缓�?

　　TCPSegMentSize是发送接受时单个数据报的最大长度，�pȝ��默认�?460�Q�收发缓冲大��ؓ8192�?

　　在SOCK_STREAM方式下，如果单次发送数据超�q?460�Q�系�l�将分成多个数据报传送，在对�Ҏ��受到的将是一个数据流�Q�应用程序需要增加断帧的判断。当然可以采用修�Ҏ��册表的方式改�?460的大��，但MicrcoSoft认�ؓ1460是最��x��率的参数�Q�不��修改�?

　　在工控系�l�中�Q�徏议关闭Nagle��法�Q�每�ơ发送数据小�?460个字节（推荐1400�Q�，�q�样每次发送的是一个完整的数据报，减少�Ҏ��Ҏ��据流的断帧处理�?

　　3、同步方式中减少断网时connect函数的阻塞时�?

　　同步方式中的断网时connect的阻塞时间�ؓ20�U�左叻I��可采用gethostbyaddr事先判断到服务主机的路径是否是通的�Q�或者先ping一下对方主机的IP地址�?

　　A、采用gethostbyaddr��d��旉��不管成功与否�?�U�左叟�?

　　例子�Q?

LONG lPort=3024;

struct sockaddr_in ServerHostAddr;//服务��L��地址

ServerHostAddr.sin_family=AF_INET;

ServerHostAddr.sin_port=::htons(u_short(lPort));

ServerHostAddr.sin_addr.s_addr=::inet_addr("192.168.1.3");

HOSTENT* pResult=gethostbyaddr((const char *) &

(ServerHostAddr.sin_addr.s_addr),4,AF_INET);

if(NULL==pResult)

{

int nErrorCode=WSAGetLastError();

TRACE("gethostbyaddr errorcode=%d",nErrorCode);

}

else

{

TRACE("gethostbyaddr %s\n",pResult->h_name);;

}

　　B、采用PING方式旉��U?�U�左�?

　　暂略

4、同步方式中解决recv�Q�send��d��问题

　　采用select函数解决�Q�在收发前先��查读写可用状态�?

　　A、读

　　例子�Q?

TIMEVAL tv01 = {0, 1};//1ms钟�g�q?实际�?-10毫秒

int nSelectRet;

int nErrorCode;

FD_SET fdr = {1, sConnect};

nSelectRet=::select(0, &fdr, NULL, NULL, &tv01);//��查可�ȝ��?

if(SOCKET_ERROR==nSelectRet)

{

nErrorCode=WSAGetLastError();

TRACE("select read status errorcode=%d",nErrorCode);

::closesocket(sConnect);

goto 重新�q�接�Q�客��h��Q�，或服务线�E�退出（服务方）;

}

if(nSelectRet==0)//��时发生�Q�无可读数据

{

�l�箋查读状态或向对方主动发�?

}

else

{

��L��?

}

　　B、写

TIMEVAL tv01 = {0, 1};//1ms钟�g�q?实际�?-10毫秒

int nSelectRet;

int nErrorCode;

FD_SET fdw = {1, sConnect};

nSelectRet=::select(0, NULL, NULL,&fdw, &tv01);//��查可写状�?

if(SOCKET_ERROR==nSelectRet)

{

nErrorCode=WSAGetLastError();

TRACE("select write status errorcode=%d",nErrorCode);

::closesocket(sConnect);

//goto 重新�q�接�Q�客��h��Q�，或服务线�E�退出（服务方）;

}

if(nSelectRet==0)//��时发生�Q�缓冲满或网�l�忙

{

//�l�箋查写状态或查读状�?

}

else

{

//发�?

}

　　5、改变TCP收发�~�冲区大��?

　　�pȝ��默认�?192�Q�利用如下方式可改变�?

SOCKET sConnect;

sConnect=::socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);

int nrcvbuf=1024*20;

int err=setsockopt(

sConnect,

SOL_SOCKET,

SO_SNDBUF,//写缓�Ԍ��ȝ��冲�ؓSO_RCVBUF

(char *)&nrcvbuf,

sizeof(nrcvbuf));

if (err != NO_ERROR)

{

TRACE("setsockopt Error!\n");

}

在设�|�缓冲时�Q�检查是否真正设�|�成功用

int getsockopt(

SOCKET s,

int level,

int optname,

char FAR *optval,

int FAR *optlen

);

　　6、服务方同一端口多IP地址的bind和listen

　　在可靠性要求高的应用中�Q�要求��用双�|�和多网�l�通道�Q�再服务方很�Ҏ��实现�Q�用如下方式可徏立客户对本机所有IP地址在端�?024下的��h��服务�?

SOCKET hServerSocket_DS=INVALID_SOCKET;

struct sockaddr_in HostAddr_DS;//服务器主机地址

LONG lPort=3024;

HostAddr_DS.sin_family=AF_INET;

HostAddr_DS.sin_port=::htons(u_short(lPort));

HostAddr_DS.sin_addr.s_addr=htonl(INADDR_ANY);

hServerSocket_DS=::socket( AF_INET, SOCK_STREAM,IPPROTO_TCP);

if(hServerSocket_DS==INVALID_SOCKET)

{

AfxMessageBox("建立数据服务器SOCKET ��p�|!");

return FALSE;

}

if(SOCKET_ERROR==::bind(hServerSocket_DS,(struct

sockaddr *)(&(HostAddr_DS)),sizeof(SOCKADDR)))

{

int nErrorCode=WSAGetLastError ();

TRACE("bind error=%d\n",nErrorCode);

AfxMessageBox("Socket Bind 错误!");

return FALSE;

}

if(SOCKET_ERROR==::listen(hServerSocket_DS,10))//10个客�?

{

AfxMessageBox("Socket listen 错误!");

return FALSE;

}

AfxBeginThread(ServerThreadProc,NULL,THREAD_PRIORITY_NORMAL);

　　在客��h��要复杂一些，�q�接断后�Q�重联不成功则应换下一个IP地址�q�接。也可采用同时连接好后备用的方式�?

　　7、用TCP/IP Winsock实现变种Client/Server

　　传统的Client/Server为客户问、服务答�Q�收发是成对出现的。而变�U�的Client/Server是指在连接时有客户和服务之分�Q�徏立好通信�q�接后，不再有严格的客户和服务之分，��M��斚w��可主动发送，需要或不需要回�{�看应用而言�Q�这�U�方式在工控行业很有用，比如RTDB作�ؓI/O Server的客��P��但I/O Server也可��d��向RTDB发送开关状态变位、随即事件等信息。在很大�E�度上减��了�|�络通信负荷、提高了效率�?

　　采用1-6的TCP/IP�~�程要点�Q�在Client和Server方均已接收优先，适当控制时序��p��实现�?br />

�? 2007-01-31 10:53 发表评论

��Z��Visual C++的Winsock API研究

�? — Wed, 31 Jan 2007 02:51:00 GMT
��Z��方便�|�络�~�程�Q?0�q�代初，由Microsoft联合了其他几家公司共同制定了一套WINDOWS下的�|�络�~�程接口�Q�即Windows Sockets规范�Q�它不是一�U�网�l�协�?而是一套开攄��、支持多�U�协议的Windows下的�|�络�~�程接口。现在的Winsock已经基本上实��C��与协议无养I��你可以��用Winsock来调用多�U�协议的功能�Q�但较常使用的是TCP/IP协议。Socket实际在计��机中提供了一个通信端口�Q�可以通过�q�个端口与�Q何一个具有Socket接口的计��机通信。应用程序在�|�络上传输，接收的信息都通过�q�个Socket接口来实现�?br />
　　微��Y为VC定义了Winsock�c�d��CAsyncSocket�c�d��z��于CAsyncSocket 的CSocket�c�，它们��单易用，读者朋友当然可以��用这些类来实现自��q��|�络�E�序�Q�但是�ؓ了更好的了解Winsock API�~�程技术，我们�q�里探讨怎样使用底层的API函数实现��单的 Winsock �|�络应用�E�式设计�Q�分别说明如何在Server端和Client端操作Socket�Q�实现基于TCP/IP的数据传送，最后给出相关的源代码�?br />
　　在VC中进行WINSOCK的API�~�程开发的时候，需要在��目中��用下面三个文�Ӟ��否则会出现编译错误�?br />
　　1�Q�WINSOCK.H: �q�是WINSOCK API的头文�g�Q�需要包含在��目中�?br />
　　2�Q�WSOCK32.LIB: WINSOCK API�q�接库文件。在使用中，一定要把它作�ؓ��目的非�~�省的连接库包含到项目文件中厅R�?

　　3�Q�WINSOCK.DLL: WINSOCK的动态连接库�Q�位于WINDOWS的安装目录下�?br />
　　一、服务器端操�?socket�Q�套接字�Q?/b>

　　1)在初始化阶段调用WSAStartup()

　　此函数在应用�E�序中初始化Windows Sockets DLL �Q�只有此函数调用成功后，应用�E�序才可以再调用其他Windows Sockets DLL中的API函数。在�E�式中调用该函数的�Ş式如下：WSAStartup((WORD)((1<<8|1)�Q�（LPWSADATA�Q?amp;WSAData)�Q�其�?1<<8|1)表示我们用的是WinSocket1.1版本�Q�WSAata用来存储�pȝ��传回的关于WinSocket的资料�?br />
　　2)建立Socket

　　初始化WinSock的动态连接库后，需要在服务器端建立一个监听的Socket�Q��ؓ此可以调用Socket()函数用来建立�q�个监听的Socket�Q��ƈ定义此Socket所使用的通信协议。此函数调用成功�q�回Socket对象�Q�失败则�q�回INVALID_SOCKET(调用WSAGetLastError()可得知原因，所有WinSocket 的函数都可以使用�q�个函数来获取失败的原因)�?br />
SOCKET PASCAL FAR socket( int af, int type, int protocol )
参数: af:目前只提�?PF_INET(AF_INET)�Q?br />type�Q�Socket 的类�?(SOCK_STREAM、SOCK_DGRAM)�Q?br />protocol�Q�通讯协定(如果使用者不指定则设�?)�Q?br />
如果要徏立的是遵从TCP/IP协议的socket�Q�第二个参数type应�ؓSOCK_STREAM�Q�如为UDP�Q�数据报�Q�的socket�Q�应为SOCK_DGRAM�?br />
　　3)�l�定端口

　　接下来要为服务器端定义的�q�个监听的Socket指定一个地址及端口（Port�Q�，�q�样客户端才知道待会要连接哪一个地址的哪个端口，为此我们要调用bind()函数�Q�该函数调用成功�q�回0�Q�否则返回SOCKET_ERROR�?br />int PASCAL FAR bind( SOCKET s, const struct sockaddr FAR *name,int namelen );

�?敎ͼ� s�Q�Socket对象名；
name�Q�Socket的地址��|��q�个地址必须是执行这个程式所在机器的IP地址�Q?br />namelen�Q�name的长度；

　　如果使用者不在意地址或端口的��|��那么可以讑֮�地址为INADDR_ANY�Q�及Port�?�Q�Windows Sockets 会自动将其设定适当之地址及Port (1024 �?5000之间的�?。此后可以调用getsockname()函数来获知其被设定的倹{�?br />
　　4�Q�监�?br />
　　当服务器端的Socket对象�l�定完成之后,服务器端必须建立一个监听的队列来接收客��L��的连接请求。listen()函数使服务器端的Socket �q�入监听状态，�q�设定可以徏立的最大连接数(目前最大值限制�ؓ 5, 最��gؓ1)。该函数调用成功�q�回0�Q�否则返回SOCKET_ERROR�?br />
int PASCAL FAR listen( SOCKET s, int backlog );
�?敎ͼ� s�Q�需要徏立监听的Socket�Q?br />backlog�Q�最大连接个敎ͼ�

　　服务器端的Socket调用完listen�Q�）后，如果此时客户端调用connect�Q�）函数提出�q�接甌��的话�Q�Server 端必��d��调用accept() 函数�Q�这��h��务器端和客户端才��正式完成通信�E�序的连接动作。�ؓ了知道什么时候客��L��提出�q�接要求�Q�从而服务器端的Socket在恰当的时候调用accept()函数完成�q�接的徏立，我们��p��使用WSAAsyncSelect�Q�）函数�Q�让�pȝ��d��来通知我们有客��L��提出�q�接��h��了。该函数调用成功�q�回0�Q�否则返回SOCKET_ERROR�?br />
int PASCAL FAR WSAAsyncSelect( SOCKET s, HWND hWnd,unsigned int wMsg, long lEvent );
参数�Q?s�Q�Socket 对象�Q?br />hWnd �Q�接收消息的�H�口句柄�Q?br />wMsg�Q�传�l�窗口的消息�Q?br />lEvent�Q�被注册的网�l�事�Ӟ��也即是应用程序向�H�口发送消息的�|��\事�g�Q�该��gؓ下列值FD_READ、FD_WRITE、FD_OOB、FD_ACCEPT、FD_CONNECT、FD_CLOSE的组合，各个值的具体含意为FD_READ�Q�希望在套接字S收到数据时收到消息；FD_WRITE�Q�希望在套接字S上可以发送数据时收到消息�Q�FD_ACCEPT�Q�希望在套接字S上收到连接请求时收到消息�Q�FD_CONNECT�Q�希望在套接字S上连接成功时收到消息�Q�FD_CLOSE�Q�希望在套接字S上连接关闭时收到消息�Q�FD_OOB�Q�希望在套接字S上收到带外数据时收到消息�?

　　具体应用�Ӟ��wMsg应是在应用程序中定义的消息名�U�ͼ�而消息结构中的lParam则�ؓ以上各种�|�络事�g名称。所以，可以在窗口处理自定义消息函数中��用以下结构来响应Socket的不同事�Ӟ��　　

switch(lParam)　
　 {case FD_READ:
　　　 …　　
　 break;
case FD_WRITE�?br />　　　 �?br />　 break;
　　　 �?br />}

　　5�Q�服务器端接受客��L��的连接请�?br />
　　当Client提出�q�接��h��Ӟ��Server 端hwnd视窗会收到Winsock Stack送来我们自定义的一个消息，�q�时�Q�我们可以分析lParam�Q�然后调用相关的函数来处理此事�g。�ؓ了��服务器端接受客户端的�q�接��h��Q�就要��用accept() 函数�Q�该函数新徏一Socket与客��L��的Socket盔R��，原先监听之Socket�l�箋�q�入监听状态，�{�待他�h的连接要求。该函数调用成功�q�回一个新产生的Socket对象�Q�否则返回INVALID_SOCKET�?br />
SOCKET PASCAL FAR accept( SCOKET s, struct sockaddr FAR *addr,int FAR *addrlen );
参数�Q�s�Q�Socket的识别码�Q?br />addr�Q�存放来�q�接的客��L��的地址�Q?br />addrlen�Q�addr的长�?/td>

　　6�Q�结�?socket �q�接

　　�l�束服务器和客户端的通信�q�接是很��单的�Q�这一�q�程可以由服务器或客��h��的�Q一端启动，只要调用closesocket()��可以了�Q�而要关闭Server端监听状态的socket�Q�同样也是利用此函数。另外，与程序启动时调用WSAStartup()憨数相对应，�E�式�l�束前，需要调�?WSACleanup() 来通知Winsock Stack释放Socket所占用的资源。这两个函数都是调用成功�q�回0�Q�否则返回SOCKET_ERROR�?br />
int PASCAL FAR closesocket( SOCKET s );
�?敎ͼ�s�Q�Socket 的识别码�Q?br />int PASCAL FAR WSACleanup( void );
�?敎ͼ� �?/td>

二、客��L��Socket的操�?br />
　　1�Q�徏立客��L��的Socket

　　客户端应用程序首先也是调用WSAStartup() 函数来与Winsock的动态连接库建立关系�Q�然后同栯��用socket() 来徏立一个TCP或UDP socket�Q�相同协定的 sockets 才能盔R��，TCP �?TCP�Q�UDP �?UDP�Q�。与服务器端的socket 不同的是�Q�客��L��的socket 可以调用 bind() 函数�Q�由自己来指定IP地址及port��L��Q�但是也可以不调�?bind()�Q�而由 Winsock来自动设定IP地址及port��L��?br />
　　2�Q�提��接申�?br />
　　客户端的Socket使用connect()函数来提��Z��服务器端的Socket建立�q�接的申��P��函数调用成功�q�回0�Q�否则返回SOCKET_ERROR�?br />
int PASCAL FAR connect( SOCKET s, const struct sockaddr FAR *name, int namelen );
�?敎ͼ�s�Q�Socket 的识别码�Q?br />name�Q�Socket惌��q�接的对方地址�Q?br />namelen�Q�name的长�?/td>

　　三、数据的传�?/b>

　　虽然��Z��TCP/IP�q�接协议�Q�流套接字）的服务是设计客户�?服务器应用程序时的主��标准，但有些服务也是可以通过无连接协议（数据报套接字�Q�提供的。先介绍一下TCP socket 与UDP socket 在传送数据时的特性：Stream (TCP) Socket 提供双向、可靠、有�ơ序、不重复的资料传送。Datagram (UDP) Socket 虽然提供双向的通信�Q�但没有可靠、有�ơ序、不重复的保证，所以UDP传送数据可能会收到无次序、重复的资料�Q�甚臌��料在传输�q�程中出现遗漏。由于UDP Socket 在传送资料时�Q��ƈ不保证资料能完整地送达�Ҏ��Q�所以绝大多数应用程序都是采用TCP处理Socket�Q�以保证资料的正��性。一般情况下TCP Socket 的数据发送和接收是调用send() 及recv() �q�两个函数来达成�Q��?UDP Socket则是用sendto() 及recvfrom() �q�两个函敎ͼ��q�两个函数调用成功发挥发送或接收的资料的长度�Q�否则返回SOCKET_ERROR�?br />
int PASCAL FAR send( SOCKET s, const char FAR *buf,int len, int flags );
参数�Q�s�Q�Socket 的识别码
buf�Q�存放要传送的资料的暂存区
len buf�Q�的长度
flags�Q�此函数被调用的方式

　　对于Datagram Socket而言�Q�若�?datagram 的大��超�q�限�Ӟ��则将不会送出��M��资料�Q��ƈ会传回错误倹{��对Stream Socket �a��Q�Blocking 模式下，若是传送系�l�内的储存空间不够存放这些要传送的资料�Q�send()��会被block住，直到资料送完为止�Q�如果该Socket被设定�ؓ Non-Blocking 模式�Q�那么将视目前的output buffer�I�间有多��，��送出多少资料�Q��ƈ不会�?block 住。flags 的值可设�ؓ 0 �?MSG_DONTROUTE�?MSG_OOB 的组合�?br />
int PASCAL FAR recv( SOCKET s, char FAR *buf, int len, int flags );
参数�Q�s�Q�Socket 的识别码
buf�Q�存放接收到的资料的暂存�?br />len buf�Q�的长度
flags�Q�此函数被调用的方式

　　对Stream Socket �a��Q�我们可以接收到目前input buffer内有效的资料�Q�但其数量不��过len的大��?br />
　　四、自定义的CMySocket�cȝ��实现代码�Q?/font>

　　�Ҏ��上面的知识，我自定义了一个简单的CMySocket�c�，下面是我定义的该�cȝ��部分实现代码�Q?br />
//////////////////////////////////////
CMySocket::CMySocket() : file://�cȝ��构造函�?br />{
　WSADATA wsaD;
　memset( m_LastError, 0, ERR_MAXLENGTH );
　// m_LastError是类内字�W�串变量,初始化用来存放最后错误说明的字符�Ԍ��
　// 初始化类内sockaddr_in�l�构变量�Q�前者存攑֮��L��地址�Q�后者对应于服务器端地址;
　memset( &m_sockaddr, 0, sizeof( m_sockaddr ) );
　memset( &m_rsockaddr, 0, sizeof( m_rsockaddr ) );
　int result = WSAStartup((WORD)((1<<8|1)�Q?&wsaD);//初始化WinSocket动态连接库;
　if( result != 0 ) // 初始化失败；
　{ set_LastError( "WSAStartup failed!", WSAGetLastError() );
　　return;
　}
}

//////////////////////////////
CMySocket::~CMySocket() { WSACleanup(); }//�cȝ��析构函数�Q?br />////////////////////////////////////////////////////
int CMySocket::Create( void )
　{// m_hSocket是类内Socket对象�Q�创��Z��个基于TCP/IP的Socket变量�Q��ƈ��D��l�该变量�Q?br />　　if ( (m_hSocket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP )) == INVALID_SOCKET )
　　{
　　　set_LastError( "socket() failed", WSAGetLastError() );
　　　return ERR_WSAERROR;
　　}
　　return ERR_SUCCESS;
　}
///////////////////////////////////////////////
int CMySocket::Close( void )//关闭Socket对象�Q?br />{
　if ( closesocket( m_hSocket ) == SOCKET_ERROR )
　{
　　set_LastError( "closesocket() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　file://重置sockaddr_in �l�构变量�Q?br />　memset( &m_sockaddr, 0, sizeof( sockaddr_in ) );
　memset( &m_rsockaddr, 0, sizeof( sockaddr_in ) );
　return ERR_SUCCESS;
}
/////////////////////////////////////////
int CMySocket::Connect( char* strRemote, unsigned int iPort )//定义�q�接函数�Q?br />{
　if( strlen( strRemote ) == 0 || iPort == 0 )
　　return ERR_BADPARAM;
　hostent *hostEnt = NULL;
　long lIPAddress = 0;
　hostEnt = gethostbyname( strRemote );//�Ҏ��计算机名得到该计��机的相兛_��容；
　if( hostEnt != NULL )
　{
　　lIPAddress = ((in_addr*)hostEnt->h_addr)->s_addr;
　　m_sockaddr.sin_addr.s_addr = lIPAddress;
　}
　else
　{
　　m_sockaddr.sin_addr.s_addr = inet_addr( strRemote );
　}
　m_sockaddr.sin_family = AF_INET;
　m_sockaddr.sin_port = htons( iPort );
　if( connect( m_hSocket, (SOCKADDR*)&m_sockaddr, sizeof( m_sockaddr ) ) == SOCKET_ERROR )
　{
　　set_LastError( "connect() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
///////////////////////////////////////////////////////
int CMySocket::Bind( char* strIP, unsigned int iPort )//�l�定函数�Q?br />{
　if( strlen( strIP ) == 0 || iPort == 0 )
　　return ERR_BADPARAM;
　memset( &m_sockaddr,0, sizeof( m_sockaddr ) );
　m_sockaddr.sin_family = AF_INET;
　m_sockaddr.sin_addr.s_addr = inet_addr( strIP );
　m_sockaddr.sin_port = htons( iPort );
　if ( bind( m_hSocket, (SOCKADDR*)&m_sockaddr, sizeof( m_sockaddr ) ) == SOCKET_ERROR )
　{
　　set_LastError( "bind() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
//////////////////////////////////////////
int CMySocket::Accept( SOCKET s )//建立�q�接函数�Q�S为监听Socket对象名；
{
　int Len = sizeof( m_rsockaddr );
　memset( &m_rsockaddr, 0, sizeof( m_rsockaddr ) );
　if( ( m_hSocket = accept( s, (SOCKADDR*)&m_rsockaddr, &Len ) ) == INVALID_SOCKET )
　{
　　set_LastError( "accept() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
/////////////////////////////////////////////////////
int CMySocket::asyncSelect( HWND hWnd, unsigned int wMsg, long lEvent )
file://事�g选择函数�Q?br />{
　if( !IsWindow( hWnd ) || wMsg == 0 || lEvent == 0 )
　　return ERR_BADPARAM;
　if( WSAAsyncSelect( m_hSocket, hWnd, wMsg, lEvent ) == SOCKET_ERROR )
　{
　　set_LastError( "WSAAsyncSelect() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
////////////////////////////////////////////////////
int CMySocket::Listen( int iQueuedConnections )//监听函数�Q?br />{
　if( iQueuedConnections == 0 )
　　return ERR_BADPARAM;
　if( listen( m_hSocket, iQueuedConnections ) == SOCKET_ERROR )
　{
　　set_LastError( "listen() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
////////////////////////////////////////////////////
int CMySocket::Send( char* strData, int iLen )//数据发送函敎ͼ�
{
　if( strData == NULL || iLen == 0 )
　　return ERR_BADPARAM;
　if( send( m_hSocket, strData, iLen, 0 ) == SOCKET_ERROR )
　{
　　set_LastError( "send() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ERR_SUCCESS;
}
/////////////////////////////////////////////////////
int CMySocket::Receive( char* strData, int iLen )//数据接收函数�Q?br />{
　if( strData == NULL )
　　return ERR_BADPARAM;
　int len = 0;
　int ret = 0;
　ret = recv( m_hSocket, strData, iLen, 0 );
　if ( ret == SOCKET_ERROR )
　{
　　set_LastError( "recv() failed", WSAGetLastError() );
　　return ERR_WSAERROR;
　}
　return ret;
}
void CMySocket::set_LastError( char* newError, int errNum )
file://WinSock API操作错误字符串设�|�函敎ͼ�
{
　memset( m_LastError, 0, ERR_MAXLENGTH );
　memcpy( m_LastError, newError, strlen( newError ) );
　m_LastError[strlen(newError)+1] = '\0';
}

　　有了上述�cȝ��定义�Q�就可以在网�l�程序的服务器和客户端分别定义CMySocket对象�Q�徏立连接，传送数据了。例如，��Z��在服务器和客��L��发送数据，需要在服务器端定义两个CMySocket对象ServerSocket1和ServerSocket2�Q�分别用于监听和�q�接�Q�客��L��定义一个CMySocket对象ClientSocket�Q�用于发送或接收数据�Q�如果徏立的�q�接数大于一�Q�可以在服务器端再定义CMySocket对象�Q�但要注意连接数不要大于五�?br />
　　�׃��Socket API函数�q�有许多�Q�如获取�q�端服务器、本地客��h��的IP地址、主机名�{�等�Q�读者可以再此基��上对CMySocket补充完善�Q�实现更多的功能�?br />

�? 2007-01-31 10:51 发表评论

Windows Socket1.1 �E�序设计

�? — Tue, 30 Jan 2007 14:07:00 GMT
一、简�?br />
　　Windows Sockets 是从 Berkeley Sockets 扩展而来的，其在�l�承 Berkeley Sockets 的基��上，又进行了新的扩充。这些扩充主要是提供了一些异步函敎ͼ��q�增加了�W�合WINDOWS消息驱动�Ҏ��的�|�络事�g异步选择机制�?br />
　　Windows Sockets�׃��部分�l�成�Q�开发组件和�q�行�l��g�?br />
　　开发组�Ӟ��Windows Sockets 实现文档、应用程序接�?API)引入库和一些头文�g�?br />
　　�q�行�l��g�Q�Windows Sockets 应用�E�序接口的动态链接库(WINSOCK.DLL)�?
　　二、主要扩充说�?/b>
　　1、异步选择机制�Q?br />
　　Windows Sockets 的异步选择函数提供了消息机制的�|�络事�g选择�Q�当使用它登记网�l�事件发生时�Q�应用程序相应窗口函数将收到一个消息，消息中指�C�Z��发生的网�l�事�Ӟ��以及与事件相关的一些信息�?br />
　　Windows Sockets 提供了一个异步选择函数 WSAAsyncSelect()�Q�用它来注册应用�E�序感兴��的�|�络事�g�Q�当�q�些事�g发生�Ӟ��应用�E�序相应的窗口函数将收到一个消息�?br />
　　函数�l�构如下�Q?/p>
int PASCAL FAR WSAAsyncSelect(SOCKET s,HWND hWnd,unsigned int wMsg,long lEvent);
　　参数说明�Q?br />
　　　hWnd�Q�窗口句�?br />
　　　wMsg�Q�需要发送的消息

　　　lEvent�Q�事�Ӟ��以下��Z��件的内容�Q?br />
��|�� 含义�Q?/td>
FD_READ 期望在套接字上收到数据（卌��准备好）时接到通知
FD_WRITE 期望在套接字上可发送数据（卛_��准备好）时接到通知
FD_OOB 期望在套接字上有带外数据到达时接到通知
FD_ACCEPT 期望在套接字上有外来�q�接时接到通知
FD_CONNECT 期望在套接字�q�接建立完成时接到通知
FD_CLOSE 期望在套接字关闭时接到通知
　　例如�Q�我们要在套接字��d��备好或写准备好时接到通知�Q�语句如下：
rc=WSAAsyncSelect(s,hWnd,wMsg,FD_READ|FD_WRITE);
　　如果我们需要注销对套接字�|�络事�g的消息发送，只要��?lEvent 讄��?
　　2、异步请求函�?br />
　　�?Berkeley Sockets 中请求服务是��d��的，WINDOWS SICKETS 除了支持�q�一�c�d��数外�Q�还增加了相应的异步��h��函数(WSAAsyncGetXByY();)�?

　　3、阻塞处理方�?br />
　　Windows Sockets ��Z��实现当一个应用程序的套接字调用处于阻塞时�Q�能够放弃CPU让其它应用程序运行，它在调用处于��d��时便�q�入一个叫“HOOK”的例程�Q�此例程负责接收和分配WINDOWS消息�Q��得其它应用程序仍然能够接收到自己的消息�ƈ取得控制权�?br />
　　WINDOWS 是非抢先的多��d��环境�Q�即若一个程序不��d��攑ּ�其控制权�Q�别的程序就不能执行。因此在设计Windows Sockets �E�序�Ӟ��管�pȝ��支持��d��操作�Q�但�q�是反对�E�序员��用该操作。但�׃�� SUN 公司下的 Berkeley Sockets 的套接字默认操作是阻塞的�Q�WINDOWS 作�ؓ�U�L��?SOCKETS 也不可避免对�q�个操作支持�?br />
　　在Windows Sockets 实现中，对于不能立即完成的阻塞操作做如下处理�Q�DLL初始化→循环操作。在循环中，它发送�Q�?WINDOWS 消息�Q��ƈ��查这�?Windows Sockets 调用是否完成�Q�在必要�Ӟ��它可以放弃CPU让其它应用程序执行（当然使用��线�E�的CPU��׃��会有�q�个�ȝ��了^_^�Q�。我们可以调�?WSACancelBlockingCall() 函数取消此阻塞操作�?br />
　　�?Windows Sockets 中，有一个默认的��d��处理例程 BlockingHook() ��单地获取�q�发�?WINDOWS 消息。如果要对复杂程序进行处理，Windows Sockets 中还�?WSASetBlockingHook() 提供用户安装自己的阻塞处理例�E�能力；与该函数相对应的则是 SWAUnhookBlockingHook()�Q�它用于删除先前安装的�Q何阻塞处理例�E�，�q��新安装默认的处理例程。请注意�Q�设计自��q��d��处理例程�Ӟ��除了函数 WSACancelBlockingHook() 之外�Q�它不能使用其它�?Windows Sockets API 函数。在处理例程中调�?WSACancelBlockingHook()函数��取消处于阻塞的操作�Q�它��结束阻塞��@环�?/p>
　　4、出错处�?br />
　　Windows Sockets ��Z��和以后多�U�程环境�Q�WINDOWS/UNIX�Q�兼容，它提供了两个出错处理函数来获取和讄��当前�U�程的最�q�错误号。（WSAGetLastEror()和WSASetLastError()�Q?/p>
　　5、启动与�l�止

　　使用函数 WSAStartup() �?WSACleanup() 启动和终止套接字�?br />
三、Windows Sockets�|�络�E�序设计核心
　　我们�l�于可以开始真正的 Windows Sockets �|�络�E�序设计了。不�q�我们还是先看一看每�?Windows Sockets �|�络�E�序都要涉及的内宏V��让我们一步步慢慢走�?/p>
　　1、启动与�l�止

　　在所�?Windows Sockets 函数中，只有启动函数 WSAStartup() 和终止函�?WSACleanup() 是必��M��用的�?br />
　　启动函数必须是第一个��用的函数�Q�而且它允许指�?Windows Sockets API 的版本，�q�获�?SOCKETS的特定的一些技术细节。本�l�构如下�Q?br />
int PASCAL FAR WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
　　其中 wVersionRequested 保证 SOCKETS 可正常运行的 DLL 版本�Q�如果不支持�Q�则�q�回错误信息�?br />我们看一下下面这�D�代码，看一下如何进�?WSAStartup() 的调�?br />
WORD wVersionRequested;// 定义版本信息变量
WSADATA wsaData;//定义数据信息变量
int err;//定义错误号变�?br />wVersionRequested = MAKEWORD(1,1);//�l�版本信息赋�?br />err = WSAStartup(wVersionRequested, &wsaData);//�l�错误信息赋�?br />if(err!=0)
{
return;//告诉用户找不到合适的版本
}
//��认 Windows Sockets DLL 支持 1.1 版本
//DLL 版本可以高于 1.1
//�pȝ��q�回的版本号始终是最低要求的 1.1�Q�即应用�E�序与DLL 中可支持的最低版本号
if(LOBYTE(wsaData.wVersion)!= 1|| HIBYTE(wsaData.wVersion)!=1)
{
WSACleanup();//告诉用户找不到合适的版本
return;
}
//Windows Sockets DLL 被进�E�接受，可以�q�入下一步操�?/td>
　　关闭函数使用�Ӟ��M��打开�q�已�q�接�?SOCK_STREAM 套接字被复位�Q�但那些已由 closesocket() 函数关闭的但仍有未发送数据的套接字不受媄响，未发送的数据仍将被发送。程序运行时可能会多�ơ调�?WSAStartuo() 函数�Q�但必须保证每次调用时的 wVersionRequested 的值是相同的�?/p>
　　2、异步请求服�?br />
　　Windows Sockets 除支�?Berkeley Sockets 中同步请求，�q�增加了了一�c�d��步请求服务函�?WSAAsyncGerXByY()。该函数是阻塞请求函数的异步版本。应用程序调用它�Ӟ��?Windows Sockets DLL 初始化这一操作�q�返回调用者，此函数返回一个异步句柄，用来标识�q�个操作。当�l�果存储在调用者提供的�~�冲区，�q�且发送一个消息到应用�E�序相应�H�口。常用结构如下：
HANDLE taskHnd;
char hostname="rs6000";
taskHnd = WSAAsyncBetHostByName(hWnd,wMsg,hostname,buf,buflen);
　　需要注意的是，�׃�� Windows 的内存对像可以设�|��ؓ可移动和可丢弃，因此在操作内存对象是�Q�必��M��?WIindows Sockets DLL 对象是可用的�?

　　3、异步数据传�?br />
　　使用 send() �?sendto() 函数来发送数据，使用 recv() 或recvfrom() 来接收数据。Windows Sockets 不鼓��q��户��用阻塞方式传输数据，因�ؓ那样可能会阻塞整�?Windows 环境。下面我们看一个异步数据传输实例：

　　假设套接�?s 在连接徏立后�Q�已�l��用了函数 WSAAsyncSelect() 在其上注册了�|�络事�g FD_READ �?FD_WRITE�Q��ƈ�?wMsg ��gؓ UM_SOCK�Q�那么我们可以在 Windows 消息循环中增加如下的分支语句�Q?/p>
case UM_SOCK:
switch(lParam)
{
case FD_READ:
len = recv(wParam,lpBuffer,length,0);
break;
case FD_WRITE:
while(send(wParam,lpBuffer,len,0)!=SOCKET_ERROR)
break;
}
break;
　　4、出错处�?br />
　　Windows 提供了一个函数来获取最�q�的错误�?WSAGetLastError()�Q�推荐的�~�写方式如下�Q?
len = send (s,lpBuffer,len,0);
of((len==SOCKET_ERROR)&&(WSAGetLastError()==WSAWOULDBLOCK)){...}

�? 2007-01-30 22:07 发表评论

Winsocket�~�程之套接字原理

�? — Tue, 30 Jan 2007 14:04:00 GMT
一、客��h��/服务器模�?br />
　　在TCP/IP�|�络中两个进�E�间的相互作用的��L��模式是客��h��/服务器模�?Client/Server model)。该模式的徏立基于以下两点：1、非对等作用�Q?、通信完全是异步的。客��h��/服务器模式在操作�q�程中采取的是主动请�C�方式：
　　首先服务器方要先启动�Q��ƈ�Ҏ��L��提供相应服务�Q�（�q�程如下�Q?br />
　　1、打开一通信通道�q�告知本��C��机，它愿意在某一个公认地址上接收客戯��求�?br />
　　2、等待客戯��求到达该端口�?br />
　　3、接收到重复服务��h��Q�处理该��h��q�发送应�{�信受��?br />
　　4、返回第二步�Q�等待另一客户��h��

　　5、关闭服务器�?br />
　　客户方：

　　1、打开一通信通道�Q��ƈ�q�接到服务器所在主机的特定端口�?br />
　　2、向服务器发送服务请求报文，�{�待�q�接收应�{�；�l�箋提出��h��…�?br />
　　3、请求结束后关闭通信通道�q�终止�?/p>
　　二、基本套接字

　　��Z��更好说明套接字编�E�原理，�l�出几个基本的套接字�Q�在以后的篇�q�中会给出更详细的��用说明�?br />
　　1、创建套接字——socket()

　　功能�Q��用前创徏一个新的套接字

　　格式�Q�SOCKET PASCAL FAR socket(int af,int type,int procotol);

　　参数�Q�af: 通信发生的区�?br />
　　type: 要徏立的套接字类�?br />
　　procotol: 使用的特定协�?/p>
　　2、指定本地地址——bind()

　　功能�Q�将套接字地址与所创徏的套接字可��p��v来�?br />
　　格式�Q�int PASCAL FAR bind(SOCKET s,const struct sockaddr FAR * name,int namelen);

　　参数�Q�s: 是由socket()调用�q�回的�ƈ且未作连接的套接字描�q�符�Q�套接字��P��?br />
　　其它�Q�没有错误，bind()�q�回0�Q�否则SOCKET_ERROR

　　地址�l�构说明�Q?br />
struct sockaddr_in
{
short sin_family;//AF_INET
u_short sin_port;//16位端口号�Q�网�l�字节顺�?br />struct in_addr sin_addr;//32位IP地址�Q�网�l�字节顺�?br />char sin_zero[8];//保留
}
　　3、徏立套接字�q�接——connect()和accept()

　　功能�Q�共同完成连接工�?br />
　　格式�Q�int PASCAL FAR connect(SOCKET s,const struct sockaddr FAR * name,int namelen);

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

　　参数�Q�同�?/p>
　　4、监听连接——listen()

　　功能�Q�用于面向连接服务器�Q�表明它愿意接收�q�接�?br />
　　格式�Q�int PASCAL FAR listen(SOCKET s, int backlog);
　　5、数据传输——send()与recv()

　　功能�Q�数据的发送与接收

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

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

　　参数�Q�buf:指向存有传输数据的缓冲区的指针�?

　　6、多路复用——select()

　　功能�Q�用来检��一个或多个套接字状态�?br />
　　格式�Q�int PASCAL FAR select(int nfds,fd_set FAR * readfds,fd_set FAR * writefds,
fd_set FAR * exceptfds,const struct timeval FAR * timeout);

　　参数�Q�readfds:指向要做��L��的指针

　　　　　writefds:指向要做写检��的指针

　　　　　exceptfds:指向要检��是否出错的指针

　　　　　timeout:最大等待时�?/p>
　　7、关闭套接字——closesocket()

　　功能�Q�关闭套接字s

　　格式�Q�BOOL PASCAL FAR closesocket(SOCKET s);

三、典型过�E�图

　　2.1 面向�q�接的套接字的系�l�调用时序图

　　2.2 无连接协议的套接字调用时序图

　2.3 面向�q�接的应用程序流�E�图

�? 2007-01-30 22:04 发表评论

Winsocket�~�程之TCP/IP体系�l�构

�? — Tue, 30 Jan 2007 13:59:00 GMT
一、TCP/IP 体系�l�构与特�?/strong>
　　1、TCP/IP体系�l�构

　　TCP/IP协议实际上就是在物理�|�上的一�l�完整的�|�络协议。其中TCP是提供传输层服务�Q�而IP则是提供�|�络层服务。TCP/IP包括以下协议�Q�（�l�构如图1.1�Q?/p>

(�?.1)

　　IP�Q?�|�间协议(Internet Protocol) 负责��L��间数据的路由和网�l�上数据的存储。同时�ؓICMP�Q�TCP�Q�　　　UDP提供分组发送服务。用戯��E�通常不需要涉及这一层�?br />
　　ARP�Q?地址解析协议(Address Resolution Protocol)
　　　此协议将�|�络地址映射到硬件地址�?br />
　　RARP�Q?反向地址解析协议(Reverse Address Resolution Protocol)
　　　此协议将��g地址映射到网�l�地址

　　ICMP�Q?�|�间报文控制协议(Internet Control Message Protocol)
　　　此协议处理信兛_��L��的差错和传送控制�?br />
　　TCP�Q?传送控制协�?Transmission Control Protocol)
　　　�q�是一�U�提供给用户�q�程的可靠的全双工字节流面向�q�接的协议。它要�ؓ用户�q�程提供虚电路服务，�q��ؓ数据可靠传输建立��查。（注：大多数网�l�用��L��序��用TCP�Q?br />
　　UDP�Q?用户数据报协�?User Datagram Protocol)
　　　�q�是提供�l�用戯��E�的无连接协议，用于传送数据而不执行正确性检查�?br />
　　FTP�Q?文�g传输协议(File Transfer Protocol)
　　　允许用户以文件操作的方式�Q�文件的增、删、改、查、传送等�Q�与另一��L��怺�通信�?br />
　　SMTP�Q?��单邮件传送协�?Simple Mail Transfer Protocol)
　　　SMTP协议为系�l�之间传送电子邮件�?br />
　　TELNET�Q�终端协�?Telnet Terminal Procotol)
　　　允许用户以虚�l�端方式讉K��q�程��L��

　　HTTP�Q?��文本传输协�?Hypertext Transfer Procotol)
　　
　　TFTP: ��单文件传输协�?Trivial File Transfer Protocol)

　　2、TCP/IP特点

　　TCP/IP协议的核心部分是传输层协�?TCP、UDP)�Q�网�l�层协议(IP)和物理接口层�Q�这三层通常是在操作�pȝ��内核中实现。因此用户一般不涉及。编�E�时�Q�编�E�界面有两种形式�Q�一、是由内核心直接提供的系�l�调用；二、��用以库函数方式提供的各种函数。前者�ؓ核内实现�Q�后者�ؓ核外实现。用��h��务要通过核外的应用程序才能实玎ͼ�所以要使用套接�?socket)来实现�?br />
　　�?.2是TCP/IP协议核心与应用程序关�p�d��?br />

(�?.2)

　　二、专用术�?/b>

　　1、套接字

　　套接字是�|�络的基本构件。它是可以被命名和寻址的通信端点�Q��用中的每一个套接字都有其类型和一个与之相�q�听�q�程。套接字存在通信区域�Q�通信区域又称地址��）中。套接字只与同一区域中的套接字交换数据（跨区域时�Q�需要执行某和�{换进�E�才能实玎ͼ�。WINDOWS 中的套接字只支持一个域——网际域。套接字��h��c�d��?br />
　　WINDOWS SOCKET 1.1 版本支持两种套接字：��套接字(SOCK_STREAM)和数据报套接�?SOCK_DGRAM)

　　2、WINDOWS SOCKETS 实现

　　一个WINDOWS SOCKETS 实现是指实现了WINDOWS SOCKETS规范所描述的全部功能的一套��Y件。一般通过DLL文�g来实�?/p>
　　3、阻塞处理例�E?br />
　　��d��处理例程(blocking hook,��d��钩子)是WINDOWS SOCKETS实现��Z��支持��d��套接字函数调用而提供的一�U�机制�?/p>
　　4、多址�q�播�Q�multicast�Q�多点传送或�l�播�Q?br />
　　是一�U�一对多的传输方式，传输发�v者通过一�ơ传输就��信息传送到一�l�接收者，与单点传�?br />(unicast)和广�?Broadcast)相对应�?/p>

�? 2007-01-30 21:59 发表评论

��\|��	含义�Q?/td>
FD_READ	期望在套接字上收到数据（卌��准备好）时接到通知
FD_WRITE	期望在套接字上可发送数据（卛_��准备好）时接到通知
FD_OOB	期望在套接字上有带外数据到达时接到通知
FD_ACCEPT	期望在套接字上有外来�q�接时接到通知
FD_CONNECT	期望在套接字�q�接建立完成时接到通知
FD_CLOSE	期望在套接字关闭时接到通知