socket编程1 tcp基本api接口与基础编程demo

本文链接：https://blog.csdn.net/weixin_41706016/article/details/120306840

TCP socket编程

学习TCP socket编程API接口，基于此入门，并编写一个TCP网络服务器与通讯客户机。
keyword: socket接口，套接字地址结构体，值-结果参数，字节序/位序，3个字节操作函数，ip地址转换函数，demo。

TCP socket API接口

#include <sys/socket.h>
int socket(int family, int type, int protocal); // 创建一个套接字，并配置
int connect(int sockfd, const struct sockaddr *servaddr, socklen_t addrlen); //
int bind(int sockfd, const struct sockaddr *myaddr, socklen_t addrlen); // 将一个
int listen(int sockfd, int backlog); //仅由TCP服务器可调用，使该套接字处于监听状态。
int accept(int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen);
//仅由TCP服务器调用，接收连接，阻塞进程。
int close(int sockfd);//进程将套接字标记为关闭，之后该进程不能再用该套接字进行read和write.
int getsockname(int sockfd, struct sockaddr *localaddr, socklen_t *addrlen);
int getpeername(int sockfd, struct sockaddr *peeraddr,  socklen_t *addrlen);
许多都不太理解。

一些数据结构

/* Structure describing a generic socket address.  */
struct sockaddr
  {
    __SOCKADDR_COMMON (sa_);	/* Common data: address family and length.  */
    char sa_data[14];		/* Address data.  */
  };
#define	__SOCKADDR_COMMON(sa_prefix) \
  sa_family_t sa_prefix##family

struct sockaddr_in {
  __kernel_sa_family_t	sin_family;	/* Address family		*/
  __be16		sin_port;	/* Port number			*/
  struct in_addr	sin_addr;	/* Internet address		*/

  /* Pad to size of `struct sockaddr'. */
  unsigned char		__pad[__SOCK_SIZE__ - sizeof(short int) -
			sizeof(unsigned short int) - sizeof(struct in_addr)];
};

解析各个函数的参数和其宏定义。

socket: int family, int type, int protocal.
    family-->协议族，可选项如下：
        AF_INET     ipv4协议
        AF_INET     ipv6协议
        AF_LOCAL    unix域协议
        AF_ROUTE    路由套接字
        AF_KEY      秘钥套接字
        others: 
    type-->套接字类型：
        SOCK_STREAM     字节流套接字
        SOCK_DGRAM      数据报套接字
        SOCK_SEQPACKET  有序分组套接字
        SOCK_RAM        原始套接字
    protocol-->套接字传输协议:
        IPPROTO_CP      TCP传输协议
        IPPROTO_UDP     UDP传输协议
        IPPROTO_SCTP    SCTP传输协议
  suc：套接字描述符sockfd; err: -1
connect: int sockfd, const struct sockaddr *servaddr, socklen_t addrlen.
    sockfd-->套接字描述符
    servaddr-->套接字地址结构的指针, 包含服务器的IP地址和端口号.
    addrlen-->servaddr的大小.
  suc: 0; err -1.
bind: int sockfd, const struct sockaddr *myaddr, socklen_t addrlen.
  suc: 0; err -1.
listen: int sockfd, int backlog.
    backlog-->规定内核应该为这个套接字排队的最大连接个数.
  suc: 0; err -1.
accept: int sockfd, struct sockaddr *cliaddr, socklen_t *addrlen.
    cliaddr-->所指的套接字地址结构指针
getsockname: int sockfd, struct sockaddr *localaddr, socklen_t *addrlen;
getpeername: int sockfd, struct sockaddr *peeraddr,  socklen_t *addrlen;
    localaddr-->套接字地址结构指针, 函数结束后指向的地址结构将装填与sockfd相关联的套接字信息.
    peeraddr-->套接字地址结构指针.

难受, 地址sockaddr这个结构体有点不太理解.

套接字地址结构

