基于SOCKET实现即时通讯聊天.doc

/*****************************************************************
*
* Description:
* TCP协议传输测试，客户端
*
* Usage:
* sender [-p:int] [-r:IP] [-n:x] [-b:x] [-t:x]
* -p:int 服务器监听端口
* -r:IP 服务器IP
* -n:x 发送包的次数
* -b:x 发送包的大小
* -t:x 发送间隔
* c1-2015/12/26
*****************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#pragma comment(lib, "wsock32.lib")

#define DEFAULT_PORT 8888 //默认端口号
#define DEFAULT_COUNT 25 //默认发送次数
#define DEFAULT_CHAR 'a' //默认填充字符
#define DEFAULT_BUFFER_LENGTH 8192 //默认包大小是8K
#define DEFAULT_INTERVAL 1000 //默认间隔时间是1秒
#define DEFAULT_PER_COUNT 1 //默认每一次发送的包个个数

BOOL bConnect = FALSE; // 先连接服务器标志
int iPort = DEFAULT_PORT;
int itime = DEFAULT_INTERVAL;
char cChar = DEFAULT_CHAR;
int dwCount = DEFAULT_COUNT;
int dwLength = DEFAULT_BUFFER_LENGTH;
int dwPcount = DEFAULT_PER_COUNT;
char szRecipient[128]; // 服务器地址

/*********************************************
* Function: usage
* Description:
* 打印帮助信息并退出
********************************************/
void tip(char *name)
{
printf("usage: %s [-p:int] [-r:IP] [-n:x] [-b:x] [-d:c] [-m:x]\n\n", name);
printf(" -p:int 服务器监听端口, 缺省为%d\n", DEFAULT_PORT);
printf(" -r:IP 服务器IP\n");
printf(" -n:x 发送数据次数, 缺省为%d次\n", DEFAULT_COUNT);
printf(" -b:x 发送包的大小，缺省为%d字节\n",DEFAULT_BUFFER_LENGTH);
printf(" -t:x 发送间隔时间，缺省为%d秒\n",DEFAULT_INTERVAL);
printf(" -m:x 每次发送包的个数，缺省值为%d个\n",DEFAULT_PER_COUNT);
ExitProcess(1);
}

/*********************************************
* Function: ValidateArgs
* Description:
* 命令行解析
********************************************/

void ValidateArgs(int argc, char **argv)
{
int i;
if (argc < 2)
tip(argv[0]);
for (i = 1; i < argc; i++)
{
if (strlen(argv[i]) <= 3 || strchr("-/", *argv[i]) == NULL)
{
continue;
}
switch (tolower(argv[i][1]))
{
case 'p':
if (strlen(argv[i]) > 3)
iPort = atoi(&argv[i][3]);
break;

case 'r':
if (strlen(argv[i]) > 3)
strcpy(szRecipient, &argv[i][3]);
break;

case 'n':
if (strlen(argv[i]) > 3)
dwCount = atol(&argv[i][3]);
break;

case 'b':

if (strlen(argv[i]) > 3)
dwLength = atol(&argv[i][3]);
break;
case 't':
if (strlen(argv[i]) > 3)
itime = atol(&argv[i][3]);
break;
case 'm':
if(strlen(argv[i])>3)
dwPcount=atol(&argv[i][3]);
break;
default:
tip(argv[0]);
break;
}
}
}

