Linux下的网络编程——网络基础、socket编程（一）

一、协议

协议：

  一组规则。

1.  7层模型和4层模型及代表协议

分层模型结构：

   OSI七层模型：  物理层、数据链路层、网络层、传输层、会话层、表示层、应用层

  TCP/IP 4层模型：网络接口层（链路层/网络接口层）、网络层、传输层、应用层

      应用层：http、ftp、nfs、ssh、telnet。。。

      传输层：TCP、UDP

      网络层：IP、ICMP、IGMP

      链路层：以太网帧协议、ARP

2.  网络传输数据封装流程

网络传输流程：

        数据没有封装之前，是不能在网络中传递。

        数据-》应用层-》传输层-》网络层-》链路层  --- 网络环境

3.  以太网帧和ARP请求

以太网帧协议：

   ARP协议：根据 Ip 地址获取 mac 地址。

   以太网帧协议：根据mac地址，完成数据包传输。

二、*IP协议

IP协议：

   版本： IPv4、IPv6  -- 4位

   TTL： time to live 。 设置数据包在路由节点中的跳转上限。每经过一个路由节点，该值-1， 减为0的路由，有义务将该数据包丢弃

   源IP： 32位。--- 4字节     192.168.1.108 --- 点分十进制 IP地址（string）  --- 二进制

   目的IP：32位。--- 4字节

三、端口号和UDP协议

UDP：

   16位：源端口号。 2^16 = 65536

   16位：目的端口号。

IP地址：可以在网络环境中，唯一标识一台主机。

端口号：可以网络的一台主机上，唯一标识一个进程。

ip地址+端口号：可以在网络环境中，唯一标识一个进程。

四、TCP协议

TCP协议：

   16位：源端口号。 2^16 = 65536

   16位：目的端口号。

   32序号;

   32确认序号。

   6个标志位。

   16位窗口大小。   2^16 = 65536

五、BS和CS模型对比

c/s模型：

   客户端服务器模型（client-server）

b/s模型：

   浏览器服务器模型（browser-server）

                       C/S                                                                  B/S

  优点： 缓存大量数据、协议选择灵活、速度快                 安全性、跨平台、开发工作量较小

  缺点： 安全性、跨平台、开发工作量较大                         不能缓存大量数据、严格遵守 http

六、***socket编程

1.网络套接字：socket

   一个文件描述符指向一个套接字（该套接字内部由内核借助两个缓冲区实现。）

   在通信过程中， 套接字一定是成对出现的。

套接字原理图：

2.网络/主机字节序

  小端法：（pc本地存储）  高位存高地址。地位存低地址。    int a = 0x12345678

   大端法：（网络存储）      高位存低地址。地位存高地址。

   TCP/IP协议规定，网络数据流应采用大端字节序

      为使网络程序具有可移植性，使同样的c代码在大端和小端计算机上编译后都能正常运行，可以调用以下库函数做网络字节序和主机字节序的转换。

  htonl --> 本地--》网络 （IP）      192.168.1.11 --> string --> atoi --> int --> htonl --> 网络字节序

   htons --> 本地--》网络 (port)

  ntohl --> 网络--》 本地（IP）

  ntohs --> 网络--》 本地（Port）

   h表示 host，n表示network，l表示32位长整数，s表示16位短整数。

网络字节序：是TCP/IP中规定好的一种数据表示格式，采用大端存储

主机字节序：不同的主机根据CPU不同采取不同的存储，其中x86采取小端存储，ARM默认小端存储，但是支持大端存储

3.*IP地址转换函数：

   int inet_pton(int af, const char *src, void *dst);    

  本地字节序（string IP） ---> 网络字节序

      af：  AF_INET(IPv4)、AF_INET6(IPv6)

      src：传入，IP地址（点分十进制）

     dst：传出，转换后的网络字节序的 IP地址。

      返回值：

          成功： 1

          异常： 0， 说明src指向的不是一个有效的ip地址。

          失败：-1

  const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);

   网络字节序 ---> 本地字节序（string IP）

      af： AF_INET(IPv4)、AF_INET6(IPv6)

      src: 网络字节序IP地址

      dst：本地字节序（string IP）

     size： dst 的大小

      返回值： 成功：dst  

                     失败：NULL

4.sockaddr地址结构

   sockaddr地址结构：   IP + port  --> 在网络环境中唯一标识一个进程。

  struct sockaddr_in addr;
 
  addr.sin_family = AF_INET/AF_INET6        man 7 ip
 
  addr.sin_port = htons(9527);
      
    int dst;
 
    inet_pton(AF_INET, "192.157.22.45", (void *)&dst);
 
  addr.sin_addr.s_addr = dst;
 
  addr.sin_addr.s_addr = htonl(INADDR_ANY);//【*】取出系统中有效的任意IP地址,二进制类型。
 
  bind(fd, (struct sockaddr *)&addr, size);

4.**** socket模型创建流程分析

****注意：

               一个客户端与一个服务端建立通信之间有3个套接字。

示例：小写字母转大写字母        hello------》HELLO

（1）socket：

#include

     int socket(int domain, int type, int protocol);    

       创建一个套接字

      domain：（IP地址协议），AF_INET、AF_INET6、AF_UNIX

      type：SOCK_STREAM、SOCK_DGRAM

      protocol: 0

      返回值：

          成功： 新套接字所对应文件描述符

          失败: -1 errno

fd = socket(AF_INET,SOCK_STREAM,0);

（2）bind :

