vc简易网络服务器、客户端实现

来源：互联网发布：琪琪看片 mac版下载编辑：程序博客网时间：2024/06/05 19:16

一、服务器部分代码
头文件:server.h

#include <winsock2.h>
#include <stdio.h>
#include <windef.h>
#ifndef TCP_SERVER_H
#define TCP_SERVER_H
#pragma warning(disable : 4996)
#define MAX_CLIENT (100)
#define LISTEN_PORT (60000)
#define CLIENT_TIMEOUT (15 * 60 * 60) /*客户端中断15分钟则服务器自动掉线*/
#define MAX_TCP_PACKET_SIZE (1492)/*tcp最大数据包字节数*/
typedef struct __client_item
{
SOCKET client;
sockaddr_in form;
unsigned int id;
DWORD dwThreadId;
HANDLE hThread;
}_client_item;
typedef struct __client_list
{
DWORD client_cnt;
_client_item client_item[MAX_CLIENT];
}_client_list;
DWORD WINAPI serve_client_thread_func( LPVOID param_ptr );
#endif/*TCP_SERVER_H*/

源文件:server.cpp

#include "server.h"
#include <sys\stat.h>
#include <time.h>
_client_list client_list;
CRITICAL_SECTION cs_serve_main;
CRITICAL_SECTION cs_serve_thread;
_client_list *get_client_list(void)
{
return &client_list;
}
void client_list_cnt_inc(void)
{
_client_list *client_list_ptr = get_client_list();
client_list_ptr->client_cnt++;
}
void client_list_cnt_dec(void)
{
_client_list *client_list_ptr = get_client_list();
client_list_ptr->client_cnt--;
}
unsigned int get_free_client_index(void)
{
int i = 0;
unsigned int id = 0;
_client_list *client_list_ptr = get_client_list();
for(i = 0; i < MAX_CLIENT; i++)
{
id = client_list_ptr->client_item[i].id;
if( UINT_MAX == id )
{
break;
}
}
return i;
}
_client_item *get_client_item(unsigned int index)
{
_client_list *client_list_ptr = get_client_list();
if( index >= MAX_CLIENT )
{
return NULL;
}
return &client_list_ptr->client_item[index];
}
void set_client_item(unsigned int index, _client_item *client_item_ptr)
{
_client_list *client_list_ptr = get_client_list();
if( index >= MAX_CLIENT )
{
return;
}
client_list_ptr->client_item[index] = *client_item_ptr;
}
SOCKET g_sk_server;
int main()
{
SOCKET server;
WSADATA wsaData;
sockaddr_in local;
int nRet = 0;
int sockaddr_in_sizeof = 0;
unsigned int index = 0;
_client_item *client_item_ptr = NULL;
_client_item client_item = {0};
_client_list *client_list_ptr = NULL;
SOCKET client;
sockaddr_in from;
DWORD dwThreadId;
HANDLE hThread;
nRet = WSAStartup(0x101, &wsaData);
if( 0 != nRet )
{
return 0;
}
// 现在我们来为sockaddr_in结构赋值。
local.sin_family = AF_INET; // 地址族
local.sin_addr.s_addr = INADDR_ANY; // 网际IP地址
local.sin_port = htons(LISTEN_PORT); // 使用的端口
// 由socket函数创建我们的SOCKET。
server = socket(AF_INET, SOCK_STREAM, 0);
//server = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP,NULL, 0, WSA_FLAG_OVERLAPPED);
// 如果socket()函数失败，我们就退出。
if( server == INVALID_SOCKET )
{
return 0;
}
// bind将我们刚创建的套接字和sockaddr_in结构联系起来。
// 它主要使用本地地址及一个特定的端口来连接套接字。
// 如果它返回非零值，就表示出现错误。
nRet = bind(server, (sockaddr*)&local, sizeof(local));
if( 0 != nRet )
{
return 0;
}
// listen命令套接字监听来自客户端的连接。
// 第二个参数是最大连接数。
nRet = listen(server, MAX_CLIENT);
if( 0 != nRet )
{
return 0;
}
g_sk_server = server;
// 我们需要一些变量来保存客户端的套接字，因此我们在此声明之。
InitializeCriticalSection(&cs_serve_main);/*初始化临界区*/
InitializeCriticalSection(&cs_serve_thread);/*初始化临界区*/
client_list_ptr = get_client_list();
memset(client_list_ptr, 0xff, sizeof(_client_list));
memset(&client, 0, sizeof(SOCKET));
memset(&from, 0, sizeof(sockaddr_in));
sockaddr_in_sizeof = sizeof(sockaddr_in);
while( TRUE )
{
index = get_free_client_index();
if( index >= MAX_CLIENT )
{/*已经达到最大连接数*/
continue;
}
client_item_ptr = get_client_item(index);
client_item_ptr->client = accept(server,
(struct sockaddr*)&client_item_ptr->form, &sockaddr_in_sizeof);
if( INVALID_SOCKET == client_item_ptr->client )
{/*连接错误*/
Sleep(500);
continue;
}else
{
printf("Connection from %s\n", inet_ntoa(client_item_ptr->form.sin_addr) );
}
/* 多线程开始*/
EnterCriticalSection(&cs_serve_main);/*进入临界区*/
hThread = CreateThread(
NULL, // no security attributes
0, // use default stack size
serve_client_thread_func, // thread function
client_item_ptr, // argument to thread function
CREATE_SUSPENDED, // use default creation flags
&dwThreadId); // returns the thread identifier
if( NULL != hThread )
{
client_item_ptr->hThread = hThread;
client_item_ptr->dwThreadId = dwThreadId;
client_item_ptr->id = index;
}
client_list_cnt_inc();
LeaveCriticalSection(&cs_serve_main);/*离开临界区*/
if( NULL != client_item_ptr->hThread )
{
ResumeThread(client_item_ptr->hThread);
}
client_item_ptr = NULL;
/*end 多线程开始*/
}
//关闭套接字，并释放套接字描述符。
closesocket(server);
WSACleanup();
DeleteCriticalSection(&cs_serve_thread);/*删除临界区*/
DeleteCriticalSection(&cs_serve_main);/*删除临界区*/
return 0;
}
void serve_client_thread_clear(SOCKET sock_client,
sockaddr_in *sockaddr_client_ptr,
UINT32 client_id,
char *msg,
_client_item *client_item_ptr
)
{
int msg_len = strlen(msg);
if( msg_len > 0 )
{
send(sock_client, msg, msg_len + 1, 0);
}
closesocket(sock_client);/*关闭连接*/
client_list_cnt_dec();
memset(client_item_ptr, 0, sizeof(_client_item));
set_client_item(client_id, client_item_ptr);
}
DWORD WINAPI serve_client_thread_func(LPVOID param_ptr)
{
char buf[MAX_TCP_PACKET_SIZE];
_client_item *client_item_ptr = (_client_item *)param_ptr;
SOCKET sock_client = 0;
sockaddr_in sockaddr_client = {0};
unsigned int client_id = 0;
_client_list *client_list_ptr = get_client_list();
int recv_size = 0;
time_t sock_free_cur_time = 0;
time_t sock_free_kill_time = 0;
int n_ret = 0;
fd_set fdread;
timeval tv;
while( NULL == client_item_ptr->hThread );
sock_client = client_item_ptr->client;
sockaddr_client = client_item_ptr->form;
client_id = client_item_ptr->id;
sprintf(buf, "%s:%d you id=%d\n", inet_ntoa(sockaddr_client.sin_addr),
sockaddr_client.sin_port, client_id);
send(sock_client, buf, strlen(buf) + 1, 0);
do
{
/*这部分代码在此处必须每次都执行*/
FD_ZERO(&fdread);//初始化fd_set
FD_SET(sock_client, &fdread);//分配套接字句柄到相应的fd_set
tv.tv_sec = 1;//这里我们打算让select等待1s后返回，避免被锁死，也避免马上返回
tv.tv_usec = 0;
/*end 这部分代码在此处必须每次都执行*/
select(0, &fdread, NULL, NULL, &tv);
n_ret = FD_ISSET(sock_client, &fdread);
if( 0 == n_ret )/*没有数据*/
{
continue;
}
recv_size = recv(sock_client, buf, sizeof(buf), 0);
if( recv_size <= 0)
{/*socket 错误，断开连接并退出*/
/*超时，线程退出*/
printf("client time out ip=%s:port=%d:id=%d\n",
inet_ntoa(sockaddr_client.sin_addr), sockaddr_client.sin_port, client_id);
EnterCriticalSection(&cs_serve_thread);/*进入临界区*/
memset(buf, 0, sizeof(buf));
serve_client_thread_clear(sock_client, &sockaddr_client, client_id, buf, client_item_ptr);
LeaveCriticalSection(&cs_serve_thread);/*离开临界区*/
ExitThread(0);/*退出线程*/
}
sock_free_cur_time = 0;
if( ('q' == buf[0]) && (0 == buf[1]) )
{/*客户端主动退出*/
sprintf(buf, "client exit server ip=%s:port=%d:id=%d\n",
inet_ntoa(sockaddr_client.sin_addr), sockaddr_client.sin_port, client_id);
EnterCriticalSection(&cs_serve_thread);/*进入临界区*/
serve_client_thread_clear(sock_client, &sockaddr_client, client_id, buf, client_item_ptr);
LeaveCriticalSection(&cs_serve_thread);/*离开临界区*/
ExitThread(0);/*退出线程*/
}
printf("ip=%s:port=%d:id=%d say:%s\n", inet_ntoa(sockaddr_client.sin_addr),
sockaddr_client.sin_port, client_id, buf);
}while( TRUE );
return 0;
}