int main(int argc, char **argv)
{
WSADATA wsd;
SOCKET s;
char *sendbuf=NULL;
int ret;
int i,j;

SOCKADDR_IN serverIP;

ValidateArgs(argc, argv);

if (WSAStartup(MAKEWORD(2, 2), &wsd) !=NO_ERROR)
{
printf("WSAStartup() failed!\n");
return 1;
}

//TCP客户端启动
s = socket(AF_INET, SOCK_STREAM, 0);
if (s == INVALID_SOCKET) {
printf("socket() failed: %d\n", WSAGetLastError());
return 1;
}

// 服务器地址设置
serverIP.sin_family = AF_INET;
serverIP.sin_port = htons((short)iPort);
serverIP.sin_addr.s_addr = inet_addr(szRecipient);
if (serverIP.sin_addr.s_addr== INADDR_NONE)
{
struct hostent *host = NULL;

host = gethostbyname(szRecipient);
if (host)
CopyMemory(&serverIP.sin_addr, host->h_addr_list[0],
host->h_length);
else
{
printf("gethostbyname() failed: %d\n", WSAGetLastError());
WSACleanup();
return 1;
}
}

printf("服务器监听端口：%d\t发送包的次数: %d\n",iPort, dwCount);
printf("发送包的大小：%d\t包的时间间隔：%d\n",dwLength, itime);
printf("每次发送包的个数:%d\n",dwPcount);

//设置发送缓冲区
sendbuf =(char *) GlobalAlloc(GMEM_FIXED, dwLength);
if (!sendbuf)
{
printf("GlobalAlloc() failed: %d\n", GetLastError());
return 1;
}
sendbuf[dwLength-1] = '\0';
memset(sendbuf, cChar, (dwLength-1));

//连接服务器
//依照指定次数和发送间隔发送数据包
for (i = 0; i<dwCount-(i*dwPcount); i++)
{
for(j=0;j<dwPcount;j++)
{
s = socket(AF_INET, SOCK_STREAM, 0);
if (connect(s, (SOCKADDR *)&serverIP, sizeof(serverIP)) ==SOCKET_ERROR)
{
printf("connect() failed: %d\n", WSAGetLastError());
closesocket(s);
WSACleanup();
return 1;
}
ret = send(s, sendbuf, dwLength, 0);
if (ret == SOCKET_ERROR)
{
printf("send() failed: %d\n", WSAGetLastError());
break;
}
else if ( ret == 0)
break;
closesocket(s);
}
Sleep(itime);
}

closesocket(s);
GlobalFree(sendbuf);
WSACleanup();
return 0;
}

/**************************
c1-2015.12.26
**************************/
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
#pragma comment(lib, "wsock32.lib")

#define DEFAULT_PORT 8888
#define DEFAULT_LISTEN_QUEUE 1000
#define MAX_BUF_LENGTH 10240

int main(void)
{
WSADATA wsd;
SOCKET servListen, servAccept;
char *recvBuf = NULL;
int ret;
int dwTcpClientSize;
SOCKADDR_IN tcpClienter, local;

//初始化socket环境
if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
{
printf("WSAStartup() failed!\n");
return 1;
}

//TCP服务器启动设置
servListen = socket(AF_INET, SOCK_STREAM, 0);
if (servListen == INVALID_SOCKET)
{
printf("socket() failed: %d\n", WSAGetLastError());
return 1;
}

memset(&local, 0, sizeof(local));

local.sin_family = AF_INET;
local.sin_addr.s_addr = htonl(INADDR_ANY);
local.sin_port = htons(DEFAULT_PORT);

//绑定本地地址
if (bind(servListen, (SOCKADDR *)&local, sizeof(local)) == SOCKET_ERROR)
{
printf("bind() failed: %d\n", WSAGetLastError());
return 1;
}

//设置监听队列长度
if (listen(servListen, DEFAULT_LISTEN_QUEUE) == -1)
{
printf("listen() failed: %d\n", WSAGetLastError());
return 1;
}

//设置接收缓冲区
recvBuf =(char *) GlobalAlloc(GMEM_FIXED, MAX_BUF_LENGTH);
if (!recvBuf)
{
printf("GlobalAlloc() failed: %d\n", GetLastError());
return 1;
}
memset(recvBuf,0, sizeof(MAX_BUF_LENGTH));

printf("等待连接......\n");
dwTcpClientSize = sizeof(tcpClienter);
while(1)
{

servAccept = accept(servListen, (struct sockaddr *)&tcpClienter,
&dwTcpClientSize);
if ( servAccept == INVALID_SOCKET)
{
printf("accept() failed: %d\n", WSAGetLastError());
break;
}

ret = recv(servAccept, recvBuf, sizeof(recvBuf), 0);
if (ret < 0)
{
printf("recv() failed: %d\n", WSAGetLastError());
break;
}
ret=ret*2*1024;

printf("\n------------------------------------------------\n");
printf("from %s recived %d bytes\n",inet_ntoa(tcpClienter.sin_addr),ret);
printf("------------------------------------------------\n");

closesocket(servAccept);
GlobalFree(recvBuf);
}
closesocket(servListen);
GlobalFree(recvBuf);
WSACleanup();

return 0;}
7