socket 相关

C# Socket 异步 SERVER

玻璃小屋 — Sun, 28 Feb 2010 14:37:00 GMT

using System;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;

// State object for reading client data asynchronously
public class StateObject
{
    // Client  socket.
    public Socket workSocket = null;
    // Size of receive buffer.
    public const int BufferSize = 1024;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();
}

public class AsynchronousSocketListener
{
    // Thread signal.
    public static ManualResetEvent allDone = new ManualResetEvent(false);

    public AsynchronousSocketListener()
    {
    }

    public static void StartListening()
    {
        // Data buffer for incoming data.
        byte[] bytes = new Byte[1024];

        // Establish the local endpoint for the socket.
        // The DNS name of the computer
        // running the listener is "host.contoso.com".
        IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
        IPAddress ipAddress = ipHostInfo.AddressList[0];
        Console.Write(ipAddress);
        IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);

        // Create a TCP/IP socket.
        Socket listener = new Socket(AddressFamily.InterNetwork,
            SocketType.Stream, ProtocolType.Tcp);

        // Bind the socket to the local endpoint and listen for incoming connections.
        try
        {
            listener.Bind(localEndPoint);
            listener.Listen(100);

           // while (true)
            for(int i = 0; i < 10; i++)
            {
                // Set the event to nonsignaled state.
                //allDone.Reset();

                // Start an asynchronous socket to listen for connections.
                Console.WriteLine("Waiting for a connection");
                listener.BeginAccept(
                    new AsyncCallback(AcceptCallback),
                    listener);

                // Wait until a connection is made before continuing.
                //allDone.WaitOne();
            }

        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }

        Console.WriteLine(" Press ENTER to continue");
        Console.Read();

    }

    public static void AcceptCallback(IAsyncResult ar)
    {
        // Signal the main thread to continue.
        //allDone.Set();

        Console.WriteLine("Client coming!!!");

        // Get the socket that handles the client request.
        Socket listener = (Socket)ar.AsyncState;
        Socket handler = listener.EndAccept(ar);

        listener.BeginAccept(
            new AsyncCallback(AcceptCallback),
            listener);

        Console.WriteLine("Waiting for a connection again");

        // Create the state object.
        StateObject state = new StateObject();
        state.workSocket = handler;
        handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
            new AsyncCallback(ReadCallback), state);
    }

    public static void ReadCallback(IAsyncResult ar)
    {
        String content = String.Empty;

        // Retrieve the state object and the handler socket
        // from the asynchronous state object.
        StateObject state = (StateObject)ar.AsyncState;
        Socket handler = state.workSocket;

        // Read data from the client socket.
        int bytesRead = handler.EndReceive(ar);

        if (bytesRead > 0)
        {
            // There  might be more data, so store the data received so far.
            state.sb.Append(Encoding.ASCII.GetString(
                state.buffer, 0, bytesRead));

            Console.WriteLine(Encoding.ASCII.GetString(state.buffer, 0, bytesRead));

            // Check for end-of-file tag. If it is not there, read
            // more data.
            content = state.sb.ToString();
            if (content.IndexOf("<EOF>") > -1)
            {
                // All the data has been read from the
                // client. Display it on the console.
                Console.WriteLine("Read {0} bytes from socket. Data : {1}",
                    content.Length, content);
                // Echo the data back to the client.
                Send(handler, content);
            }
            else
            {
                // Not all data received. Get more.
                handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
                new AsyncCallback(ReadCallback), state);
            }
        }
        else
        {
            Console.WriteLine("Client Leave!");
        }
    }

    private static void Send(Socket handler, String data)
    {
        // Convert the string data to byte data using ASCII encoding.
        byte[] byteData = Encoding.ASCII.GetBytes(data);

        // Begin sending the data to the remote device.
        handler.BeginSend(byteData, 0, byteData.Length, 0,
            new AsyncCallback(SendCallback), handler);
    }

    private static void SendCallback(IAsyncResult ar)
    {
        try
        {
            // Retrieve the socket from the state object.
            Socket handler = (Socket)ar.AsyncState;

            // Complete sending the data to the remote device.
            int bytesSent = handler.EndSend(ar);
            Console.WriteLine("Sent {0} bytes to client.", bytesSent);

            handler.Shutdown(SocketShutdown.Both);
            handler.Close();

        }
        catch (Exception e)
        {
            Console.WriteLine(e.ToString());
        }
    }

    public static int Main(String[] args)
    {
        StartListening();
        return 0;
    }
}

句柄仅仅是索引。。不要轻易去搞副本。。

玻璃小屋 — Wed, 15 Jul 2009 08:37:00 GMT

