大家都推荐一下，有window网络服务器的开源项目吗？

[xl5338870]

大家都推荐一下，有window网络服务器的开源项目吗？

[xl5338870]

推荐的好的都有分噢

[DentistryDoctor]

到www.sf.net上去找吧。

[acejoy]

你指的是什么呢？完成什么工作的？
如果是网络编程的基础库，首选ACE ── windows／linux通用，C++，开源，工业级质量，
高效、稳定可靠。能开发windows服务端程序，内部是完成端口实现，也能用于客户端程序。
基本上日常网络编程工作的80%都做了，做东西又快又好，缺点是：难学，一般人都学不会。。。

──────────────────────
国内专业的ACE论坛开通：
www.acejoy.com
www.acedevelop.com
涉及ACE使用和开发，服务器端软件的设计，P2P技术，
网络编程等内容。
欢迎加入，大家一起交流、学习成长！

[xl5338870]

包含一些网络服务器代码：比如sock代理服务器，一些协议的库，还有处理大规模网络连接的成功例子

[一剑]

给你一个就：

完成端口实现，发送数据效率3MB每秒

服务端头文件：


// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (C) 1993-1997 Microsoft Corporation. All Rights Reserved.
//
// MODULE: socksrv.h
//
// PURPOSE: Definitions and prototypes for socksrv.c
//

#include <windows.h>
#include <tchar.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <wsipx.h>
#include "commdef.h"

#define MAXIMUM_NUMBER_OF_CLIENTS 64
#define MAXIMUM_NUMBER_OF_WORKERS 32
#define FILE_SIZE ((1024*1024*8)-CLIENT_OUTBOUND_BUFFER_MAX)

#define SIXTY_FOUR_K (64*1024)
#define SIXTEEN_K (16*1024)
DWORD InitialBuffer[SIXTY_FOUR_K/sizeof(DWORD)];
#define NUMBER_OF_WRITES ((FILE_SIZE+CLIENT_OUTBOUND_BUFFER_MAX)/SIXTY_FOUR_K)

#define CLIENT_CONNECTED 0x00000001
#define CLIENT_DONE 0x00000002

typedef struct _PER_CLIENT_DATA {
SOCKET Socket;
OVERLAPPED Overlapped;
CLIENT_IO_BUFFER IoBuffer;
CHAR OutboundBuffer[CLIENT_OUTBOUND_BUFFER_MAX];
DWORD Flags;
HANDLE hEvent;
} PER_CLIENT_DATA, *PPER_CLIENT_DATA;

typedef struct _PER_THREAD_DATA {
DWORD TotalTransactions;
DWORD TotalBytesTransferred;
} PER_THREAD_DATA, *PPER_THREAD_DATA;

PER_THREAD_DATA ThreadData[MAXIMUM_NUMBER_OF_WORKERS];
PER_CLIENT_DATA ClientData[MAXIMUM_NUMBER_OF_CLIENTS];
BOOL fVerbose;
BOOL fTcp;
DWORD dwNumberOfClients;
DWORD dwNumberOfWorkers;
DWORD dwConcurrency;
DWORD dwWorkIndex;
SYSTEM_INFO SystemInfo;
HANDLE CompletionPort;
DWORD dwActiveClientCount;
HANDLE hBenchmarkComplete;
HANDLE hBenchmarkStart;
DWORD StartTime;
DWORD EndTime;
HANDLE hFile;

DWORD
WINAPI
Random (
DWORD nMaxValue
);


VOID
WINAPI
ShowUsage(
VOID
);

VOID
WINAPI
ParseSwitch(
CHAR chSwitch,
int *pArgc,
char **pArgv[]
);

BOOL
WINAPI
CreateNetConnections(
VOID
);

BOOL
WINAPI
CreateWorkers(
VOID
);

DWORD
WINAPI
WorkerThread(
LPVOID WorkContext
);

VOID
WINAPI
CompleteBenchmark(
VOID
);

VOID
WINAPI
SortTheBuffer(
LPDWORD Destination,
LPDWORD Source,
int DwordCount
);

[一剑]

实现文件：

#include "socksrv.h"

