Partage de technologie

Programmation réseau : concepts de base

2024-07-12

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

1. Modèle OSI

Modèle OSI ===》Modèle d'interconnexion de systèmes ouverts ==》est divisé en 7 couches :
Modèle idéal ==》Pas encore réalisé
TFTP
b /etc/passwd
un /etc/123
Couche d'application
Gzip de chiffrement et de décryptage de la couche de présentation
Déconnexion du réseau de la couche session, état de la connexion, maintien de la proximité et maintien de la vie

Fichier de protocole UDP TCP de couche de transport vidéo, audio
NAT IP de la couche réseau

Vérification de la trame de formatage des données du commutateur de couche de liaison
Couche physique 100 Mo/8 Gbits Câble coaxial 100 Mo 10 Go 2,4 G 5G

De bas en haut, le bas est le plus basique

2. Modèle TCP/IP

Modèle TCP/IP ==》Modèle Internet ==》est divisé en 4 couches :
Modèle pratique ===》Norme industrielle
pile de protocoles TCP/IP
Couche d'application ====》Application
Couche de transport ====》Numéro de port TCP UDP (quelle méthode de transmission est utilisée,TCP fiable，UDP a des performances en temps réel élevées）
Couche réseau ====》Adresse IP (Comment trouver l'autre partie et l'hôte）
Couche d'interface ====》Pilote de carte réseau 1 Go
pcap ,,,

3. Suite de protocoles TCP/IP

www.taobao.com ---> 192.168.0.19
www.voa.com vpn
Résolution de nom de domaine DNS (généralement basée sur la province)


DHCP (protocole de configuration dynamique d'hôte)
Couche d'application:HTTP (page Web) TFTP (transfert de fichiers trivial à courte portée)FTP (transfert Internet longue distance)
                   SNMP (Gérer et surveiller les périphériques, systèmes et applications réseau)DNS ...
Couche de transport : TCP UDP 56k cat
Couche réseau : IP ICMP (ping) RIP OSPF IGMP...
Couche d'interface : ARP (Address Resolution Protocol) RARP... ip--->mac
arp,,,,
    192.160.0.112 

1. Bases du réseau

Bases du réseau ===》Classe ABCDE
010  3333344444
Adresse IP == bits réseau + bits hôte

Classification de l'adresse IP : ipv4 décimal pointé 712934
    Catégorie A: Réseau à très grande échelle
                          8    8     8    8
        1.0.0.0 - 126.255.255.255  126.1.1.1 
        ID de réseau                                126.1.1.2
       255.0.0.0 (masque de sous-réseau)  
privé:
        10.0.0.0 - 10.255.255.255
        127.0.0.1
    Catégorie B: Grands et moyens réseaux
        128.0.0.0 - 191.255.255.255
        128.2.1.2  128.2.7.2
        255.255.0.0
privé:
        172.16.0.0 - 172.31.255.255

   Catégorie C: Petits et moyens réseaux
       192.0.0.0 - 223.255.255.255
        255.255.255.0
privé:
       192.168.0.0 - 192.168.255.255
Routage statique
        192.168.0.0
        Passerelle 192.168.0.1
        192.168.0.255 (diffusion, tout le monde sur le réseau local peut le recevoir)

   Catégorie D: Multidiffusion etdiffuser
        224.0.0.0 - 239.255.255.255 (Chat de groupe, non ouvert à tout le monde, non limité au réseau local)
        192.168.0.255 == 255.255.255.255 (uniquement LAN, une personne envoie, tout le monde reçoit)
        235.1.2.3
        192.168.1.0 
Passerelle 192.168.0.1
192.168.1.255 Diffusion

Catégorie E : Expérimental
        240.0.0.0 - 255.255.255.255
        
Réseau de classe C :
Les trois premiers groupes de l'adresse IP sont l'adresse réseau et le quatrième groupe est l'adresse de l'hôte.
Le bit le plus élevé du binaire doit être : commençant par 110xxxxx
Plage de représentation décimale : 192.0.0.0 -223.255.255.255
Masque de réseau par défaut : 255.255.255.0
Nombre de réseaux : 2^24, environ 2,09 millions
Nombre d'hôtes : 2^8 254 + 2 ===》1 est la passerelle 1 est diffusée
Adresse privée : 192.168.xx Adresse LAN.
  
  sudo vim/etc/network/interfaces "Configurer le réseau"
sudo /etc/init.d/networking restart
redémarrage sudo
    192.168.0.0
Route 192.168.0.1
192.168.0.255 boardcast
801.ng
Configuration pour un accès Internet sur une seule machine :
1. Ayez une interface réseau et branchez le câble réseau.
2. Avoir une adresse IP
3. Configurez les paramètres réseau
           ip (modifier l'ip temporaire) : ifconfig ethX XXXX/24 up ifconfig ens33 192.168.0.13/24 (masque de sous-réseau) jusqu'à 255.255.255.0
Passerelle : ajout de route par défaut gw xxxx
DNS : vi /etc/resolv.conf ==>serveur de noms 8.8.8.8
            Test : ping www.baidu.com
            filetstatistique -anp (peut afficher l'état du réseau de l'ordinateur)

2.Interface réseau

1. prise de courant (Descripteur de fichier - périphérique réseau associé） ==》Socket BSD ==》Un ensemble de fonctions d'interface pour la communication réseau.prise API  interface d'applicationinterface de fonction
        2. adresse IP+port adresse+port===》L'adresse est utilisée pourIdentifier l'hôte
Port utiliséIdentifier les applications

          Le port est divisé en port TCP/port UDP, la plage est : 1-65535
Il est convenu que les ports situés dans un rayon de 1 000 sont utilisés par le système.
http://www.baidu.com/
                3306
telnet 21
ssh 22

3. Ordre des octets du réseau

        Stockage Big Endian (bits faibles dans mémoire haute - périphériques réseau)
     Little endian 0x12345678 (bit faible dans mémoire faible - hôte)
        12 00   
        00 12
        192.168.0.12 (big-endian) "bit le plus significatif stocké en premier"
       12.0.168.192 (petit endian)

4. UDP (datagramme utilisateur)

1. Caractéristiques : pas de lien, peu fiable, big data

2. Cadre : mode C/S

serveur : socket() ===>bind()===>recvfrom()===>close()
client : socket() ===>bind()===>sendto() ===>close()

Remarque : Les paramètres de socket() doivent être ajustés.

socket(PF_INET,SOCK_DGRAM,0);

      bind() client(c) est facultatif，Un ou plusieurs côtés serveur sont requis。

1. prise

int socket(domaine int, type int, protocole int);
Fonction : Le programme propose au noyauCréer un descripteur de socket basé sur la mémoire

paramètre:famille d'adresses de domaine, PF_INET == AF_INET ==>Programme Internet
PF_UNIX == AF_UNIX ==>programme autonome
          Type de prise :
Prise de streaming SOCK_STREAM ===》TCP
Socket de datagramme utilisateur SOCK_DGRAM ===>UDP
Prise brute SOCK_RAW ===》IP
          protocol protocol ==》0 signifie s'adapter automatiquement au protocole de la couche application.

Valeur de retour : retour réussiL'identifiant de socket demandé
Échec -1 ;

2.lier

int lier(int sockfd, struct sockaddr *mon_adresse, chaussettes_t addrlen);
Fonction : Si la fonction est enTerminal de serviceAppelé, cela signifie associer le fichier descripteur de fichier lié au paramètre 1 à l'adresse d'interface spécifiée par le paramètre 2 pourAccepter les données de cette interface。

Si la fonction est enAccord clientS'il est utilisé, cela signifie que les données doivent être extraites du descripteur où se trouve le paramètre 1 et du dispositif d'interface où se trouve le paramètre 2. envoyer。

Remarque : S'il s'agit d'un client, cette fonction peut être omise et les données seront envoyées par l'interface par défaut.
paramètre:Descripteur de fichier sockfd et identifiant de socket précédemment créés via la fonction socket
          my_addr est le pointeur de structure de l'interface physique.Représente des informations sur l'interface

struct sockaddr structure d'adresse universelle
      {
u_short sa_family ; adresse à la famille
char sa_data[14] ; informations sur l'adresse
      };

La structure d'adresse réseau convertie est la suivante :
struct _sockaddr_in ///Structure d'adresse réseau
      {
u_short sin_family ; adresse à la famille
u_short sin_port; ///Port d'adresse
struct in_addr sin_addr; ///Adresse IP
char sin_zero[8];
      };

structure in_addr
      {
dans_addr_t s_addr;
      }

socklen_t addrlen : la longueur du paramètre 2.
Valeur de retour : succès 0
Échec -1 ;

3.Envoyerreprendrefonction:

ssize_t envoyer à(int sockfd, const void *buf, taille_t longueur,drapeaux int,
                       structure const sockaddr *dest_addr, chaussettes_t addrlen);

Fonction : utilisé pour envoyer des messages à l'autre partie dans le protocole UDPenvoyer des données。
paramètre:identifiant de socket local sockfd
           améliorer le stockage des données locales, généralement les données à envoyer
          len longueur des données à envoyer
          flags Comment envoyer des données,0 signifie bloquer l'envoi

          dest_addr : obligatoire, indiquant la structure d'informations de l'hôte cible à envoyer
        addrlen : longueur de l'adresse cible

Valeur de retour : Réussite Longueur des données envoyées
Échec -1 ;


ssize_t reçu à partir de(int sockfd, vide *buf, taille_t longueur, drapeaux int,
                           structure sockaddr *src_addr, chaussettes_t *addrlen);

Fonction : utilisé dans le protocole UDPObtenirLes données envoyées par l'autre partie.
paramètre:identifiant de socket local sockfd
          buff La zone mémoire où les données doivent être stockées, généralement un tableau ou une mémoire dynamique
        len est la longueur des données à obtenir, généralement la taille du buff.
           méthode d'acquisition des drapeaux,0 blocage

          src_addr est facultatif et représente la structure des informations d'adresse de l'autre partie If.NUL,exprimerNe vous souciez pas de l'adresse de l'autre partie
          addrlen La taille de la structure des informations d'adresse de l'autre partie, siAdresse de l'autre partieOuiNULL, alorsCette valeur est également NULL
Valeur de retour : longueur des données reçues avec succès
Échec -1 ;

4.Fermer

fermer() ===> Fermez l'identifiant de socket spécifié ;

Avis

1. Les données et les données ont des limites
2. Le nombre d'envoi et de réception doit correspondre
3.recvfrom bloquera
4.sento ne bloquera pas (recvfrom ne reçoit pas, n'affecte pas l'envoi de sento) 

   c cherche s

serveur.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. }

client.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. }

Profil personnel

Il se consacre à la recherche technologique depuis plus de 30 ans et maîtrise divers langages tels que java, linux, javascript, php, css, etc. Il a apporté de nombreuses contributions dans le domaine de l'open source. station de documentation pour les développeurs pour partager certains problèmes de développement technologique pour référence future.

mes coordonnées

Mail