基于TCP的简单socket通信

前两天开始翻看UNIX网络编程，看到了一个基于TCP的socket通信实例（客户端向服务器请求当前时间），于是自己在vs上实现了下，以加深对socket通信流程的了解，代码如下：

客户端

#include <windows.h>
#include <iostream>
#include <cassert>
#include <io.h>
#include "../../Server/Server/SocketUtil.h"

#pragma comment(lib, "Ws2_32.lib")

const int ServerPort = 2013;
const char* pServerIP = "127.0.0.1";

int main()
{
//初始化winsock
WSAData wsaData;
memset(&wsaData, NULL, sizeof(WSAData));
if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
{
RecordError("init winsock failed");
return 0;
}

SocketHolder sholder;
//创建socket
int sockFd = 0;
if ((sockFd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
RecordError("socket create error");
return 0;
}

sholder.SetSocketFd(sockFd);
//初始化socket地址
sockaddr_in servAddr;
//sockaddr_in最后8个字节用于占位，为了与sockaddr大小一致
memset(&servAddr, NULL, sizeof(sockaddr_in));
servAddr.sin_family = AF_INET;
/*
* htons将host字节序排列的数转化为network字节序排列的short类型(端口号是16位的)
* ServerPort=13,在本地按主机字节序存储为(按16位)0000 0000 0000 1101，
* 转化为网络字节序为0000 1101 0000 0000,为3328
*/
servAddr.sin_port = htons(ServerPort);
assert(pServerIP);
/*
* inet_pton将标准文本形式的IP地址转化为数字二进制形式
* server ip为127.0.0.1
* s_addr=1<<24 + 127=16777343，IP地址为32位
*/
servAddr.sin_addr.s_addr = inet_addr(pServerIP);

//请求连接服务器
std::cout<<"start connect ..."<<std::endl;
if (connect(sockFd, (sockaddr*)(&servAddr), sizeof(servAddr)) < 0)
{
//10061:服务器拒绝连接 10060:连接超时
RecordError("connect failed");
return 0;
}

std::cout<<"host sockfd = "<<sockFd<<std::endl;
PrintClientConnectInfo(servAddr);
std::cout<<std::endl;
std::cout<<"connect successed"<<std::endl;
int nCount = 0;
char buf[MAX_PATH] = {0};
while ((nCount = recv(sockFd, buf, sizeof(buf), 0)) > 0)
{
std::cout<<buf;
memset(buf, NULL, sizeof(buf));
}
return 0;
}

服务器端

#include <Windows.h>
#include <ctime>
#include <iostream>
#include <io.h>
#include "SocketUtil.h"

#pragma comment(lib, "Ws2_32.lib")
const int ServerPort = 2013;

int main ()
{
WSAData wsaData;
memset(&wsaData, NULL, sizeof(WSAData));
if (WSAStartup(MAKEWORD(2,2), &wsaData) != 0)
{
RecordError("init winsock failed");
return 0;
}

SocketHolder sholder;

int nListeningSocket = socket(AF_INET, SOCK_STREAM, 0);
if (nListeningSocket < 0)
{
RecordError("listening socket create error");
return 0;
}

sholder.SetSocketFd(nListeningSocket);

sockaddr_in serverAddr;
memset(&serverAddr, NULL, sizeof(sockaddr_in));
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(ServerPort);
serverAddr.sin_addr.s_addr = htonl(INADDR_ANY);

int nBindResult = bind(nListeningSocket, (sockaddr*)&serverAddr, sizeof(serverAddr));
if (nBindResult != 0)
{
RecordError("server bind failed");
return 0;
}

int nListeningResult = listen(nListeningSocket, 5);
if (nListeningResult != 0)
{
RecordError("listen failed");
return 0;
}

int nConnectedSock = INVALID_SOCKET;
time_t t = 0;
char timeBuf[MAX_PATH] = {0};

std::cout<<"start server ..."<<std::endl;
while (true)
{
nConnectedSock = accept(nListeningSocket, (sockaddr*)NULL, NULL);
if (nConnectedSock == INVALID_SOCKET)
{
RecordError("accept failed");
continue;
}

sockaddr_in clientAddr;
memset(&clientAddr, NULL, sizeof(clientAddr));
int nSize = sizeof(clientAddr);
getpeername(nConnectedSock,(sockaddr *)&clientAddr,&nSize);

std::cout<<"receive a request sockfd = "<<nConnectedSock<<" ";
PrintClientConnectInfo(clientAddr);
std::cout<<std::endl;

t = time(NULL);
sprintf_s(timeBuf, sizeof(timeBuf), "%.24s\r\n", ctime(&t));
//write(nConnectedSock, timeBuf, strlen(timeBuf));
send(nConnectedSock, timeBuf, strlen(timeBuf), 0);
closesocket(nConnectedSock);
}
std::cout<<"stop server ..."<<std::endl;
return 0;
}

工具

#pragma once

void int2ipstr (const int ip, char *buf);

struct sockaddr_in;
void PrintClientConnectInfo (const sockaddr_in& clientAddr);
void RecordError(const char* pInfo);

class SocketHolder
{
public:
SocketHolder();
~SocketHolder();

void SetSocketFd(int nSockFd);

private:
int m_nSockFd;
};

#include "SocketUtil.h"
#include <Windows.h>
#include <iostream>
#include <cassert>

void int2ipstr (const int ip, char *buf)
{
sprintf_s(buf, MAX_PATH, "%u.%u.%u.%u",
(unsigned char) * ((char *) &ip + 0),
(unsigned char) * ((char *) &ip + 1),
(unsigned char) * ((char *) &ip + 2),
(unsigned char) * ((char *) &ip + 3));
}

void PrintClientConnectInfo (const sockaddr_in& clientAddr)
{
std::cout<<"port = "<<ntohs(clientAddr.sin_port)<<",";
char ip[MAX_PATH] = {0};
int2ipstr(clientAddr.sin_addr.s_addr, ip);
std::cout<<"IP ="<<" "<<ip;
}

void RecordError(const char* pInfo)
{
int errorCode = WSAGetLastError();
std::cout<<pInfo<<std::endl;
}

SocketHolder::SocketHolder()
: m_nSockFd(0)
{

}

void SocketHolder::SetSocketFd(int nSockFd)
{
assert(nSockFd);
m_nSockFd = nSockFd;
}

SocketHolder::~SocketHolder()
{
if(m_nSockFd > 0)
closesocket(m_nSockFd);
WSACleanup();
}

在windows中，客户端程序的流程是 初始化winsock库->创建socket->创建服务器地址(端口和IP)->请求连接->接收响应数据->释放资源

服务器端的流程是 初始化winsock库->创建监听socket->创建监听地址->将监听socket文件描述符与监听地址绑定->开始监听->接收请求->处理请求并响应->继续等待请求

客户端输出结果：



服务器端输出结果(客户端运行四次)：



以上的程序可以成功的在客户端输出向服务器请求到的时间，但是我对服务器端getpeername(nConnectedSock,(sockaddr *)&clientAddr,&nSize)得到的客户端机器的地址值不是很理解，我本以为服务器端监听到的socket描述符(88)应该和客户端创建的socket描述符（84） 是相等的，而且端口号也应该是相等的（2013），但每次接到的请求端口号都增加1，该问题有待解决。

补充：

通过向朋友请教并查看资料，对以上提出的两个疑问有了理解。

（1）当服务器端收到一个请求后服务器会产生一个socket句柄，他和客户端创建的是不一样的，这个新产生的句柄是用来连接客户端和服务器的；

（2）服务器收到的请求的客户机的地址中端口一直在变，是因为客户端在通信时是不用绑定端口的，内核会选择一个可用端口进行通信，所以会变。