简介
WinSock (Windows Sockets) API是微软操作系统的socket可编程库,起先是基于Berkeley sockets的.后来引入了微软自己的特点. 在这边文章中我将通过Winsock试着向您介绍socket编程，并假定你从未在任何系统上进行过任何形式的网络编程。
如果您手头只有一台计算机，请您不要担心。您任然可以进行Winsock编程。您可以使用127.0.0.1的本地回路地址，即localhost地址。因此如果您有一个TCP服务器运行在您的计算机上，在同一台机器上一个客户端程序可以通过本地回路地址连接到您的服务器端。
简单的TCP服务器
在本文中我通过一个简单的TCP服务器向你介绍Winsock，我将按部就班向您一一介绍。但在此之前，有些事情您必须先做，以开始我们的Winsock编程之前的实实在在的必备工作。
1.首先使用VC++6.0工程向导创建一个Win32控制台程序。
2.确保设置支持MFC的选项选中。
3.将#include <winsock2.h>添加到stdafx.h头文件中。
4.将#include <conio.h>添加到stdafx.h头文件中。
5.将ws2_32.lib添加到工程链接选项中。
主函数
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
{
int nRetCode = 0;
cout << "Press ESCAPE to terminate program\r\n";
AfxBeginThread(ServerThread,0);
while(_getch()!=27);
return nRetCode;
}
在main()中我们首先启动一个线程然后循环执行_getch()。_getch()将等待直到某个按键按下并返回读取字符的ASCII值时结束等待。循环直到返回值为27时结束，27是ESCAPE的ASCII码。您可能担心我们即时按下了ESCAPE键，开启的线程仍将处于激活状态。这个您大可放心。因为当main()返回时我们的进程将终止，由我们的进程创建的线程也将陡然终止。
cout << "Press ESCAPE to terminate program\r\n";
AfxBeginThread(ServerThread,0);
while(_getch()!=27);
return nRetCode;
}
在main()中我们首先启动一个线程然后循环执行_getch()。_getch()将等待直到某个按键按下并返回读取字符的ASCII值时结束等待。循环直到返回值为27时结束，27是ESCAPE的ASCII码。您可能担心我们即时按下了ESCAPE键，开启的线程仍将处于激活状态。这个您大可放心。因为当main()返回时我们的进程将终止，由我们的进程创建的线程也将陡然终止。
return nRetCode;
}
在main()中我们首先启动一个线程然后循环执行_getch()。_getch()将等待直到某个按键按下并返回读取字符的ASCII值时结束等待。循环直到返回值为27时结束，27是ESCAPE的ASCII码。您可能担心我们即时按下了ESCAPE键，开启的线程仍将处于激活状态。这个您大可放心。因为当main()返回时我们的进程将终止，由我们的进程创建的线程也将陡然终止。
ServerThread函数
现在我们将列出ServerThread 函数并使用代码注释解释每个关联的代码航。这就是我们的TCP服务端的基本功能。它在端口20248监听。当有一个客户端连接时，服务端将向客户端发送包含自身IP地址的消息到客户端并关闭次连接同时在端口20248等待下一个连接。同时将在控制台窗口打印消息，指示服务器IP地址和客户端连接的ip地址。
{
cout << "Starting up TCP server\r\n";
//SOCKET的实际类型是unsigned int.
//在Unix中, socket句柄跟文件句柄一样也是unsigned int
//在windows中socket句柄跟文件句柄不完全一样所以定义新的
//SOCKET类型来处理.
SOCKET server;
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//SOCKET的实际类型是unsigned int.
//在Unix中, socket句柄跟文件句柄一样也是unsigned int
//在windows中socket句柄跟文件句柄不完全一样所以定义新的
//SOCKET类型来处理.
SOCKET server;
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
return 0;
}
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//SOCKET的实际类型是unsigned int.
//在Unix中, socket句柄跟文件句柄一样也是unsigned int
//在windows中socket句柄跟文件句柄不完全一样所以定义新的
//SOCKET类型来处理.
SOCKET server;
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
return 0;
}
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//SOCKET的实际类型是unsigned int.
//在Unix中, socket句柄跟文件句柄一样也是unsigned int
//在windows中socket句柄跟文件句柄不完全一样所以定义新的
//SOCKET类型来处理.
SOCKET server;
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
return 0;
}
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//SOCKET的实际类型是unsigned int.
//在Unix中, socket句柄跟文件句柄一样也是unsigned int
//在windows中socket句柄跟文件句柄不完全一样所以定义新的
//SOCKET类型来处理.
SOCKET server;
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
return 0;
}
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//SOCKET的实际类型是unsigned int.
//在Unix中, socket句柄跟文件句柄一样也是unsigned int
//在windows中socket句柄跟文件句柄不完全一样所以定义新的
//SOCKET类型来处理.
SOCKET server;
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
return 0;
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//SOCKET的实际类型是unsigned int.
//在Unix中, socket句柄跟文件句柄一样也是unsigned int
//在windows中socket句柄跟文件句柄不完全一样所以定义新的
//SOCKET类型来处理.
SOCKET server;
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
return 0;
}
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//SOCKET的实际类型是unsigned int.
//在Unix中, socket句柄跟文件句柄一样也是unsigned int
//在windows中socket句柄跟文件句柄不完全一样所以定义新的
//SOCKET类型来处理.
SOCKET server;
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
return 0;
}
return 0;
}
//SOCKET的实际类型是unsigned int.
//在Unix中, socket句柄跟文件句柄一样也是unsigned int
//SOCKET类型来处理.
SOCKET server;
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSADATA是个结构体，在WSAStartup中被填充
WSADATA wsaData;
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//sockaddr_in 指定TCP/IP sockets的socket地址.
//这个适用于其他的协议.
sockaddr_in local;
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup为调用WinSock准备初始化的工作.
//第一个参数指定编程使用的WinSock规范的最高版本号
int wsaret=WSAStartup(0x101,&wsaData);
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//WSAStartup成功返回0.
//失败则程序退出.
if(wsaret!=0)
{
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//现在我们填充sockaddr_in结构体
local.sin_family=AF_INET; //地址族
local.sin_addr.s_addr=INADDR_ANY; //IP地址通配符
local.sin_port=htons((u_short)20248); //使用的端口号
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//创建SOCKET
server=socket(AF_INET,SOCK_STREAM,0);
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//socket()函数调用失败则程序退出
if(server==INVALID_SOCKET)
{
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//bind关联socket到sockaddr_in结构指定的ip地址和端口号
//返回非0表示成功
if(bind(server,(sockaddr*)&local,sizeof(local))!=0)
{
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//listen指示socket监听即将到来的socket连接
//backlog表示最大的连接数
if(listen(server,10)!=0)
{
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们需要一个变量保存客户端的socket.
SOCKET client;
sockaddr_in from;
int fromlen=sizeof(from);
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
while(true)//一直循环
{
char temp[512];
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//accept()将接收一个客户端连接
client=accept(server,
(struct sockaddr*)&from,&fromlen);
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
sprintf(temp,"Your IP is %s\r\n",inet_ntoa(from.sin_addr));
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//我们只是简单地返回一些字符串到客户端
send(client,temp,strlen(temp),0);
cout << "Connection from " << inet_ntoa(from.sin_addr) <<"\r\n";
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//关闭客户端socket
closesocket(client);
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//closesocket()关闭服务器socket并释放socket描述符
closesocket(server);
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
//确保进程不再使用WS2_32.DLL
WSACleanup();
return 0;
}
return 0;
}
UINT ServerThread(LPVOID pParam)
测试方法
启动服务器，用telnet连接到本机端口20248。
结语
到此,通过本文您知道了如何创建一个简单的Winsock TCP服务器.如需进一步掌握Winsock，请关注我的其他文章，谢谢！
400
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