打个比方：
你到旅馆住，人家给你一 503号房间的钥匙。你小子私自去配了几把相同的钥匙，分给你的小蜜、二奶们。有一天你突然不想在这里住了，把退房、结帐、还钥匙。走人了。。但是忘记告诉小蜜、二奶们不要来了。。。。这时就危险了。别人恰好开了503号房。。。你小蜜和二奶去了。。。。这这不是就成免费给别人用了？

    BOOL bRet = FALSE;
    char szBuf[1024] = {0};
    SOCKET s = socket(0,SOCK_STREAM,IPPROTO_TCP);

    SOCKET s1 = s;
    SOCKET s2 = s;
    SOCKET s3 = s;

    closesocket(s);
    s = NULL;

    SOCKET s4 = socket(0,SOCK_STREAM,IPPROTO_TCP);

    SOCKADDR_IN sockAddr;
    memset(&sockAddr,0,sizeof(sockAddr));

    sockAddr.sin_family = AF_INET;
    sockAddr.sin_addr.s_addr = inet_addr("61.153.202.157");

    sockAddr.sin_port = htons((u_short)80);

    if(connect(s1,(SOCKADDR*)&sockAddr, sizeof(sockAddr)) != SOCKET_ERROR)
    {
        sprintf(szBuf,"Get xxx ");
        send(s1,szBuf,strlen(szBuf),0);
        recv(s1,szBuf,sizeof(szBuf),0);
        bRet = TRUE;
    }

完成端口(IOCP) 也可以这样用~~呵呵~ 用来充当线程之间的数据队列~

玻璃小屋 — Wed, 30 Apr 2008 02:42:00 GMT

完成端口貌似就是用 PostQueuedCompletionStatus/GetQueuedCompletionStatus 来管理一个事件队列的~ 即使没有文件和Socket IO，我们单单用他来管理线程之间的数据传递，貌似也很好用啊。。。。 ;p

// Test32.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <stdlib.h>
#include <windows.h>
#include <process.h>
#include <iostream>

HANDLE m_hCompletionPort;

volatile BOOL m_bShutDown;

struct TESTOVERLAPPED
{
    OVERLAPPED    m_ol;
    CHAR        szData[512];
};

UINT WINAPI IOWorkerThreadProc(LPVOID pParam)
{
    BOOL            bError            = FALSE;
    DWORD            dwIoSize        = 0;
    DWORD            dwCmpKey        = 0;
    LPOVERLAPPED    lpOverlapped    = NULL;
    TESTOVERLAPPED*    pOverlapBuff    = NULL;

    while ( !bError )
    {
        pOverlapBuff        = NULL;
        dwCmpKey = 0;
        // Get a completed IO request.
        BOOL bIORet = GetQueuedCompletionStatus(m_hCompletionPort, &dwIoSize, (LPDWORD) &dwCmpKey, &lpOverlapped, INFINITE);
        // Simulate workload (for debugging, to find possible reordering)
        //Sleep(20);

        // If Something whent wrong..
        if (!bIORet)
        {
            DWORD dwIOError = GetLastError();
            if(dwIOError != WAIT_TIMEOUT) // It was not an Time out event we wait for ever (INFINITE)
            {

                    continue;

            }
        }// if (!bIORet)

        if(bIORet && lpOverlapped && dwCmpKey)
        {
            pOverlapBuff=CONTAINING_RECORD(lpOverlapped, TESTOVERLAPPED, m_ol);
            if(pOverlapBuff!=NULL)
            {
                //pThis->ProcessIOMessage(pOverlapBuff, dwCmpKey, dwIoSize);
                printf("ThreaId：0x%x %d %s ",GetCurrentThreadId(),dwCmpKey,pOverlapBuff->szData);
            }

            delete pOverlapBuff;
        }

        if((dwCmpKey == NULL) && (pOverlapBuff == NULL) && m_bShutDown)
        {
            bError = TRUE;
        }
    }

    printf("Thread dead!");

    return 0xdead;
}

int _tmain(int argc, _TCHAR* argv[])
{
    m_hCompletionPort = CreateIoCompletionPort( INVALID_HANDLE_VALUE, NULL, 0, 0 );

    uintptr_t hThread =_beginthreadex(0,0,IOWorkerThreadProc, 0,0, NULL);
    hThread =_beginthreadex(0,0,IOWorkerThreadProc, 0,0, NULL);
    hThread =_beginthreadex(0,0,IOWorkerThreadProc, 0,0, NULL);

    m_bShutDown = FALSE;

    for(int i = 0; i < 30; i++)
    {
        DWORD dwCmpKey = i;
        TESTOVERLAPPED * pOverlapBuff = new TESTOVERLAPPED;
        memset(pOverlapBuff->szData,0,sizeof(pOverlapBuff->szData));
        sprintf(pOverlapBuff->szData,"CMD ID：%d",i);
        PostQueuedCompletionStatus(m_hCompletionPort, 0, (ULONG_PTR) &dwCmpKey, &pOverlapBuff->m_ol);
    }

    m_bShutDown = TRUE;
    PostQueuedCompletionStatus(m_hCompletionPort,0,0,0);

    getchar();

    return 0;
}

输出：

