TCP/IP网络编程读书笔记-简单的套接字编程（1）

在linux和windows下都是通过套接字编程进行网络编程。不同的系统上通信有部分差别，现在刚开始学习，给自己学习的时候一个总结。

一，socket函数的套接字步骤

第一，linux网络编程中接受连接请求（服务器端）套接字的四个步骤：

1）调用socket函数创建套接字
2）调用bind函数分配IP地址和端口号
3）调用listen函数转为可接收请求状态
4）调用accept函数受理连接请求

第二，linux网络编程中请求连接（客户端）套接字的两个步骤：

1）调用socket函数创建套接字
2）调用connect函数向服务器端发送连接请求

第三，windows网络编程中接受连接请求（服务器端）套接字的六个步骤：

1）调用WSAStartup设置程序中用到的Winsock版本
2）调用socket函数创建套接字
3）调用bind函数分配IP地址和端口号
4）调用listen函数转为可接收请求状态
5）调用accept函数受理连接请求
6）调用WSACleanup函数关闭设置

第四，windows网络编程中请求连接（客户端）套接字的三个步骤：

1）调用WSAStartup设置程序中用到的Winsock版本
2）调用socket函数创建套接字
3）调用connect函数向服务器端发送连接请求

二，文件操作

第一，linux的文件操作，（文件与套接字同用文件描述符）

1）打开文件

 int open（const char *path, int flag）
//成功返回文件描述符，失败为-1；
//path 为文件名路径
//flag 为打开模式信息

2）关闭文件

int close（int fd）
//成功时返回0，失败返回-1；
//fd 为文件描述符

3）数据写入文件

ssize_t write（int fd, const void *buf, size_t nbytes）
//成功返回字节数，失败返回-1；
//fd 为文件描述符
//buf 为传输数据缓冲地址值
//nbytes 为传输数据的字节数

4）读取文件数据

ssize_t read(int fd, const void *buf, size_t nbytes)
//成功返回字节数，失败返回-1；
//fd 为文件描述符
//buf 为接受数据缓冲地址值
//nbytes 为接受数据的字节数

第二，windows的套接字句柄操作（文件为文件句柄，套接字为套接字句柄，两个区别对待）

1）打开文件

int open（const char *path, int flag）
//成功返回文件描述符，失败为-1；
//path 为文件名路径
//flag 为打开模式信息

2)关闭文件

int close（int fd）
成功时返回0，失败返回-1；
fd 为文件描述符

3）数据传输函数

int send(SOCKET s, const char *buf, int len, ine flags)
//成功返回传输字节数，失败返回SOCKET_ERROR
//s 表示句柄I/O函数的套接字句柄值
//buf 为传输数据缓冲地址值
//len 为传输数据的字节数
//flags 为传输数据时用到的多种选项信息

4）数据接受函数

int recv(SOCKET s, const char *buf, int len, ine flags)
//成功返回接收字节数，失败返回SOCKET_ERROR
//s 表示句柄I/O函数的套接字句柄值
//buf 为接收数据缓冲地址值
//len 为接收数据的最大字节数
//flags 为接收数据时用到的多种选项信息

三，套接字类型和协议设置

第一，linux下的套接字类型和协议设置

1）创建套接字，socket函数

int socket（int domain， int type， int protocol）
//成功时返回文件句柄，失败时返回-1.
//domain 套接字中使用的协议族信息
//type 套接字数据传输类型信息
//protocol 计算机间通信使用的协议信息

（1）domain所选的协议族

名称	协议族
PF_INET	IPV4互联网协议族
PF_INET6	IPV6互联网协议族

（2）type套接字类型

Type类型	作用
SOCK_STREAM	面向连接的套接字
SOCK_DGRAM	面向消息的套接字

（3）protocol协议的最终选择

同一协议中存在多个数据类型传输方式相同的协议，就通过protocol区分最终协议，如果只有一个，默认为0