int _CRTAPI1
main (
int argc,
char *argv[],
char *envp[]
)
{

char chChar, *pchChar;
DWORD lc;
BOOL b;
int WriteCount;

//
// try to get timing more accurate... Avoid context
// switch that could occur when threads are released
//

SetThreadPriority (GetCurrentThread (), THREAD_PRIORITY_TIME_CRITICAL);

//
// Figure out how many processors we have to size the minimum
// number of worker threads and concurrency
//

GetSystemInfo (&SystemInfo);

fVerbose = FALSE;
dwNumberOfClients = 2;
dwNumberOfWorkers = 2 * SystemInfo.dwNumberOfProcessors;
dwConcurrency = SystemInfo.dwNumberOfProcessors;
fTcp = TRUE;
dwWorkIndex = 4;

while (--argc)
{
pchChar = *++argv;
if (*pchChar == '/' || *pchChar == '-')
{
while (chChar = *++pchChar)
{
ParseSwitch (chChar, &argc, &argv);
}
}
}

//
// If we are doing file I/O, then create a large file that clients
// can randomly seek and read from
//

srand (1);

//
// Create a new file and make it the correct size
//

DeleteFile ("socksrv.dat");

hFile = CreateFile (
"socksrv.dat",
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_ALWAYS,
FILE_FLAG_DELETE_ON_CLOSE | FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED,
NULL
);
if (hFile == INVALID_HANDLE_VALUE)
{
fprintf (stderr, "SOCKSRV: Error opening file %d\n", GetLastError ());
exit (1);
}

//
// Initialize the file with random data
//

ClientData[0].Overlapped.Offset = 0;
for (WriteCount = 0; WriteCount < NUMBER_OF_WRITES; WriteCount++)
{

for (lc = 0; lc < SIXTEEN_K; lc++)
{
InitialBuffer[lc] = (DWORD) rand ();
}

b = WriteFile (hFile, InitialBuffer, sizeof (InitialBuffer), &lc, &ClientData[0].Overlapped);

if (!b && GetLastError () != ERROR_IO_PENDING)
{
fprintf (stderr, "SOCKSRV: Error in pre-write %d\n", GetLastError ());
exit (1);
}
b = GetOverlappedResult (
hFile,
&ClientData[0].Overlapped,
&lc,
TRUE
);
if (!b || lc != sizeof (InitialBuffer))
{
fprintf (stderr, "SOCKSRV: Wait for pre-write failed %d\n", GetLastError ());
exit (1);
}
ClientData[0].Overlapped.Offset += lc;
}

srand (1);
fprintf (stdout, "SOCKSRV: %2d Clients %2d Workers Concurrency %d Using %s WorkIndex %d\n",
dwNumberOfClients,
dwNumberOfWorkers,
dwConcurrency,
fTcp ? "TCP" : "IPX",
dwWorkIndex
);

if (!CreateNetConnections ())
{
exit (1);
}

if (!CreateWorkers ())
{
exit (1);
}

if (fVerbose)
{
fprintf (stdout, "Workers Created, Waiting for Clients to complete\n");
}

CompleteBenchmark ();

exit (1);
return 1;
}

[一剑]

VOID
WINAPI
CompleteBenchmark (
VOID
)
{
DWORD LowestTicks;
DWORD HighestTicks;
DWORD TotalTicks;
DWORD TotalIterations;
DWORD TotalBytesTransferred;
DWORD i;

StartTime = GetTickCount ();
SetEvent (hBenchmarkStart);
WaitForSingleObject (hBenchmarkComplete, INFINITE);
EndTime = GetTickCount ();

LowestTicks = ClientData[0].IoBuffer.u.IAmDone.TotalTicks;
HighestTicks = ClientData[0].IoBuffer.u.IAmDone.TotalTicks;
TotalTicks = EndTime - StartTime;
TotalIterations = 0;
TotalBytesTransferred = 0;

for (i = 0; i < dwNumberOfClients; i++)
{
TotalIterations += ClientData[i].IoBuffer.u.IAmDone.TotalIterations;
TotalBytesTransferred += ClientData[i].IoBuffer.u.IAmDone.TotalBytesTransferred;

//
// find fastest client
//
if (LowestTicks > ClientData[i].IoBuffer.u.IAmDone.TotalTicks)
{
LowestTicks = ClientData[i].IoBuffer.u.IAmDone.TotalTicks;
}

//
// find slowest client
//
if (HighestTicks < ClientData[i].IoBuffer.u.IAmDone.TotalTicks)
{
HighestTicks = ClientData[i].IoBuffer.u.IAmDone.TotalTicks;
}
}

fprintf (stdout, "\nSOCKSRV:TPS, %ld (Fastest Client %dms Slowest Client %dms)\n",
(TotalIterations * 1000) / TotalTicks,
LowestTicks,
HighestTicks
);

if (fVerbose)
{
fprintf (stdout, "\n%ld bytes transferred in %ld iterations, time = %ld ms\n",
TotalBytesTransferred,
TotalIterations,
TotalTicks
);

for (i = 0; i < dwNumberOfWorkers; i++)
{
fprintf (stdout, "Thread[%2d] %d Transactions %d Bytes\n",
i,
ThreadData[i].TotalTransactions,
ThreadData[i].TotalBytesTransferred
);
}
}
}