ThreaId：0x890  1310516 CMD ID：0
ThreaId：0x890  1310516 CMD ID：3
ThreaId：0xa18  1310516 CMD ID：2
ThreaId：0xc90  1310516 CMD ID：1
ThreaId：0xc90  1310516 CMD ID：6
ThreaId：0xc90  1310516 CMD ID：7
ThreaId：0xc90  1310516 CMD ID：8
ThreaId：0xc90  1310516 CMD ID：9
ThreaId：0xc90  1310516 CMD ID：10
ThreaId：0xc90  1310516 CMD ID：11
ThreaId：0xa18  1310516 CMD ID：5
ThreaId：0xa18  1310516 CMD ID：13
ThreaId：0xa18  1310516 CMD ID：14
ThreaId：0xa18  1310516 CMD ID：15
ThreaId：0xa18  1310516 CMD ID：16
ThreaId：0xa18  1310516 CMD ID：17
ThreaId：0xa18  1310516 CMD ID：18
ThreaId：0xa18  1310516 CMD ID：19
ThreaId：0xa18  1310516 CMD ID：20
ThreaId：0xa18  1310516 CMD ID：21
ThreaId：0xa18  1310516 CMD ID：22
ThreaId：0xa18  1310516 CMD ID：23
ThreaId：0x890  1310516 CMD ID：4
ThreaId：0xc90  1310516 CMD ID：12
ThreaId：0xa18  1310516 CMD ID：24
ThreaId：0xa18  1310516 CMD ID：27
ThreaId：0xc90  1310516 CMD ID：26
ThreaId：0x890  1310516 CMD ID：25
ThreaId：0xa18  1310516 CMD ID：28
ThreaId：0xc90  1310516 CMD ID：29
Thread dead!

Windows 下面的IOCP有关的数据包分包、拆包机制。

玻璃小屋 — Fri, 14 Mar 2008 07:31:00 GMT

1、IOCP 在异步投递数据的时候，是把数据缓冲区锁定的，就是在你投递之后，在它实际通过网络发送之前，你投递了多大的缓冲区，他就锁定多大。
2、通常在写socket 连接很多的服务端程序的时候，我们都期望把内存分配机制写成内存池的方式，就是避免频繁的从系统中申请和释放内存，据说这样会增加内存碎片。
3、通常我们每次发送的不同用途的实际数据包的大小都不是固定的。

由于以上几点，就决定了以下事实：

写内存池时，一般情况下都是固定大小的内存块。如果按程序中最大的实际数据包的大小来规定内存池每个内存块的大小。当发送数据包时，会造成IOCP锁定数据包，浪费内存。比如 struct SendData 大小是 2048 bytes，struct LogData 大小是 256 bytes。这时如果按 2048bytes 当内存池中内存块的大小，那么我每分配一个 LogData 也将占用 2048 bytes 。这无疑是很大的浪费。所以为了避免浪费或减少浪费，我们可以定义内存池中的内存块的大小为 512 bytes，这时N bytes (n > 512) 大小的数据包，需要分成 n/512 个包来发送。

这样，对于 TCP 数据流来说，我们在发送时需要把自己的实际数据包先分解成每 512 bytes 大小的二级分包，然后再一包一包的发送。
在接收时，我们需要从TCP数据流中先拆分出二级分包。然后再从二级分包中组合出我们的实际数据包。

老外好人多 hook winsocket 的开原代码

玻璃小屋 — Tue, 30 Jan 2007 03:21:00 GMT

http://www.viksoe.dk/code/wepmetering.htm

detours IAT SPI 记几个关键字。

玻璃小屋 — Thu, 25 Jan 2007 15:52:00 GMT

关于拦截、修改 socket 数据的。
呵呵，以后随笔不要写了。。。记住开发中要用的技术的关键字，然后 baidu就可以了