2）分配IP和端口，bind函数

int bind(int sockfd, struct sockaddr * myaddr, socklen_t addrlen)
//成功返回0，失败返回-1
//sockfd 套接字文件描述符
//myaddr 结构体变量地址值,包括IP地址和端口号
//addrlen 结构体变量的长度

地址信息的表示，sockaddr结构体

（1）网络地址与主机地址

IP地址	字节数
IPv4	4字节地址族
IPv6	16字节地址族

（2）网络地址分类

IPv4地址族	网络号与主机号字节	首字节范围	首字节开始
A类	1+3	0~127	0开头
B类	2+2	128~191	10开头
C类	3+1	192~223	110开头

（3）IPv4地址的结构体

struct sockaddr_in
{
   sa_family_t     sin_family;    //地址族
   uint16_t        sin_port;      //16位的TCP、UDP端口号
   struct in_addr  sin_addr;      //32位IP地址
   char            sin_zero[8];   //不使用
}

成员sin_family，地址族

地址族	含义
AF_INET	IPv4地址族
AF_INET6	IPv6地址族

成员sin_port，端口号的选择
端口号为网络字节序，统一为大端序，但计算机有些采用小端序，所以存在一个转换问题

字节序转换	含义
htons	把short（s）型数据从主机（h）转换为网络（n）字节序
htonl	把long（l）型数据从主机（h）转换为网络（n）字节序
ntohs	把short（s）型数据从网络（n）转换为主机（h）字节序
ntohl	把long（l）型数据从网络（n）转换为主机（h）字节序

成员sin_addr,32位IP地址（32位整数形式）
涉及到一个字符型与32位整数型的转换

struct in_addr
{
   In_addr_t       s_addr;       //32位IPv4地址
}

//IP字符返回为整数型
#include<arpa/inet.h> 
in_addr_t inet_addr(const char * string);
//成功时返回32位大端整数型值，失败时返回INADDR_ERROR。

//利用in_addr结构体，转换完的IP字符直接存入结构体中
#include<arpa/inet.h>
int inet_aton(const char* string, struct in_addr * addr)
//成功时返回1，失败为0

#include<arpa/inet.h>
char * inet_ntoa(struct in_addr adr)
//成功时返回转换的IP字符串，失败时为-1

3）连接请求状态，listen函数

include<sys/socket.h>
int listen(int sock, int backlog)
//成功时返回0，失败为-1
//sock 套接的文件描述符
//backlog 连接请求队列的长度，表示最多有几个连接请求进入队列

4）受理客户端连接请求，accep函数

#include<sys/socket.h>
int accept(int sock, struct sockaddr * addr, socket_t *addrlen)
//成功时返回创建的套接字文件描述符，失败时返回-1
//sock 服务器套接字的文件描述符
//addr 保存发起连接请求的客户端信息的地址
//addrlen 第二个参量addr的结构体长度

5) 创建连接请求队列，connect函数

int connect(int sock, struct sockaddr* servaddr, socklen_t addrlen)
//成功时返回0，失败时返回-1
//sock 客户端套接字文件描述符
//servaddr 保存目标服务器端地址信息的变量地址
//addrlen_t 地址变量长度

第二，windows下的套接字类型和协议设置

1）Winsock的初始化

#include<winsock2.h>
int WSAStartup(WORD wVersionRequested, LPWSADATA lpWSAData)
//成功时返回0，失败时返回非0的错误代码
//wVersionRequested 程序员要用的Winsock版本信息
//lpWSAData  WSADATA结构体的地址值

版本号的格式

MAKEWORD(1,2); 主版本为1，副版本为2，返回0x0201；

2）创建套接字，调用socket函数

SOCKET socket（int af， int type， int protocol）
//成功时返回套接字句柄，失败时返回INVALID_SOCKET.
//af 套接字中使用的协议族信息
//type 套接字数据传输类型信息
//protocol 计算机间通信使用的协议信息

