Compartir tecnología

Programación de redes: conceptos básicos

2024-07-12

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

1. modelo OSI

Modelo OSI ===》Modelo de interconexión de sistemas abiertos ==》se divide en 7 capas:
Modelo ideal ==》Aún no realizado
TFTP
b /etc/contraseña
un /etc/123
Capa de aplicación
Cifrado y descifrado de la capa de presentación gzip
Desconexión de la red de la capa de sesión, estado de la conexión, mantener cerca y mantener vivo

Capa de transporte protocolo tcp udp archivo de vídeo y audio
NAT IP de capa de red

Verificación del marco de formato de datos del cambio de capa de enlace
Capa física 100Mb/8 Gbits 100MB cable coaxial 10Gb 2.4G 5G

De abajo hacia arriba, la parte inferior es la más básica.

2. Modelo TCP/IP

Modelo TCP/IP ==》modelo de Internet ==》se divide en 4 capas:
Modelo práctico ===》Estándar industrial
pila de protocolos tcp/ip
Capa de aplicación ====》Aplicación
Capa de transporte ====》Número de puerto tcp udp (qué método de transmisión se utiliza,TCP confiable，UDP tiene un alto rendimiento en tiempo real）
Capa de red ====》Dirección IP (Cómo encontrar a la otra parte y al anfitrión）
Capa de interfaz ====》Controlador de tarjeta de red 1GB
cap ,,,

3. Conjunto de protocolos TCP/IP

www.taobao.com ---> 192.168.0.19
vpn www.voa.com
Resolución de nombres de dominio DNS (generalmente según la provincia)


DHCP (Protocolo de configuración dinámica de host)
Capa de aplicación:HTTP (página web) TFTP (transferencia de archivos trivial de corto alcance)FTP (transferencia de larga distancia por Internet)
                   SNMP (Administrar y monitorear dispositivos, sistemas y aplicaciones de red)Sistema de nombres de dominio...
Capa de transporte: TCP UDP 56k cat
Capa de red: IP ICMP (ping) RIP OSPF IGMP...
Capa de interfaz: ARP (Protocolo de resolución de direcciones) RARP... ip--->mac
arpa,,,,
    192.160.0.112 

1. Conceptos básicos de la red

Conceptos básicos de la red ===》Clase ABCDE
010  3333344444
Dirección IP == bits de red + bits de host

Clasificación de dirección IP: decimal con puntos ipv4 712934
    Categoría A: Red de muy gran escala
                          8    8     8    8
        1.0.0.0 - 126.255.255.255  126.1.1.1 
        Identificación de red                                126.1.1.2
       255.0.0.0 (máscara de subred)  
privado:
        10.0.0.0 - 10.255.255.255
        127.0.0.1
    Categoría B: Redes grandes y medianas
        128.0.0.0 - 191.255.255.255
        128.2.1.2  128.2.7.2
        255.255.0.0
privado:
        172.16.0.0 - 172.31.255.255

   Categoría C: Redes pequeñas y medianas
       192.0.0.0 - 223.255.255.255
        255.255.255.0
privado:
       192.168.0.0 - 192.168.255.255
Enrutamiento estatico
        192.168.0.0
        Puerta de enlace 192.168.0.1
        192.168.0.255 (Transmisión, todos en la LAN pueden recibirla)

   Categoría D: Multidifusión ytransmisión
        224.0.0.0 - 239.255.255.255 (chat grupal, no abierto a todos, no limitado a LAN)
        192.168.0.255 == 255.255.255.255 (solo LAN, una persona envía, todos reciben)
        235.1.2.3
        192.168.1.0 
192.168.0.1 Puerta de enlace
192.168.1.255 Transmisión

Categoría E: Experimental
        240.0.0.0 - 255.255.255.255
        
Red clase C:
Los primeros tres grupos de la dirección IP son la dirección de red y el cuarto grupo es la dirección del host.
El bit más alto del binario debe ser: comenzando con 110xxxxx
Rango de representación decimal: 192.0.0.0 -223.255.255.255
Máscara de red predeterminada: 255.255.255.0
Número de redes: 2^24, alrededor de 2,09 millones
Número de hosts: 2^8 254 + 2 ===》1 es la puerta de enlace 1 que se transmite
Dirección privada: dirección LAN 192.168.xx.
  
  sudo vim/etc/network/interfaces "Configurar red"
sudo /etc/init.d/networking restart
sudo reiniciar
    192.168.0.0
Ruta 192.168.0.1
192.168.0.255 transmisión de tablero
801.ng
Configuración para acceso a Internet de una sola máquina:
1. Tenga una interfaz de red y conecte el cable de red.
2. Tener una dirección IP
3. Configurar los ajustes de red
           ip (modificar ip temporal): ifconfig ethX XXXX/24 up ifconfig ens33 192.168.0.13/24 (máscara de subred) arriba 255.255.255.0
Puerta de enlace: agregar ruta predeterminada gw xxxx
DNS: vi /etc/resolv.conf ==>servidor de nombres 8.8.8.8
            Prueba: ping www.baidu.com
            netoestadística -anp (puede ver el estado de la red de la computadora)

2. Interfaz de red

1. enchufe zócalo (Descriptor de archivo: dispositivo de red asociado) == "Zócalo BSD =="Un conjunto de funciones de interfaz para la comunicación en red..enchufe api  interfaz de aplicacióninterfaz de función
        2. IP+puerto DIRECCIÓN+puerto===》La dirección se utiliza paraIdentificar anfitrión
Puerto utilizadoIdentificar aplicaciones

          El puerto se divide en puerto TCP/puerto UDP, el rango es: 1-65535
Se acuerda que el sistema utilice puertos dentro de 1000.
http 80 www.baidu.com
                3306
telnet21
ssh22

3. Orden de bytes de la red

        Almacenamiento big endian (bits bajos en memoria alta: dispositivos de red)
     Little endian 0x12345678 (bit bajo en memoria baja - host)
        12 00   
        00 12
        192.168.0.12 (big-endian) "el bit más significativo se almacena primero"
       12.0.168.192 (pequeño endian)

4. UDP (datagrama de usuario)

1. Características: Sin vínculo, poco confiable, big data

2. Marco: modo C/S

servidor：socket() ===>bind()===>recvfrom()===>close()
cliente：socket() ===>bind()===>sendto() ===>close()

Nota: Es necesario ajustar los parámetros de socket().

zócalo(PF_INET,SOCK_DGRAM,0);

      bind() cliente(c) es opcional，Se requieren lados del servidor。

1. zócalo

int zócalo(dominio int, tipo int, protocolo int);
Función: El programa propone al kernelCrear un descriptor de socket basado en memoria

parámetro:familia de direcciones de dominio, PF_INET == AF_INET ==>programa de Internet
PF_UNIX == AF_UNIX ==>programa independiente
          tipo de enchufe:
Conector de transmisión SOCK_STREAM ===》TCP
SOCK_DGRAM Zócalo de datagrama de usuario ===>UDP
SOCK_RAW conector sin formato ===》IP
          protocolo protocolo ==》0 significa adaptarse automáticamente al protocolo de la capa de aplicación.

Valor de retorno: retorno exitosoLa identificación del socket solicitado
Fallo -1;

2.enlazar

int enlazar(entero sockfd, estructura sockaddr *mi_dirección, dirección socklen_t);
Función: Si la función está enTerminal de servicioLlamado, significa asociar el archivo descriptor de archivo relacionado con el parámetro 1 con la dirección de interfaz especificada por el parámetro 2 paraAceptar datos de esta interfaz。

Si la función está enSintonía del clienteSi se usa, significa que los datos deben extraerse del descriptor donde se encuentra el parámetro 1 y del dispositivo de interfaz donde se encuentra el parámetro 2. mandar。

Nota: Si es un cliente, esta función se puede omitir y los datos se enviarán por la interfaz predeterminada.
parámetro:Descriptor de archivo sockfd e ID de socket creados previamente a través de la función de socket
          my_addr es el puntero de estructura de la interfaz física.Representa información sobre la interfaz.

estructura sockaddr estructura de dirección universal
      {
u_short sa_family; dirección de la familia
char sa_data[14]; información de dirección
      };

La estructura de direcciones de red convertida es la siguiente:
struct _sockaddr_in /// Estructura de direcciones de red
      {
u_short sin_family; dirección de la familia
u_short sin_port; /// Puerto de dirección
struct in_addr sin_addr; /// Dirección IP
char sin_zero[8];
      };

estructura en_dirección
      {
en_addr_t s_addr;
      }

socklen_t addrlen: la longitud del parámetro 2.
Valor de retorno: éxito 0
Fallo -1;

3.Enviartomar el controlfunción:

ssize_t enviar a(entero sockfd, constante void *buf, tamaño_t len,banderas int,
                       constante estructura sockaddr *dest_addr, dirección socklen_t);

Función: Se utiliza para enviar mensajes a la otra parte en protocolo UDP.enviar datos。
parámetro:ID de socket local de sockfd
           Mejora el almacenamiento de datos local, generalmente los datos que se enviarán.
          longitud de los datos a enviar
          banderas Cómo enviar datos,0 significa bloquear el envío

          dest_addr: requerido, indica la estructura de información del host de destino a enviar
        addrlen: longitud de la dirección de destino

Valor de retorno: Éxito Longitud de los datos enviados
Fallo -1;


ssize_t recibir de(entero sockfd, vacío *buf, tamaño_t len, banderas int,
                           estructura sockaddr *dirección_src, calcetín_t *addrlen);

Función: utilizado en el protocolo UDPObtenerLos datos enviados por la otra parte.
parámetro:ID de socket local de sockfd
          buff El área de memoria donde se almacenarán los datos, generalmente una matriz o memoria dinámica.
        len es la longitud de los datos que se obtendrán, generalmente el tamaño del beneficio.
           método de adquisición de banderas,0 bloqueo

          src_addr es opcional y representa la estructura de información de dirección de la otra parte.NULO,expresarNo me importa la dirección de la otra parte
          addrlen El tamaño de la estructura de información de la dirección de la otra parte, siDirección de la otra parteSíNuloL, entoncesEste valor también es NULL
Valor de retorno: longitud de los datos recibidos correctamente
Fallo -1;

4.Cerrar

cerca() ===>Cerrar la identificación del socket especificado;

Aviso

1. Los datos y los datos tienen límites
2. El número de envío y recepción debe corresponder.
3.recvfrom bloqueará
4.sento no se bloqueará (recvfrom no recibe, no afecta el envío de sento) 

   c busca s

servidor.c

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <unistd.h>  
  4. #include <string.h>  
  5. #include <sys/types.h>  
  6. #include <sys/socket.h>  
  7. #include <netinet/in.h>   
  8. #include <arpa/inet.h>  
  9. #include <time.h>  
  10.  
  11. typedef struct sockaddr *SA;  
  12.   
  13. int main(int argc, char *argv[])  
  14. {  
  15.     int sockfd = socket(AF_INET, SOCK_DGRAM, 0); // 创建一个UDP套接字  
  16.     if(-1 == sockfd) // 检查socket调用是否失败  
  17.     {  
  18.         perror("socket"); // 打印错误信息  
  19.         exit(1); // 退出程序  
  20.     }  
  21.   
  22.     // 定义服务器地址和客户端地址结构体（尽管客户端地址通常在recvfrom中填充）  
  23.     struct sockaddr_in ser, cli;  
  24.     bzero(&ser, sizeof(ser)); // 初始化服务器地址结构体  
  25.     bzero(&cli, sizeof(cli)); // 初始化客户端地址结构体（但这里实际上不需要提前初始化）  
  26.   
  27.     // 设置服务器地址结构体  
  28.     ser.sin_family = AF_INET;  
  29.     ser.sin_port = htons(50000); // 端口号转换为网络字节序  
  30.     ser.sin_addr.s_addr = inet_addr("192.168.203.128"); // 服务器IP地址  
  31.   
  32.     // 将套接字绑定到服务器地址和端口  
  33.     int ret = bind(sockfd, (SA)&ser, sizeof(ser));  
  34.     if(-1 == ret)  
  35.     {  
  36.         perror("bind"); // 绑定失败时打印错误信息  
  37.         exit(1); // 退出程序  
  38.     }  
  39.   
  40.     socklen_t len = sizeof(cli); // 用于recvfrom的客户端地址长度  
  41.   
  42.     // 无限循环接收数据并发送响应  
  43.     while(1)  
  44.     {  
  45.         char buf[512] = {0}; // 准备接收数据的缓冲区  
  46.         // 接收数据，注意这里&len是必需的，因为recvfrom会修改它以反映实际接收到的客户端地址长度  
  47.         recvfrom(sockfd, buf, sizeof(buf), 0, (SA)&cli, &len);  
  48.   
  49.         time_t tm;  
  50.         time(&tm); // 获取当前时间  
  51.   
  52.         // 这里有一个问题：buf被用于接收数据，然后又被用于存储新的字符串（包括原始数据和时间戳）  
  53.         // 这会导致原始数据被覆盖。应该使用另一个缓冲区来存储最终的发送数据  
  54.         sprintf(buf, "%s %s", buf, ctime(&tm)); // 将时间戳附加到接收到的数据上  
  55.   
  56.         // 发送数据回客户端，但注意len在这里已经被recvfrom修改，表示客户端地址的长度  
  57.         // 对于sendto，我们应该使用sizeof(cli)或重新初始化len  
  58.         sendto(sockfd, buf, strlen(buf), 0, (SA)&cli, len); // 这里使用len可能不是最佳实践  
  59.     }  
  60.   
  61.     // 注意：由于程序进入了一个无限循环，下面的close和return语句实际上永远不会被执行  
  62.     close(sockfd); // 正常情况下应该关闭套接字  
  63.     return 0; // 程序正常结束  
  64. }

cliente.c

  1. #include <stdio.h>  
  2. #include <stdlib.h>  
  3. #include <unistd.h>  
  4. #include <string.h>  
  5. #include <sys/types.h>          /* See NOTES */  
  6. #include <sys/socket.h>  
  7. #include <netinet/in.h>  
  8. #include <netinet/ip.h>  
  9. #include <arpa/inet.h>  
  10. #include <time.h>  
  11.   
  12. // 定义一个类型别名SA，指向sockaddr结构体  
  13. typedef struct sockaddr *SA;  
  14. // 注意：它尝试定义一个函数指针类型而不是简单的结构体指针。  
  15.  
  16.   
  17. int main(int argc, char *argv[])  
  18. {  
  19.     // 创建一个UDP套接字  
  20.     int sockfd = socket(AF_INET, SOCK_DGRAM, 0);  
  21.     if(-1 == sockfd)  
  22.     {  
  23.         perror("socket"); // 如果创建套接字失败，打印错误信息  
  24.         exit(1); // 退出程序  
  25.     }  
  26.   
  27.     // 初始化sockaddr_in结构体，用于指定服务器地址和端口  
  28.     struct sockaddr_in ser;  
  29.     bzero(&ser, sizeof(ser)); // 将结构体内存清零  
  30.     ser.sin_family = AF_INET; // 使用IPv4地址  
  31.     // 将端口号从主机字节序转换为网络字节序  
  32.     ser.sin_port = htons(50000);  
  33.     // 将点分十进制的IP地址字符串转换为网络字节序的整数  
  34.     ser.sin_addr.s_addr = inet_addr("192.168.203.128");  
  35.   
  36.     // 无限循环，发送数据并尝试接收响应  
  37.     while(1)  
  38.     {  
  39.         char buf[512] = "hello,this is udp test"; // 准备发送的数据  
  40.         // 发送数据到指定的服务器地址和端口  
  41.         sendto(sockfd, buf, strlen(buf), 0, (SA)&ser, sizeof(ser));  
  42.           
  43.         // 清空缓冲区，准备接收数据  
  44.         bzero(buf, sizeof(buf));  
  45.         // 尝试接收数据，但源地址和端口被设置为NULL，这通常是不正确的  
  46.         // 在实际应用中，应该提供一个sockaddr_in结构体来接收源地址和端口信息  
  47.         recvfrom(sockfd, buf, sizeof(buf), 0, NULL, NULL);  
  48.           
  49.         // 打印接收到的数据（但在这个例子中，由于recvfrom的源地址和端口被设置为NULL，它可能不会按预期工作）  
  50.         printf("buf is %sn", buf);  
  51.           
  52.         // 等待1秒后再发送下一个数据包  
  53.         sleep(1);  
  54.     }  
  55.   
  56.     // 注意：由于程序进入了一个无限循环，下面的close和return语句实际上永远不会被执行  
  57.     close(sockfd); // 关闭套接字  
  58.     return 0; // 程序正常结束  
  59. }

Perfil personal

Se ha dedicado a la investigación de tecnología durante más de 30 años y domina varios lenguajes como java, linux, javascript, php, css, etc. Ha realizado muchas contribuciones en el campo del código abierto. Estación de documentación para desarrolladores para compartir algunos problemas en el desarrollo de tecnología para referencia futura.

Mi informacion de contacto

Correo