Socket网络编程基础

首先来写点网络基础知识。

什么是地址？

在网络通信中，两个进程分别位于不同的机子上，在互联网中，两台机子不能位于不同的网络，这些网络通过网络连接设备连接（网关，网桥，路由器）。

所以，要找到正确的地址，需要进行三级寻址：

某一主机可与多个网络连接，必须指定该主机唯一的标识符。
网络上，每台主机应该有其唯一的地址。
每一台主机上的每一个进程应该有在该主机上的唯一标识符。

什么是IP地址和端口？

IP地址：用于在局域网或者互联网中区分不同主机的编号。它用点分十进制法来表示，分4段，每段8位，总长为32位长，如：192.163.0.12。IP地址指定的不是主机，而是网络接口设备。若一个主机有两个网络接口，那么就会有2个IP地址。一般情况，我们的主机都只有一个网络接口设备，所以只有一个IP地址，IP地址可以在dos窗口中用ipconfig命令查看。对于服务器来说，则会有多个网络接口设备，每个网络接口设备都会有一个IP地址。

端口（PORT）：在同一台主机里，可能会有各种不同的网络通讯软件，一个端口在同一时间内只能给某一个软件的进程使用。各种不同的软件占用了各自不同的端口之后，数据送达到这台主机后，就会自动按端口进行分理输送。在OSI七层模型中，传输层与网络层的主要区别就是传输层提供进程通信的能力。所以，网络通信最终的地址只靠主机地址是不够的，还要包括一个描述进程的标识符。基于此，TCP/IP协议提出了协议端口的概念，用这个来标识通信的进程。

TCP/UDP协议：
在传输层上，有两大协议，分别是TCP协议和UDP协议。

TCP协议是一种面向连接的，可靠的通信协议，它遵循三次握手原则，保证资源被准确送到目的地址。

UDP协议是一种无连接的传输层协议，提供面向事务的简单不可靠信息的传送。它效率高，但不能保证传送准确性，不可靠。

TCP端口和UDP端口各有65536个，一般小于1024的为保留端口，我们一般使用大于1024的端口。

常见的端口有：
TCP:
FTP 21
Telnet 23
SMTP 25
HTTP 80
POP3 110

UDP:
DNS 53
Tftp 69

大端和小端模式：
不同的计算机存放多字节值的顺序不同，分为大端模式和小端模式。

大端模式为：内存高地址存放数据低位字节数据，内存低地址存放数据高位字节数据。
小端模式为：内存高地址存放数据高位字节数据，内存低地址存放数据低位数据。

如：一个数为0x10203040，则：

大端模式存储为：10 20 30 40

小端模式存储为：40 30 20 10

要判断主机字节序，我这说两种方法：

方法一：

DWORD dwSmallNum = 0x01020304;
if(*(BYTE)&dwSmallNum == 0x04)
{
    std::cout << "小端模式" << std::endl; 
} 
else
{
    std::cout << "大端模式" << std::endl; 
}

方法二：

DWORD dwSmallNum =  0x01020304;
if(dwSmallNum == htonl(dwSmallNum))
{
    std::cout << "大端模式" << std::endl; 
} 
else
{
    std::cout << "小端模式" << std::endl; 
}

面向连接的协议：
面向连接的协议很像打电话，两台计算机在第一次进行数据收发之前，需要先在两者之间建立一个通信通道，这样便可确保两台计算机在一条路径上可以互相沟通，其本质上，连接为一个管道，它收发数据不但顺序一致，而且内容完全相同。我们在打电话时，需要拨打号码，别人接听后，便可沟通，沟通完毕，便可挂断电话。

面向连接使用的是TCP协议，服务端与客户端需要的Winsock函数如下：

服务端：

socket() --> bind() --> listen() --> accept() -->send()/recv() --> closesocket()

客户端：

socket --> connect() --> send()/recv() -->closesocket()

非面向连接的协议：

这种方式下，要发送数据，只需直接将要发送的数据传出即可，无需管是否送到。客户端在收到后，也不会有任何回应。怎么样，是不是感觉有点像寄信呢？

