Begrip van Sockets

Introductie

Sockets zijn een manier om interprocescommunicatie mogelijk te maken tussen programma’s die op een server draaien, of tussen programma’s die op afzonderlijke servers draaien. Communicatie tussen servers maakt gebruik van netwerksokkels, die het Internet Protocol (IP) gebruiken om gegevens te encapsuleren en te verzenden en ontvangen.

Netwerksokkels op zowel clients als servers worden aangeduid met hun sokkeladres. Een adres is een unieke combinatie van een transportprotocol zoals het Transmission Control Protocol (TCP) of het User Datagram Protocol (UDP), een IP-adres en een poortnummer.

In deze zelfstudie leert u over de volgende verschillende soorten sokkels die worden gebruikt voor interprocescommunicatie:

• Stream-sokkels, die TCP gebruiken als hun onderliggende transportprotocol
• Datagram-sokkels, die UDP gebruiken als hun onderliggende transportprotocol
• Unix Domeinsokkels, die lokale bestanden gebruiken om gegevens te verzenden en ontvangen in plaats van netwerkinterfaces en IP-pakketten.

In elk gedeelte van deze zelfstudie leert u ook hoe u de respectievelijke soorten sokkels kunt opnoemen op een Linux-systeem. U zult elk type sokkel onderzoeken met behulp van een verscheidenheid aan opdrachtregelhulpprogramma’s.

Vereisten

De voorbeelden in deze tutorial zijn gevalideerd op een Ubuntu 20.04-server. U kunt deze tutorial volgen met de meeste moderne Linux-distributies op een lokale computer of een externe server, zolang u de equivalent versie van elk van de benodigde tools voor uw distributie hebt geïnstalleerd.

Om aan de slag te gaan met Ubuntu 20.04, hebt u één server nodig die is geconfigureerd door onze Initiële serverconfiguratie voor Ubuntu 20.04 gids te volgen.

U hebt ook een paar andere pakketten nodig om sockets op uw systeem te kunnen onderzoeken. Zorg ervoor dat de pakketcache van uw systeem is bijgewerkt met het apt update commando:

sudo apt update 

Vervolgens installeert u de vereiste pakketten met dit commando:

sudo apt install iproute2 netcat-openbsd socat

Het iproute2 pakket bevat het ss hulpprogramma, dat we zullen gebruiken om sockets te inspecteren. We zullen het netcat-openbsd pakket gebruiken om netcat te installeren. Let op dat netcat wordt afgekort tot nc wanneer het wordt aangeroepen op de commandoregel. Ten slotte zullen we het socat pakket gebruiken om voorbeeldsockets te maken.

Wat is een Stream Socket?

Stroomsockets zijn verbindinggeoriënteerd, wat betekent dat pakketten die naar en van een netwerksocket worden verzonden, door het hostbesturingssysteem worden afgeleverd voor verwerking door een toepassing. Op netwerk gebaseerde stroomsockets gebruiken meestal het Transmission Control Protocol (TCP) om gegevens te encapsuleren en te verzenden via een netwerkinterface.

TCP is ontworpen als een betrouwbaar netwerkprotocol dat vertrouwt op een stateful verbinding. Gegevens die worden verzonden door een programma met behulp van een TCP-gebaseerde stroomsocket, zullen met succes worden ontvangen door een extern systeem (onder voorbehoud van geen routerings-, firewall- of andere connectiviteitsproblemen). TCP-pakketten kunnen in willekeurige volgorde aankomen op een fysieke netwerkinterface. In het geval dat pakketten uit de volgorde arriveren, zullen de netwerkadapter en het hostbesturingssysteem ervoor zorgen dat ze worden herassembleerd in de juiste volgorde voor verwerking door een toepassing.

A typical use for a TCP-based stream socket would be for a web server like Apache or Nginx handling HTTP requests on port 80, or HTTPS on port 443. For HTTP, a socket address would be similar to 203.0.113.1:80, and for HTTPS it would be something like 203.0.113.1:443.

Het maken van TCP-gebaseerde stroomsockets

In het volgende voorbeeld zult u de socat (afkorting voor SOcket CAT)-opdracht gebruiken om een webserver te emuleren die luistert naar HTTP-verzoeken op poort 8080 (de alternatieve HTTP-poort). Vervolgens zult u de socket onderzoeken met behulp van de ss– en nc-opdrachten.

