Explication détaillée des sockets (TCP et UDP)

little bottle
Libérer: 2023-04-05 19:38:01
avant
3520 Les gens l'ont consulté

Lors de l'apprentissage de LInux, les sockets de programmation réseau sont la base et un point difficile à apprendre pour les novices. Grâce à cet article, les lecteurs peuvent pleinement comprendre les adresses IP, les numéros de port, les concepts TCP, UDP et l'API de socket à travers des illustrations et le code de l'auteur. idées d’implémentation. Utilisation, communication client/serveur simulée, etc.

  • Marc : Il a fallu 18 minutes pour lire le blog + implémentation du code
  • Explication détaillée des sockets (TCP et UDP)


Focus de l'article :
  • Adresse IP, numéro de port...

  • API du socket

  • Implémentation du client/serveur UDP


  • Socket est un mécanisme de communication dans la programmation réseau et l'unité opérationnelle de base de la communication réseau qui prend en charge TCP/IP. est un point final pour la communication bidirectionnelle entre les processus sur différents hôtes. En termes simples, il s'agit d'un accord entre les deux parties communicantes. Les fonctions pertinentes du socket sont utilisées pour terminer le processus de communication.

Comme introduit précédemment, il existe de nombreuses façons de communication inter-processus locale (IPC). Les plus courantes sont résumées comme suit :

 1、管道(包括无名管道和命名管道);
 2、消息队列;
 3、信号量;
 4、共享存储。
 5、……( Socket和Streams支持不同主机上的两个进程IPC)。
Copier après la connexion
Comprendre le processus de communication de la couche réseau. :

Explication détaillée des sockets (TCP et UDP)

Première introduction à l'IP :

(IP est : IP du protocole Internet)

Explication détaillée des sockets (TCP et UDP)

Dans Lors de la communication, l'IP peut être divisée en IP source et IP de destination.

Comparez l'envoi express : la communication réseau équivaut à l'envoi et à la réception d'IP express, c'est l'adresse du destinataire/expéditeur. ne suffit pas, il faut aussi connaître la livraison. Qui est la personne ? Ceci est comparé au concept de numéros de port dans le réseau. Le numéro de port identifie un processus et indique au système d'exploitation à quel programme les données actuelles sont transmises pour analyse.


Numéro de port :

Le numéro de port (port) est le contenu du protocole de la couche transport.

  • Le numéro de port est un entier de 2 octets de 16 bits

  • Le numéro de port est utilisé pour identifier un processus et indiquer au système d'exploitation ; système selon lequel le programme actuel doit transmettre les données pour analyse

  • L'adresse IP + le numéro de port peuvent identifier un processus d'un certain hôte sur le réseau

  • Un numéro de port ne peut être occupé que par un seul processus.

Numéro de port et processus :
  • Concept
Le processus a un caractère unique Identification pid, les numéros de port peuvent également identifier les processus ;

Un processus peut être lié à plusieurs numéros de port, mais un numéro de port ne peut pas être lié à plusieurs processus.

  • Numéro de port source et numéro de port de destination
Le segment de données du protocole de couche de transport (TCP/IP) contient Les deux numéros de port, appelés respectivement numéro de port source et numéro de port de destination, décrivent "à qui appartiennent les données ? À qui sont-elles envoyées ?" ) Protocole de contrôle de transmission, orienté connexion. Il s'agit d'un protocole général qui assure une transmission de données fiable.

Protocole de couche transport

    Connecté
  • Transmission fiable
  • Orienté flux d'octets
  • UDP :
  • (UDP) User Datagram Protocol est un protocole orienté sans connexion. L’utilisation de ce protocole ne nécessite pas que les deux applications établissent au préalable une connexion. Le protocole UDP ne permet pas de récupération d'erreur et ne peut pas assurer la retransmission des données, la sécurité de la transmission des données de ce protocole est donc médiocre.