非面向连接的协议使用的是UDP协议，服务端与客户端的winsock函数如下：

服务端：

socket() --> bind() --> sendto() / recvfrom() --> closesocket()

客户端：

socket() --> sendto() / recvfrom() --> closesocket()

什么是套接字？

计算机本身是不能互相通讯的，而是计算机软件之间，在同一主机或不同主机之间进行通讯，数据之间的传输是在软件之间进行的。套接字，通俗地讲，它类似于文件指针，是一种用于软件之间数据收发的句柄。

一、Winsocket库的初始化：

int WSAStartup (
    WORD wVersionRequested,
    LPWSADATA lpWSAData
);

要使用Winsock的相关函数，我们先要对Winsock进行初始化，在使用完后，还要进行释放。

wVersionRequested：这个参数表示winsock库的版本号，一般为2.2。
lpWSAData：这是一个指向WSADATA的指针，返回0为成功。

释放函数：

int  WSACleanup (void);

二、套接字的创建与关闭：

SOCKET socket (
    int af,
    int type,
    int protocol
);

创建一个套接字，也就是创建一个网络通讯句柄的意思。socket只是返回你以后在系统调用中可能用到的socket描述符，错误时返回-1。使用WSAGetLastError()可以查看错误原因。

af:这个参数用来表示地址族，在window下可用的有AF_INET和PF_INET,这两个宏在winsock2.h下的定义是相同的。

image

AF表示地址族，PF表示协议族。对于windows来说，它们没有区别。而在unix/linux中，它们是不相同的。一般我们在调用socket函数时应该使用PF_INET,在设置地址时使用AF_INET。

type：这个参数用于告诉内核使用哪种套接字描述符的类型。通常有3个值：
SOCK_STREAM 流套接字
SOCK_DGRAM 数据包套接字
SOCK_RAW 原始协议接口

protocol：这个参数用来指定应用程序所使用的通信协议。也有3个值:

IPPROTO_TCP
IPPROTO_UDP
IPPROTO_ICMP

这三个值和第二个参数上的三个值是相对应的。第二个参数使用SOCK_STREAM，则第三个参数为IPPROTO_TCP。第二个参数使用SOCK_DGRAM，则第三个参数为IPPROTO_UDP。（注：前面两种情况下，第三个参数可以默认为0）

第二个参数使用SOCK_ICMP，则第三个参数为IPPROTO_ICMP。

三、地址和信息的绑定

int bind ( 
    SOCKET s, 
    const struct sockaddr FAR* name, 
    int namelen
);

这个函数用来完成套接字与地址端口信息的绑定。就像我们购买了一部手机，要打电话，我们首先应该插上我们的手机卡。

s：第一个参数是新创建的套接字描述符，就是刚才用socket创建的那个。
name：这是一个sockaddr结构体，提供套接字一个地址和端口信息。
namelen：name的大小

struct sockaddr {
    u_short  sa_family; 
    char sa_data[14]; 
};

这个结构共有16个字节，在它之前还要使用一个结构体，定义如下：

struct sockaddr_in{ 
    short sin_family; 
    unsigned short  sin_port; 
    struct in_addr sin_addr; 
    char sin_zero[8];
};

这个结构是为了保持各个特定协议之间的兼容性。向bind()指定地址和端口时，向sockaddr_in中填充相应的内容；调用函数时使用sockaddr。

在sockaddr_in中，还有一个结构体in_addr：