简单说就是有多种"套接字地址"结构体, 如下:
ipv4套接字地址结构体  -->struct sockaddr_in;
ipv6套接字地址结构体  -->struct sockaddr_in6;
通用套接字地址结构体  -->struct sockaddr;
新通用套接字地址结构体-->struct sockaddr_storage;
在这里进行简化，去掉源代码中复杂的嵌套. 一项项解读.
struct sockaddr_in  // <netinet/in.h>
{
  uint16 sin_family;        //地址族
  uint16 sin_port;          //端口
  struct in_addr sin_addr;  //ipv4地址, uint32.
  unsigned char sin_zero[]; //0填充，将剩余位填充为0，
}     // 一共16字节
struct sockaddr_in  // <sys/socket.h>
{
  uint16 sa_family;        //地址族 和 结构长度， 一般仅有地址族
  char sa_data[14];        //包含socket地址信息
}     // 一共16字节
struct sockaddr_in6 // <netinet/in.h>
{
  uint16 sin6_family;         //地址族
  uint16 sin6_port;           //端口
  uint32 sin6_flow_info;      //待补充
  struct in6_addr sin6_addr;  //ipv6地址，uint8 [16]十六个字节;
  uint32 sin6_scope_id;       //待补充
}     // 28字节
struct sockaddr_storage   // <sys/socket.h>
{
  uint16 ss_family;       //地址族
  char __ss_padding[];    //填充，128-已经用的
  ulong __ss_align;       //强制所需对齐，用来指示需要对齐的信息。
}     // 128字节

值-结果参数

1、单纯传值，或者传一个地址但只是让函数读，不会写，不会更改这个变量的值。
  bind, connect, sendto.
2、值-结果参数：传入一个地址，允许它读该变量，并且将结果写入该变量。
  accept, recvfrom, getsockname, getpeername.

字节序和位序

注意大小端指的是字节序，也就是说一个字节为最小单位。此时不关心一个字节内部的存储方式。
  大端：0x1234-->高地址0x34，低地址0x12.
  小端：0x1234-->高地址0x12，低地址0x34.
1、网络字节序。使用大端字节序。
#include <netinet/in.h>
uint16_t htons(uint16_t host16bit);
uint32_t htonl(uint32_t host32bit); //返回网络字节序的值
uint16_t ntohs(uint16_t net16bit);
uint32_t ntohl(uint32_t net32bit);  //返回主机字节序的值
2、位序/比特序。
  待补充。

字节操作函数 bzero, bcopy, bcmp.

#include <strings.h>
void bzero(void *dest, size_t nbytes);
void bcopy(const void *src, void *dest, size_t nbytes);
int bcmp(const void *ptr1, const void ptr2, size_t nbytes); //相等为0，否则为非0。

ip地址转换函数

场景：地址点分十进制数字符串 和 网络字节序二进制值 互相转换。
#include <arpa/inet.h>
int inet_aton(const cahr *strptr, struct in_addr *addrptr);
  // 将str字符串转换为整数放到 addrp 所指地址中。
  // suc 字符串有效 return 1; err 0;
in_addr_t inet_addr(const char *strptr);
  // suc 字符串有效 return ipv4地址; err return INADDR_NONE;
char *inet_ntoa(struct in_addr inaddr);
  //return 指向字符串的指针。
//新函数。
int inet_pton(int family, const char *strptr, void *addrptr);
  // suc 1; 输入非有效 return 0; err -1;
const char *inet_ntop(int family, const void *addrptr, char *strptr, size_t len);
  // suc 指向结果的指针; err NULL.
  // strptr不能为空。

demo, 写一个server, client 的demo.

// tcp_demo.h
#ifndef TCP_DEMO
#define TCP_DEMO

#define BACKLOG_MAX 10
#define BUF_MAX 32
#define SEND_BUF_MAX BUF_MAX
#define RECV_BUF_MAX BUF_MAX

const char server_ip[] = "127.0.0.1";
const int server_port = 8000;


#endif // #ifndef TCP_DEMO

// tcp_server_demo.c
// 实现一个 TCP server 可以处理 TCP client的请求.
// 根据client发送的请求, 返回不同的信息.
/*
目前只实现了, 单一的收发固定信息, 其他的之后再完善.
*/
#include "tcp_demo.h"

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