Voer eerst de volgende socat-opdrachten uit om twee TCP-gebaseerde sockets te maken die luisteren naar verbindingen op poort 8080, met behulp van IPv4- en IPv6-interfaces:

socat TCP4-LISTEN:8080,fork /dev/null&
socat TCP6-LISTEN:8080,ipv6only=1,fork /dev/null&

• De TCP4-LISTEN:8080 en TCP6-LISTEN:8080 argumenten zijn het protocoltype en het poortnummer om te gebruiken. Ze vertellen socat om TCP-sockets te maken op poort 8080 op alle IPv4- en IPv6-interfaces, en om naar elke socket te luisteren voor inkomende verbindingen. socat kan luisteren op elke beschikbare poort op een systeem, dus elke poort van 0 tot 65535 is een geldige parameter voor de socketoptie.
• De fork-optie wordt gebruikt om ervoor te zorgen dat socat blijft draaien nadat het een verbinding heeft afgehandeld, anders zou het automatisch afsluiten.
• Het /dev/null-pad wordt gebruikt in plaats van een extern socketadres. In dit geval vertelt het socat om elke inkomende invoer naar het bestand /dev/null te schrijven, wat het stilzwijgend negeert.
• De ipv6only=1-vlag wordt gebruikt voor het IPv6-socket om het besturingssysteem te vertellen dat de socket niet is geconfigureerd om pakketten naar IPv4-gemapt IPv6-adressen te sturen. Zonder deze vlag zal socat binden aan zowel IPv4- als IPv6-adressen.
• Het &-teken instrueert de shell om het commando op de achtergrond uit te voeren. Deze vlag zorgt ervoor dat socat blijft draaien terwijl u andere commando’s oproept om de socket te onderzoeken.

U ontvangt output zoals hieronder weergegeven, wat aangeeft de twee socat-proces-ID’s die op de achtergrond worden uitgevoerd in uw shell-sessie. Uw proces-ID’s zullen verschillend zijn van degene die hier zijn gemarkeerd:

Output
[1] 434223
[2] 434224

Nu je twee socat-processen hebt die luisteren op TCP-poort 8080 op de achtergrond, kun je de sockets bekijken met behulp van de ss– en nc-hulpprogramma’s.

Het onderzoeken van op TCP gebaseerde streamsockets

Om TCP-sockets op een moderne Linux-systeem te onderzoeken met behulp van het ss-commando, voer je het uit met de volgende vlaggen om de uitvoer te beperken:

• De -4– en -6-vlaggen vertellen ss om alleen IPv4- of IPv6-sockets respectievelijk te onderzoeken. Als deze optie wordt weggelaten, worden beide sets sockets weergegeven.
• De t-vlag beperkt de uitvoer tot TCP-sockets. Standaard geeft de ss-tool alle soorten sockets weer die in gebruik zijn op een Linux-systeem.
• De l-vlag beperkt de uitvoer tot luisterende sockets. Zonder deze vlag zouden alle TCP-verbindingen worden weergegeven, wat zaken zou omvatten zoals SSH, cliënten die verbonden kunnen zijn met een webserver, of verbindingen die je systeem mogelijk heeft met andere servers.
• De n-vlag zorgt ervoor dat poortnummers worden weergegeven in plaats van servicenamen.

Voer eerst het ss -4 -tln-commando uit om de IPv4 TCP-gebaseerde sockets te onderzoeken die luisteren naar verbindingen op je systeem:

ss -4 -tln

Je ontvangt output zoals de volgende:

Output
State      Recv-Q     Send-Q         Local Address:Port           Peer Address:Port     Process     
. . .
LISTEN     0          1                    0.0.0.0:8080                  0.0.0.0:*
. . .

Er kunnen andere regels zijn met andere poorten in uw uitvoer, afhankelijk van welke services op uw systeem draaien. Het gemarkeerde gedeelte 0.0.0.0:8080 van de uitvoer geeft aan dat de IPv4 TCP-socket luistert op alle beschikbare IPv4-interfaces op poort 8080. Een service die alleen luistert op een specifiek IPv4-adres, zal alleen dat IP tonen in het gemarkeerde veld, bijvoorbeeld 203.0.113.1:8080.

Voer nu dezelfde ss opdracht opnieuw uit, maar met de -6 vlag:

ss -6 -tln

U krijgt uitvoer zoals het volgende:

Output
State    Recv-Q   Send-Q     Local Address:Port     Peer Address:Port  Process  
. . .
LISTEN   0        5                   [::]:8080               [::]:*
. . .

Er kunnen andere regels zijn met andere poorten in uw uitvoer, afhankelijk van welke services op uw systeem draaien. Het gemarkeerde gedeelte [::]:8080 van de uitvoer geeft aan dat de IPv6 TCP-socket luistert op alle beschikbare IPv6-interfaces op poort 8080 (zoals aangegeven door de ::-tekens, die IPv6-notatie zijn voor een adres samengesteld uit alleen nullen). Een service die alleen luistert op een specifiek IPv6-adres, zal alleen dat IP tonen in het gemarkeerde veld, bijvoorbeeld [2604:a880:400:d1::3d3:6001]:8080.

Verbinding maken met op TCP gebaseerde streamsockets

U hebt tot nu toe geleerd hoe u TCP-sockets kunt maken en opnoemen op zowel IPv4- als IPv6-interfaces. Nu u twee sockets hebt die luisteren naar verbindingen, kunt u experimenteren met het verbinden met sockets met behulp van het netcat-hulpprogramma.

Het gebruik van netcat om TCP-verbindingen met lokale en externe sockets te testen is een zeer nuttige probleemoplossingstechniek die kan helpen bij het isoleren van connectiviteits- en firewallproblemen tussen systemen.

Om verbinding te maken met de IPv4-socket via het lokale loopback-adres met behulp van netcat, voert u het volgende commando uit:

nc -4 -vz 127.0.0.1 8080

• De -4-vlag vertelt netcat om IPv4 te gebruiken.
• De -v-vlag wordt gebruikt om uitvoer uitgebreid weer te geven op uw terminal.
• De –z-optie zorgt ervoor dat netcat alleen verbinding maakt met een socket, zonder enige gegevens te verzenden.
• Het lokale loopback-IP-adres 127.0.0.1 wordt gebruikt omdat uw systeem zijn eigen unieke IP-adres heeft. Als u het IP-adres van uw systeem kent, kunt u ook daarmee testen. Bijvoorbeeld, als het openbare of privé-IP-adres van uw systeem 203.0.113.1 is, kunt u dat in plaats van het loopback-IP gebruiken.

U ontvangt output zoals het volgende:

Output
Connection to 127.0.0.1 (127.0.0.1) 8080 port [tcp/http-alt] succeeded!

De gemarkeerde regel is de output van netcat. Het geeft aan dat netcat verbinding heeft gemaakt met de TCP-socket die luistert op het loopback-IPv4-adres 127.0.0.1 op poort 8080. U kunt de tweede regel negeren, deze is afkomstig van het socat-proces dat op de achtergrond in uw terminal wordt uitgevoerd.

Nu kunt u dezelfde verbindings test herhalen, maar met behulp van IPv6. Voer het volgende netcat-commando uit:

nc -6 -vz ::1 8080

U zou output moeten ontvangen zoals het volgende:

Output
Connection to ::1 8080 port [tcp/http] succeeded!

De gemarkeerde regel is de output van netcat. Het geeft aan dat netcat verbinding heeft gemaakt met de TCP-socket die luistert op het loopback-IPv6-adres ::1 op poort 8080. Opnieuw kunt u de tweede regel output negeren.

Om uw sockets op te schonen, moet u het fg (foreground) commando uitvoeren voor elk socat proces dat u heeft aangemaakt. Vervolgens zult u CTRL+C gebruiken om elk socat te sluiten. fg brengt processen naar de voorgrond van uw terminal in de omgekeerde volgorde waarin u ze hebt gestart, dus wanneer u het uitvoert, zal de tweede socat instantie degene zijn waarmee u als eerste interacteert.

Voer fg uit om de tweede IPv6 socat instantie naar de voorgrond van uw terminal te brengen. Voer vervolgens CTRL+C uit om deze te sluiten.

fg

U ontvangt output zoals het volgende:

Output
socat TCP6-LISTEN:8080,ipv6only=1,fork /dev/null

Druk op CTRL+C om het proces te stoppen.

Voer nu opnieuw fg uit om de eerste IPv4 socket op te schonen. U zou output moeten hebben zoals het volgende:

Output
socat TCP4-LISTEN:8080,fork /dev/null