2、客户端代码
头文件:client.h

#include <winsock2.h>
#include <stdio.h>
#include <windef.h>
#ifndef TCP_CLIENT_H
#define TCP_CLIENT_H
#pragma warning(disable : 4996)
#define TCP_SERVER_ADDR "192.168.0.2"
#define TCP_SERVER_PORT (60000)
#define MAX_TCP_PACKET_SIZE (1492)/*tcp最大数据包字节数*/
#endif/*end TCP_CLIENT_H*/

源文件:client.cpp

#include "client.h"
int main()
{
int nRet = 0;
WORD wVersionRequested;//版本号
WSADATA wsaData;
SOCKET sock;
SOCKADDR_IN server_addr;
char buf[MAX_TCP_PACKET_SIZE];
int recv_size = 0;
wVersionRequested = MAKEWORD(1, 1);//1.1版本的套接字
nRet = WSAStartup(wVersionRequested, &wsaData);
if( nRet )
{
return nRet;
}
if (LOBYTE(wsaData.wVersion) != 1 ||
HIBYTE(wsaData.wVersion) != 1)
{
return -1;
}//判断高低字节是不是1,如果不是1.1的版本则退出
sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if( INVALID_SOCKET == sock )
{
return -1;
}
server_addr.sin_addr.S_un.S_addr = inet_addr(TCP_SERVER_ADDR);
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(TCP_SERVER_PORT);
nRet = connect(sock, (SOCKADDR*)&server_addr, sizeof(SOCKADDR) );
if( 0 != nRet )
{
return nRet;
}
recv(sock, buf, sizeof(buf), 0);
printf(buf);
do
{
memset(buf, 0, sizeof(buf));
printf("please write some thing:");
gets(buf);
send(sock, buf, strlen(buf) + 1, 0);
if( ('q'== buf[0]) && (0 == buf[1]) )
{
recv_size = recv(sock, buf, sizeof(buf), 0);
printf(buf);
break;
}
}while( TRUE );
closesocket(sock);
WSACleanup();//必须调用这个函数清除参数
return 0;
}

阅读(378) | 评论(0) | 转发(0) |

上一篇：BMP之一：bmp格式解析很容易理解

下一篇：构建基本的嵌入式Linux根文件系统