Protocole de couche transport

    Aucune connexion
  • Transmission peu fiable
  • Orienté datagramme
  • Ordre des octets du réseau :


Comment définir l'adresse du flux de données du réseau ?

Explication détaillée des sockets (TCP et UDP)

  • En fait, il est facile de comprendre ce problème, qui est un problème endian plus particulier en langage C.

Explication détaillée des sockets (TCP et UDP)L'émetteur envoie par ordre d'adresse mémoire de bas en haut ;

    L'hôte récepteur stocke par ordre d'adresse mémoire de bas en haut ;
  • Règlementations TCP/IP : le flux de données du réseau doit être dans l'ordre des octets big-endian, c'est-à-dire
  • octet de poids fort de l'adresse

    ;

  • Que l'hôte soit big-endian ou small-endian, les réglementations TCP/IP doivent être respectées

  • Si l'expéditeur est small-endian, les données ; doit être converti en big-endian avant l'envoi.
socket API:
//创建socket文件描述符  (TCP/UDP,客户端+服务器)

int socket(int domain, int type, int protocol);
Copier après la connexion

参数1(domain): 选择创建的套接字所用的协议族; <br/> AF_INET : IPv4协议; <br/> AF_INET6: IPv6协议; <br/> AF_LOCAL: Unix域协议; <br/> AF_ROUTE:路由套接口; <br/> AF_KEY :密钥套接口。 <br/>参数2(type):指定套接口类型,所选类型有: <br/> SOCK_STREAM:字节流套接字; <br/> SOCK_DGRAM : 数据报套接字; <br/> SOCK_RAW : 原始套接口。 <br/> procotol: 使用的特定协议,一般使用默认协议(NULL)。

//绑定端口号  (TCP/IP,服务器)
int bind(int socket, const struct sockaddr *address, socklen_t address_len);
Copier après la connexion

参数1(socket) : 是由socket()调用返回的并且未作连接的套接字描述符(套接字号)。 <br/>参数2(address):指向特定协议的地址指针。 <br/>参数3(address_len):上面地址结构的长度。 <br/>返回值:没有错误,bind()返回0,否则SOCKET_ERROR。

//开始监听socket  (TCP,服务器)
int listen(int socket, int backlog);
Copier après la connexion

参数1(sockfd):是由socket()调用返回的并且未作连接的套接字描述符(套接字号)。 <br/>参数2(backlog):所监听的端口队列大小。

//接受请求  (TCP,服务器)
int accept(int socket, struct sockaddr* address, socklen_t* address_len);
Copier après la connexion

参数1(socket) : 是由socket()调用返回的并且未作连接的套接字描述符(套接字号)。 <br/>参数2(address):指向特定协议的地址指针。 <br/>参数3(addrlen):上面地址结构的长度。 <br/>返回值:没有错误,bind()返回0,否则SOCKET_ERROR。

//建立连接  (TCP,客户端)
int connect(int sockfd, const struct struct sockaddr *addr, aocklen_t addrlen);
Copier après la connexion
//关闭套接字
int close(int fd);
Copier après la connexion

参数(fd):是由socket()调用返回的并且未作连接的套接字描述符(套接字号)。

socket API是一层抽象的网络编程接口,适用于各种底层网络协议,如IPv4,IPv6,……

简单的TCP网络程序:
  • TCP客户—服务器程序的执行流程图:

Explication détaillée des sockets (TCP et UDP)

服务器代码:

#include<iostream>
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
using namespace std;

#define SERVER_PORT  5050               //端口号
#define SERVER_IP    "192.168.3.254"    //服务器ip
#define QUEUE_SIZE   5                  //所监听端口队列大小

