第一章网络编程基础

A类地址	0.0.0.0~127.255.255.255	2^7(网络号)	2^24(主机号)	大型网络
B类地址	128.0.0.0~191.255.255.255	2^14(网络号)	2^16(主机号)	名地址网管中心
C类地址	192.0.0.0~223.255.255.255	2^21(网络号)	2^8(主机号)	校园网或企业网或家庭网
D类地址	224.0.0.0~239.255.255.255			组播地址
E类地址	240.0.0.0~255.255.255.255			保留

特殊的IP地址（即不能分配给主机使用的IP地址）：

1.网络地址：用于标识网络，有效网络+主机号全是0的IP地址

例如：192.168.50.183 -->相应的网络地址是192.168.50.0

128.1.2.3 -->相应的网络地址是128.1.0.0

12.1.2.3 -->相应的网络地址是12.0.0.0

2.广播地址：用于给局域网内所有的主机发送数据使用，有效网络号+主机号全是1的IP地址

例如：192.168.50.183 -->相应的广播地址是192.168.50.255

128.1.2.3 -->相应的广播地址是128.1.255.255

12.1.2.3 -->相应的广播地址是12.255.255.255

下列哪些IP地址可以分配给主机使用 __B C__

A. 230.1.2.3 B.1.2.3.4 C.220.1.2.3 D.244.1.2.3

下列哪些IP地址可以分配给主机使用 ___ABCD___

A. 223.1.2.3 B. 222.1.2.3 C.192.1.2.3 D.10.1.2.3

给定IP:192.168.1.12，请问该IP地址的网络地址是什么，广播地址是什么。请问该网络地址中可用主机号是多少个。主机号个数是多少个？

网络地址是192.168.1.0 广播地址是192.168.1.255

掐头去尾，可用主机号为254个，主机号个数是256=2^8

子网掩码（重难点）

二级IP地址划分后，主机的基数还是比较大的，所以引入了另外一个概念：子网掩码。

利用子网掩码可以将主机号进行再次划分：

IP = 网络号 + 子网号 + 主机号

三级划分比较灵活，可以选择划分也可以选择不划分，甚至划分的部分都比较灵活，只要是2的幂次方就行，2，4，8……

1.子网掩码

子网掩码：用于将一个大的IP网络中的主机号划分为若干小的子网络。其作用如下：

1.指明一个IP地址的哪些位表示的是主机所在的子网。

2.指明哪些位表示的是主机的位掩码。

3.子网掩码不能单独使用，必须和IP地址结合使用。

2.默认子网掩码

C类IP地址的默认子网掩码：11111111 11111111 11111111 00000000 --> 255.255.255.0

B类IP地址的默认子网掩码：11111111 11111111 00000000 00000000 --> 255.255.0.0

A类IP地址的默认子网掩码：11111111 00000000 00000000 00000000 --> 255.0.0.0

D类和E类没有子网掩码；

C类IP地址的默认子网掩码：11111111 11111111 11111111 00000000 --> 255.255.255.0

                                              11111111 11111111 11111111 10000000 --> 255.255.255.128

                                              11111111 11111111 11111111 11000000 -->255.255.255.192

                                              11111111 11111111 11111111 11100000 -->255.255.255.224

                                              11111111 11111111 11111111 11000011-->错误的，1必须连续

3.子网掩码的使用

格式：IP地址&子网掩码得到子网网段

IP: 192.168.50.183 & 子网掩码: 255.255.255.0

11000000 10101000 00110010 10110111

& 11111111 11111111 11111111 00000000

======================================

11000000 10101000 00110010 00000000 -->192.168.50.0 -->子网网段

192.168.50.183是属于192.168.50这个子网网段中的IP地址。

主机号从0~255范围主机，通过这个子网掩码得到的结果均为192.168.50.0 即子网网段。

所以通过默认子网掩码没有划出新的子网网段。

通过默认子网掩码，其中IP地址的后8bit，被0遮掩了，因为在计算子网网段的时候不关心主机号是多少。

也可以写作：192.168.50.0/24 24:代表子网掩码中有24个1，或者说IP地址中有24bit没有被0遮掩。

IP: 192.168.50.183 & 子网掩码: 255.255.255.128

        11000000 10101000 00110010 1 0110111

& 11111111    11111111 11111111 1 0000000 ======================================

        11000000 10101000 00110010 1 0000000 -->192.168.50.128 -->子网网段

范围：

主机号在[128,255]范围内的主机，& 255.255.255.128，的出来的结果均192.168.50.128/25子网网段。