3）分配IP和端口，调用bind函数

int bind(SOCKET s, struct sockaddr * name, int namelen)
//成功返回0，失败返回-1
//s 套接字文件描述符
//name 结构体变量地址值,包括IP地址和端口号
//namelen 结构体变量的长度

与linux上面的套接字及地址分配地址基本一致，改为变量名

windows下两个转换函数，WSAStringTOAddress&WSAAddressToString

WSAStringTOAddress将地址信息字符串适当填入结构体变量

INT WSAStringToAddress （
    LPTSTR AddressString, INT AddressFamily, 
    LPWSAPROTOCOL_INFO lpProtocolInfo,
    LPSOCKADDR lpAddress, LPINT lpAddressLength
 ）
 //成功返回0，失败返回SOCKET_ERROR
 //AddressString 含有IP和端口号的字符串，“203.211.218.102:9190”
 //AddressFamily 第一个参数中地址族的信息
 //lpProtocolInfo 设备协议提供者，默认为NULL
 //lpAddress 保存转换结果的字符串地址值
 //lpAddressLength 存有地址信息的字符串长度

WSAAddressToString将结构体中的地址转换为字符串

INT WSAAddressToString （
    LPSOCKADDR lpsaAddress， DWORD dwAddressLength，
    LPWSAPROTOCOL_INFO lpProtocolInfo,
    LPSTR lpszAddressString, LPDWORD lpdwAddressStringLength
 ）
 //成功返回0，失败返回SOCKETLength
 //lpsaAddress 转换地址结构体的地址
 //dwAddressLength 第一个参数结构体的长度
 //lpProtocolInfo 设备协议提供者，默认为NULL
 //lpszAddressString 转换结果的字符串地址
 //lpdwAddressStringLength 转换地址信号的字符串长度

4）连接请求状态，调用listen函数

int listen(int sock, int backlog)
//成功时返回0，失败为-1
//sock 套接的文件描述符
//backlog 连接请求队列的长度，表示最多有几个连接请求进入队列

5）受理客户端连接请求，调用accep函数

SOCKET accept(SOCKET s, struct sockaddr * addr, int *addrlen)
//成功时返回创建的套接字文件描述符，失败时返回-1
//s 服务器套接字的文件描述符
//addr 保存发起连接请求的客户端信息的地址
//addrlen 第二个参量addr的结构体长度

6）关闭设置，调用WSACleanup函数

int WSAClearnup(void)
//成功时返回0，失败返回SOCKET_ERROR
//归还Winsock相关库给Windows

7）创建连接请求队列，connect函数

int connect(SOCKET　s，const struct sockaddr *name, int namelen)
//成功时返回0，失败时返回SOCKET_ERROR
//s 套接字文件描述符
//name 结构体变量地址值,包括IP地址和端口号
//namelen 结构体变量的长度

四，linux下实现套接字通信

服务器端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

void error_handling(char *message);