int main(int argc, char *argv[])
{
    //创建一个套接字,并检测是否创建成功
    int sockSer;                        
    sockSer = socket(AF_INET, SOCK_STREAM, 0);
    if(sockSer == -1){
        perror("socket");
    }

    //设置端口可以重用,可以多个客户端连接同一个端口,并检测是否设置成功
    int yes = 1;
    if(setsockopt(sockSer, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1){
        perror("setsockopt");
    }

    struct sockaddr_in addrSer,addrCli;        //创建一个记录地址信息的结构体
    addrSer.sin_family = AF_INET;              //所使用AF_INET协议族
    addrSer.sin_port = htons(SERVER_PORT);     //设置地址结构体中的端口号
    addrSer.sin_addr.s_addr = inet_addr(SERVER_IP);   //设置其中的服务器ip

    //将套接字地址与所创建的套接字号联系起来。并检测是否绑定成功
    socklen_t addrlen = sizeof(struct sockaddr);
    int res = bind(sockSer,(struct sockaddr*)&addrSer, addrlen);
    if(res == -1)
        perror("bind");

    listen(sockSer, QUEUE_SIZE);       //监听端口队列是否由连接请求,如果有就将该端口设置位可连接状态,等待服务器接收连接

    printf("Server Wait Client Accept......\n");
    //如果监听到有连接请求接受连接请求。并检测是否连接成功,成功返回0,否则返回-1
    int sockConn = accept(sockSer, (struct sockaddr*)&addrCli, &addrlen);
    if(sockConn == -1)
        perror("accept");
    else
    {
        printf("Server Accept Client OK.\n");
        printf("Client IP:> %s\n", inet_ntoa(addrCli.sin_addr));
        printf("Client Port:> %d\n",ntohs(addrCli.sin_port));
    }

    char sendbuf[256];         //申请一个发送缓存区
    char recvbuf[256];         //申请一个接收缓存区
    while(1)
    {
        printf("Ser:>");
        scanf("%s",sendbuf);
        if(strncmp(sendbuf,"quit",4) == 0)    //如果所要发送的数据为"quit",则直接退出。
            break;
        send(sockConn, sendbuf, strlen(sendbuf)+1, 0);   //发送数据
        recv(sockConn, recvbuf, 256, 0);    //接收客户端发送的数据
        printf("Cli:> %s\n",recvbuf);
    }

    close(sockSer);         //关闭套接字
    return 0;
}
Copier après la connexion

客户端代码:

#include<iostream>
#include<unistd.h>
#include<stdio.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
using namespace std;

#define SERVER_PORT  5050
#define SERVER_IP    "192.168.3.254"

int main(int argc, char *argv[])
{
    //创建客户端套接字号,并检测是否创建成功
    int sockCli;
    sockCli = socket(AF_INET, SOCK_STREAM, 0);
    if(sockCli == -1)
        perror("socket");

    //创建一个地址信息结构体,并对其内容进行设置
    struct sockaddr_in addrSer;     
    addrSer.sin_family = AF_INET;         //使用AF_INET协议族
    addrSer.sin_port = htons(SERVER_PORT);  //设置端口号
    addrSer.sin_addr.s_addr = inet_addr(SERVER_IP);   //设置服务器ip

    bind(sockCli,(struct sockaddr*)&addrCli, sizeof(struct sockaddr));    //将套接字地址与所创建的套接字号联系起来

    //创建一个与服务器的连接,并检测连接是否成功
    socklen_t addrlen = sizeof(struct sockaddr);
    int res = connect(sockCli,(struct sockaddr*)&addrSer, addrlen);
    if(res == -1)
        perror("connect");
    else
        printf("Client Connect Server OK.\n");

    char sendbuf[256];     //申请一个发送数据缓存区
    char recvbuf[256];     //申请一个接收数据缓存区
    while(1)
    {
        recv(sockCli, recvbuf, 256, 0);    //接收来自服务器的数据
        printf("Ser:> %s\n",recvbuf);
        printf("Cli:>");
        scanf("%s",sendbuf);
        if(strncmp(sendbuf,"quit", 4) == 0)    //如果客户端发送的数据为"quit",则退出。
            break;
        send(sockCli, sendbuf, strlen(sendbuf)+1, 0);   //发送数据
    }
    close(sockCli);       //关闭套接字
    return 0;
}
Copier après la connexion
简单的UDP网络程序:

Explication détaillée des sockets (TCP et UDP)

  • 相对与TCP来说,UDP安全性差,面向无链接。所以UDP地实现少了连接与接收连接的操作。所以在收发数据时就不能再用send()和recvfrom()了,而是用sendto()和recvto()之名从哪收发数据。
ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);
Copier après la connexion