Druk op CTRL+C om het proces te stoppen.

U heeft nu IPv4 en IPv6 sockets gemaakt, onderzocht en verbonden op uw systeem. Deze technieken en tools zullen werken op lokale ontwikkelingssystemen of externe productieservers, dus probeer te experimenteren met elke tool om meer vertrouwd te raken met hoe ze kunnen worden gebruikt om TCP sockets te testen en problemen op te lossen.

Wat is een Datagram Socket?

Datagram sockets zijn connectionless, wat betekent dat pakketten die van en naar een socket worden verzonden individueel worden verwerkt door applicaties. Op het netwerk gebaseerde datagram sockets gebruiken meestal het User Datagram Protocol (UDP) om gegevens te encapsuleren en te verzenden.

UDP codeert geen sequentie-informatie in pakketkoppen en er is geen foutcorrectie ingebouwd in het protocol. Programma’s die datagramgebaseerde netwerksockets gebruiken, moeten hun eigen foutafhandeling en gegevensordening logica opbouwen om succesvolle gegevensoverdracht te garanderen.

UDP-sockets worden vaak gebruikt door Domain Name System (DNS) servers. Standaard gebruiken DNS-servers poort 53 om vragen voor domeinnamen te verzenden en ontvangen. Een voorbeeld van een UDP-socketadres voor een DNS-server zou vergelijkbaar zijn met 203.0.113.1:53.

Het Network Time Protocol (NTP) gebruikt een UDP-socket op poort 123 om klokken tussen computers te synchroniseren. Een voorbeeld van een UDP-socket voor het NTP-protocol zou 203.0.113.1:123 zijn.

Datagramsockets maken

Zoals in het vorige voorbeeld van TCP-sockets, zult u in deze sectie opnieuw socat gebruiken om een NTP-server te emuleren die luistert naar verzoeken op UDP-poort 123. Vervolgens zult u de sockets onderzoeken die u maakt met behulp van de ss– en nc-opdrachten.

Voer eerst de volgende socat-opdrachten uit om twee UDP-sockets te maken die luisteren naar verbindingen op poort 123, met behulp van IPv4- en IPv6-interfaces:

sudo socat UDP4-LISTEN:123,fork /dev/null&
sudo socat UDP6-LISTEN:123,ipv6only=1,fork /dev/null&

U ontvangt uitvoer zoals de volgende, die de twee socat-proces-ID’s aangeeft die op de achtergrond van uw shell-sessie worden uitgevoerd. Uw proces-ID’s zullen verschillend zijn dan de hier gemarkeerde:

Output
[1] 465486
[2] 465487

• Elke opdracht is voorafgegaan door sudo, omdat poorten 0 tot 1024 gereserveerd zijn op de meeste systemen. sudo voert een opdracht uit met beheerdersrechten, waardoor socat zich kan binden aan elke poort in het gereserveerde bereik.
• De argumenten UDP4-LISTEN:123 en UDP6-LISTEN:123 zijn het protocoltype en de poort om te gebruiken. Ze vertellen socat om UDP-gebaseerde sockets te maken op poort 123 op zowel IPv4- als IPv6-interfaces, en om te luisteren naar inkomende gegevens. Nogmaals, elke poort in het gehele bereik van 0-65535 is een geldige parameter voor UDP-sockets.
• De argumenten fork, ipv6only=1 en /dev/null worden op dezelfde manier gebruikt als beschreven in het vorige TCP-voorbeeld.

Nu u twee socat-processen heeft die luisteren op UDP-poort 123, kunt u de sockets onderzoeken met behulp van de hulpprogramma’s ss en nc.

Het onderzoeken van Datagramsockets

Om UDP-sockets op een modern Linux-systeem te onderzoeken met behulp van het ss-commando, voer je het uit met de volgende -4, -6 en -uln vlaggen om de uitvoer te beperken:

De u-vlag beperkt de uitvoer tot UDP-sockets. De andere vlaggen zijn hetzelfde als die gebruikt in het vorige TCP-voorbeeld.

Voer eerst het ss -4 -uln commando uit om de IPv4 UDP-sockets te onderzoeken die luisteren naar verbindingen op je systeem:

ss -4 -uln

Je ontvangt een uitvoer zoals de volgende:

Output
State      Recv-Q     Send-Q         Local Address:Port           Peer Address:Port     Process     
. . .
UNCONN   0        0                 0.0.0.0:123            0.0.0.0:*
. . .