int main(int argc, char *argv[])
{
    int serv_sock;
    int clnt_sock;

    struct sockaddr_in serv_addr;
    struct sockaddr_in clnt_addr;
    socklen_t clnt_addr_size;

    char message[]="Hello World!";

    if(argc!=2){
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    serv_sock=socket(PF_INET, SOCK_STREAM, 0);
    if(serv_sock == -1)
        error_handling("socket() error");

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family=AF_INET;
    serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
    serv_addr.sin_port=htons(atoi(argv[1]));

    if(bind(serv_sock, (struct sockaddr*) &serv_addr, sizeof(serv_addr))==-1 )
        error_handling("bind() error"); 

    if(listen(serv_sock, 5)==-1)
        error_handling("listen() error");

    clnt_addr_size=sizeof(clnt_addr);  
    clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_addr,&clnt_addr_size);
    if(clnt_sock==-1)
        error_handling("accept() error");  

    write(clnt_sock, message, sizeof(message));
    close(clnt_sock);   
    close(serv_sock);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

客户端

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>

void error_handling(char *message);

int main(int argc, char* argv[])
{
    int sock;
    struct sockaddr_in serv_addr;
    char message[30];
    int str_len;

    if(argc!=3){
        printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    sock=socket(PF_INET, SOCK_STREAM, 0);
    if(sock == -1)
        error_handling("socket() error");

    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family=AF_INET;
    serv_addr.sin_addr.s_addr=inet_addr(argv[1]);
    serv_addr.sin_port=htons(atoi(argv[2]));

    if(connect(sock, (struct sockaddr*)&serv_addr, sizeof(serv_addr))==-1) 
        error_handling("connect() error!");

    str_len=read(sock, message, sizeof(message)-1);
    if(str_len==-1)
        error_handling("read() error!");

    printf("Message from server: %s \n", message);  
    close(sock);
    return 0;
}

void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

五，windows下实现套接字通信

服务器端

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
void ErrorHandling(char* message);

int main(int argc, char* argv[])
{
    WSADATA wsaData;
    SOCKET hServSock, hClntSock;        
    SOCKADDR_IN servAddr, clntAddr;     

    int szClntAddr;
    char message[]="Hello World!";

    if(argc!=2) 
    {
        printf("Usage : %s <port>\n", argv[0]);
        exit(1);
    }

    if(WSAStartup(MAKEWORD(2, 2), &wsaData)!=0)
        ErrorHandling("WSAStartup() error!"); 

    hServSock=socket(PF_INET, SOCK_STREAM, 0);
    if(hServSock==INVALID_SOCKET)
        ErrorHandling("socket() error");

    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family=AF_INET;
    servAddr.sin_addr.s_addr=htonl(INADDR_ANY);
    servAddr.sin_port=htons(atoi(argv[1]));

    if(bind(hServSock, (SOCKADDR*) &servAddr, sizeof(servAddr))==SOCKET_ERROR)
        ErrorHandling("bind() error");  

    if(listen(hServSock, 5)==SOCKET_ERROR)
        ErrorHandling("listen() error");

    szClntAddr=sizeof(clntAddr);        
    hClntSock=accept(hServSock, (SOCKADDR*)&clntAddr,&szClntAddr);
    if(hClntSock==INVALID_SOCKET)
        ErrorHandling("accept() error");  

    send(hClntSock, message, sizeof(message), 0);
    closesocket(hClntSock);
    closesocket(hServSock);
    WSACleanup();
    return 0;
}

void ErrorHandling(char* message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

客户端

#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>
void ErrorHandling(char* message);

int main(int argc, char* argv[])
{
    WSADATA wsaData;
    SOCKET hSocket;
    SOCKADDR_IN servAddr;

    char message[30];
    int strLen;

    if(argc!=3)
    {
        printf("Usage : %s <IP> <port>\n", argv[0]);
        exit(1);
    }

    if(WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
        ErrorHandling("WSAStartup() error!");  

    hSocket=socket(PF_INET, SOCK_STREAM, 0);
    if(hSocket==INVALID_SOCKET)
        ErrorHandling("socket() error");

    memset(&servAddr, 0, sizeof(servAddr));
    servAddr.sin_family=AF_INET;
    servAddr.sin_addr.s_addr=inet_addr(argv[1]);
    servAddr.sin_port=htons(atoi(argv[2]));

    if(connect(hSocket, (SOCKADDR*)&servAddr, sizeof(servAddr))==SOCKET_ERROR)
        ErrorHandling("connect() error!");

    strLen=recv(hSocket, message, sizeof(message)-1, 0);
    if(strLen==-1)
        ErrorHandling("read() error!");
    printf("Message from server: %s \n", message);  

    closesocket(hSocket);
    WSACleanup();
    return 0;
}

void ErrorHandling(char* message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}

第一次写读书笔记，如有问题，欢迎大家指正
作者：vanish_dust