static int server( void )
{
    // 服务器进程创建自己的套接字, 并获得套接字描述符.
    int sock_family     = AF_INET;
    int sock_type       = SOCK_STREAM;
    int sock_protocal   = IPPROTO_TCP;
    int sockfd = socket(sock_family, sock_type, sock_protocal); 
    
    // 创建套接字地址结构, 包含套接字地址族, 套接字地址ip, 套接字地址端口三个重要信息.
    struct sockaddr_in server_sockaddr;
    memset(&server_sockaddr, '\0', sizeof(server_sockaddr));
    server_sockaddr.sin_family = AF_INET;
    inet_aton(server_ip, &server_sockaddr.sin_addr);
    server_sockaddr.sin_port = server_port;

    // 将服务器进程套接字绑定该套接字地址.
    bind(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(server_sockaddr));

    // 设定等待队列长度, 套接字更改为监听模式.
    int backlog = BACKLOG_MAX;
    listen(sockfd, backlog);

    // 创建缓冲区, 待会可以放一些数据.
    char recv_buf[RECV_BUF_MAX + 1];
    char send_buf[SEND_BUF_MAX + 1];
    memset(recv_buf, '\0', sizeof(recv_buf));
    memset(send_buf, '\0', sizeof(send_buf));

    // 为客户进程创建套接字描述符, 套接字地址结构体, 套接字地址结构体长度 变量, 用于保存客户进程的信息.
    int client_sockfd;
    struct sockaddr_in client_sockaddr;
    socklen_t client_sockaddr_len;
    int count = 0;
    while(1){

        printf("server count=%d\n", count);
        count ++;
        // 从等待队列中获取一个客户请求, 并为该客户创建一个套接字描述符, 并将其套接字地址结构体及其长度保存在上面的变量中.
        client_sockfd = accept(sockfd, (struct sockaddr *)&client_sockaddr, &client_sockaddr_len);

        // 认为客户进程与服务器进程已经连接, 接下来可以进行数据的交流.
        int res = read(client_sockfd, recv_buf, RECV_BUF_MAX);
        printf("Server get some data(%d)\n%s\n", res, recv_buf);
        strncpy(send_buf, "I am server.", SEND_BUF_MAX);
        write(client_sockfd, send_buf, SEND_BUF_MAX);
        
        // 关闭客户进程的套接字, 接下来当前进程(服务器进程)不能够使用该套接字进行读写等操作.
        close(client_sockfd);
        break;
    }
    // 关闭服务器进程的套接字, 接下来服务器进程不能够使用该套接字进行读写等操作.
    close(sockfd);
    return 0;
}

int main( void )
{
    server();
    return 0;
}

// tcp_client_demo.c
#include "tcp_demo.h"

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

#include <time.h>


static int client( void )
{
    int sock_family     = AF_INET;
    int sock_type       = SOCK_STREAM;
    int sock_protocal   = IPPROTO_TCP;
    int sockfd = socket(sock_family, sock_type, sock_protocal); 

    char send_buf[BUF_MAX + 1];
    char recv_buf[BUF_MAX + 1];
    memset(send_buf, '\0', sizeof(send_buf));
    memset(recv_buf, '\0', sizeof(recv_buf));
    strncpy(send_buf, "info", BUF_MAX);

    struct sockaddr_in server_sockaddr;
    server_sockaddr.sin_family = AF_INET;
    inet_pton(server_sockaddr.sin_family, server_ip, &server_sockaddr.sin_addr);
    server_sockaddr.sin_port = server_port;

    int count = 0;
    while(1){
        printf("client count=%d\n", count);
        count ++;

        connect(sockfd, (struct sockaddr *)&server_sockaddr, sizeof(server_sockaddr));
        while (1)
        {
            write(sockfd, send_buf, BUF_MAX);
            int res = read(sockfd, recv_buf, BUF_MAX);
            printf("client get some data(%d)\n%s\n", res, recv_buf);
            break;
        }
        break;
    }
    close(sockfd);
    return 0;
}
int main( void )
{
    client();
    return 0;
}

总结

基本使用了tcp socket编程的一些API接口，包括：
socket, bind, listen, accept, connect, 还有一个套接字地址结构体struct sockaddr_in的基本结构和基础使用。