参数1(sockfd):是由socket()调用返回的并且未作连接的套接字描述符(套接字号) <br/>参数2(buf):指向存有发送数据的缓冲区的指针 <br/>参数3(len):缓冲区长度。 <br/> **参数4(flags):**flags的值或为0,或为其他

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);
Copier après la connexion

参数1(sockfd):是由socket()调用返回的并且未作连接的套接字描述符(套接字号) <br/>参数2(buf):指向存有接收数据的缓冲区的指针 <br/>参数3(len):缓冲区长度 <br/> **参数4(flags):**flags的值或为0,或为其他

服务器端代码:

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/socket.h>

int main()
{
    //创建一个套接字,并检测是否创建成功
    int sockSer = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockSer == -1)
        perror("socket");

    struct sockaddr_in addrSer;  //创建一个记录地址信息的结构体 
    addrSer.sin_family = AF_INET;    //使用AF_INET协议族 
    addrSer.sin_port = htons(5050);     //设置地址结构体中的端口号
    addrSer.sin_addr.s_addr = inet_addr("192.168.3.169");  //设置通信ip

    //将套接字地址与所创建的套接字号联系起来,并检测是否绑定成功
    socklen_t addrlen = sizeof(struct sockaddr);
    int res = bind(sockSer,(struct sockaddr*)&addrSer, addrlen);
    if(res == -1)
        perror("bind");

    char sendbuf[256];    //申请一个发送数据缓存区
    char recvbuf[256];    //申请一个接收数据缓存区
    struct sockaddr_in addrCli;
    while(1)
    {
        recvfrom(sockSer,recvbuf,256,0,(struct  sockaddr*)&addrCli, &addrlen);     //从指定地址接收客户端数据
        printf("Cli:>%s\n",recvbuf);

        printf("Ser:>");    
        scanf("%s",sendbuf);
        sendto(sockSer,sendbuf,strlen(sendbuf)+1,0,(struct sockaddr*)&addrCli, addrlen);    //向客户端发送数据
    }
    return 0;
}
Copier après la connexion

客户端代码:

#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<sys/socket.h>

int main()
{
    //创建一个套接字,并检测是否创建成功
    int sockCli = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockCli == -1){
        perror("socket");
    }

    addrSer.sin_family = AF_INET;    //使用AF_INET协议族 
    addrSer.sin_port = htons(5050);     //设置地址结构体中的端口号
    addrSer.sin_addr.s_addr = inet_addr("192.168.3.169");  //设置通信ip
    socklen_t addrlen = sizeof(struct sockaddr);


    char sendbuf[256];    //申请一个发送数据缓存区
    char recvbuf[256];    //申请一个接收数据缓存区

    while(1){
        //向客户端发送数据
        printf("Cli:>");
        scanf("%s",sendbuf);
        sendto(sockCli, sendbuf, strlen(sendbuf)+1, 0, (struct sockaddr*)&addrSer, addrlen);   
        接收来自客户端的数据
        recvfrom(sockCli, recvbuf, BUFFER_SIZE, 0, (struct sockaddr*)&addrSer, &addrlen);
        printf("Ser:>%s\n", recvbuf);

    }

    return 0;
}
Copier après la connexion

Explication détaillée des sockets (TCP et UDP)

<br/>
Copier après la connexion
【推荐课程:TCP/IP视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!

Étiquettes associées:
source:csdn.net
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Derniers articles par auteur
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal