Compartilhamento de tecnologia

Programação de Rede: Conceitos Básicos

2024-07-12

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

1. Modelo OSI

Modelo OSI ===》Modelo de Interconexão de Sistema Aberto ==》é dividido em 7 camadas:
Modelo ideal ==》Ainda não realizado
tftp
b /etc/senha
um /etc/123
Camada de aplicação
Criptografia e descriptografia da camada de apresentação gzip
Desconexão da rede da camada de sessão, status da conexão, keep-close keep-alive

Camada de transporte tcp udp arquivo de protocolo vídeo, áudio
IP da camada de rede NAT

Verificação do quadro de formatação de dados da troca da camada de link
Camada física 100Mb/8 Gbits 100MB cabo coaxial 10Gb 2.4G 5G

De baixo para cima, o fundo é o mais básico

2. Modelo TCP/IP

Modelo TCP/IP ==》Modelo de Internet ==》está dividido em 4 camadas:
Modelo Prático ===》Padrão Industrial
pilha de protocolos tcp/ip
Camada de aplicação ====》Aplicação
Camada de transporte ====》Número da porta tcp udp (qual método de transmissão é usado,tcp confiável，UDP tem alto desempenho em tempo real）
Camada de rede ====》Endereço IP (Como encontrar a outra parte e o anfitrião）
Camada de interface ====》 Driver da placa de rede 1 GB
pcap ,,,

3. Conjunto de protocolos TCP/IP

www.taobao.com ---> 192.168.0.19
www.voa.com vpn
Resolução de nomes de domínio DNS (geralmente com base na província)


DHCP (protocolo de configuração de host dinâmico)
Camada de aplicação:HTTP (página da web) TFTP (transferência trivial de arquivos de curto alcance)FTP (transferência de longa distância pela Internet)
                   SNMP (Gerenciar e monitorar dispositivos, sistemas e aplicativos de rede)DNS ...
Camada de transporte: TCP UDP 56k cat
Camada de rede: IP ICMP (ping) RIP OSPF IGMP...
Camada de interface: ARP (Protocolo de resolução de endereço) RARP... ip--->mac
arp,,,,
    192.160.0.112 

1. Noções básicas de rede

Noções básicas de rede ===》Aula ABCDE
010  3333344444
Endereço IP == bits de rede + bits de host

Classificação de endereço IP: decimal pontilhado ipv4 712934
    Categoria A: Rede de grande escala
                          8    8     8    8
        1.0.0.0 - 126.255.255.255  126.1.1.1 
        ID de rede                                126.1.1.2
       255.0.0.0 (máscara de sub-rede)  
privado:
        10.0.0.0 - 10.255.255.255
        127.0.0.1
    Categoria B: Redes de grande e médio porte
        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

   Categoria C: Redes de pequeno e médio porte
       192.0.0.0 - 223.255.255.255
        255.255.255.0
privado:
       192.168.0.0 - 192.168.255.255
Roteamento Estático
        192.168.0.0
        Porta de entrada 192.168.0.1
        192.168.0.255 (Transmissão, todos na LAN podem recebê-la)

   Categoria D: Multitransmissão etransmissão
        224.0.0.0 - 239.255.255.255 (bate-papo em grupo, não aberto a todos, não limitado a LAN)
        192.168.0.255 == 255.255.255.255 (somente LAN, uma pessoa envia, todos recebem)
        235.1.2.3
        192.168.1.0 
Gateway 192.168.0.1
192.168.1.255 Transmissão

Categoria E: Experimental
        240.0.0.0 - 255.255.255.255
        
Rede classe C:
Os primeiros três grupos do endereço IP são o endereço de rede e o quarto grupo é o endereço do host.
O bit mais alto do binário deve ser: começando com 110xxxxx
Faixa de representação decimal: 192.0.0.0 -223.255.255.255
Máscara de rede padrão: 255.255.255.0
Número de redes: 2 ^ 24, cerca de 2,09 milhões
Número de hosts: 2^8 254 + 2 ===》1 é o gateway 1 é transmitido
Endereço privado: endereço LAN 192.168.xx.
  
  sudo vim/etc/network/interfaces "Configurar rede"
sudo /etc/init.d/networking reiniciar
sudo reinicialização
    192.168.0.0
Rota 192.168.0.1
192.168.0.255 transmissão de placa
801.ng
Configuração para acesso à Internet em uma única máquina:
1. Tenha uma interface de rede e conecte o cabo de rede.
2. Tenha um endereço IP
3. Defina as configurações de rede
           ip (modificar ip temporário): ifconfig ethX XXXX/24 up ifconfig ens33 192.168.0.13/24 (máscara de sub-rede) até 255.255.255.0
Gateway: rota adicionar padrão gw xxxx
DNS： vi /etc/resolv.conf ==>nameserver 8.8.8.8
            Teste: ping www.baidu.com
            líquidoEstado -anp (pode visualizar o status da rede do computador)

2. Interface de rede

1. soquete soquete (Descritor de arquivo - dispositivo de rede associado） ==》Soquete BSD ==》Um conjunto de funções de interface para comunicação em rede。soquete APIs  interface de aplicaçãointerface de função
        2. ip+porta endereço+porta===》O endereço é usado paraIdentificar anfitrião
Porta usadaIdentificar aplicativos

          A porta é dividida em porta TCP/porta UDP, o intervalo é: 1-65535
Fica acordado que as portas dentro de 1000 são usadas pelo sistema.
http 80 www.baidu.com
                3306
telnet 21
ssh22- ...

3. Ordem de bytes da rede

        Armazenamento big endian (bits baixos em memória alta - dispositivos de rede)
     Little endian 0x12345678 (bit baixo em pouca memória - host)
        12 00   
        00 12
        192.168.0.12 (big-endian) “bit mais significativo armazenado primeiro”
       12.0.168.192 (pequeno endian)

4. UDP (datagrama do usuário)

1. Recursos: sem link, big data não confiável

2. Estrutura: modo C/S

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

Nota: Os parâmetros de socket() precisam ser ajustados.

soquete(PF_INET,SOCK_DGRAM,0);

      bind() cliente(c) é opcional，Lado(s) do servidor são obrigatórios。

1. soquete

soquete int(domínio int, tipo int, protocolo int);
Função: O programa propõe ao kernelCrie um descritor de soquete baseado em memória

parâmetro:família de endereços de domínio, PF_INET == AF_INET ==>programa de Internet
PF_UNIX == AF_UNIX ==>programa independente
          tipo tipo de soquete:
Soquete de streaming SOCK_STREAM ===》TCP
Soquete de datagrama do usuário SOCK_DGRAM ===>UDP
Soquete bruto SOCK_RAW ===》IP
          protocol protocol ==》0 significa adaptação automática ao protocolo da camada de aplicação.

Valor de retorno: retorno com sucessoO ID do soquete solicitado
Falha -1;

2.vincular

int vincular(int meia fd, struct sockaddr *meu_endereço, endereço da meia_t);
Função: Se a função estiver emTerminal de serviçoChamado, significa associar o arquivo descritor de arquivo relacionado ao parâmetro 1 com o endereço da interface especificado pelo parâmetro 2 paraAceite dados desta interface。

Se a função estiver emSintonia do clienteSe utilizado, significa que os dados devem ser retirados do descritor onde está localizado o parâmetro 1 e do dispositivo de interface onde está localizado o parâmetro 2. enviar。

Nota: Se for um cliente, esta função poderá ser omitida e os dados serão enviados pela interface padrão.
parâmetro:descritor de arquivo sockfd e ID de soquete criado anteriormente por meio da função de soquete
          my_addr é o ponteiro de estrutura da interface física.Representa informações sobre a interface

estrutura de endereço universal sockaddr
      {
u_short sa_family; endereço família;
char sa_data[14];
      };

A estrutura de endereço de rede convertida é a seguinte:
struct _sockaddr_in ///Estrutura de endereço de rede
      {
u_short sin_family; endereço família;
u_short sin_port; ///Porta de endereço
struct in_addr sin_addr; ///Endereço IP
char sin_zero[8];
      };

estrutura in_addr
      {
em_addr_t s_addr;
      }

socklen_t addrlen: o comprimento do parâmetro 2.
Valor de retorno: sucesso 0
Falha -1;

3.Enviarassumirfunção:

ssize_t enviar para(int meia fd, const vazio *buf, tamanho_t len,sinalizadores int,
                       const struct sockaddr *dest_addr, endereço da meia_t);

Função: Usado para enviar mensagens para outra parte no protocolo UDPenviar dados。
parâmetro:ID do soquete local do sockfd
           melhorar o armazenamento de dados local, geralmente os dados a serem enviados
          len comprimento dos dados a serem enviados
          flags Como enviar dados,0 significa bloquear o envio

          dest_addr: obrigatório, indicando a estrutura de informações do host de destino a ser enviada
        addrlen: comprimento do endereço de destino

Valor de retorno: comprimento dos dados de sucesso enviados
Falha -1;


ssize_t recvfrom(int meia fd, vazio *buf, tamanho_t len, sinalizadores int,
                           estrutura sockaddr *src_addr, meias_t *endereço);

Função: usado no protocolo UDPObtivermosOs dados enviados pela outra parte.
parâmetro:ID do soquete local do sockfd
          buff A área de memória onde os dados serão armazenados, geralmente um array ou memória dinâmica
        len é o comprimento dos dados a serem obtidos, geralmente o tamanho do buff.
           método de aquisição de bandeiras,0 bloqueio

          src_addr é opcional e representa a estrutura de informações de endereço da outra parte If.NULO,expressarNão se importe com o endereço da outra parte
          addrlen O tamanho da estrutura de informações de endereço da outra parte, seEndereço da outra partesimNULOeu, entãoEste valor também é NULL
Valor de retorno: comprimento de dados recebidos com sucesso
Falha -1;

4.Fechar

fechar() ===>Feche o ID do soquete especificado;

Perceber

1. Dados e dados têm limites
2. O número de envio e recebimento deve corresponder
3.recvfrom irá bloquear
4.sento não irá bloquear (recvfrom não recebe, não afeta o envio de sento) 

   c procura por 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 pessoal

Ele se dedica à pesquisa de tecnologia há mais de 30 anos e é proficiente em diversas linguagens como java, linux, javascript, php, css, etc. estação de documentação do desenvolvedor para compartilhar alguns problemas no desenvolvimento de tecnologia para referência futura.

minhas informações de contato

Correspondência