Er kunnen andere regels met andere poorten in je uitvoer staan, afhankelijk van welke services op je systeem draaien. Het gemarkeerde deel 0.0.0.0:123 van de uitvoer geeft aan dat de IPv4 UDP-socket beschikbaar is op alle IPv4-interfaces op poort 123. Een service die alleen beschikbaar is op een specifiek IPv4-adres, zal alleen dat IP laten zien in het gemarkeerde veld, bijvoorbeeld 203.0.113.1:123.

Voer nu hetzelfde ss-commando opnieuw uit, maar met de -6-vlag:

ss -6 -uln

Je ontvangt een uitvoer zoals de volgende:

Output
State    Recv-Q   Send-Q     Local Address:Port     Peer Address:Port  Process  
. . .
UNCONN   0        0                   [::]:123              [::]:*
. . .

Er kunnen andere regels zijn met andere poorten in uw uitvoer, afhankelijk van welke services op uw systeem worden uitgevoerd. Het gemarkeerde [::]:123 gedeelte van de uitvoer geeft aan dat de IPv6 TCP-socket beschikbaar is op alle IPv6-interfaces op poort 123 (zoals aangegeven door de :: karakters). Een service die alleen beschikbaar is op een specifiek IPv6-adres, toont alleen dat IP-adres in het gemarkeerde veld, bijvoorbeeld [2604:a880:400:d1::3d3:6001]:123.

Het testen van Datagramsockets

Nu u bekend bent met het maken en opsommen van UDP-sockets op zowel IPv4- als IPv6-interfaces, kunt u experimenteren met het verbinden met hen. Net als bij TCP-sockets kunt u experimenteren met UDP-sockets met behulp van het netcat-hulpprogramma.

Om verbinding te maken met het voorbeeld UDP-socket op poort 123 dat u hebt gemaakt in het vorige gedeelte van deze tutorial, voert u het volgende netcat-commando uit:

nc -4 -u -vz 127.0.0.1 123

• De -4 vlag vertelt netcat om IPv4 te gebruiken.
• De -u optie instrueert netcat om UDP in plaats van TCP te gebruiken.
• De -v vlag wordt gebruikt om uitgebreide uitvoer naar uw terminal te printen.
• De –z optie zorgt ervoor dat netcat alleen verbinding maakt met een socket, zonder enige gegevens te verzenden.
• Het lokale loopback IP-adres 127.0.0.1 wordt gebruikt omdat uw systeem zijn eigen unieke IP-adres zal hebben. Als u het IP-adres van uw systeem kent, kunt u dat ook gebruiken voor de test. Bijvoorbeeld, als het publieke of private IP-adres van uw systeem 203.0.113.1 is, kunt u dat in plaats van het loopback-IP gebruiken.

U krijgt output zoals het volgende:

Output
Connection to 127.0.0.1 123 port [udp/ntp] succeeded!

De output geeft aan dat netcat geen foutmelding heeft ontvangen van de UDP-socket die luistert op het loopback-IP 127.0.0.1 met het IPv4-adres op poort 123. Dit gebrek aan een foutreactie wordt gebruikt om af te leiden dat de socket op 127.0.0.1:123 beschikbaar is. Dit gedrag is anders dan bij TCP-sockets, die pakketten moeten uitwisselen om te bevestigen of een socket beschikbaar is.

Nu kunt u dezelfde verbindingstest herhalen maar met gebruik van IPv6. Voer de volgende netcat-opdracht uit:

nc -6 -u -vz ::1 123

U zou output zoals het volgende moeten ontvangen:

Output
Connection to ::1 123 port [udp/ntp] succeeded!!

De uitvoer geeft aan dat netcat geen foutmelding heeft ontvangen van de UDP-socket die luistert op het loopback-adres ::1 IPv6 op poort 123. Opnieuw wordt het ontbreken van een foutreactie gebruikt om te concluderen dat de socket op ::1:123 beschikbaar is.

Om uw sockets op te schonen, moet u het fg (foreground) commando uitvoeren voor elk socat-proces dat u heeft gemaakt. Vervolgens gebruikt u CTRL+C om elk socat-proces te sluiten.

Voer fg uit om de tweede IPv6 socat instantie naar de voorgrond van uw terminal te brengen. Voer vervolgens CTRL+C uit om het te sluiten.

