国产精品久久久一本精品,欧美v日韩v国产v,国产精品久久久久久久久借妻

[转]Flex Socket �?C++ 通讯 --- 安全沙箱问题解决

Wed, 16 Mar 2011 02:22:00 GMT

Flex Socket �?C++ 通讯 --- 安全沙箱问题解决

最�q�一个项目的客户端要�Ҏ��Flex�Q��用Socket与C++通讯旉��C��安全沙箱问题�Q�这是我的解��x��法；

1):�{�略文�g与主套接字在同一端口�Q�只需调用 Socket.connect() �?XMLSocket.connect() �Ҏ��Q?/p>

2):�{�略文�g与主套接字在不同端口�Q�需使用�Ҏ��?#8220;xmlsocket”语法调用 Security.loadPolicyFile() �Ҏ��Q�如下所�C�：

Security.loadPolicyFile("xmlsocket://server.com:2525");

先调�?Security.loadPolicyFile() �Ҏ��Q�然后再调用 Socket.connect() �?XMLSocket.connect() �Ҏ��?/p>

��试代码�Q��用同一端口

view plaincopy to clipboardprint?
#include
#include
#include
using namespace std;
#pragma comment(lib,"ws2_32.lib")

void main()
{
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;
    short port=1800;//端口�?nbsp;

    wVersionRequested = MAKEWORD( 1, 1 );
    err = WSAStartup( wVersionRequested, &wsaData );//初始化套接字
    if ( err != 0 )
    {
        return;
    }

    if ( LOBYTE( wsaData.wVersion ) != 1 || HIBYTE( wsaData.wVersion ) != 1 )
    {
        WSACleanup( );
        return;
    }

    SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);//创徏套接�?nbsp;
    SOCKET sockConn;//用来和客��L��通信的套接字
    SOCKADDR_IN addrSrv;//用来和客��L��通信的套接字地址
    addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
    addrSrv.sin_family=AF_INET;
    addrSrv.sin_port=htons(port);

    bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));//�l�定端口
    listen(sockSrv,5);//侦听

    printf("Server %d is listening......\n",port);

    SOCKADDR_IN addrClient;

    int len=sizeof(SOCKADDR);
    char buf[4096];//接收的数�?nbsp;
    char rbuf[100]=
        " "
        ""
        " ";//套接字策略文�?nbsp;

    while(1)
    {
        //接受�q�接
        sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);
        printf("Accept connection from %s\n",inet_ntoa(addrClient.sin_addr));

recv:
        //接收数据
        int bytes;
        if((bytes=recv(sockConn,buf,sizeof(buf),0))==SOCKET_ERROR)
        {
            printf("接收数据��p�|!\n");
            exit(-1);
        }

        buf[bytes]='\0';
        printf("Message from %s: %s\n",inet_ntoa(addrClient.sin_addr),buf);

        if (0 == strcmp(buf,""))
        {
            //发送数�?nbsp;
            if(send(sockConn,rbuf,strlen(rbuf)+1,0)==SOCKET_ERROR)
            {
                printf("发送数据失败！");
                exit(-1);
            }
            printf("Message to %s: %s\n",inet_ntoa(addrClient.sin_addr),rbuf);
        }
        else
        {
            //Echo
            if(send(sockConn,buf,strlen(buf)+1,0)==SOCKET_ERROR)
            {
                printf("发送数据失败！");
                exit(-1);
            }
            printf("Message to %s: %s\n",inet_ntoa(addrClient.sin_addr),buf);
            goto recv;
        }
        //清理套接字占用的资源
        closesocket(sockConn);
    }
}
#include
#include
#include
using namespace std;
#pragma comment(lib,"ws2_32.lib")

void main()
{
WORD wVersionRequested;
WSADATA wsaData;
int err;
short port=1800;//端口�?br>
wVersionRequested = MAKEWORD( 1, 1 );
err = WSAStartup( wVersionRequested, &wsaData );//初始化套接字
if ( err != 0 )
{
   return;
}

if ( LOBYTE( wsaData.wVersion ) != 1 || HIBYTE( wsaData.wVersion ) != 1 )
{
   WSACleanup( );
   return;
}

SOCKET sockSrv=socket(AF_INET,SOCK_STREAM,0);//创徏套接�?br>SOCKET sockConn;//用来和客��L��通信的套接字
SOCKADDR_IN addrSrv;//用来和客��L��通信的套接字地址
addrSrv.sin_addr.S_un.S_addr=htonl(INADDR_ANY);
addrSrv.sin_family=AF_INET;
addrSrv.sin_port=htons(port);

bind(sockSrv,(SOCKADDR*)&addrSrv,sizeof(SOCKADDR));//�l�定端口
listen(sockSrv,5);//侦听

printf("Server %d is listening......\n",port);

SOCKADDR_IN addrClient;

int len=sizeof(SOCKADDR);
char buf[4096];//接收的数�?br>char rbuf[100]=
   " "
   ""
   " ";//套接字策略文�?br>
while(1)
{
        //接受�q�接
   sockConn=accept(sockSrv,(SOCKADDR*)&addrClient,&len);
   printf("Accept connection from %s\n",inet_ntoa(addrClient.sin_addr));

recv:
   //接收数据
   int bytes;
   if((bytes=recv(sockConn,buf,sizeof(buf),0))==SOCKET_ERROR)
   {
    printf("接收数据��p�|!\n");
    exit(-1);
   }

buf[bytes]='\0';
printf("Message from %s: %s\n",inet_ntoa(addrClient.sin_addr),buf);

   if (0 == strcmp(buf,""))
   {
    //发送数�?br>    if(send(sockConn,rbuf,strlen(rbuf)+1,0)==SOCKET_ERROR)
    {
     printf("发送数据失败！");
     exit(-1);
    }
    printf("Message to %s: %s\n",inet_ntoa(addrClient.sin_addr),rbuf);
   }
   else
   {
    //Echo
    if(send(sockConn,buf,strlen(buf)+1,0)==SOCKET_ERROR)
    {
     printf("发送数据失败！");
     exit(-1);
    }
    printf("Message to %s: %s\n",inet_ntoa(addrClient.sin_addr),buf);
    goto recv;
   }
        //清理套接字占用的资源
        closesocket(sockConn);
}
}

无论是哪�U�情况，服务器均必须�{�待客户端的�W�一�ơ传输之后再军_��是发送策略文件还是徏立主�q�接。当 Flash Player ��h��{�略文�g�Ӟ��它始�l�会在徏立连接后传输以下字符�Ԍ��

服务器收到此字符串后�Q�即会传输该�{�略文�g。程序对于策略文件请求和主连接�ƈ不会使用同一�q�接�Q�因此应在传输策略文件后关闭�q�接。如果不关闭�q�接�Q�Flash Player ��关闭策略文件连接，之后重新�q�接以徏立主�q�接�?/p>

附网�l�资料：

1,首先��目标服务器�?43端口是否提供安全�{�略
2,如果1没有��到�{�略�Q�则��actionscript是否使用了Security.loadPolicyFile(xmlsocket://) 手段提供安全�{�略�Q�如果还没检��到�Q�则使用�W?步检��?br>3,��目标服务器目标端口是否提供安全�{�略

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/xuxiangwin/archive/2009/07/07/4324218.aspx

��不�?/a> 2011-03-16 10:22 发表评论

【�{】完成端口的一个简单封装类

Fri, 18 Jan 2008 13:29:00 GMT

/////////////////////////////////////////////////////////////////////////////////////

// Iocp 头文�?/span>

#pragma once

#include

#pragma comment( lib, "ws2_32.lib" )

const int OP_READ = 0;

const int OP_WRITE = 1;

const int OP_ACCEPT = 2;

OVERLAPPEDPLUS �l�构体设计思�\

OVERLAPPED 是一个固定的用于处理�|�络消息事�g�q�回值的�l�构体变�?/span>

在完成端口和重叠I/O模型里用于返回消息事件的�l�果

因�ؓ在处理网�l�消息的时候，发送的是一个返回值的�l�构体指针，只要�l�构�?/span>

的前面部分满��系�l�的要求�Q�在�pȝ��操作成功的时候也��׃��把这个结构体指针

发回�l�用��P��我们只要在系�l�定义的�l�构体后面扩展一些自��q��东西�Q�就可以

很轻杄��定该消息是谁发�q�来的�?/span>

不过好像完成端口在设计的时候也满��了这��L��需求，所以在�q�里我只是放�?/span>

一些与�pȝ��q�接有关的数据，用户需要存攄��数据�q�里��׃��在存�?/span>

�q�里存储与系�l�相关的数据有：

socket

OpCode 本次消息的操作类型（在完成端口的操作里面�Q�是以消息通知�pȝ��Q?/span>

��L��?/span>/写数据，都是要发�q�样的消息结构体�q�去的，所以如果系�l�要同时

�q�行��d��操作的话�Q�就需要有一个变量来区分操作了）

WSABUF wbuf; // ��d��~�冲区结构体变量

DWORD dwBytes, dwFlags; // 一些在��d��时用到的标志性变�?/span>

char buf[4096]; // 自己的缓冲区

上面�?/span>4个变量存攄��是一些与消息相关的数据，都是一些操作上用到的，

�q�些东西都是固定的，具体作用需要参考一下完成端口相兛_��数的参数接口

struct OVERLAPPEDPLUS

{

OVERLAPPED ol;

SOCKET s;

int OpCode;

WSABUF wbuf;

DWORD dwBytes, dwFlags;

char buf[4096];

};

class CIOCP

{

protected:

HANDLE g_hwThread; // 工作�U�程句柄

DWORD m_wthreadID;

HANDLE g_haThread; // �q�接�U�程句柄

DWORD m_athreadID;

public:

bool m_workThread;

bool m_acceptThread;

HANDLE m_hIocp; // 完成端口的句�?/span>

SOCKET m_sSocket;

public:

CIOCP(void);

~CIOCP(void);

virtual void OnRead(void * p, char *buf, int len){};

virtual void OnAccept(SOCKET socket);

virtual void OnClose(void * p){};

bool SetIoCompletionPort(SOCKET socket, void *p, char *buf = NULL, int len = 0);

// 把一�?/span>socket与一个自定义的结构体兌��到完成端口（相当于把socket与一个结构体变量�q�行�l�定�Q�，

// �q�样当发送上�?/span>3�U�网�l�事件的时候，该结构体变量会再传回�l�程�?/span>

// �q�样��可以区分当前网�l�事件是那个socket发出�?/span>

bool Init(void);

bool Listen(int port);

static DWORD __stdcall WorkThread(LPVOID Param);

static DWORD __stdcall AcceptThread(LPVOID Param);

};

class CIOCPClient: public CIOCP

{

protected:

SOCKET m_socket;

public:

bool Connect(char *ip, int port);

void Send(char *buf, int len);

};

//////////////////////////////////////////////////////////////////////////////////////////

// Iocp 实现文�g

#include "StdAfx.h"

#include "iocp.h"

static bool bInit = false;

DWORD __stdcall CIOCP::WorkThread(LPVOID Param)

{

CIOCP * pthis = (CIOCP *)Param;

void * re;

OVERLAPPED * pOverlap;

DWORD berByte;

while(pthis->m_workThread)

{

int ret;

ret = GetQueuedCompletionStatus(pthis->m_hIocp, &berByte, (LPDWORD)&re, (LPOVERLAPPED *)&pOverlap, INFINITE);

if (ret == ERROR_SUCCESS)

{

}

if (berByte == 0)

{

// 客户端断开�q�接

pthis->OnClose(re);

OVERLAPPEDPLUS *olp = (OVERLAPPEDPLUS *)pOverlap;

closesocket(olp->s);

delete olp; // 释放 �?/span>socket�l�定的结构体变量

continue;

}

if (re == NULL) return 0;

OVERLAPPEDPLUS *olp = (OVERLAPPEDPLUS *)pOverlap;

switch(olp->OpCode)

{

case OP_READ:

pthis->OnRead(re, olp->wbuf.buf, berByte); // 调用 OnRead() 通知应用�E�序�Q�服务器收到来自客户端的�|�络数据

WSARecv(olp->s, &olp->wbuf, 1, &olp->dwBytes, &olp->dwFlags, &olp->ol, NULL); // �l�箋调用一个接收的 I/O 异步��h��

break;

default:

break;

}

return 0;

}

DWORD __stdcall CIOCP::AcceptThread(LPVOID Param)

{

CIOCP * pthis = (CIOCP *)Param;

while(pthis->m_acceptThread)

{

SOCKET client;

if ((client= accept(pthis->m_sSocket, NULL, NULL)) == INVALID_SOCKET)

{

// 错误处理

}

pthis->OnAccept(client); // 调用 OnAccept()通知应用�E�序有新客户端连�?/span>

}

return 1;

}

CIOCP::CIOCP(void)

{

}

CIOCP::~CIOCP(void)

{

}

bool CIOCP::Init(void)

{

if (bInit)

return true;

WSADATA wsd;

if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)

return false;

bInit = true;

return true;

}

bool CIOCP::Listen(int port)

{

if (!bInit)

if (!Init())

return false;

m_sSocket = socket(AF_INET, SOCK_STREAM, 0);

if (m_sSocket == INVALID_SOCKET)

return false;

//SOCKADDR_IN addr;

sockaddr_in addr;

addr.sin_family = AF_INET;

addr.sin_port = htons(port);

addr.sin_addr.S_un.S_addr = htonl(INADDR_ANY);

//addr.sin_addr.S_un.S_addr = inet_addr(ip);

if (bind(m_sSocket, (struct sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR)

return false;

if (listen(m_sSocket, 10) == SOCKET_ERROR)

return false;

if ((m_hIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 0)) == NULL) // 创徏完成端口的句�?/span>

return false;

this->m_acceptThread = true;

g_haThread = CreateThread(NULL, 0, AcceptThread, (LPVOID)this, 0, &m_athreadID); // 创徏�q�接�U�程�Q�用来接收客��L��的连�?/span>

this->m_workThread = true;

g_hwThread = CreateThread(NULL, 0, WorkThread, (LPVOID)this, 0, &m_wthreadID); // 创徏工作�U�程�Q�用来处理完成端口消息的

return true;

}

bool CIOCP::SetIoCompletionPort(SOCKET socket, void *p, char *buf, int len)

{

if (CreateIoCompletionPort((HANDLE)socket, m_hIocp, (ULONG_PTR)p, 0) == NULL)

return false;

OVERLAPPEDPLUS *olp = new OVERLAPPEDPLUS;

memset(olp, 0, sizeof(OVERLAPPEDPLUS));

olp->s = socket;

if (buf)

{

// �q�里可以使用用户自定义的�~�冲区地址�Q�如果用户不惌��|�，也可以采用默认分配的�~�冲�?/span>

olp->wbuf.buf = buf;

olp->wbuf.len = len;

}

else

{

olp->wbuf.buf = olp->buf;

olp->wbuf.len = 4096;

}

olp->OpCode = OP_READ;

int ret = WSARecv(olp->s, &olp->wbuf, 1, &olp->dwBytes, &olp->dwFlags, &olp->ol, NULL);

if (ret == SOCKET_ERROR)

if (WSAGetLastError() != ERROR_IO_PENDING)

return false;

return true;

}

void CIOCP::OnAccept(SOCKET socket)

{

this->SetIoCompletionPort(socket, NULL);

}

//===================================================================================

bool CIOCPClient::Connect(char *ip, int port)

{

// �q�接服务�?/span>

if (!bInit)

if (!Init())

return false;

// 初始化连�?/span>socket

m_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

if (m_socket == SOCKET_ERROR)

{

// printf("cocket Create fail");

return false;

}

// 填写服务器地址信息

// 端口�?/span>1982

// IP地址�?/span>INADDR_ANY�Q�注意��?/span>htonl��?/span>IP地址转换为网�l�格�?/span>ServerAddr.sin_family = AF_INET;

sockaddr_in ClientAddr;

ClientAddr.sin_family = AF_INET;

ClientAddr.sin_port = htons(port);

ClientAddr.sin_addr.s_addr = inet_addr(ip);

// �l�定监听端口

bind(m_socket, (SOCKADDR *)&ClientAddr, sizeof(ClientAddr));

if (connect(m_socket, (SOCKADDR *)&ClientAddr, sizeof(ClientAddr)) == SOCKET_ERROR)

{

return false;

}

if ((m_hIocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, NULL, 0)) == NULL) // 创徏完成端口的句�?/span>

return false;

this->m_workThread = true;

g_hwThread = CreateThread(NULL, 0, WorkThread, (LPVOID)this, 0, &m_wthreadID); // 创徏工作�U�程�Q�用来处理完成端口消息的

this->SetIoCompletionPort(m_socket, &m_socket); // 讄��完成端口监听�?/span>socket

return true;

}

void CIOCPClient::Send(char *buf, int len)

{

send(m_socket, buf, len, 0);

}

///////////////////////////////////////////////////////////////////////////////////

// IOCPclient 应用代码

#include "stdafx.h"

#include "IOCP.h"

#include "TClientSocket.h"

class Iocp :public CIOCPClient

{

void OnRead(void * p, char *buf, int len)

{

printf(buf);

Sleep(1000);

this->Send(buf, len);

}

};

int _tmain(int argc, _TCHAR* argv[])

{

Iocp iocp;

iocp.Init();

iocp.Connect("127.0.0.1", 4311);

iocp.Send("test\0", 5);

gets(new char[1000]);

return 0;

}

��不�?/a> 2008-01-18 21:29 发表评论

【�{】完成端口与高性能服务器程序开�?

Fri, 18 Jan 2008 13:27:00 GMT

早在两年前我��已�l�能很熟�l�的�q�用完成端口�q�种技术了,只是一直没有机会将它用在什么项目中,�q�段旉��见到�q�种技术被�q�分炒作,�q�分的神�U�化,��想写一��解释它如何工作的文�?惛_��诉大家它没有传说中的那么高深难懂!有什么错误的地方�q�请高�h指正.转蝲��h��明出处及作�?谢谢!

以一个文件传输服务端��Z��,在我的机器上它只起两个线�E�就可以为很多个个客��L��同时提供文�g下蝲服务,�E�序的性能会随机器内CPU个数的增加而线性增�?我尽可能做到使它清晰易懂,虽然�E�序很小却用��C��NT 5的一些新�Ҏ�?重叠IO,完成端口以及�U�程�?��Z��q�种模型的服务端�E�序应该是NT�pȝ��上性能最好的�?

首先.做�ؓ完成端口的基��,我们应该理解重叠IO,�q�需要你已经理解了内核对象及操作�pȝ��的一些概忉|��?什么是信号/非信��h�?什么是�{�待函数,什么是成功�{�待的副作用,什么是�U�程挂�v�{?如果�q�些概��o�q�没有理�?你应该先看一下Windows 核心�~�程中的相关内容.如果已经理解�q�些,那么重叠IO对你来说�q�不�?

你可以这栯��为重叠IO,现在你已�l�进入一个服务器/客户机环�?请不要�؜淆概�?�q�里的服务器是指操作�pȝ��,而客��h��是指你的�E�序(它进行IO操作),是当你进行IO操作(send,recv,writefile,readfile....)时你发送一个IO��h��l�服务器(操作�pȝ��),由服务器来完成你需要的操作,然后你什么事都没有了,当服务器完成IO��h��时它会通知�?当然在这期间你可以做��M��?一个常用的技巧是在发送重叠IO��h��?�E�序在一个��@环中一边调用PeekMessage,TranslateMessage和DispatchMessage更新界面,同时调用GetOverlappedResult�{�待服务器完成IO操作,更高效一点的做法是��用IO完成例程来处理服务器(操作�pȝ��)�q�回的结�?但�ƈ不是每个支持重叠IO操作的函数都支持完成例程如TransmitFile函数.

�?.一�ơ重叠写操作�q�程(GetOverlappedResult�Ҏ��):
1.填写一个OVERLAPPED�l�构
2.�q�行一�ơ写操作,�q�指定重叠操作参�?上面的OVERLAPPED�l�构变量的指�?
3.做其它事(如更新界�?
4.GetOverlappedResult取操作结�?br>5.如果IO��h��没有完成,�q�且没有出错则回到期�Q?br>6.处理IO操作�l�果

�?.一�ơ重叠写操作�q�程(完成例程�Ҏ��):
1.填写一个OVERLAPPED�l�构
2.�q�行一�ơ写操作,�q�指定重叠操作参�?上面的OVERLAPPED�l�构变量的指�?,�q�指定完成例�E?br>3.做其它事(如更新界�?
4.当完成例�E�被调用说明IO操作已经完成或出�?现在可以�Ҏ��作结果进行处理了

如果你已�l�理解上面的概念,��已�l�很接近IO完成端口�?当然�q�只是很常规的重叠操作它已经非常高效,但如果再�l�合多线�E�对一个File或是Socket�q�行重叠IO操作��׃��非常复杂,通常�E�序员很难把握这�U�复杂度.完成端口可以说就是�ؓ了充分发挥多�U�程和重叠IO操作相结合的性能而设计的.很多人都说它复杂,其实如果你自己实��C��个多�U�程的对一个File或是Socket�q�行重叠IO操作的程�?注意是多个线�E�对一个HANDLE或SOCKET�q�行重叠IO操作,而不是启一个线�E�对一个HANDLE�q�行重叠IO操作)��׃��发现完成端口实际上简化了多线�E�里使用重叠IO的复杂度,�q�且性能更高,性能高在�?下面�q�行说明.

我们可能写过�q�样的服务端�E�序:

�?.�ȝ��?
1.监听一个端�?br>2.�{�待�q�接
3.当有�q�接来时
4.启一个线�E�对�q�个客户端进行处�?br>5.回到2

服务�U�程:
1.��d��L��h��
2.如果客户端不再有��h��,执行6
3.处理��h��
4.�q�回操作�l�果
5.回到1
6.退出线�E?br>
�q�是一�U�最��单的�|�络服务器模�?我们把它优化一�?br>
�?.�ȝ��?
1.开一个线�E�池,里面有机器能承受的最大线�E�数个线�E?�U�程都处于挂�?suspend)状�?br>1.监听一个端�?br>2.�{�待�q�接
3.当有�q�接来时
4.从线�E�池里Resume一个线�E�对�q�个客户端进行处�?br>5.回到2

服务�U�程与例3模型里的相同,只是当线�E�处理完客户端所有请求后,不是退��是回到�U�程�?再次挂�v让出CPU旉��,�q�等待�ؓ下一个客��h��服务.当然在此期间�U�程会因为IO操作(服务�U�程的第1,5操作,也许�q�有其它��d��操作)挂�v自己,但不会回到线�E�池,也就是说它一�ơ只能�ؓ一个客��L��服务.

�q�可能是你能惛_��的最高效的服务端模型了吧!它与�W�一个服务端模型相比��了很多个用��h��到内核态的CONTEXT Switch,反映也更加快�?也许你可能觉得这很微不��?�q�说明你�~�少对大规模高性能服务器程�?比如�|�游服务�?的认�?如果你的服务端程序要对几千万个客��L��q�行服务�?�q�也是微软Windows NT开发组在NT 5以上的系�l�中��d��U�程池的原因.

思考一下什么样的模型可以让一个线�E��ؓ多个客户端服务呢!那就要蟩出每来一个连接启�U�程为其服务的固定思维模式,我们把线�E�服务的最��单元分割�ؓ单独的读或写操作(注意是读或写不是��d��?,而不是一个客��L��从连接到断开期间的所有读写操�?每个�U�程都��用重叠IO�q�行��d��操作,投递了��d��h��后线�E�回到线�E�池,�{�待为其它客��h��服务,当操作完成或出错时再回来处理操作�l�果,然后再回到线�E�池.

看看�q�样的服务器模型:
�?.�ȝ��?
1.开一个线�E�池,里面有机器内CPU个数两倍的�U�程,�U�程都处于挂�?suspend)状�?它们在都�{�处理一�ơ重叠IO操作的完成结�?br>1.监听一个端�?br>2.�{�待�q�接
3.当有�q�接来时
4.投递一个重叠读操作��d��命��o
5.回到2

服务�U�程:
1.如果��d��?则处理读取的内容(如HTTP GET命��o),否则执行3
2.投递一个重叠写操作(如返回HTTP GET命��o需要的�|�页)
3.如果是一个写操作完成,可以再投递一个重叠读操作,��d��客户机的下一个请�?或者是关闭�q�接(如HTTP协议里每发完一个网��就断开)
4.取得下一个重叠IO操作�l�果,如果IO操作没有完成或没有IO操作则回到线�E�池

假设�q�是一个WEB服务器程�?可以看到工作者线�E�是以读或写为最��的工作单元�q�行�?在主�E�序里面�q�行了一�ơ重叠读操作

当读操作完成时一个线�E�池中的一个工作者线�E�被�Ȁ�z�d��得了操作�l�果,处理GET或POST命��o,然后发送一个网��内�?发送也是一个重叠操�?然后处理对其它客��h��的IO操作�l�果,如果没有其它的东襉K��要处理时回到�U�程池等�?可以看到使用�q�种模型发送和接收可以是也可以不是一个线�E?

当发送操作完成时,�U�程池中的一个工作者线�E�池�Ȁ�z?它关闭连�?HTTP协议),然后处理其它的IO操作�l�果,如果没有其它的东襉K��要处理时回到�U�程池等�?

看看在这��L��模型中一个线�E�怎么为多个客��L��服务,同样是模拟一个WEB服务器例�?

假如现在�pȝ��中有两个�U�程,ThreadA,ThreadB它们在都�{�处理一�ơ重叠IO操作的完成结�?br>
当一个客��h��ClientA�q�接来时�ȝ��序投递一个重叠读操作,然后�{�待下一个客��h��q�接,当读操作完成时ThreadA被激�z?它收��C��个HTTP GET命��o,然后ThreadA使用重叠写操作发送一个网��늻�ClientA,然后立即回到�U�程池等待处理下一个IO操作�l�果,�q�时发送操作还没有完成,又有一个客��h��ClientB�q�接�?�ȝ��序再投递一个重叠读操作,当读操作完成时ThreadA(当然也可能是ThreadB)再次被激�z?它重复同��h��?收到一个GET命��o,使用重叠写操作发送一个网��늻�ClientB,�q�次它没有来得及回到�U�程池时,又有一个连接ClientC�q�入,�ȝ��序再投递一个重叠读操作,��L��作完成时ThreadB被激�z?因�ؓThreadA�q�没有回到线�E�池)它收��C��个HTTP GET命��o,然后ThreadB使用重叠写操作发送一个网��늻�ClientC,然后ThreadB回到�U�程�?�q�时ThreadA也回��C��U�程�?

可以惌��现在有三个挂��L��发送操作分别是ThreadA发送给ClientA和ClientB的网��?以及ThreadB发送给ClientC的网��?它们由操作系�l�内核来处理.ThreadA和ThreadB现在已经回到�U�程�?可以�l�箋为其它�Q何客��L��服务.

当对ClientA的重叠写操作已经完成,ThreadA(也可以是ThreadB)又被�Ȁ�z�d��关闭与ClientA�q�接,但还没有回到�U�程�?与此同时发送给ClientB的重叠写操作也完�?ThreadB被激�z?因�ؓThreadA�q�没有回到线�E�池)它关闭与ClientB的连�?然后回到�U�程�?�q�时ClientC的写操作也完�?ThreadB再次被激�z?因�ؓThreadA�q�是没有回到�U�程�?,它再关闭与ClientC的连�?�q�时ThreadA回到�U�程�?ThreadB也回到线�E�池.�q�时对三个客��L��的服务全部完�?可以看到在整个服务过�E�中,"建立�q�接","��L��?,"写数�?�?关闭�q�接"�{�操作是逻辑上连�l�而实际上分开�?

到现在�ؓ止两个线�E�处理了三次��L��作和三次写操�?在这些读写操作过�E�中所出现的状态机(state machine)是比较复杂的,我们模拟的是�l�过我简化过�?实际上的状态要比这个还要复杂很�?然而这��L��服务端模型在客户端请求越多时与前两个模型相比的性能��高.而��用完成端口我们可以很�Ҏ��实现�q�样的服务器模型.

微��Y的IIS WEB服务器就是��用这��L��服务端模�?很多��什么阿帕奇服务器比IIS的性能好什么什么的我表�C�怀�?除非阿帕奇服务器可以��线�E�分割成,为更��的单元服务,我觉得不太可�?�q�种完成端口模型已经��单个读或写操作作�ؓ最��的服务单元,我觉得在相同机器配置的情况下IIS的性能要远�q�高于其它WEB服务�?�q�也是从实现机理上来分析�?如果出现性能上的差别可能是在不同的操作系�l�上,也许Linux的内核比Windows的要�?有�h真的研究�q�吗?�q�是大家一起在炒作�?

对于状态机概念,在很多方面都用到,TCPIP中有,�~�译原理中有,OpengGL中有�{�等,我的��L��数学不好(我是会计专业不学�q�个),不过�q�是搞懂了些,我想如果你多�׃��旉��?�q�是可以搞懂�?最后是一个简单的文�g传输服务器程序代�?只用了两个线�E?我的机器里只有一块CPU)��可以服务多个客��L��.我调试时用它同时�?个nc客户端提供文件下载服务都没有问题,当然更多也不会有问题,只是略�ؓ使用了一下NT 5的线�E�池和完成端口技术就可以有这样高的性能,更不用说IIS的性能�?

希望大家不要陷在�q�个�E�序的框架中,Ctrl+C,Ctrl+V没有什么意�?要理解它的实�?�E�序使用Visual C++ 6.0 SP5+2003 Platform SDK�~�译通过,在Windows XP Professional下调试运行通过.�E�序�q�行的最低要求是Windows 2000操作�pȝ��.

/********************************************************************
created: 2005/12/24
created: 24:12:2005 20:25
modified: 2005/12/24
filename: d:\vcwork\iocomp\iocomp.cpp
file path: d:\vcwork\iocomp
file base: iocomp
file ext: cpp
author: kruglinski(kruglinski_at_gmail_dot_com)

purpose: 利用完成端口技术实现的高性能文�g下蝲服务�E�序
*********************************************************************/

#define _WIN32_WINNT 0x0500

#include
#include
#include
#include //一使用输入输出��程序顿时增�?0K
#include
#include
#include
#include

using namespace std;

#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"mswsock.lib")

const int MAX_BUFFER_SIZE=1024;
const int PRE_SEND_SIZE=1024;
const int QUIT_TIME_OUT=3000;
const int PRE_DOT_TIMER=QUIT_TIME_OUT/80;

typedef enum{IoTransFile,IoSend,IoRecv,IoQuit} IO_TYPE;

typedef struct
{
SOCKET hSocket;
SOCKADDR_IN ClientAddr;
}PRE_SOCKET_DATA,*PPRE_SOCKET_DATA;

typedef struct
{
OVERLAPPED oa;
WSABUF DataBuf;
char Buffer[MAX_BUFFER_SIZE];
IO_TYPE IoType;
}PRE_IO_DATA,*PPRE_IO_DATA;

typedef vector SocketDataVector;
typedef vector IoDataVector;

SocketDataVector gSockDataVec;
IoDataVector gIoDataVec;

CRITICAL_SECTION csProtection;

char* TimeNow(void)
{
time_t t=time(NULL);
tm *localtm=localtime(&t);
static char timemsg[512]={0};

strftime(timemsg,512,"%Z: %B %d %X,%Y",localtm);
return timemsg;
}

BOOL TransFile(PPRE_IO_DATA pIoData,PPRE_SOCKET_DATA pSocketData,DWORD dwNameLen)
{
//�q�一句是为nc做的,你可以修改它
pIoData->Buffer[dwNameLen-1]='\0';

HANDLE hFile=CreateFile(pIoData->Buffer,GENERIC_READ,0,NULL,OPEN_EXISTING,0,NULL);
BOOL bRet=FALSE;

if(hFile!=INVALID_HANDLE_VALUE)
{
cout<<"Transmit File "<Buffer<<" to client"< pIoData->IoType=IoTransFile;
memset(&pIoData->oa,0,sizeof(OVERLAPPED));
*reinterpret_cast(pIoData->Buffer)=hFile;
TransmitFile(pSocketData->hSocket,hFile,GetFileSize(hFile,NULL),PRE_SEND_SIZE,reinterpret_cast(pIoData),NULL,TF_USE_SYSTEM_THREAD);
bRet=WSAGetLastError()==WSA_IO_PENDING;
}
else
cout<<"Transmit File "<<"Error:"<
return bRet;
}

DWORD WINAPI ThreadProc(LPVOID IocpHandle)
{
DWORD dwRecv=0;
DWORD dwFlags=0;

HANDLE hIocp=reinterpret_cast(IocpHandle);
DWORD dwTransCount=0;
PPRE_IO_DATA pPreIoData=NULL;
PPRE_SOCKET_DATA pPreHandleData=NULL;

while(TRUE)
{
if(GetQueuedCompletionStatus(hIocp,&dwTransCount,
reinterpret_cast(&pPreHandleData),
reinterpret_cast(&pPreIoData),INFINITE))
{
if(0==dwTransCount&&IoQuit!=pPreIoData->IoType)
{
cout<<"Client:"
<ClientAddr.sin_addr)
<<":"<ClientAddr.sin_port)
<<" is closed"<
closesocket(pPreHandleData->hSocket);

EnterCriticalSection(&csProtection);
IoDataVector::iterator itrIoDelete=find(gIoDataVec.begin(),gIoDataVec.end(),pPreIoData);
gIoDataVec.erase(itrIoDelete);
SocketDataVector::iterator itrSockDelete=find(gSockDataVec.begin(),gSockDataVec.end(),pPreHandleData);
gSockDataVec.erase(itrSockDelete);
LeaveCriticalSection(&csProtection);

delete *itrIoDelete;
delete *itrSockDelete;

continue;
}

switch(pPreIoData->IoType){
case IoTransFile:
cout<<"Client:"
<ClientAddr.sin_addr)
<<":"<ClientAddr.sin_port)
<<" Transmit finished"< CloseHandle(*reinterpret_cast(pPreIoData->Buffer));
goto LRERECV;

case IoSend:
cout<<"Client:"
<ClientAddr.sin_addr)
<<":"<ClientAddr.sin_port)
<<" Send finished"<
LRERECV:
pPreIoData->IoType=IoRecv;
pPreIoData->DataBuf.len=MAX_BUFFER_SIZE;
memset(&pPreIoData->oa,0,sizeof(OVERLAPPED));

WSARecv(pPreHandleData->hSocket,&pPreIoData->DataBuf,1,
&dwRecv,&dwFlags,
reinterpret_cast(pPreIoData),NULL);

break;

case IoRecv:
cout<<"Client:"
<ClientAddr.sin_addr)
<<":"<ClientAddr.sin_port)
<<" recv finished"< pPreIoData->IoType=IoSend;

if(!TransFile(pPreIoData,pPreHandleData,dwTransCount))
{
memset(&pPreIoData->oa,0,sizeof(OVERLAPPED));
strcpy(pPreIoData->DataBuf.buf,"File transmit error!\r\n");
pPreIoData->DataBuf.len=strlen(pPreIoData->DataBuf.buf);

WSASend(pPreHandleData->hSocket,&pPreIoData->DataBuf,1,
&dwRecv,dwFlags,
reinterpret_cast(pPreIoData),NULL);
}
break;

case IoQuit:
goto LQUIT;

default:
;
}
}
}

LQUIT:
return 0;
}

HANDLE hIocp=NULL;
SOCKET hListen=NULL;

BOOL WINAPI ShutdownHandler(DWORD dwCtrlType)
{
PRE_SOCKET_DATA PreSockData={0};
PRE_IO_DATA PreIoData={0};

PreIoData.IoType=IoQuit;

if(hIocp)
{
PostQueuedCompletionStatus(hIocp,1,
reinterpret_cast(&PreSockData),
reinterpret_cast(&PreIoData));

cout<<"Shutdown at "<
//让出CPU旉��,让线�E�退�?br> for(int t=0;t<80;t+=1)
{
Sleep(PRE_DOT_TIMER);
cout<<".";
}

CloseHandle(hIocp);
}

int i=0;

for(;i {
PPRE_SOCKET_DATA pSockData=gSockDataVec[i];
closesocket(pSockData->hSocket);
delete pSockData;
}

for(i=0;i {
PPRE_IO_DATA pIoData=gIoDataVec[i];
delete pIoData;
}

DeleteCriticalSection(&csProtection);
if(hListen)
closesocket(hListen);

WSACleanup();
exit(0);
return TRUE;
}

LONG WINAPI MyExceptionFilter(struct _EXCEPTION_POINTERS *ExceptionInfo)
{
ShutdownHandler(0);
return EXCEPTION_EXECUTE_HANDLER;
}

u_short DefPort=8182;

int main(int argc,char **argv)
{
if(argc==2)
DefPort=atoi(argv[1]);

InitializeCriticalSection(&csProtection);
SetUnhandledExceptionFilter(MyExceptionFilter);
SetConsoleCtrlHandler(ShutdownHandler,TRUE);

hIocp=CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,0);

WSADATA data={0};
WSAStartup(0x0202,&data);

hListen=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if(INVALID_SOCKET==hListen)
{
ShutdownHandler(0);
}

SOCKADDR_IN addr={0};
addr.sin_family=AF_INET;
addr.sin_port=htons(DefPort);

if(bind(hListen,reinterpret_cast(&addr),
sizeof(addr))==SOCKET_ERROR)
{
ShutdownHandler(0);
}

if(listen(hListen,256)==SOCKET_ERROR)
ShutdownHandler(0);

SYSTEM_INFO si={0};
GetSystemInfo(&si);
si.dwNumberOfProcessors<<=1;

for(int i=0;i {

QueueUserWorkItem(ThreadProc,hIocp,WT_EXECUTELONGFUNCTION);
}

cout<<"Startup at "< <<"work on port "< <<"press CTRL+C to shutdown"<
while(TRUE)
{
int namelen=sizeof(addr);
memset(&addr,0,sizeof(addr));
SOCKET hAccept=accept(hListen,reinterpret_cast(&addr),&namelen);

if(hAccept!=INVALID_SOCKET)
{
cout<<"accept a client:"<
PPRE_SOCKET_DATA pPreHandleData=new PRE_SOCKET_DATA;
pPreHandleData->hSocket=hAccept;
memcpy(&pPreHandleData->ClientAddr,&addr,sizeof(addr));

CreateIoCompletionPort(reinterpret_cast(hAccept),
hIocp,reinterpret_cast(pPreHandleData),0);

PPRE_IO_DATA pPreIoData=new(nothrow) PRE_IO_DATA;

if(pPreIoData)
{
EnterCriticalSection(&csProtection);
gSockDataVec.push_back(pPreHandleData);
gIoDataVec.push_back(pPreIoData);
LeaveCriticalSection(&csProtection);

memset(pPreIoData,0,sizeof(PRE_IO_DATA));
pPreIoData->IoType=IoRecv;
pPreIoData->DataBuf.len=MAX_BUFFER_SIZE;
pPreIoData->DataBuf.buf=pPreIoData->Buffer;
DWORD dwRecv=0;
DWORD dwFlags=0;
WSARecv(hAccept,&pPreIoData->DataBuf,1,
&dwRecv,&dwFlags,
reinterpret_cast(pPreIoData),NULL);
}
else
{
delete pPreHandleData;
closesocket(hAccept);
}
}
}

return 0;
}

参考资�?
《MSDN 2001�?br>《Windows �|�络�~�程�?br>《Windows 核心�~�程�?br>《TCP/IP详解�?/font>

��不�?/a> 2008-01-18 21:27 发表评论

socket�~�程—技术实�?

Thu, 17 Jan 2008 14:22:00 GMT

什么是socket�Q�socket��是...�Q�我在这里就不抄书了�Q�有兴趣的同仁去查查书吧�?br>不过�q�要说一句，socket��是不同�q�程之间的一�U�通信方式。就象打电话是朋友之间的一�U�通信方式是一栗��个人理解：所�?#8220;通信”�Q�就是相互之间发送数据。有人理解socket是不同计��机之间的一�U�通信�?br>式，�q�是不确切的。两个进�E�，不管是运行在同一台计��机上，�q�是�q�行在不同计��机上，都可通过
socket技术进行通信�?br>
socket套接字的使用需要有�|�卡的支持，所以socket一般都被用来在不同机器之间通信�Q�而如果在同一台计��机上的两个�q�程�q�行通信�Q�通常采用效率更高的共享内存技术来实现�?br>
两个�q�程之间�q�行通讯�Q�就需要两个进�E�同旉��在运行了�Q�废话）�Q�在具体实现中，两个�q�程我们通常要区别对待，一个进�E�专门等待另一个进�E�给自己发消息，收到消息后进行处理，在把处理�l�果发送回厅R��我们把专门处理消息、提供服务的�q�程�U�Cؓ服务器端�Q�把发送消息、请求处理的�q�程�U�Cؓ客户端。��M��q�程��是客户端发送一个消息给服务器端�Q�服务器端进�E�收到消息进行处理，把处理结果发送给客户端。恩�Q�就是这栗��?br>
�q�有一个问题，如果我现在有一个进�E�要跟另一台计��机上的某个�q�程�q�行socket通信�Q�那在我�q�个�q�程中如何指定另一个进�E�呢�Q�这里还需要说一下另一个概念——端口，如果把操作系�l�比作一座房子的话，那端口就是房子的�H�口�Q�是�pȝ��外界同系�l�内部进行通信的通道。在socket实现中，我们不进行另一个进�E�的指定�Q�而是指定发送消息或接收消息的端口号。比如说现在�q�程A要给�q�程B发消息，我们会把消息发送到�q�程B所�q�行的计��机的端口N上，而进�E�B此时正在监视端口N�Q�这栯��E�B��p��收到�q�程A发送来的数据，同样�q�程B也把消息发送到该端口上�Q�进�E�A也能从该端口收到�q�程B发送来的数据，当然�Q�这需要客��L��和服务器端关于端口号�q�行一个约定，卛_��同操作同一个端口。如果客��L��把消息发送到端口N1上，而服务器端监视的是端口N2�Q�那通信一定不能成功。端口号最大�ؓ65535�Q�不能比�q�个再大了，但在我们自己的程序中��量不要用小�?024的端口号�Q�小�?024的端口好很多都被�pȝ��使用了，比如23被telnet所使用�?br>
socket的实现是很简单的�Q�只要按照一定的步骤�Q�就可马上徏立一个这��L��通信通道�?br>
下面较详�l�的介绍几个核心的函敎ͼ�

SOCKET socket(int af, int type, int protocol);
无论是客��L��q�是服务器端�Q�下面这个函数是一定要用到的，也是最先用到的�?br>�q�个函数是要告诉�pȝ��Q�给我准备好一个socket通道�Q�我要和其它�q�程通信了。函数的�q�回值很重要�Q�我们要��C��来，它表�C�系�l��ؓ我们准备好的�q�个socket通道�Q�在以后的每个socket相关函数中都会用刎ͼ�如果�q�个值等于SOCKET_ERROR�Q�表�C�函数执行失败了。函数的参数我们分别�l�：PF_INET、SOCK_STREAM和IPPROTO_TCP�?br>
int bind(SOCKET s, const sockaddr *addr, int namelen);
�q�个函数只有服务器端�E�序使用�Q�作用是与某个socket通道�l�定。可以用�q�回值判断该函数执行�l�果怎么��P��如果�{�于SOCKET_ERROR�Q�那��是��p�|了。第一个参数s�Q�就是socket()函数的返回��|��在结构addr中，我们要给定一个端口号�Q�namelen�{�于�l�构sockaddr的大��?br>
int listen(SOCKET s, int backlog);
�q�个函数只有服务器端�E�序使用�Q�作用是监听该端口。返回��g��bind函数意义一栗��?br>
int accept(SOCKET s, sockaddr *addr, int *addrlen);
�q�个函数只有服务器端�E�序使用�Q�作用是响应客户端的�q�接。返回��g��bind函数意义一栗��?br>
int connect(SOCKET s, const sockaddr *name, int namelen);
�q�个函数只有客户端程序��用，作用是把客户端和某个计算机的某个端口建立�q�接。返回��g��bind函数意义一栗��第一个参数s�Q�就是socket()函数的返回��|��在结构name中，我们要给定一个端口号和目的机器名�Q�namelen�{�于�l�构sockaddr的大��?br>
int send(SOCKET s, char *buf, int len, int flags);
int recv(SOCKET s, char *buf, int len, int flags);
�q�两个函数就是发送数据和接收数据�Q�客��L��和服务器端程序都能用�Q�哪个发送哪个接收不用说了吧�Q�呵��c�?br>从函数的�q�回值可以检查函数执行是否成功。参��C��buf是指向发送或接收的数据的指针�Q�len是数据长度。flags我们�l�个0��可以（其实是我不知道具体含义）�?br>
最后就是关闭socket了，�q�个很容易忘掉，但这个函数很重要�Q�一定要用�?br>int closesocket(SOCKET s);

好了�Q�关键函数就�q�么几个�Q�下图是�q�几个函数的执行��序�Q?br>
client�?service�?br>
|                    |
v                 v
socket()       socket()
|                          |
|                          v
|                        bind()
|                          |
|                          v
|                        listen()
|                          |
|                          v
|                        accept() 挂�v�Q�直到有客户端来�q�接
|                          |
v                  三段握手�q�程 |
connect()       <-------------> |
|                       |
v 发送消�? v
+---> send() ---------------> recv() <-------+
| | . |
| | . 处理消息 |
| v 响应消息 . |
+---- recv() <--------------- send() --------+
| |
v |
close() ---------------> recv()
|
v
closesocket()

上图我觉得能很好的说明客��L��和服务器端的�q�行轨迹�?br>
使用以上几个函数�?linux �pȝ��上就可成功徏立一个socket通信�q��\�Q�但如果在windows�pȝ��上，�q�要用到另一个函敎ͼ�
int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData);
在windows�pȝ��上，首先要执行这个函敎ͼ�所以要把这个函数放在socket()函数的前面�?br>
我对上面的函数进行了一些封装，��省篇�q�，我去掉所有注释和非重要的函数�Q�在�q�里可以看到各个函数的具体用法：

�?VC60 环境下要�q�行下面的函敎ͼ�要包含头文�g errno.h �?winsock2.h�Q�还有，在连接的时候要�q�接上ws2_32.dll文�g�?br>
�q�是头文件内容：
class Socket {
public:

bool setup();

void close();

bool connect(string host, int port);

bool listen();

int accept();

int recv(char *buf, int len);

int recv(int new_fd, char *buf, int len);

int send(const char *msg, int len);

int send(int new_fd, const char *msg, int len);

private:
int _fd;
};

�q�是实现文�g内容�Q?br>bool Socket::setup() {

WSADATA wsd;
_fd = WSAStartup(MAKEWORD(2,2), &wsd);
if(_fd) {
return false;
}

_fd = ::socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (_fd == -1) {
return false;
}
return true;
}

bool Socket::listen() {
struct sockaddr_in my_addr;

my_addr.sin_family = AF_INET;
my_addr.sin_port = htons(52309);
my_addr.sin_addr.s_addr = INADDR_ANY;

if(::bind(_fd, (struct sockaddr *)&my_addr, sizeof(struct sockaddr)) == SOCKET_ERROR) {
return false;
}

if(::listen(_fd, BACKLOG) == SOCKET_ERROR) {
return false;
}

return true;
}

int Socket::accept()
{
int new_fd;
struct sockaddr_in their_addr;
int sin_size = sizeof(their_addr);

printf("accepting... \n");

new_fd = ::accept(_fd,
(struct sockaddr *)&their_addr,
&sin_size);
return new_fd == SOCKET_ERROR ? -1:new_fd;
}

bool Socket::connect(string host, int port) {
struct hostent *_h = gethostbyname(host.c_str());
if (_h == 0) {
return false;
}

struct in_addr *_addr = (struct in_addr *)_h->h_addr;
struct sockaddr_in sin;
sin.sin_family = AF_INET;
sin.sin_addr = *_addr;
sin.sin_port = htons(port);

if (::connect(_fd, (sockaddr *)&sin, sizeof(sin)) == SOCKET_ERROR) {
return false;
}

return true;
}

int Socket::recv(int new_fd, char *buf, int len)
{
int nb = ::recv(new_fd, buf, len, 0);
if (nb == -1) {
printf("Error! recv.\n");
}
return nb;
}

int Socket::recv(char *buf, int len) {
return recv(_fd, buf, len);
}

int Socket::send(const char *msg, int len) {
return send(_fd, msg, len);
}

int Socket::send(int new_fd, const char *msg, int len)
{
int nb = ::send(new_fd, msg, len, 0);
if (nb == -1) {
printf("Error! send.\n");
}

return nb;
}

void Socket::close() {

int trytimes = 0;
while(::closesocket(_fd) && trytimes < CLOSE_TRY_TIMES)
trytimes++;

if(trytimes == 10) {
printf("Cannot close socket!\n");
}
}

好，socket�c�L��装好了�Q�下面就是组�l�了�Q�服务器端和客户端是不一��L��Q�下面分别给��Z��码，到这里已�l�就很简单了�?br>
客户端：
int main(int argc, char **argv)
{
printf("socket of client is run ...\n");
Socket s;
if (!s.connect("dezhi", 52309))
return 0;

char *msg = "ok, send a message.";
for (int i=0; i<10; i++) {
s.send(msg, 20);
printf("message = %s\n", msg);
}
s.send("q", 1);
s.close();

return 0;
}

服务器：
int main(int argc, char **argv) {
printf("socket of service is run ...\n");

Socket s;
s.listen();
int new_fd = s.accept();

char buf[8];
buf[7] = '\0';
while (1) {
if (s.recv(new_fd, buf, 5) != -1) {
printf("%s\n", buf);
if (buf[0] == 'q')
break;
}
}
s.close();
}

下面��行结果：
客户端：
socket of client is run ...
Socket: WSAStartup success execute.
Socket: socket success execute.
Socket: Establish the connection to "127.0.0.1:52309"
message = ok, send a message.
message = ok, send a message.
message = ok, send a message.
message = ok, send a message.
message = ok, send a message.
message = ok, send a message.
message = ok, send a message.
message = ok, send a message.
message = ok, send a message.
message = ok, send a message.
Socket: Close connection to "127.0.0.1:52309"
Press any key to continue

服务器端
socket of service is run ...
Socket: WSAStartup success execute.
Socket: socket success execute.
bind ok!
listen ok!
accepting...
ok, send a message.
ok, send a message.
ok, send a message.
ok, send a message.
ok, send a message.
ok, send a message.
ok, send a message.
ok, send a message.
ok, send a message.
ok, send a message.
qk, send a message.
Press any key to continue

��到�q�里吧。socket的相兛_��容可�q�不止这些，我在�q�里只是�l�大家来个抛砖引玉，��x��IӞ��路还很�O�ѝ��关于详�l�的实现代码�Q�去我的《源码》上扑֐��Q�不攑֜��q�里�Q�是��Z��让篇�q�小些�?/font>

��不�?/a> 2008-01-17 22:22 发表评论

Winsock工作模型 ( �?)

Thu, 17 Jan 2008 13:22:00 GMT

首先得弄清楚同步、异步、阻塞、非��d��的概��c�?br>同步和异步是针对通讯的工作模式，��d��和非��d��是指socket的I/O操作�?br>实际上对于socket�Q�只存在��d��和非��d��Q�同步与异步是在�E�序实现上有所不同�?br>以阻塞的方式执行recv函数�Q�在没有收到数据前，此函数是不会�q�回的，所以这很容易执行函数的�U�程处于�{�待I/O上的数据状态，然后被挂赗��非��d��׃��一��P��执行recv时候不��有没有数据都立卌��回，有数据时�q�回数据�Q�没数据时返回错误。非��d��可以带来�E�序的高效，也带来了写程序中必须注意的地方，非阻塞情况下�Q�发送与接收数据时候，要用戯��q��理自��q��~�冲区，�q�且要记录发送与接受的位�|�，因�ؓ很可能发送与接受数据的�Q务不能一�ơ完成，需要多�ơ调用send和recv才可以完成�?br>本来同步异步是用来表�C�通讯模式的，通信的同步，主要是指客户端在发送请求后�Q�必��d��在服务端有回应后才发送下一个请求。所以这个时候的所有请求将会在服务端得到同步。通信的异步，指客��L��在发送请求后�Q�不必等待服务端的回应就可以发送下一个请求，�q�样对于所有的��h��动作来说��会在服务端得到异步�Q�这条请求的链�\��p��是一个请求队列，所有的动作在这里不会得到同步的。但是个人感觉，在说到socket的同步异步时候，同步跟阻塞概念差不多�Q�都是有了结果才�q�回�Q�异步则是告诉系�l�我要recv数据�Q�然后马上返回，�{�待数据来了后，�pȝ��跟程序说数据��C��Q�然后程序再recv数据。引用在�|�上看到的比较好的描�q?#8220;��d�� block 是指�Q�你拨通某人的电话�Q�但是此��Z��在，于是你拿着电话�{�他回来�Q�其间不能再用电话。同步大概和��d��差不多。非��d�� nonblock 是指�Q�你拨通某人的电话�Q�但是此��Z��在，于是你挂断电话，待会儿再打。至于到时候他回来没有�Q�只有打了电话才知道。即所谓的“轮询 / poll”。异步是指，你拨通某人的电话�Q�但是此��Z��在，于是你叫接电话的人告诉那�?leave a message)�Q�回来后�l�你打电话（call back�Q��?#8221;

昄��Q�异步要高效一些。在Winsock中实现异步的�Ҏ��有很多，Winsock工作模型有下面六�U?br>    一�Q�select模型
    二：WSAAsyncSelect模型
    三：WSAEventSelect模型
    四：Overlapped I/O 事�g通知模型
    五：Overlapped I/O 完成例程模型
    六：IOCP模型
从一到六��来��高�U�，��来��高效，实现��来��复杂。曾在网上看��C��些比�ȝ��来很好的说明�q�些模型�Q�在�q�里引用一下�?/p>

老陈有一个在外地工作的女儿，不能�l�常回来�Q�老陈和她通过信�g联系。他们的信会被邮递员投递到他们的信��里�?br>一�Q�select模型

老陈非常想看到女儿的信。以至于他每�?0分钟��׃��楼检查信��，看是否有奛_��的信~~~~~
在这�U�情况下�Q?#8220;下楼��查信��?#8221;然后回到��g��耽误了老陈太多的时��_��以至于老陈无法做其他工作�?/p>

二：WSAAsyncSelect模型

后来�Q�老陈使用了微软公司的新式信箱。这�U�信��非常先�q�，一旦信��里有新的信�Ӟ��盖茨��׃��l�老陈打电话：喂，大爷�Q�你有新的信件了�Q�从此，老陈再也不必频繁上下楼检查信��׃��Q�牙也不��g��Q�你瞅准了，蓝天......不是�Q�微软~~~~~~~~

三：WSAEventSelect模型

后来�Q�微软的信箱非常畅销�Q�购买微软信��q��Z��百万计数......以至于盖茨每�?4��时�l�客��h��电话�Q�篏得腰酸背痛，喝蚁力神都不好��~~~~~~
微��Y改进了他们的信箱�Q�在客户的家中添加一个附加装�|�，�q�个装置会监视客��L��信箱�Q�每当新的信件来��_��此装�|�会发出“��C��件到�?#8221;壎ͼ�提醒老陈��L��信。盖茨终于可以睡觉了�?/p>

四：Overlapped I/O 事�g通知模型

后来�Q�微软通过调查发现�Q�老陈不喜�Ƣ上下楼收发信�g�Q�因��Z��下楼其实很浪�Ҏ��间。于是微软再�ơ改�q�他们的信箱。新式的信箱采用了更为先�q�的技术，只要用户告诉微��Y自己的家在几楼几��P��新式信箱会把信�g直接传送到用户的家中，然后告诉用户�Q�你的信件已�l�放��C��的家中了�Q�老陈很高��_��因�ؓ他不必再亲自收发信�g了！

五：Overlapped I/O 完成例程模型

老陈接收到新的信件后�Q�一般的�E�序是：打开信封----掏出信纸----阅读信�g----回复信�g......��Z��q�一步减�ȝ��戯��担，微��Y又开发了一�U�新的技术：用户只要告诉微��Y对信件的操作步骤�Q�微软信��将按照�q�些步骤��d��理信�Ӟ��不再需要用户亲自拆�?阅读/回复了！老陈�l�于�q�上了小资生�z�！

六：IOCP模型

微��Y信箱��g��很完��，老陈也很满意。但是在一些大公司情况却完全不同！�q�些大公司有��C��万计的信��，每秒钟都有数以百计的信�g需要处理，以至于微软信��q��常因��负药��转而崩溃！需要重新启动！微��Y不得不��出杀手锏......
微��Y�l�每个大公司�z�了一名名�?#8220;Completion Port”的超�U�机器�h�Q�让�q�个机器人去处理那些信�g�Q?/p>

其实�Q�上面每�U�模型都有优点，要根据程序需求而适当选择合适的模型�Q�前面三�U�模型效率已�l�比较高�Q�实现�v来难道不大，很多一般的�|�络�E�序都采用前三种模型�Q�只有对�|�络要求特别高的一些服务器才会考虑用后面的那些模型。MFC中的CAsyncSocket�c�d��是用的WSAAsyncSelect模型�Q�电驴中也是用的�q�种�Q�不�q�在��L��对应socket的时候进行了优化�Q�查找更快，在GridCast中采用的是WSAEventSelect模型�Q�等待�?/p>

BTW�Q�上面所说均在Windows�q�_��下，只用WinSock才有�q�么多模型，在linux下，好像��只有第一�U�select模式�Q�我对linux下的socket不是很了解，应该也有很多提高效率的地斏V�?/p>

��不�?/a> 2008-01-17 21:22 发表评论