通过255.255.255.128该子网掩码可以划分出两个子网网段(前25位：24位有效网络号 + 1位有效子网号）

                        192.168.50.0/25 ---> 128个主机号

                        192.168.50.128/25 ---> 128个主机号

注意：

子网网段的个数 = 2^ (子网掩码中多加的1的个数)

每个子网网段中主机号的个数 = 2^ (子网掩码中0的个数)

特殊的IP地址：

每个子网网段都有自己的子网网段地址，有效地址 + 有效子网号 + 主机号全是0的IP地址。掐头

每个子网网段中都有自己的子网广播地址。去尾

题型1：

        给定IP地址，给定要划出多少个子网，求子网掩码以及主机号个数，可用主机号个数。

130.1.2.3，请问默认子网掩码是什么？若要划出6个子网网段，求子网掩码是什么？主机号个数是多少个？

B类：255.255.0.0
6-->8个 = 2^3，所以要多加3个1， 255.255.224.0
子网掩码中剩下13个0，每个网段中主机号个数：2^13个，每个网段中可用主机号个数2^13-2，所有网段中可用的主机号个数2^16-16

题型2：

        每一类的默认子网掩码是什么

C类IP地址的默认子网掩码：

                                11111111 11111111 11111111 00000000 --> 255.255.255.0

B类IP地址的默认子网掩码：

                                11111111 11111111 00000000 00000000 --> 255.255.0.0

A类IP地址的默认子网掩码：

                                11111111 00000000 00000000 00000000 --> 255.0.0.0

题型：

        给定子网网段，计算子网掩码是什么？

192.168.0.64/26，问子网掩码是什么，问该网段的网段地址和广播地址分别是什么

          255.255.255.192

          网段地址 192.168.0.64 广播地址：192.168.0.127

练习：

某个公司有4 部门：行政研发售后营销，每个部门20台电脑接入公司局域网交换机。

如果在192.168.1.0网段划分每个部分的子网，写出所有可用的子网掩码？子网的地址范围是什么？

答：

所以至少划分出4个子网网段：255.255.255. 1100 0000 --> 255.255.255.192 每个子网网段中，主机号的个数为：64个
划分出8个子网网段：255.255.255. 1110 0000 --> 255.255.255.224 每个子网网段中，主机号的个数为：32个

                        192.168.1.2~192.168.1.62 192.168.1.0/26

                        192.168.1.65~192.168.1.126 192.168.1.64/26

                        192.168.1.129~192.168.1.190 192.168.1.128/26

                        192.168.1.193~192.168.1.254 192.168.1.192/26

注解：每个划分出来的部分要去掉子网网段地址和子网广播地址两个IP地址

网关

概念：网关是一个网络通向其他网络的IP地址。

目前家用路由器一般使用192.168.1.1和192.168.0.1作为LAN接口的地址，这个两个也是最常用的网关地址。

域名系统

由于使用IP地址来指定计算机不方便人们记忆，且输入时候容易出错，用字符标识网络种计算机名称方法。这种命名方法就像每个人的名字，这就是域名（Domian Name）

域名服务器（Domain Name server）：用来处理IP地址和域名之间的转换。

域名系统（Domain Name System，DNS）：域名翻译成IP地址的软件

一个域名，可以绑定多个ip

域名结构

例如：

域名 www.baidu.com.cn （从右向左看）

1.cn为高级域名，也叫一级域名，它通常分配给主干节点，取值为国家名，cn代表中国

2.com为网络名，属于二级域名，它通常表示组织或部门

中国互联网二级域名共40个，edu表示教育部门，com表示商业部门，gov表示政府，军队mil等等。

3.baidu为机构名，在此为三级域名，表示百度

4.www：万维网world wide web，也叫环球信息网，是一种特殊的信息结构框架。

端口号

为了区分一台主机收到的数据包交给哪个进程处理，使用端口号来区分。程序启动后将端口号和进程绑定在一起。

网络里面的通讯是由 IP地址+端口号来决定

端口号存储在 2个字节无符号整数中（unsigned short int），范围是[1, 65535]。

众所周知的端口号：

1~1023端口我们编程时候不要使用，是那些”VIP“应用程序占了

TCP 21端口：FTP文件传输服务

TCP 23端口：TELNET终端仿真服务

TCP 25端口：SMTP简单邮件传输服务

UDP 53端口：DNS域名解析服务

UDP 69端口：TFTP文件传输服务

TCP 80端口：HTTP超文本传输服务

TCP 110端口：POP3邮局协议版本3

TCP 443端口：HTTPS加密超文本传输服务

TCP和UDP的端口号是相互独立的

可以使用的：1024~49151，就是我们平时编写服务器使用的端口号

临时端口号：49152~65535，这部分是客户端运行时候动态选择的（随机选取的时候有可能会往前一点）

跨主机传输

字节序

概念：

字节序是指不同类型的CPU主机，内存存储 多字节整数 序列的方式。
1. float， char类型，字符串，没有字节序
2. short, int， long, long long有字节序的说法。
小端字节序：低序字节存储在低地址上。
大端字节序：低序字节存储在高地址上，高序字节存储在低地址上。

数据的读取顺序：从低地址往高地址读取，将读取出来的内容通过大小端转换得到实际内容。

简述字节序的概念，并用共用体（联合体）的方式计算本机是大端还是小端

1.概念：

字节序是指不同类型的CPU主机，内存存储 多字节整数 序列的方式。
1. float， char类型，字符串，没有字节序
2. short, int， long, long long有字节序的说法。
小端字节序：低序字节存储在低地址上。
大端字节序：低序字节存储在高地址上，高序字节存储在低地址上。

#include <stdio.h>

typedef union
{
    unsigned int a;
    unsigned char b;
}_t;


int main(int argc, const char *argv[])
{
    unsigned int a = 0x87654321;
    char* ptr = (char*)&a;

    if(0x21 == *ptr)
    {
        printf("little-endian\n");
    }                                     
    else if(0x87 == *ptr)
    {
        printf("big-endian\n");
    }

    _t text;
    text.a = 0x01;
    if(0x01 == text.b)
    {
        printf("little-endian\n");
    }
    else
    {
        printf("big-endian\n");
    }

    return 0;
}

本地字节序与网络字节序

本地字节数：主机字节序（Host Byte Order） HBO

网络字节序（Network Byte Order） NBO，网络字节序规定使用大端字节序。

在跨主机传输过程中，需要使用统一的字节序，即网络字节序，避免兼容性问题。

字节序转换函数

1.htons htonl 其功能是将主机字节序转换为网络字节序

头文件：
       #include <arpa/inet.h>

       uint32_t htonl(uint32_t hostlong);
       uint16_t htons(uint16_t hostshort);
参数：
    指定要转换成网络字节序的整型：分别是32bit和16bit;
返回值：
    成功，返回转换后网络字节序的整型
    
#include <stdio.h>
#include <arpa/inet.h>

int main(int argc, const char *argv[])
{
    unsigned int a = 0x87654321;
    printf("%#x\n", a);             //0x87654321
    printf("%#x\n", htonl(a));      //0x21436587

    printf("%#x\n", htons(a));      //0x2143                 
    
    return 0;
}

2.ntohs ntohl 其功能是将网络字节序转换为主机字节序

头文件：
       #include <arpa/inet.h>
原型：
       uint32_t ntohl(uint32_t netlong);
       uint16_t ntohs(uint16_t netshort);
参数：
    uint32_t hostlong：32位网络字节序整型;
    uint16_t hostshort：16位网络字节序整型;

返回值：
    成功，返回转换成主机字节序的整型;

结构体对齐

编译器会对结构体进行对齐，加速CPU取值周期，由于数据对齐也是与操作系统相关，不同的主机如果使用不同的对齐方式，会导致数据无法解析。所以网络传输结构体的时候需要取消结构体对齐；

#include <stdio.h>

#pragma pack(1)         //设置默认对齐系数 ：（）中的参数只能填2^n (n=0,1,2,3,4,5......)  

typedef struct
{
    char a;     //1
    int b;      //4
    int d;      //4
}_A;

#pragma pack()      //重置默认对其系数,重新置为8

typedef struct
{
    char a;     //1
    int b;      //4
    int d;      //4
} __attribute__((packed))  B;       //取消结构体对齐


typedef struct
{   
    char a;     //1
                //3
    int b;      //4
    int d;      //4
}_C;

int main(int argc, const char *argv[])
{   
    printf("%ld\n", sizeof(_A));    //9
    printf("%ld\n", sizeof(_B));    //9
    printf("%ld\n", sizeof(_C));    //12

    
    return 0;
}

类型长度

int long int不同操作系统这两个数据类型所占的字节数可能是不一样的

解决方式：可以通过通用类型：uint8_t uint16_t uint32_t

因为涉及到跨平台，不同平台会有不同的字长

#include <stdint.h>

typedef struct
{
    uint8_t a;      //1
    uint32_t b;      //4
    uint16_t d;      //2
}_A;

IP转换

由于IP地址本质上是一个4个字节的无符号整数，所以在跨主机传输中也有字节序的概念。

所以需要将IP地址转换成网络字节序。

"192.168.8.189" ---->本机字节序的整型 0xC0A808BD---->网络字节序0xBD08A8C0

"192.168.31.42"----> 0xC0A81F2A ---->0x2A1FA8C0

"192.168.2.145"---->本机字节序的整型0xC0A80291--->网络字节序的整型数0x9102A8C0

1. 点分十进制--->网络字节序

1）inet_aton

头文件：
       #include <sys/socket.h>
       #include <netinet/in.h>
       #include <arpa/inet.h>
原型：
       int inet_aton(const char *cp, struct in_addr *inp);
参数：
    char *cp：源IP地址的点分十进制字符串，例如 “192.168.1.10”;
    struct in_addr *inp：存储转换成网络字节序的IP;
           typedef uint32_t in_addr_t;
           struct in_addr {
               in_addr_t s_addr;
           };
返回值：
    成功，返回非0;
    失败，返回0;

只能转换IPv4
    
例子：
 #define IP  "192.168.1.10"      //0xC0A8010A
 int main(int argc, const char *argv[])
 {
     struct in_addr inp;
 
     if(inet_aton(IP, &inp) == 0)
     {
         printf("转换失败\n");
         return -1;
     }
 
     printf("%#X\n", inp.s_addr);    //0X0A01A8C0
                                                           
     return 0;
 }

2）inet_pton

既可以转IPv4也能处理IPv6

头文件：
       #include <arpa/inet.h>
原型：
       int inet_pton(int af, const char *src, void *dst);
参数：
    int af：协议族
            AF_INET         IPV4
            AF_INET6        IPV6
     char *src：指定要转换成网络字节序的点分十进制字符串;
     void* dst
           typedef uint32_t in_addr_t;
           struct in_addr {
               in_addr_t s_addr;
           };

            af == AF_INETa;
            struct in6_addr
            {

            }
返回值：
    成功，返回1；
    失败，返回0或者-1，更新errno;

#define IP "192.168.1.3" //0xC0A80103 --> 0x301A8C0 

    struct in_addr inp;
    inet_pton(AF_INET, IP, &inp);
    printf("%#X\n", inp.s_addr);        //0x301A8C0

3）inet_addr 最常用

头文件：
       #include <sys/socket.h>
       #include <netinet/in.h>
       #include <arpa/inet.h>
原型：
       uint32_t inet_addr(const char *cp);
参数：
     char *cp：源IP地址的点分十进制字符串，例如 “192.168.1.10”;
返回值：
    成功，返回转换后的网络字节序IP地址;
                    typedef uint32_t in_addr_t;

    失败，返回INADDR_NONE (usually -1);

只能转换IPv4;


例子：
    printf("%#X\n", inet_addr(IP));

2. 网络字节序--->点分十进制

1）inet_ntoa 常用

头文件：
       #include <sys/socket.h>
       #include <netinet/in.h>
       #include <arpa/inet.h>
原型：
       char *inet_ntoa(struct in_addr in);
参数：
    struct in_addr in：指定要转换成点分十进制字符串的IP地址;
           typedef uint32_t in_addr_t;
           struct in_addr {
               in_addr_t s_addr;
           };
返回值：
    成功，返回点分十进制字符串的首地址;

只能转换IPv4;

printf("%s\n", inet_ntoa(inp));

2）inet_ntop

头文件：
       #include <arpa/inet.h>
原型：
       const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
参数：
    int af：协议族
            AF_INET         IPV4
            AF_INET6        IPV6
    void* src：存储要转换成点分十进制字符串的IP首地址;
           typedef uint32_t in_addr_t;
           struct in_addr {
               in_addr_t s_addr;
           };

            af == AF_INETa;
            struct in6_addr
            {
            }
    char *dst：存储转换后的结果，点分十进制的首地址;
    socklen_t size：缓冲区大小，其实就是指定多大的空间用于转换IP;
返回值：
    成功，返回字符串的首地址，就是dst;
    失败，返回NULL，更新errno;     

例子：
     char ip[20];
     if(inet_ntop(AF_INET, &inp, ip, sizeof(ip)) == NULL)
     {
         perror("ient_ntop");
         return -1;                                            
     }
     printf("%s\n", ip);