fg

U ontvangt een uitvoer zoals de volgende:

Output
sudo socat UDP6-LISTEN:123,ipv6only=1,fork /dev/null

Druk op CTRL+C om het proces te stoppen.

Voer nu opnieuw fg uit om de eerste IPv4-socket op te schonen. U krijgt een uitvoer zoals de volgende:

Output
sudo socat UDP4-LISTEN:123,fork /dev/null

Druk op CTRL+C om het proces te stoppen.

U heeft nu IPv4- en IPv6-UDP-sockets aangemaakt, onderzocht en getest op uw systeem. Probeer te experimenteren met elk gereedschap om meer vertrouwd te raken met hoe ze kunnen worden gebruikt om UDP-sockets te testen en problemen op te lossen.

Wat is een Unix Domain Socket?

Programma’s die op dezelfde server draaien, kunnen ook met elkaar communiceren via Unix Domain Sockets (UDS). Unix Domain Sockets kunnen op stream-gebaseerd of datagram-gebaseerd zijn. Bij het gebruik van domeinsokkels wordt data rechtstreeks uitgewisseld tussen programma’s in de kernel van het besturingssysteem via bestanden op het hostbestandssysteem. Om gegevens te verzenden of ontvangen via domeinsokkels, lezen en schrijven programma’s naar hun gedeelde socketbestand, waarbij ze volledig netwerkgebaseerde sockets en protocollen omzeilen.

Unix Domain Sockets worden veel gebruikt door databasesystemen die niet hoeven te worden aangesloten op een netwerkinterface. Bijvoorbeeld, MySQL op Ubuntu gebruikt standaard een bestand genaamd /var/run/mysqld/mysql.sock voor communicatie met lokale clients. Klanten lezen van en schrijven naar de socket, net als de MySQL-server zelf.

PostgreSQL is een ander databasesysteem dat een socket gebruikt voor lokale, niet-netwerkcommunicatie. Typisch gebruikt het standaard /run/postgresql/.s.PGSQL.5432 als zijn socketbestand.

Het maken van Unix Domain Sockets

In de vorige secties heb je onderzocht hoe TCP wordt gebruikt met streamsockets en hoe UDP wordt gebruikt met datagramsockets. In deze sectie zul je socat gebruiken om zowel op stroom gebaseerde als op datagram gebaseerde Unix Domain Sockets te maken zonder TCP of UDP te gebruiken om gegevens te encapsuleren om over netwerken te verzenden. Vervolgens zul je de sockets die je hebt gemaakt onderzoeken met behulp van de ss en nc commando’s. Ten slotte zul je leren over het testen van Unix Domain Sockets met behulp van netcat.

Om te beginnen, voer de volgende socat commando’s uit om twee socketbestanden te maken:

socat unix-listen:/tmp/stream.sock,fork /dev/null&
socat unix-recvfrom:/tmp/datagram.sock,fork /dev/null&

• Het eerste commando instrueert socat om een socket te maken met behulp van het adres type unix-listen, wat een op stroom gebaseerde UDS zal maken.
• Het tweede commando specificeert unix-recvfrom als het sockettype, wat een op datagram gebaseerde UDS zal maken
• Beide commando’s specificeren een bestandsnaam na de : scheider. De bestandsnaam is het adres van de socket zelf. Voor het eerste streamvoorbeeld is het /tmp/stream.sock en voor het tweede datagramvoorbeeld is het /tmp/datagram.sock. Merk op dat de naam van een socket willekeurig is, maar het helpt als deze beschrijvend is bij het oplossen van problemen.
• De argumenten fork en /dev/null worden op dezelfde manier gebruikt als beschreven in de voorbeelden van Stream en Datagramsockets.

Nu je je twee UDS sockets hebt gemaakt, kun je ze onderzoeken met behulp van de ss en nc hulpprogramma’s.

Unix-Domeinsockets onderzoeken

Om alle luisterende Unix-Domeinsockets op te lijsten, voer het ss -xln commando uit. Het x vlag zorgt ervoor dat alleen domeinsockets worden weergegeven.

ss -xln

Je krijgt output zoals het volgende:

Output
Netid State  Recv-Q Send-Q      Local Address:Port   Peer Address:Port  Process
. . .
u_str LISTEN 0      5        /tmp/stream.sock 436470            * 0             
u_dgr UNCONN 0      0      /tmp/datagram.sock 433843            * 0
 . . .