BOOL
WINAPI
CreateNetConnections (
void
)
{
DWORD i;
SOCKET listener;
INT err;
WSADATA WsaData;
DWORD nbytes;
BOOL b;

err = WSAStartup (0x0101, &WsaData);
if (err == SOCKET_ERROR)
{
fprintf (stdout, "WSAStartup Failed\n");
return FALSE;
}

//
// Open a socket to listen for incoming connections.
//

if (fTcp)
{

SOCKADDR_IN localAddr;

listener = socket (AF_INET, SOCK_STREAM, 0);
if (listener == INVALID_SOCKET)
{
fprintf (stdout, "Socket Create Failed\n");
return FALSE;
}

//
// Bind our server to the agreed upon port number. See
// commdef.h for the actual port number.
//
ZeroMemory (&localAddr, sizeof (localAddr));
localAddr.sin_port = htons (SERVPORT);
localAddr.sin_family = AF_INET;

err = bind (listener, (PSOCKADDR) & localAddr, sizeof (localAddr));
if (err == SOCKET_ERROR)
{
fprintf (stdout, "Socket Bind Failed\n");
if (WSAGetLastError () == WSAEADDRINUSE)
fprintf (stdout, "The port number may already be in use.\n");
return FALSE;
}

}
else
{

SOCKADDR_IPX localAddr;

listener = socket (AF_IPX, SOCK_STREAM, NSPROTO_SPX);
if (listener == INVALID_SOCKET)
{
fprintf (stdout, "Socket Create Failed\n");
return FALSE;
}

ZeroMemory (&localAddr, sizeof (localAddr));
localAddr.sa_socket = htons (7);
localAddr.sa_family = AF_IPX;

err = bind (listener, (PSOCKADDR) & localAddr, sizeof (localAddr));
if (err == SOCKET_ERROR)
{
fprintf (stdout, "Socket Bind Failed\n");
return FALSE;
}
}

//
// Prepare to accept client connections. Allow up to 5 pending
// connections.
//
err = listen (listener, 5);
if (err == SOCKET_ERROR)
{
fprintf (stdout, "Socket Listen Failed\n");
return FALSE;
}


//
// Only Handle a single Queue
//

for (i = 0; i < dwNumberOfClients; i++)
{

//
// Accept incoming connect requests and create wait events for each.
//

//
// If we are doing file I/O, each client will need its own event
// to use for async file I/O
//

if (hFile)
{
ClientData[i].hEvent = CreateEvent (NULL, TRUE, FALSE, NULL);
if (!ClientData[i].hEvent)
{
fprintf (stdout, "Client Event Create Failed\n");
return FALSE;
}
}

ClientData[i].Socket = accept (listener, NULL, NULL);
if (ClientData[i].Socket == INVALID_SOCKET)
{
fprintf (stdout, "Accept Failed\n");
return FALSE;
}

if (fVerbose)
{
fprintf (stdout, "Client Connection Accepted\n");
}

//
// note the 16 says how many concurrent cpu bound threads to allow thru
// this should be tunable based on the requests. CPU bound requests will
// really really honor this.
//

CompletionPort = CreateIoCompletionPort (
(HANDLE) ClientData[i].Socket,
CompletionPort,
(DWORD) i,
dwConcurrency
);

if (!CompletionPort)
{
fprintf (stdout, "CompletionPort Create Failed\n");
return FALSE;
}

ClientData[i].Flags = CLIENT_CONNECTED;

//
// Start off an asynchronous read on the socket.
//

ClientData[i].Overlapped.hEvent = NULL;

b = ReadFile (
(HANDLE) ClientData[i].Socket,
&ClientData[i].IoBuffer,
sizeof (CLIENT_IO_BUFFER),
&nbytes,
&ClientData[i].Overlapped
);

if (!b && GetLastError () != ERROR_IO_PENDING)
{
fprintf (stdout, "ReadFile Failed\n");
return FALSE;
}
}

dwActiveClientCount = dwNumberOfClients;
hBenchmarkComplete = CreateEvent (NULL, TRUE, FALSE, NULL);
if (!hBenchmarkComplete)
{
fprintf (stdout, "Create Benchmark Complete Event Failed\n");
return FALSE;
}
hBenchmarkStart = CreateEvent (NULL, TRUE, FALSE, NULL);
if (!hBenchmarkStart)
{
fprintf (stdout, "Create Benchmark Start Event Failed\n");
return FALSE;
}

return TRUE;
}

BOOL
WINAPI
CreateWorkers (
void
)
{
DWORD ThreadId;
HANDLE ThreadHandle;
DWORD i;

for (i = 0; i < dwNumberOfWorkers; i++)
{

ThreadHandle = CreateThread (
NULL,
0,
WorkerThread,
&ThreadData[i],
0,
&ThreadId
);
if (!ThreadHandle)
{
fprintf (stdout, "Create Worker Thread Failed\n");
return FALSE;
}

CloseHandle (ThreadHandle);
}

return TRUE;
}