#include

    int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);    

     给socket绑定一个 地址结构 (IP+port)

      sockfd: socket 函数返回值      

  struct sockaddr_in addr;
 
  addr.sin_family = AF_INET;
 
  addr.sin_port = htons(9527);
 
  addr.sin_addr.s_addr = htonl(INADDR_ANY);
 
  addr: 传入参数(struct sockaddr *)&addr
 
  addrlen: sizeof(addr) 地址结构的大小。

bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));//给服务器socket绑定地址结构（IP+port)

   返回值：

          成功：0

          失败：-1 errno

（3）listen

int listen(int sockfd, int backlog);    

设置同时与服务器建立连接的上限数。（同时进行3次握手的客户端数量）

      sockfd: socket 函数返回值

      backlog：上限数值。最大值 128.

      返回值：

          成功：0

          失败：-1 errno  

（4）*accept

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

阻塞等待客户端建立连接，成功的话，返回一个与客户端成功连接的socket文件描述符。

      sockfd: socket 函数返回值

      addr：传出参数。成功与服务器建立连接的那个客户端的地址结构（IP+port）

          socklen_t clit_addr_len = sizeof(addr);

          addrlen：传入传出。 &clit_addr_len

           入：addr的大小。 出：客户端addr实际大小。

      返回值：

          成功：能与客户端进行数据通信的 socket 对应的文件描述。

          失败： -1 ， errno

（5）connect

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);    

使用现有的 socket 与服务器建立连接

         sockfd： socket 函数返回值

 struct sockaddr_in srv_addr;       // 服务器地址结构
 
 srv_addr.sin_family = AF_INET;
 
 srv_addr.sin_port = htons(9527)    跟服务器bind时设定的 port 完全一致。
 
 inet_pton(AF_INET, "服务器的IP地址"，&srv_adrr.sin_addr.s_addr);
 
 addr：传入参数,服务器的地址结构    
 
 addrlen：服务器的地址结构的大小

connect(cfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));

      返回值：

          成功：0

          失败：-1 errno

     如果不使用bind绑定客户端地址结构, 采用"隐式绑定".

5.****CS模型的TCP通信分析

TCP通信流程分析:

  （1） server:

      1. socket()   创建socket

      2. bind()  绑定服务器地址结构

      3. listen()   设置监听上限

      4. accept()   阻塞监听客户端连接

      5. read(fd)   读socket获取客户端数据

      6. 小--大写   toupper()

      7. write(fd)

      8. close();

   （2）client:

      1. socket()   创建socket

      2. connect(); 与服务器建立连接

      3. write() 写数据到 socket

      4. read()  读转换后的数据。

      5. 显示读取结果

      6. close()

（3）**server的实现

#include <stdio.h>
#include <ctype.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
 
#define SERV_PORT 9527
 
 
void sys_err(const char *str)
{
    perror(str);
    exit(1);
}
 
int main(int argc, char *argv[])
{
    int lfd = 0, cfd = 0;    //建立联系通信
    int ret, i;
    char buf[BUFSIZ], client_IP[1024];
 
    struct sockaddr_in serv_addr, clit_addr;  // 定义服务器地址结构 和 客户端地址结构
    socklen_t clit_addr_len;          // 客户端地址结构大小
 
    serv_addr.sin_family = AF_INET;       // IPv4
    serv_addr.sin_port = htons(SERV_PORT);    // 转为网络字节序的 端口号
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);  // 获取本机任意有效IP
 
    lfd = socket(AF_INET, SOCK_STREAM, 0);    //创建一个 socket
    if (lfd == -1) {
        sys_err("socket error");
    }
 
    bind(lfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));//给服务器socket绑定地址结构（IP+port)
 
    listen(lfd, 128);         //  设置监听上限
 
    clit_addr_len = sizeof(clit_addr);  //  获取客户端地址结构大小
 
    cfd = accept(lfd, (struct sockaddr *)&clit_addr, &clit_addr_len); // 阻塞等待客户端连接请求
    if (cfd == -1)
        sys_err("accept error");
 
    printf("client ip:%s port:%d\n", 
            inet_ntop(AF_INET, &clit_addr.sin_addr.s_addr, client_IP, sizeof(client_IP)), 
            ntohs(clit_addr.sin_port)); // 根据accept传出参数，获取客户端 ip 和 port
 
    while (1) {
        ret = read(cfd, buf, sizeof(buf));    // 读客户端数据
        write(STDOUT_FILENO, buf, ret);     // 写到屏幕查看
 
        for (i = 0; i < ret; i++)       // 小写 -- 大写
            buf[i] = toupper(buf[i]);
 
        write(cfd, buf, ret);         // 将大写，写回给客户端。
    }
 
    close(lfd);
    close(cfd);
 
    return 0;
}

（4）client的实现

#include <stdio.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
 
#define SERV_PORT 9527
 
void sys_err(const char *str)
{
  perror(str);
  exit(1);
}
 
int main(int argc, char *argv[])
{
    int cfd;
    int conter = 10;
    char buf[BUFSIZ];
    
    struct sockaddr_in serv_addr;          //服务器地址结构
 
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(SERV_PORT);
    //inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr.s_addr);
    inet_pton(AF_INET, "127.0.0.1", &serv_addr.sin_addr);
 
    cfd = socket(AF_INET, SOCK_STREAM, 0);
    if (cfd == -1)
        sys_err("socket error");
 
    int ret = connect(cfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr));
    if (ret != 0)
        sys_err("connect err");
 
    while (--conter) {
        write(cfd, "hello\n", 6);
        ret = read(cfd, buf, sizeof(buf));
        write(STDOUT_FILENO, buf, ret);
        sleep(1);
    }
 
    close(cfd);
 
  return 0;
}