Let op het gemarkeerde u_str gedeelte van de /tmp/stream/sock regel. Dit veld geeft aan dat het sockettype stream-based UDS is. De tweede regel toont dat het type u_dgr is, wat betekent dat het sockettype datagram-based is.

Aangezien Unix-Domeinsockets bestanden zijn, kunnen de gebruikelijke Linux gebruikers- en groepsrechten en toegangscontroles worden gebruikt om te beperken wie verbinding kan maken met het socket. Je kunt ook bestandssysteemtools zoals ls, mv, chown en chmod gebruiken om UDS-bestanden te onderzoeken en te manipuleren. Tools zoals SELinux kunnen ook worden gebruikt om UDS-bestanden te labelen met verschillende beveiligingscontexten.

Om te controleren of een bestand een UDS-socket is, gebruik de ls, file of stat hulpprogramma’s. Het is echter belangrijk op te merken dat geen van deze tools kan bepalen of een UDS stream- of datagramgebaseerd is. Gebruik de ss tool voor de meest complete informatie over een Unix-Domeinsocket.

Om een socket op het bestandssysteem te onderzoeken, toont het stat hulpprogramma de meest relevante informatie. Voer het uit op de sockets die je eerder hebt gemaakt:

stat /tmp/stream.sock /tmp/datagram.sock

Je ontvangt uitvoer zoals het volgende:

Output
  File: /tmp/stream.sock
  Size: 0             Blocks: 1          IO Block: 131072 socket
Device: 48h/72d    Inode: 1742        Links: 1
Access: (0755/srwxr-xr-x)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2021-03-01 18:10:25.025755168 +0000
Modify: 2021-03-01 18:10:25.025755168 +0000
Change: 2021-03-01 18:22:42.678231700 +0000
 Birth: -
  File: /tmp/datagram.sock
  Size: 0             Blocks: 1          IO Block: 131072 socket
Device: 48h/72d    Inode: 1743        Links: 1
Access: (0755/srwxr-xr-x)  Uid: (    0/    root)   Gid: (    0/    root)
Access: 2021-03-01 18:10:25.025755168 +0000
Modify: 2021-03-01 18:10:25.025755168 +0000
Change: 2021-03-01 18:10:25.025755168 +0000
 Birth: -

Merk op dat voor elk bestand het type socket is (gemarkeerd helemaal rechts in de uitvoer) en de toegangsmodus een s-karakter heeft vóór de bestandsmachtigingen.

De ls-hulpprogramma geeft ook aan of een bestand een socket is. Voer ls -l uit om de bestanden te bekijken:

ls -l /tmp/stream.sock /tmp/datagram.sock

Je ontvangt uitvoer zoals het volgende. Let op dat voor sockets de bestandsmodus het s-karakter bevat vóór de velden met bestandsmachtigingen:

Output
srwxr-xr-x 1 root root 0 Mar  1 18:10 /tmp/datagram.sock
srwxr-xr-x 1 root root 0 Mar  1 18:10 /tmp/stream.sock

Nu je Unix Domain Sockets hebt aangemaakt en hebt geleerd hoe je ze kunt onderzoeken met behulp van ss en verschillende op het bestandssysteem gebaseerde hulpprogramma’s, is de volgende stap om de sockets te testen met een tool zoals netcat.

Het testen van Unix Domain Sockets

Het hulpprogramma netcat kan worden gebruikt om verbinding te maken met Unix Domain Sockets, evenals TCP- en UDP-sockets waarover je eerder in deze handleiding hebt geleerd. Om verbinding te maken met de voorbeeldsockets die je hebt gemaakt, moet je een extra vlag -U specificeren bij het uitvoeren van het netcat-commando. Deze vlag vertelt netcat om verbinding te maken met een UDS, in tegenstelling tot een op TCP of UDP gebaseerd netwerksocket.

Bovendien, als de socket op datagrammen is gebaseerd, gebruik je de vlag -u om netcat opdracht te geven datagrammen te gebruiken zoals we hebben geleerd in het gedeelte over Datagram Socket van deze handleiding.

Laten we beginnen met het onderzoeken van UDS-sockets door verbinding te maken met de op stroom gebaseerde socket met de volgende opdracht:

nc -U -z /tmp/stream.sock