struct in_addr {
    union {
            struct { u_char s_b1,s_b2,s_b3,s_b4; } S_un_b;
            struct { u_short s_w1,s_w2; } S_un_w;
            u_long S_addr;
    } S_un;

它是一个union S_un，包括一个u_long和两个结构体。IP地址一般是用点分十进制表示的，而in_addr结构体却未提供用来保存IP地址的数据类型，所以需要一个转换函数，把点分表示的ip地址转换为in_addr可以接受的类型。

unsigned long inet_addr (
    const char FAR * cp  
);

使用这个函数可以把点分十进制的ip地址转换为一个unsigned long类型。

char FAR * inet_ntoa (
  struct in_addr in  
);

使用这个函数把unsigned long类型的数据转换为点分十进制表示。

四、监听

int listen (
  SOCKET s,    // 指定要监听的套接字
  int backlog   // 允许进入请求的最大连接数
);

backlog表示允许进入请求的最大连接数，在winsock中一般由此宏表示：

image

五、接受连接请求

SOCKET accept (
  SOCKET s,                   // 要监听的套接字描述符
  struct sockaddr FAR* addr,  // 指向sockaddr的指针，返回客户端的地址信息
  int FAR* addrlen            // 指向int，传入sockaddr的大小
);

这个函数用于从连接请求的队列中获取连接信息。

六、连接

int connect (
    SOCKET s,  // 套接字描述符                        
    const struct sockaddr FAR*  name,  // 一个指向sockaddr的指针，其中保存了服务端的IP地址和端口号 
    int namelen  // 指定sockaddr的长度                   
);

接受请求了，就可以进行连接了。

七、通信

一切就绪，现在便可以进行通信了。

int send (
    SOCKET s,              // accept()返回的套接字描述符          
    const char FAR * buf,  // 发送消息的缓冲区 
    int len,               // buf的长度          
    int flags              // 通常为0          
);

这个用于发送消息。

int recv (
    SOCKET s,       
    char FAR* buf,  
    int len,        
    int flags       
);

这个用于接收消息，其参数和send()使用方法是一样的。

下面这是UDP的，在UDP中，不需要listen()和accept()，客户端也不需要connect()，通信函数变为这样：

int sendto (
    SOCKET s,  // 套接字描述符                        
    const char FAR * buf,  // 发送数据的缓冲区         
    int len,  // buf的长度                    
    int flags,  // 0                   
    const struct sockaddr FAR * to,  // 这是一个指向sockaddr结构体的指针，给出了接收消息的地址信息
    int tolen  // to的长度                  
);

int recvfrom (  
    SOCKET s,                     
    char FAR* buf,              
    int len,                      
    int flags,                  
    struct sockaddr FAR* from,    
    int FAR* fromlen            
);

用法和sendto相同。

现在就来写一个简单的TCP通信：

服务端：

// SocketServer.h
#include 
#include 
#include 
#pragma comment(lib, "ws2_32")

class SocketServer
{
public:                                  
    SocketServer();                      // 初始化，创建，分配
    ~SocketServer();                     // 释放
    void Listen();                       // 监听
    void Accept();                       // 接受
    void SendMsg(const char* message);   //发送
    void RecvMsg();                      //接收

private:
    void PrintError(const char* err) const;

private:
    WSADATA m_wWsaData;
    SOCKET m_hServSock, m_hClntSock;
    SOCKADDR_IN m_sServAddr, m_sClntAddr;
    int m_iClntAddr;
    char m_sMessage[MAXBYTE];
};

// SocketServer.cpp
#include "SocketServer.h"
#pragma warning(disable:4996)

SocketServer::SocketServer()
{
    //初始化套接字
    if (WSAStartup(MAKEWORD(2, 2), &m_wWsaData) != 0)
    {
        PrintError("WSAStartup()");
    }

    //创建套接字
    m_hServSock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (INVALID_SOCKET == m_hServSock)
    {
        PrintError("socket()");
    }

    //填充sockaddr_in结构体
    memset(&m_sServAddr, 0, sizeof(m_sServAddr));
    m_sServAddr.sin_family = AF_INET;
    m_sServAddr.sin_addr.s_addr = htonl(INADDR_ANY);
    m_sServAddr.sin_port = htons(8888);

    //分配IP地址和端口号
    if (bind(m_hServSock, (SOCKADDR*)&m_sServAddr, sizeof(m_sServAddr)) == SOCKET_ERROR)
    {
        PrintError("bind()");
    }
}

SocketServer::~SocketServer()
{
    closesocket(m_hServSock);
    closesocket(m_hClntSock);
    WSACleanup();  //终止前注销初始化的套接字库
}

void SocketServer::Listen()
{
    //端口监听
    if (listen(m_hServSock, SOMAXCONN) == SOCKET_ERROR)
    {
        PrintError("listen()");
    }
}

void SocketServer::Accept()
{
    m_iClntAddr = sizeof(m_sClntAddr);

    //受理连接请求
    m_hClntSock = accept(m_hServSock, (struct sockaddr*)&m_sClntAddr, &m_iClntAddr);
    if (SOCKET_ERROR == m_hClntSock)
    {
        PrintError("accept()");
    }

    //输出客户端的IP地址和端口号
    std::cout << "ClientIp：" << inet_ntoa(m_sClntAddr.sin_addr)
        << " Port：" << ntohs(m_sClntAddr.sin_port) << std::endl;
}

void SocketServer::SendMsg(const char* message)
{
    strcpy(m_sMessage, message);

    //向连接的用户传输数据
    send(m_hClntSock, m_sMessage, sizeof(m_sMessage) + sizeof(char), 0);
}

void SocketServer::RecvMsg()
{
    //接收数据
    recv(m_hClntSock, m_sMessage, sizeof(m_sMessage) + sizeof(char), 0);
    std::cout << "Message from client:" << m_sMessage << std::endl;
}

void SocketServer::PrintError(const char* err) const
{
    std::cerr << err << " error!" << std::endl;
    std::cin.get();
    exit(1);  //退出
}

使用：

#include 
#include "SocketServer.h"

int main()
{
    char msg[] = "Hello Client";
    SocketServer sockServ;
    sockServ.Listen();
    sockServ.Accept();
    sockServ.SendMsg(msg);
    sockServ.RecvMsg();

    return 0;
}

客户端：

// SocketClnt.h
#include 
#include 
#pragma comment(lib, "ws2_32")

class SocketClnt
{
public:
    SocketClnt();
    ~SocketClnt();
    void Connect();
    void SendMsg(const char *message);
    void RecvMsg();

private:
    void PrintError(const char *err) const;

private:
    WSADATA m_wWsaData;
    SOCKET m_hSocket;
    SOCKADDR_IN m_sServAddr;
    char m_sMessage[MAXBYTE];
};

// SocketClnt.cpp
#include "SocketClnt.h"
#pragma warning(disable:4996)

SocketClnt::SocketClnt()
{
    //初始化套接字
    if (WSAStartup(MAKEWORD(2, 2), &m_wWsaData) != 0)
    {
        PrintError("WSAStartup()");
    }

    //创建套接字
    m_hSocket = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (INVALID_SOCKET == m_hSocket)
    {
        PrintError("socket()");
    }

    memset(&m_sServAddr, 0, sizeof(m_sServAddr));
    m_sServAddr.sin_family = AF_INET;
    m_sServAddr.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
    m_sServAddr.sin_port = htons(8888);
}

SocketClnt::~SocketClnt()
{
    closesocket(m_hSocket);
    WSACleanup();
}

void SocketClnt::Connect()
{
    //通过套接字向服务端发出链接请求
    if (connect(m_hSocket, (sockaddr*)&m_sServAddr, sizeof(m_sServAddr)))
    {
        PrintError("connect()");
    }
}

void SocketClnt::SendMsg(const char *message)
{
    strcpy(m_sMessage, message);

    //发送数据到服务端
    send(m_hSocket, m_sMessage, sizeof(m_sMessage) + sizeof(char), 0);
}

void SocketClnt::RecvMsg()
{
    //接受服务端发来的数据
    recv(m_hSocket, m_sMessage, sizeof(m_sMessage) + sizeof(char), 0);
    std::cout << "Message from server:" << m_sMessage << std::endl;
}

void SocketClnt::PrintError(const char* err) const
{
    std::cerr << err << " error!" << std::endl;
    std::cin.get();
    exit(1);
}

使用：

#include 
#include "SocketClnt.h"

int main()
{
    char msg[] = "Hello Server";
    SocketClnt sockClnt;
    sockClnt.Connect();
    sockClnt.RecvMsg();
    sockClnt.SendMsg(msg);

    return 0;
}

运行如下：

image

Socket网络编程基础

你可能感兴趣的:(Socket网络编程基础)