重叠模型的UDP(转自http://community.csdn.net/Expert/TopicView3.asp?id=4984210)

玻璃小屋 — Sun, 19 Nov 2006 02:04:00 GMT

回复人：f_acme(沧海一声笑) ( ) 信誉：100

2006-9-2 11:48:13

得分:0

我用重叠模型写的UDP服务器，也是用于音视频传输的，不过我的这是服务器方面的，不是客户端的，贴出来给大家参考下，觉得有点不好，各位顺便提下意见：

DWORD WINAPI Server::CreateRecvUDPThread(LPVOID lpParam)
{
Server* lp_this = (Server*)lpParam;

lp_this->m_udpFront = 0;
lp_this->m_udpTail = 0;
memset(&lp_this->m_udpDataQueue, 0, sizeof(UDPData)*UDPQUEUELEN);
DWORD id;
//UDPThread为处理UDP数据线程，我用的是一个接收数据线程，一个处理线程，此为接收线程
::CreateThread(NULL, 0, UDPThread, lp_this, 0, &id);

WSAOVERLAPPED ol;
WSAEVENT hEvent[10];
WSABUF wsaBuf;
DWORD nRecv = 0;
DWORD bFlag = 0;
DWORD dwTrans = 0;
DWORD nRet = 0;

int count = 0;
int index;
char buf[BUFFER_SIZE] = {'\0'};

SOCKADDR_IN from;
int fromLen = sizeof(SOCKADDR_IN);

hEvent[0] = WSACreateEvent();
wsaBuf.buf = buf;
wsaBuf.len = BUFFER_SIZE;
memset(&ol, 0, sizeof(WSAOVERLAPPED));
ol.hEvent = hEvent[0];

//循环接受UDP数据包
while(true)
{
nRet = WSARecvFrom(lp_this->m_udpsock, &wsaBuf, 1, &nRecv, &bFlag, (sockaddr*)&from, &fromLen, &ol, NULL);
if (nRet ==SOCKET_ERROR)
{
if (WSAGetLastError() != WSA_IO_PENDING)
{
lp_this->Error("wsarecv error!");
return 0;
}
index = WSAWaitForMultipleEvents(1, hEvent, FALSE, WSA_INFINITE, FALSE);
index -= WSA_WAIT_EVENT_0;
WSAResetEvent(hEvent[index]);
switch(index)
{
case 0:
{
WSAGetOverlappedResult(lp_this->m_udpsock, &ol, &dwTrans, FALSE, &bFlag);
if(dwTrans == 0)
{
lp_this->Error("WSAGetOverlappedResult error!");
//WSACloseEvent(hEvent[index]);
//return 0;
continue;
}

//拷贝接收到的数据到缓冲队列中，用于处理线程进行处理
lp_this->m_udpTail = (lp_this->m_udpTail + 1) % UDPQUEUELEN;
lp_this->m_udpDataQueue[lp_this->m_udpTail].len = dwTrans;
memcpy(lp_this->m_udpDataQueue[lp_this->m_udpTail].buff, wsaBuf.buf, dwTrans);
memcpy((char*)&lp_this->m_udpDataQueue[lp_this->m_udpTail].from, (char*)&from, sizeof(from));
//通知处理线程有数据
::PostThreadMessage(id, WM_UDPDATA, NULL, NULL);

wsaBuf.buf = buf;
wsaBuf.len = BUFFER_SIZE;
}
break;
default:
lp_this->Error("default error!");
break;
}
}
}
return 0;
}

http://community.csdn.net/Expert/TopicView3.asp?id=4984210

关于MFC的CSocket和CAsyncSocket封装的一个大误解！

玻璃小屋 — Mon, 23 Oct 2006 05:51:00 GMT

说实话！开始用CSocket和 CAsyncSocket的时候觉的很好用。都是用来写客户端的嘛！比如 ftp啦，什么的。都是单线程的。
可是后来做的多了，听的多了。似乎大家都对CSocket和CAsyncSocket斥之以鼻！后来要写服务器方面的程序了连接多了，线程模式也是多线程了。查了很多资料，都说这两个封装的效率很低。似乎是每创建一个CSocket对象，都会创建一个窗口。这样的话，如果写服务器程序，几百几千个socket的话，就有几百几千的windows了。。。那就晕了。。。。。

直到某一天有了如下我老人家自以为是，最后砸了自己的脚的对话：

2006-10-23 12:39:26 周伯通
CAsyncSocket的OnSend,OnSend等会重入吗？

2006-10-23 12:40:36 周伯通
[:D]

2006-10-23 12:41:17 ㊣毛毛
啥叫重入？？包的顺序混乱？

2006-10-23 12:41:30 ㊣毛毛
写服务端？还是客户端？

2006-10-23 12:42:19 周伯通
就是一个OnReceive没结束，令一个OnReceive又开始了

2006-10-23 12:42:32 周伯通
老大，你连这个都不懂？

2006-10-23 12:42:41 周伯通
我今天眼花了？

2006-10-23 12:43:45 ㊣毛毛
他是基于消息的。

2006-10-23 12:44:23 周伯通
进不进对列？

2006-10-23 12:45:05 ㊣毛毛
[:L]

2006-10-23 12:45:20 周伯通
[:D]

2006-10-23 12:45:35 周伯通
你是汉正街的水货

2006-10-23 12:45:53 ㊣毛毛
每个CAsyncSocket都有一个窗口。

2006-10-23 12:46:08 周伯通
你是汉正街的水货

2006-10-23 12:46:28 ㊣毛毛
当有数据的时候，socket 会发消息给这个窗口。

2006-10-23 12:47:01 周伯通
每个调用了AfxSockInit的线程都只有一个窗口！

2006-10-23 12:47:23 周伯通
五年前我最喜欢哪这个问题考别人

2006-10-23 12:47:35 ㊣毛毛
我真晕。。。

2006-10-23 12:47:40 周伯通
[:D]

2006-10-23 12:48:31 周伯通
1000个连接要是有1000个隐藏窗口，硬件厂商就高兴了

2006-10-23 12:48:36 周伯通
[:D]

2006-10-23 12:49:51 周伯通
你是开发人员？还是冒牌的？

2006-10-23 12:49:55 周伯通
[:D]

2006-10-23 12:50:04 ㊣毛毛
唉。

2006-10-23 12:50:41 周伯通
[:P]

2006-10-23 12:52:03 周伯通
别生气，开个玩笑

2006-10-23 12:54:06 周伯通
{5CBB6

2006-10-23 13:02:55 周伯通
伤心了？

2006-10-23 13:03:00 周伯通
自卑了？

2006-10-23 13:08:06 周伯通
I am sorry!

2006-10-23 13:09:33 ㊣毛毛
刚刚查了半天代码。。应该是每个线程一个窗口！

2006-10-23 13:09:49 ㊣毛毛
每个有 CSocket的线程！

2006-10-23 13:10:01 周伯通
也不一定

2006-10-23 13:10:09 ㊣毛毛
应该是的。

2006-10-23 13:10:29 周伯通
关键是看该线程是否调用AfxSockInit

2006-10-23 13:11:03 ㊣毛毛
。。。不调用根本就不能用 socket 函数 -.-

2006-10-23 13:11:26 周伯通
取决与AfxSockInit创建的一个数据结构，就是那个我特烦的模块线程状态

2006-10-23 13:11:54 周伯通
因为有人可能只在主线程中Call sockInit

2006-10-23 13:13:43 周伯通
我不知道这样做现在还可不可以！！

2006-10-23 13:14:02 周伯通
Long Long ago是可以的

2006-10-23 13:16:31 ㊣毛毛
按他的模式，是每个线程都有一个 socket wnd..

2006-10-23 13:16:58 周伯通
对

2006-10-23 13:17:08 周伯通
但他又。。

2006-10-23 13:17:17 周伯通
唉

2006-10-23 13:17:26 周伯通
不清不白

。。。所以结论应该是：不是创建一个新的CSocket对象就要创建一个新的窗口。而是同一个线程里面的 CSocket对象共享一个m_hSocketWindow。所以这样看来，我以前的每个CSocket一个窗口的想法就错了，所以按此想法推理的CSocket写服务器程序效率的结论似乎也占不住脚！CSocket应该还是不错的封装！效率差在什么地方？？差在低层消息循环的开销？可是其他模型在实际工程中的同步什么的开销也应该不少吧？？请路过的老鸟指教？？

另外线程数据的结构如下，摘自afxstat_.h

// AFX_MODULE_THREAD_STATE (local to thread *and* module)
class AFX_MODULE_THREAD_STATE : public CNoTrackObject
{
public:
AFX_MODULE_THREAD_STATE();
virtual ~AFX_MODULE_THREAD_STATE();

// current CWinThread pointer
CWinThread* m_pCurrentWinThread;

// list of CFrameWnd objects for thread
CTypedSimpleList<CFrameWnd*> m_frameList;

// temporary/permanent map state
DWORD m_nTempMapLock; // if not 0, temp maps locked
CHandleMap* m_pmapHWND;
CHandleMap* m_pmapHMENU;
CHandleMap* m_pmapHDC;
CHandleMap* m_pmapHGDIOBJ;
CHandleMap* m_pmapHIMAGELIST;

// thread-local MFC new handler (separate from C-runtime)
_PNH m_pfnNewHandler;

#ifndef _AFX_NO_SOCKET_SUPPORT
// WinSock specific thread state
HWND m_hSocketWindow;
#ifdef _AFXDLL
CEmbeddedButActsLikePtr<CMapPtrToPtr> m_pmapSocketHandle;
CEmbeddedButActsLikePtr<CMapPtrToPtr> m_pmapDeadSockets;
CEmbeddedButActsLikePtr<CPtrList> m_plistSocketNotifications;
#else
CMapPtrToPtr* m_pmapSocketHandle;
CMapPtrToPtr* m_pmapDeadSockets;
CPtrList* m_plistSocketNotifications;
#endif
#endif

// common controls thread state
CToolTipCtrl* m_pToolTip;
CWnd* m_pLastHit;       // last window to own tooltip
INT_PTR m_nLastHit;         // last hittest code
TOOLINFO* m_pLastInfo;    // last TOOLINFO structure
INT_PTR m_nLastStatus;      // last flyby status message
CControlBar* m_pLastStatus; // last flyby status control bar
};

(zt) Socket 的 Send Recv 的长度问题?

玻璃小屋 — Thu, 19 Jan 2006 05:38:00 GMT

一个包没有固定长度，以太网限制在46－1500字节，1500就是以太网的MT

U，超过这个量，TCP会为IP数据报设置偏移量进行分片传输，现在一般可

允许应用层设置8k（NTFS系统）的缓冲区，8k的数据由底层分片，而应用

层看来只是一次发送。

windows的缓冲区经验值是4k

Socket本身分为两种，流(TCP)和数据报(UDP)，你的问题针对这两种不同

使用而结论不一样。甚至还和你是用阻塞、还是非阻塞Socket来编程有关

。
1、通信长度，这个是你自己决定的，没有系统强迫你要发多大的包，实

际应该根据需求和网络状况来决定。对于TCP，这个长度可以大点，但要

知道，Socket内部默认的收发缓冲区大小大概是8K，你可以用SetSockOpt

来改变。但对于UDP，就不要太大，一般在1024至10K。注意一点，你无论

发多大的包，IP层和链路层都会把你的包进行分片发送，一般局域网就是

1500左右，广域网就只有几十字节。分片后的包将经过不同的路由到达接

收方，对于UDP而言，要是其中一个分片丢失，那么接收方的IP层将把整

个发送包丢弃，这就形成丢包。显然，要是一个UDP发包佷大，它被分片

后，链路层丢失分片的几率就佷大，你这个UDP包，就佷容易丢失，但是

太小又影响效率。最好可以配置这个值，以根据不同的环境来调整到最佳

状态。
send()函数返回了实际发送的长度，在网络不断的情况下，它绝不会返回

(发送失败的)错误，最多就是返回0。对于TCP你可以字节写一个循环发送

。当send函数返回SOCKET_ERROR时，才标志着有错误。
但对于UDP，你不要写循环发送，否则将给你的接收带来极大的麻烦。所

以UDP需要用SetSockOpt来改变Socket内部Buffer的大小，以能容纳你的

发包。明确一点，TCP作为流，发包是不会整包到达的，而是源源不断的

到，那接收方就必须组包。而UDP作为消息或数据报，它一定是整包到达

接收方。

2、关于接收，一般的发包都有包边界，首要的就是你这个包的长度要让

接收方知道，于是就有个包头信息，对于TCP，接收方先收这个包头信息

，然后再收包数据。一次收齐整个包也可以，可要对结果是否收齐进行验

证。这也就完成了组包过程。UDP，那你只能整包接收了。要是你提供的

接收Buffer过小，TCP将返回实际接收的长度，余下的还可以收，而UDP不

同的是，余下的数据被丢弃并返回WSAEMSGSIZE错误。注意TCP，要是你提

供的Buffer佷大，那么可能收到的就是多个发包，你必须分离它们，还有

就是当Buffer太小，而一次收不完Socket内部的数据，那么Socket接收事

件(OnReceive)，可能不会再触发，使用事件方式进行接收时，密切注意

这点。这些特性就是体现了流和数据包的区别。

补充一点，接收BuffSize >= 发送BuffSize >= 实际发送Size，对于内外

部的Buffer都适用，上面讲的主要是Socket内部的Buffer大小关系。

3、TCP是有多少就收多少，如果没有当然阻塞Socket的recv就会等，直到

有数据，非阻塞Socket不好等，而是返回WSAEWOULDBLOCK。UDP，如果没

有数据，阻塞Socket就会等，非阻塞Socket也返回WSAEWOULDBLOCK。如果

有数据，它是会等整个发包到齐，并接收到整个发包，才返回。

（转）浅析:setsockopt()改善程序的健壮性

玻璃小屋 — Fri, 25 Nov 2005 08:27:00 GMT

浅析:setsockopt()改善程序的健壮性

转自：http://www.sureserv.com/bbs/read.php?fid=26&tid=18&page=lastpost&fpage=1

关于DONTLINGER和SO_LINGER的讲究还不少 -_-

不断的收到coolmei25 (梅生)的答谢，我都不好意思了（我都没帮到他),下面
写出我在网络编程中的一点心得体会，希望对他(^_^也对大家)有帮助:
1. 如果在已经处于 ESTABLISHED状态下的socket(一般由端口号和标志符区分）调用
closesocket（一般不会立即关闭而经历TIME_WAIT的过程）后想继续重用该socket：
BOOL bReuseaddr=TRUE;
setsockopt(s,SOL_SOCKET ,SO_REUSEADDR,(const char*)&bReuseaddr,sizeof(BOOL));
2. 如果要已经处于连接状态的soket在调用closesocket后强制关闭，不经历
TIME_WAIT的过程：
BOOL bDontLinger = FALSE;
setsockopt(s,SOL_SOCKET,SO_DONTLINGER,(const char*)&bDontLinger,sizeof(BOOL));
3.在send(),recv()过程中有时由于网络状况等原因，发收不能预期进行,而设置收发时限：
int nNetTimeout=1000;//1秒
//发送时限
setsockopt(socket，SOL_S0CKET,SO_SNDTIMEO，(char *)&nNetTimeout,sizeof(int));
//接收时限
setsockopt(socket，SOL_S0CKET,SO_RCVTIMEO，(char *)&nNetTimeout,sizeof(int));
4.在send()的时候，返回的是实际发送出去的字节(同步)或发送到socket缓冲区的字节
(异步);系统默认的状态发送和接收一次为8688字节(约为8.5K)；在实际的过程中发送数据
和接收数据量比较大，可以设置socket缓冲区，而避免了send(),recv()不断的循环收发：
// 接收缓冲区
int nRecvBuf=32*1024;//设置为32K
setsockopt(s,SOL_SOCKET,SO_RCVBUF,(const char*)&nRecvBuf,sizeof(int));
//发送缓冲区
int nSendBuf=32*1024;//设置为32K
setsockopt(s,SOL_SOCKET,SO_SNDBUF,(const char*)&nSendBuf,sizeof(int));
5. 如果在发送数据的时，希望不经历由系统缓冲区到socket缓冲区的拷贝而影响
程序的性能：
int nZero=0;
setsockopt(socket，SOL_S0CKET,SO_SNDBUF，(char *)&nZero,sizeof(nZero));
6.同上在recv()完成上述功能(默认情况是将socket缓冲区的内容拷贝到系统缓冲区)：
int nZero=0;
setsockopt(socket，SOL_S0CKET,SO_RCVBUF，(char *)&nZero,sizeof(int));
7.一般在发送UDP数据报的时候，希望该socket发送的数据具有广播特性：
BOOL bBroadcast=TRUE;
setsockopt(s,SOL_SOCKET,SO_BROADCAST,(const char*)&bBroadcast,sizeof(BOOL));
8.在client连接服务器过程中，如果处于非阻塞模式下的socket在connect()的过程中可
以设置connect()延时,直到accpet()被呼叫(本函数设置只有在非阻塞的过程中有显著的
作用，在阻塞的函数调用中作用不大)
BOOL bConditionalAccept=TRUE;
setsockopt(s,SOL_SOCKET,SO_CONDITIONAL_ACCEPT,(const char*)&bConditionalAccept,sizeof(BOOL));
9.如果在发送数据的过程中(send()没有完成，还有数据没发送)而调用了closesocket(),以前我们
一般采取的措施是"从容关闭"shutdown(s,SD_BOTH),但是数据是肯定丢失了，如何设置让程序满足具体
应用的要求(即让没发完的数据发送出去后在关闭socket)？
struct linger {
u_short l_onoff;
u_short l_linger;
};
linger m_sLinger;
m_sLinger.l_onoff=1;//(在closesocket()调用,但是还有数据没发送完毕的时候容许逗留)
// 如果m_sLinger.l_onoff=0;则功能和2.)作用相同;
m_sLinger.l_linger=5;//(容许逗留的时间为5秒)
setsockopt(s,SOL_SOCKET,SO_LINGER,(const char*)&m_sLinger,sizeof(linger));
Note:1.在设置了逗留延时，用于一个非阻塞的socket是作用不大的，最好不用;
2.如果想要程序不经历SO_LINGER需要设置SO_DONTLINGER，或者设置l_onoff=0；
10.还一个用的比较少的是在SDI或者是Dialog的程序中，可以记录socket的调试信息：
(前不久做过这个函数的测试，调式信息可以保存，包括socket建立时候的参数,采用的
具体协议，以及出错的代码都可以记录下来）
BOOL bDebug=TRUE;
setsockopt(s,SOL_SOCKET,SO_DEBUG,(const char*)&bDebug,sizeof(BOOL));
11.附加：往往通过setsockopt()设置了缓冲区大小，但还不能满足数据的传输需求，
我的习惯是自己写个处理网络缓冲的类，动态分配内存;下面我将这个类写出，希望对
初学者有所帮助：

//仿照String 改写而成
//==============================================================================
// 二进制数据，主要用于收发网络缓冲区的数据
// CNetIOBuffer 以 MFC 类 CString 的源代码作为蓝本改写而成，用法与 CString 类似，
// 但是 CNetIOBuffer 中存放的是纯粹的二进制数据，'\0' 并不作为它的结束标志。
// 其数据长度可以通过 GetLength() 获得，缓冲区地址可以通过运算符 LPBYTE 获得。

//==============================================================================
// Copyright (c) All-Vision Corporation. All rights reserved.
// Module: NetObject
// File: SimpleIOBuffer.h
// Author: gdy119
// Email : 8751webmaster@126.com
// Date: 2004.11.26
//==============================================================================
// NetIOBuffer.h
#ifndef _NETIOBUFFER_H
#define _NETIOBUFFER_H
//=============================================================================
#define MAX_BUFFER_LENGTH 1024*1024
//=============================================================================
//主要用来处理网络缓冲的数据
class CNetIOBuffer
{
protected:
LPBYTE m_pbinData;
int m_nLength;
int m_nTotalLength;
CRITICAL_SECTIONm_cs;
void Initvalibers();
public:
CNetIOBuffer();
CNetIOBuffer(const LPBYTE lbbyte, int nLength);
CNetIOBuffer(const CNetIOBuffer&binarySrc);
virtual ~CNetIOBuffer();
//=============================================================================
BOOL CopyData(const LPBYTE lbbyte, int nLength);
BOOL ConcatData(const LPBYTE lbbyte, int nLength);
void ResetIoBuffer();
int GetLength() const;
BOOL SetLength(int nLen);
LPBYTE GetCurPos();
int GetRemainLen();
BOOL IsEmpty() const;
operator LPBYTE() const;
static GetMaxLength() { return MAX_BUFFER_LENGTH; }
const CNetIOBuffer& operator=(const CNetIOBuffer& buffSrc);
};
#endif //
// NetOBuffer.cpp: implementation of the CNetIOBuffer class.
//======================================================================
#include "stdafx.h"
#include "NetIOBuffer.h"
//======================================================================
//=======================================================================
// Construction/Destruction
CNetIOBuffer::CNetIOBuffer()
{
Initvalibers();

}
CNetIOBuffer::CNetIOBuffer(const LPBYTE lbbyte, int nLength)
{
Initvalibers();
CopyData(lbbyte, nLength);
}
CNetIOBuffer::~CNetIOBuffer()
{
delete []m_pbinData;
m_pbinData=NULL;
DeleteCriticalSection(&m_cs);

}
CNetIOBuffer::CNetIOBuffer(const CNetIOBuffer&binarySrc)
{

Initvalibers();
CopyData(binarySrc,binarySrc.GetLength());

}
void CNetIOBuffer::Initvalibers()
{

m_pbinData = NULL;
m_nLength = 0;
m_nTotalLength = MAX_BUFFER_LENGTH;
if(m_pbinData==NULL)
{
m_pbinData=new BYTE[m_nTotalLength];
ASSERT(m_pbinData!=NULL);
}
InitializeCriticalSection(&m_cs);
}
void CNetIOBuffer::ResetIoBuffer()
{
EnterCriticalSection(&m_cs);
m_nLength = 0;
memset(m_pbinData,0,m_nTotalLength);
LeaveCriticalSection(&m_cs);
}

BOOL CNetIOBuffer::CopyData(const LPBYTE lbbyte, int nLength)
{
if( nLength > MAX_BUFFER_LENGTH )
return FALSE;

ResetIoBuffer();
EnterCriticalSection(&m_cs);
memcpy(m_pbinData, lbbyte, nLength );
m_nLength = nLength;
LeaveCriticalSection(&m_cs);

return TRUE;
}

BOOL CNetIOBuffer::ConcatData(const LPBYTE lbbyte, int nLength)
{
if( m_nLength + nLength > MAX_BUFFER_LENGTH )
return FALSE;

EnterCriticalSection(&m_cs);
memcpy(m_pbinData+m_nLength, lbbyte, nLength );
m_nLength += nLength;
LeaveCriticalSection(&m_cs);

return TRUE;
}

int CNetIOBuffer::GetLength() const
{
return m_nLength;
}

BOOL CNetIOBuffer::SetLength(int nLen)
{
if( nLen > MAX_BUFFER_LENGTH )
return FALSE;

EnterCriticalSection(&m_cs);
m_nLength = nLen;
LeaveCriticalSection(&m_cs);

return TRUE;
}

LPBYTE CNetIOBuffer::GetCurPos()
{

if( m_nLength < MAX_BUFFER_LENGTH )

return (m_pbinData+m_nLength);

else
return NULL;
}

CNetIOBuffer:: operator LPBYTE() const
{
return m_pbinData;
}

int CNetIOBuffer::GetRemainLen()
{

return MAX_BUFFER_LENGTH - m_nLength;

}
BOOL CNetIOBuffer::IsEmpty() const
{
return m_nLength == 0;
}

const CNetIOBuffer& CNetIOBuffer:: operator=(const CNetIOBuffer& buffSrc)
{
if(&buffSrc!=this)
{
CopyData(buffSrc, buffSrc.GetLength());

}
return *this;

}

回复人： PiggyXP(【小猪】●至爱VC，至爱网络版●) ( ) 信誉：204

其实我觉得第5条很应该值得注意
int nZero=0;
setsockopt(socket，SOL_S0CKET,SO_SNDBUF，(char *)&nZero,sizeof(nZero));

记得以前有些朋友讨论过，socket虽然send成功了，但是其实只是发送到数据缓冲区里面了，而并没有真正的在物理设备上发送出去；而通过这条语句，将发送缓冲区设置为0，即屏蔽掉发送缓冲以后，一旦send返回（当然是就阻塞套结字来说），就可以肯定数据已经在发送的途中了^_^，但是这样做也许会影响系统的性能

to:Sander()
UDP也有拷贝过程，但是UDP包有最大限制为64K；
TCP_NODELAY 一般用在the normal data stream 上；
12.发送数据时候一般是系统缓冲区满以后才发送，现在设置为只要系统
缓冲区有数据就立刻发送：
BOOL bNodelay=TRUE;
SetSockOpt(s,IPPROTO_TCP,TCP_NODELAY,(const char*)&bNodelayt,sizeof(BOOL));

回复人： od4ys(风风) ( ) 信誉：100

setoptsock（）这个函数设置成端口复用的时候，很容易对一些没有进行单独bind模式的程序造成危害。
比如old的 ping icmp door，简单的sniffer后，收到包，然后设置setoptsock bind web服务，然后建立个cmd进程 bind再80端口。