De -U vertelt netcat dat het verbinding maakt met een Unix Domain Socket.
De –z optie zorgt ervoor dat netcat alleen verbinding maakt met een socket, zonder enige gegevens te verzenden.
De /tmp/stream.sock is het adres van de socket op het bestandssysteem.

U ontvangt geen uitvoer van netcat wanneer u de opdracht uitvoert. Als een socket echter niet beschikbaar is, geeft netcat een foutmelding zoals de volgende:

Output
nc: unix connect failed: No such file or directory
nc: /tmp/stream.sock: No such file or directory

Dus de afwezigheid van uitvoer van netcat bij het testen van een op stroom gebaseerde UDS-socket betekent dat de verbinding succesvol was.

Herhaal het testproces, dit keer voor de op datagram gebaseerde UDS:

nc -uU -z /tmp/datagram.sock

De extra -u vlag wordt toegevoegd om netcat te vertellen dat de externe socket een datagramsocket is. Opnieuw ontvangt u geen uitvoer als de test succesvol is.

Als er geen socket op het adres is, ontvangt u een foutmelding zoals de volgende:

Output
nc: unix connect failed: No such file or directory
nc: /tmp/datagram.sock: No such file or directory

Om uw sockets op te ruimen, moet u het fg (voorgrond) commando uitvoeren voor elk socat-proces dat u hebt gemaakt. Vervolgens gebruikt u CTRL+C om elk socat-proces te sluiten.

Voer fg uit om de op datagram gebaseerde socat-instantie naar de voorgrond van uw terminal te brengen:

fg

U ontvangt uitvoer zoals de volgende:

Output
socat unix-recvfrom:/tmp/datagram.sock,fork /dev/null

Voer CTRL+C uit om het te sluiten. U ontvangt geen uitvoer.

Voer nu opnieuw fg uit om de eerste op stroom gebaseerde UDS-socket op te schonen.

Opnieuw zou u uitvoer moeten hebben zoals de volgende:

Output
socat unix-listen:/tmp/stream.sock,fork /dev/null

Voer CTRL+C uit om het proces te beëindigen. U ontvangt geen uitvoer.

U hebt nu Unix Datagram Sockets-aansluitingen gemaakt, onderzocht en getest op uw systeem. Probeer te experimenteren met netcat en socat om meer vertrouwd te raken met hoe u gegevens kunt verzenden en ontvangen via een UDS, evenals hoe u Unix Domain-aansluitingen kunt testen en debuggen.

Conclusie

In deze tutorial hebt u verkend hoe verschillende soorten sockets worden gebruikt op een Linux-systeem. U hebt geleerd over op stroom gebaseerde sockets, die meestal TCP gebruiken voor netwerkcommunicatie. U hebt ook geleerd over op datagrammen gebaseerde sockets, die UDP gebruiken om gegevens over netwerken te verzenden. Ten slotte hebt u verkend hoe Unix Domain Sockets op een lokale server zowel op stroom als op datagrammen gebaseerd kunnen zijn.

In elke sectie hebt u het hulpprogramma ss gebruikt om informatie te verzamelen over sockets op een Linux-systeem. U hebt geleerd hoe de verschillende vlaggen die het ss-gereedschap biedt, u kunnen helpen om de uitvoer te beperken tot specifieke soorten sockets wanneer u sockets op een systeem onderzoekt.

Eindelijk heb je de netcat- en socat-tools gebruikt om elk van de drie verschillende soorten sockets te creëren en ermee verbinding te maken die in deze handleiding worden besproken. Het hulpprogramma netcat wordt veel gebruikt om verbinding te maken met sockets, maar het kan ook sockets creëren. De documentatie ervan (man nc) bevat vele voorbeelden van hoe het in beide modi kan worden gebruikt. Het hulpprogramma socat is een geavanceerder hulpmiddel dat kan worden gebruikt om verbinding te maken met en veel verschillende soorten sockets die niet worden behandeld in deze handleiding. De documentatie ervan (man socat) bevat ook talrijke voorbeelden van de verschillende manieren waarop het kan worden gebruikt.

Het begrijpen van wat sockets zijn en hoe ze werken is een kernvaardigheid voor systeembeheer. De tools en technieken waarmee je hebt geëxperimenteerd in deze handleiding zullen je helpen vertrouwder te worden met sockets, en hoe je ze kunt oplossen als je servers en applicaties niet correct met elkaar communiceren.