Betriebssysteme Kapitel 11 - pc01-lsw.ee.hm.eduthomas/Vorlesung/VBS/vbsbx.pdfSockets in LINUX – Grundlagen (1) ... PF_IPX Novell Internet-Protokolle (IPX) PF_NETLINK "Kernel User

FACHHOCHSCHULE MUENCHEN FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK FG TECHNISCHE INFORMATIK I – BS – B00 – 00 – TH – 03 -----------------------------------------------------------------------------------

Betriebssysteme

Kapitel 11

11. Socket-Schnittstelle in LINUX 11.1. Überblick über das Socket-API 11.2. UNIX Domain Sockets 11.3. INET Sockets

FACHHOCHSCHULE MUENCHEN FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK FG TECHNISCHE INFORMATIK I – BS – B11 – 00 – TH – 04 ------------------------------------------------------------------------------------

Sockets in LINUX – Grundlagen (1) •••• Allgemeines

◇ Linux stellt auch das BSD Socket API zur Verfügung. Dieses kann als die heutige Standard-Schnittstelle für die Programmierung von Netzwerkverbindungen betrachtet werden. ⇒ Sockets ermöglichen eine Interprozesskommunukation (IPC) über Rechnergrenzen hinweg. Sie lassen sich aber auch als lokaler IPC-Mechanismus innerhalb eines Rechners einsetzen.

◇ Das Socket API realisiert eine einheitliche Schnittstelle für unterschiedliche Netzwerkprotokolle. Die Schnittstelle ist so konzipiert, dass jederzeit neue Protokolle ohne Änderung der Schnittstelle hinzugefügt werden können. Netzwerkprotokolle werden in Abhängigkeit von ihren Kommunikationseigenschaften in verschiedene Protokoll-Typen unterteilt (z.B. Datagramm-Protokolle, Stream-Protokolle usw) und in Protokollfamilien (Kommunikations-Domänen, communiction domains) zusammengefaßt (z.B. TCP/IP-Protokoll-Familie, Novell IPX-Protokoll usw)

◇ Sockets ermöglichen eine bidirektionale Kommunikation. Ein Socket bildet einen Kommunikations-Endpunkt � Jeder der beiden an einer Kommunikation beteiligten Prozesse benötigt einen Socket.

◇ Ein Socket wird – wie eine Datei – über einen File Deskriptor referiert � für jeden Socket existiert eine struct file-Struktur (File-Objekt). Damit können für eine Socket-Kommunikation Dateibearbeitungs-Funktionen (System Calls) eingesetzt werden. •••• Realisierung von Sockets

◇ Sockets werden durch spezielle Datenstrukturen und durch spezielle Funktionen realisiert. Im virtuellen Dateisystem (Virtual File System) werden sie durch spezielle Inodes (VFS-Inodes) repräsentiert. Diese besitzen eine socket-spezifische Komponente vom Typ struct socket

◇ Datenstruktur struct socket (definiert in "linux/include/linux/net.h")

typedef enum { SS_FREE = 0, /* not allocated */ SS_UNCONNECTED, /* unconnected to any socket */ SS_CONNECTING, /* in process of connecting */ SS_CONNECTED, /* connected to socket */ SS_DISCONNECTING /* in process of disconnecting */ } socket_state; struct socket { socket_state state; unsigned long flags; struct proto_ops* ops; struct inode* inode; struct fasync_struct* fasync_list; /* Asynchronous wake up list */ struct file* file; /* File back pointer for gc */ struct sock* sk; struct wait_queue* wait; short type; unsigned char passcred; unsigned char tli; };

Bedeutung einiger Komponenten : ops Pointer auf Struktur mit Pointern auf Funktionen für protokollfamilienspezifische Socket-Operationen inode Pointer auf Beginn des Inodes zu dem die struct socket Struktur gehört sk Pointer auf eine Unterstruktur mit protokollspezifischen Informationen type Socket-Typ (entsprechend dem Protokoll-Typ)

FACHHOCHSCHULE MUENCHEN FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK FG TECHNISCHE INFORMATIK V – BS – B12 – 00 – TH – 04 -----------------------------------------------------------------------------------

Socketrelevante Verwaltungsstrukturen in LINUX

•••• Überblick :

...

d_inode

...

Dentry-Objekt

struct dentry

next

...

struct sk_buff_head

...

files

...

Prozess- Deskriptor

task_struct

...

fd_array[0]

... fd_array[i]

...

struct files_struct

File-Objekt struct file

...

f_dentry

f_op

...

BSD-Socket- spezifische

File-Operationen, u.a read write close

usw

struct sock

...

family

prot

type

protocol

socket

receive_queue

write_queue

...

Protokoll- spezifische

Socketoperationen, u.a. close connect sendmsg

usw

struct sk_buff

next

prev

...

data

...

struct sk_buff

next

prev

...

data

...

Inode-Objekt struct inode

...

struct socket

u.socket_i state ops

inode file sk

type ...

Protokollfamilien- spezifische

Socketoperationen, u.a. dup bind

connect

usw

next

...

struct

sk_buff_head


Prinzip der Socket-Kommunikation (1) •••• Kommunikationsprinzip Die Kommunikation über Sockets erfolgt nach dem Client-Server-Modell : Ein Server-Prozess stellt Dienstleistungen über eine definierte Schnittstelle zur Verfügung, die von Client-Prozessen genutzt werden können. I.a. findet zwischen Client und Server eine bidirektionale Kommunikation statt. Diese erfolgt asymmetrisch auf der Basis eines festgelegten Protokolls nach dem Request-Response-Prinzip : Der Client richtet zu einem beliebigen Zeitpunkt, also asynchron, Anforderungen an den Server. Dieser antwortet i.a. innerhalb einer bestimmten Zeit, also synchron. Ein Server kann häufig zu mehreren Clients eine Kommunikationsverbindung unterhalten.

•••• Kommunikationsverbindungsarten Die Semantik einer Socket-Kommunikation wird durch den mit jedem Socket assoziierten Protokoll-Typ festgelegt. Neben weiteren Kommunikationseigenschaften bestimmt dieser die Verbindungsart der Kommunikation. Man unterscheidet :

◈◈◈◈ verbindungsorientierte Kommunikation Zwischen Client und Server wird für die Dauer der Kommunikation eine ständige – virtuelle – Verbindung hergestellt. Diese Verbindung muß aufgebaut werden, bevor die eigentliche Kommunikation stattfinden kann � Die einzelnen Sendeoperationen benötigen keine expliziten Angaben über die Empfängeradresse. Andere Prozesse können in eine derartige Verbindung nicht eindringen. Wichtigster Protokoll-Typ mit dieser Verbindungart : SOCK_STREAM. ◈◈◈◈ verbindungslose Kommunikation Zwischen Client und Server wird keine ständige Kommunikationsverbindung hergestellt. Mit jedem übertragenen Nachrichtenpaket wird die Verbindung zwischen Sender und Empfänger erneut aufgebaut. � Jeder Sendeoperation muß die Adresse des Empfängers explizit mitgegeben werden. Wichtigster Protokoll-Typ mit dieser Verbindungart : SOCK_DGRAM.

Anforderung

Antwort

Server

Client 1

Client 2

Client n

...

FACHHOCHSCHULE MUENCHEN FACHBEREICH ELEKTROTECHNIK UND INFORMATIONSTECHNIK BEREICH DATENTECHNIK V – BS – B13 – 02 – TH – 04 -----------------------------------------------------------------------------------

Prinzip der Socket-Kommunikation (2)

•••• Prinzipieller Ablauf einer verbindungsorientierten Socket-Komunikation

◇ Bei der Socket-Erzeugung (Socket-API-Funktion socket()) wird der Protokoll-Typ und damit die Verbindungsart festgelegt.

◇ Der Aufbau der Socket-Verbindung wird durch ein symmetrisches Rendezvous zwischen den Funktionen accept() und connect() hergestellt : accept() blockiert bis ein Aufruf von connect() das Rendezvous herbeiführt. Andererseits blockiert connect() bis accept() das Rendezvous herbeiführt. Allerdings darf der Client connect() erst nach dem Aufruf von listen() durch den Server ausführen. Ein Aufruf von connect() vor listen() endet mit einer Fehlermeldung.

◇ Die Kommunikation zwischen Client und Server kann mittels der System Calls write() und read() oder alternativ mit den Socket-API-Funktionen send() und recv() erfolgen

◇ Nach Beendigung der Kommunikation sollte der Socket wieder geschlossen werden (System Call close())

Client Server

read()

write() read()

write()

Kommunikation

close() close() Schließen des Sockets

socket() socket()

bind()

Erzeugen eines Sockets

Binden des Sockets an eine lokale Adresse

� Socket wird initialisiert


listen()

accept()

connect()

Verbindungsaufbau

Mitteilung des Server- Prozesses an den Kernel,

daß er zu einer Verbindungs- aufnahme bereit ist

Warten auf einen Verbindungsversuch und

Akzeptieren des Verbindungswunsches

Äußerung eines Verbindungswunsches

unter Angabe der Serveradresse

(falls Socket noch nicht gebunden ist, wird er

automatisch durch den Kernel an eine geeignete lokale Adresse gebunden)


Prinzip der Socket-Kommunikation (3)

•••• Prinzipieller Ablauf einer verbindungslosen Socket-Komunikation

◇ In jedem sendto()-Aufruf ist die Adresse des Empfängers anzugeben. Durch den Aufruf wird – neben den eigentlichen Daten – auch die Adresse des jeweiligen Absenders übertragen. Der Client muß die Adresse des Servers kennen. Mit jedem Aufruf von sendto() wird seine eigene Adresse an den Server übertragen. Dieser erhält die übermittelten Daten und die Adresse des Clients durch den Aufruf von recvfrom(). Damit ist er in der Lage seinerseits mittels sendto() Informationen (Antwort) an den Client zu übertragen.

Client Server

socket() socket()

recvfrom()

bind()

sendto() recvfrom()

sendto()

close() close()

Komunikation


Binden des Sockets an eine lokale Adresse

� Socket wird initialisiert

Schließen des Sockets

falls Socket noch nicht gebunden ist, wird er

automatisch durch den Kernel an eine geeignete

lokale Adresse gebunden



Socket-API in LINUX – Überblick (1)

•••• Prinzipielle Realisierung Das Socket-API besteht aus einer Reihe von Betriebssystemfunktionen, die alle als Unterfunktionen des System Calls socketcall() (Funktions-Nr. 102) realisiert sind. Die einzelnen API-Funktionen sind durch eine Unterfunktions-Nr. gekennzeichnet, die im Register EBX übergeben wird.

•••• Socket-API-Funktionen und Unterfunktions-Nummer Die Unterfunktions-Nummern für die Socket-API-Funktionen sind in <linux/net.h> definiert.

#define SYS_SOCKET 1 /* sys_socket(2) */ #define SYS_BIND 2 /* sys_bind(2) */ #define SYS_CONNECT 3 /* sys_connect(2) */ #define SYS_LISTEN 4 /* sys_listen(2) */ #define SYS_ACCEPT 5 /* sys_accept(2) */ #define SYS_GETSOCKNAME 6 /* sys_getsockname(2) */ #define SYS_GETPEERNAME 7 /* sys_getpeername(2) */ #define SYS_SOCKETPAIR 8 /* sys_socketpair(2) */ #define SYS_SEND 9 /* sys_send(2) */ #define SYS_RECV 10 /* sys_recv(2) */ #define SYS_SENDTO 11 /* sys_sendto(2) */ #define SYS_RECVFROM 12 /* sys_recvfrom(2) */ #define SYS_SHUTDOWN 13 /* sys_shutdown(2) */ #define SYS_SETSOCKOPT 14 /* sys_setsockopt(2) */ #define SYS_GETSOCKOPT 15 /* sys_getsockopt(2) */ #define SYS_SENDMSG 16 /* sys_sendmsg(2) */ #define SYS_RECVMSG 17 /* sys_recvmsg(2) */

socket()

socketcall()

bind() recmsg() ...

int 0x80

(EAX = 102)

sys_socketcall()

sys_socket() sys_bind() sys_... sys_recmsg()

User-Mode

System-Mode

FACHHOCHSCHULE MUENCHEN FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK FG TECHNISCHE INFORMATIK V – BS – B14 – 02 – TH – 06 ------------------------------------------------------------------------------------

Socket-API in LINUX – Überblick (2)

•••• Adress-Familien Sockets werden an eine Adresse gebunden (� Socket-Adresse). Diese Adresse referiert den jeweiligen Kommunikations- teilnehmer eindeutig (z.B. im Netzwerk : Netzwerk-Adresse). Der genaue Aufbau einer derartigen Adresse hängt von der Protokoll-Familie, für den der Socket eingesetzt wird, ab. � Jeder Protokoll-Familie entspricht eine Adress-Familie. Protokoll-Familie und Adress-Familie werden durch die gleiche ganzzahlige Konstante (Familien-Nr) referiert. Ihnen sind symbolische Namen zugeordnet, die in der durch <sys/socket.h> eingebundenen Headerdatei <bits/socket.h> definiert sind. Die wichtigsten von LINUX unterstützten Protokoll- und Adress-Familien sind :

•••• Generischer Socket-Adress-Typ Das Socket-API abstrahiert die unterschiedlichen Adressen durch einen generischen Socket-Adress-Typ. In diversen API-Funktionen wird ein Pointer auf diesen Typ als Parameter verwendet. Beim Aufruf dieser Funktionen muss der Pointer auf den tatsächlich verwendeten protokollfamilien-spezifischen Adress- typ in einen Pointer auf den generischen Adresstyp gecastet werden. Zusätzlich ist in einem gesonderten Parameter die Länge des tatsächlich verwendeten Adresstyps zu übergeben. Der generische Socket-Adress-Typ struct sockaddr ist in der durch <sys/socket.h> eingebundenen Headerdatei <bits/socket.h> wie folgt definiert :

Familien-Nr Protokoll-Familie Adress-Familie "Kommunikations-Domäne" 1 PF_UNIX, PF_LOCAL AF_UNIX, AF_LOCAL UNIX-Domain-Sockets (lokale Kommunikation) 2 PF_INET AF_INET IPv4 Internet-Protokoll-Familie (TCP/IP, Version 4) 3 PF_AX25 AF_AX25 Amateur-Radio AX.25 Protokoll 4 PF_IPX AF_IPX Novell Internet-Protokolle (IPX) 5 PF_APPLETALK AF_APPLETALK Appletalk DDP 9 PF_X25 AF_X25 ITU-T X.25 / ISO-8208 Protokoll 10 PF_INET6 AF_INET6 IPv6 Internet-Protokoll-Familie (TCP/IP, Version 6) 16 PF_NETLINK AF_NETLINK "Kernel User Interface Device" 17 PF_PACKET AF_PACKET "Low Level Packet Interface" 23 PF_IRDA AF_IRDA IRDA Sockets 31 PF_BLUETOOTH AF_BLUETOOTH Bluetooth Sockets

struct sockaddr { unsigned short sa_family; /* Address family, AF_xxx */ char sa_data[14]; /* Address Data */ };


LINUX Socket-API-Funktion socket

•••• Funktionalität : Erzeugung eines Sockets. Rückgabe eines den Socket referierenden File Deskriptors. •••• Interface :

▫ Header-Datei : <sys/socket.h>

▫ Parameter : domain Protokoll-Familie. Die wichtigsten zulässigen Werte sind : PF_UNIX, PF_LOCAL UNIX-Domain-Sockets (lokale Kommunikation) PF_INET IPv4 Internet-Protokoll-Familie (TCP/IP, Version 4) PF_INET6 IPv6 Internet-Protokoll-Familie (TCP/IP, Version 6) PF_IPX Novell Internet-Protokolle (IPX) PF_NETLINK "Kernel User Interface Device" PF_X25 ITU-T X.25 / ISO-8208 Protokoll PF_AX25 Amateur-Radio AX.25 Protokoll PF_APPLETALK Appletalk DDP PF_PACKET "Low Level Packet Interface" PF_IRDA Protokoll für IRDA PF_BLUETOOTH Protokoll für Bluetooth type Protokoll-Typ (Socket-Typ) Zulässig sind prinzipiell die folgenden Werte : SOCK_STREAM verbindungsorientiertes Protokoll, streambasiert, mit Einhaltung der Datenreihenfolge (Sequencing), mit Fehlerkontrolle SOCK_DGRAM verbindungsloses Protokoll, paketbasiert, ohne Sequen- cing und ohne Fehlerkontrolle, feste max. Paketgrösse SOCK_SEQPACKET verbindungsorientiertes Protokoll, paketbasiert, mit Sequencing und Fehlerkontrolle, feste max. Paketgrösse SOCK_RDM verbindungsorientiertes Protokoll, paketbasiert, ohne Sequencing, mit Fehlerkontrolle SOCK_RAW direkter Zugriff zur Netzwerkschicht (z.B. IP) ermöglicht die Implementierung neuer Transportschicht- protokolle im User-Bereich (nur für Prozesse mit EUID==0) protocol zu verwendendes Protokoll. Meist kann der Wert 0 übergeben werden � der Kernel wählt das Standard- Protokoll des angegebenen Typs der Protokoll-Familie aus. (Normalerweise existiert innerhalb einer Protokoll-Familie nur ein Protokoll eines bestimmten Typs.)

▫ Rückgabewert : - File Deskriptor, über den der Socket referiert wird, bei Erfolg - -1 im Fehlerfall, errno wird entsprechend gesetzt •••• Implementierung : mittels System Call Nr. 102 (socketcall()), Unterfunktion Nr. 1 �� sys_socketcall(...) (in net/socket.c) � sys_socket(...) (in net/socket.c) •••• Anmerkung : Der erzeugte Socket ist nicht initialisiert, d.h. an keine Resource (Adresse) gebunden. � Seine Verwendung (Lesen und Schreiben) ist noch nicht möglich.

int socket(int domain, int type, int protocol);


LINUX Socket-API-Funktion bind

•••• Funktionalität : Binden eines Sockets an eine lokale Adresse. ("Zuordnung eines Namens" zum Socket) •••• Interface :


▫ Parameter : sockfd File-Deskriptor , der Socket referiert addr Pointer auf lokale Adresse, an die der Socket gebunden werden soll. Art und Aufbau der Adresse sind abhängig von der Protokoll-Familie (Adress-Familie) des Sockets. Der Pointer auf die tatsächliche Adresse muss in struct sockaddr* gecastet werden. addrlen Länge der durch addr referierten Adresse in Bytes

▫ Rückgabewert : - 0 bei Erfolg - -1 im Fehlerfall, errno wird entsprechend gesetzt •••• Implementierung : mittels System Call Nr. 102 (socketcall()), Unterfunktion Nr. 2 �� sys_socketcall(...) (in net/socket.c) � sys_bind(...) (in net/socket.c) •••• Anmerkungen: 1. Der Datentyp socklen_t ist in der Headerdatei <sys/socket.h> definiert als unsigned int. 2. Üblicherweise verzichtet der Client-Prozess auf ein explizites Binden des Sockets an eine lokale Adresse. Stattdessen überlässt er es dem Kernel, den Socket – bei der Äußerung eines Verbin- dungswunsches bzw beim erstmaligen Schreiben (verbindungslose Kommunikation) – an eine geeignete Adresse zu binden.

int bind(int sockfd, struct sockaddr* addr, socklen_t addrlen);


LINUX Socket-API-Funktion listen

•••• Funktionalität : Mitteilung des (Server-)Prozesses an den Kernel, daß er für eine Verbindungsaufnahme über den Socket durch andere Prozesse (Client-Prozesse) bereit ist. Anwendung nur für verbindungsorientierte Protokolle •••• Interface :


▫ Parameter : sockfd File-Deskriptor , der Socket referiert backlog Festlegung der maximal erlaubten Anzahl wartender Verbindungswünsche ("pending connections") in der listen queue. Verbindungswunsch : Aufruf von connect() durch einen Client-Prozess. Stehen bereits backlog Verbindungswünsche an, schlagen weitere Aufrufe von connect() fehl. Die Implementierung kann den angegebenen Wert auf einen von ihr vorgese- henen Maximalwert begrenzen. Grundsätzlich soll jede Implementierung backlog-Werte bis zu SOMAXCONN (definiert in <bits/socket,h>, eingebunden durch <sys/socket.h>) unterstützen Im Kernel 2.6 ist SOMAXCONN definiert zu 128.

▫ Rückgabewert : - 0 bei Erfolg - -1 im Fehlerfall, errno wird entsprechend gesetzt •••• Implementierung : mittels System Call Nr. 102 (socketcall()), Unterfunktion Nr. 4 �� sys_socketcall(...) (in net/socket.c) � sys_listen(...) (in net/socket.c)

int listen(int sockfd, int backlog);


LINUX Socket-API-Funktion accept

•••• Funktionalität : Akzeptieren eines Verbindungswunsches zu einem Socket durch einen Serverprozess Anwendung nur für verbindungsorientierte Protokolle. Die Funktion wandelt den nächsten anstehenden Verbindungswunsch (aus der gegebenenfalls vorhandenen Warteschlange) in eine akzeptierte Verbindung um. Hierfür wird ein neuer Socket erzeugt, über den eine sich anschließende Kommunikation abgewickelt werden kann. Der ursprüngliche Socket wird nicht verändert. Er steht für eine Kom- munikation nicht zur Verfügung, sondern nur für das Warten auf – weitere – Verbindungs- wünsche. Der neu erzeugte Socket hat die gleichen Eigenschaften wie der ursprüngliche Socket. Rückgabe eines den neu erzeugten Socket referierenden File-Deskriptors. Steht kein Verbindungswunsch an, blockiert die Funktion solange bis einer auftritt. Es sei denn der Socket ist mit fcntl() als NON_BLOCKING markiert worden. In diesem Fall kehrt die Funktion sofort mit dem Fehler EAGAIN zurück. •••• Interface :


▫ Parameter : sockfd File-Deskriptor , der Socket referiert, zu dem der Verbindungswunsch ansteht. addr Pointer auf Adress-Struktur, in die der Kernel die Socket-Adresse des Prozesses, der den Verbindungswunsch äußert (Client-Prozeß), ablegt Art und Aufbau dieser Struktur sind abhängig von der Protokoll-Familie (Adress-Familie) des Sockets. Der Pointer auf die tatsächliche Adress-Struktur muss gecastet werden in struct sockaddr*

Wird der NULL-Pointer übergeben, erfolgt keine Eintragung durch den Kernel. paddrlen Pointer auf Variable, in die der Kernel die Adresslänge des Prozesses, der den Verbindungswunsch geäußert hat, ablegt. Beim Aufruf sollte *paddrlen auf die Größe der durch addr referierten Adress-Struktur gesetzt werden.

▫ Rückgabewert : - File Deskriptor, über den der neu erzeugte Socket referiert wird, bei Erfolg - -1 im Fehlerfall, errno wird entsprechend gesetzt •••• Implementierung : mittels System Call Nr. 102 (socketcall()), Unterfunktion Nr. 5 �� sys_socketcall(...) (in net/socket.c) � sys_accept(...) (in net/socket.c) •••• Anmerkungen : 1. Der Datentyp socklen_t ist in der Headerdatei <sys/socket.h> definiert als unsigned int. 2. Die – bidirektional mögliche – Kommunikation über den neu erzeugten Socket-File- Deskriptor kann mittels der System Calls read() und write() bzw send() und recv() abgewickelt werden. Nach Beendigung der Kommunikation ist der Socket-File-Deskriptor mittels close() zu schließen.

int accept(int sockfd, struct sockaddr* addr, socklen_t* paddrlen);


LINUX Socket-API-Funktion connect

•••• Funktionalität : Initiierung eines Verbindungswunsches zu einem Socket durch einen Client. Wird die Funktion mit einem ungebundenen Socket aufgerufen, findet ein implizites Binden des Sockets an eine geeignete lokale Adresse statt. Die Adresse, an die der Socket gebunden ist, wird zum Serverprozess übertragen. Wenn der Verbindungswunsch durch den Serverprozess akzeptiert wird, kehrt die Funktion erfolgreich zurück. Anwendung nur für verbindungsorientierte Protokolle. •••• Interface :


▫ Parameter : sockfd File-Deskriptor , der den Socket des Client-Prozesses referiert servaddr Pointer auf die Adresse, an die der Socket des Ziel-Serverprozesses ( zu dem eine Verbindung aufgebaut werden soll) gebunden ist Art und Aufbau der Adresse sind abhängig von der Protokoll-Familie (Adress-Familie) des Sockets. Der Pointer auf die tatsächliche Adresse muss in struct sockaddr* gecastet werden. addrlen Länge der durch servaddr referierten Adresse in Bytes

▫ Rückgabewert : - 0 bei Erfolg - -1 im Fehlerfall, errno wird entsprechend gesetzt •••• Implementierung : mittels System Call Nr. 102 (socketcall()), Unterfunktions Nr. 3 �� sys_socketcall(...) (in net/socket.c) � sys_connect(...) (in net/socket.c) •••• Anmerkung : Der Datentyp socklen_t ist in der Headerdatei <sys/socket.h> definiert als unsigned int.

int connect(int sockfd, struct sockaddr* servaddr, socklen_t addrlen);

HOCHSCHULE MUENCHEN FAKULTÄT FÜR ELEKTROTECHNIK UND INFORMATIONSTECHNIK FG TECHNISCHE INFORMATIK V – BS – B15 – 06 – TH – 07 ------------------------------------------------------------------------------------

LINUX Socket-API-Funktion setsockopt

•••• Funktionalität : Setzen von Optionen für Sockets •••• Interface :


▫ Parameter : sock File-Deskriptor des Sockets level Typ der Option Beispiele : - SOL_SOCKET generische Socket-Option (auf Socket-Ebene interpretiert) (definiert in <asm/socket.h>, - indirekt – eingebunden durch <sys/socket.h>) - Protokoll-Nummer des die Option interpretierenden Protokolls (Protokoll-Nummern sind u.a. in /etc/protocols enthalten) option zu setzende Option, Angabe durch symbolischen Namen (mögliche Werte sind definiert in der durch <sys/socket.h> - indirekt – eingebundenen Headerdatei <asm/socket.h>) Beispiel : - SO_REUSEADDR Adresse, an die Socket gebunden ist, kann in sehr kurzer Zeit wieder verwendet werden (sonst i.a. erst nach längerer Wartezeit, z.B. bei TCP-Ports 2 min) val Pointer auf Speicherbereich (Variable), der den Wert der zu setzenden Option enthält. Die meisten generischen Socket-Optionen verwenden hierfür eine int-Variable (!=0 : Setzen der Option, ==0 : Rücksetzen der Option) vallen Grösse des Speicherbereichs (in Bytes), auf den val zeigt.

▫ Rückgabewert : - 0 bei Erfolg - -1 im Fehlerfall, errno wird entsprechend gesetzt •••• Implementierung : mittels System Call Nr. 102 (socketcall()), Unterfunktion Nr. 14 �� sys_socketcall(...) (in net/socket.c) � sys_setsockopt(...) (in net/socket.c) •••• Beispiel für Anwendung : Bei INET-Socket-Kommunikation : Aufhebung der Beschränkung, dass der Serverprozess sein lokales Port erst nach einer längeren Wartezeit erneut binden kann � Unmittelbar nach Aufheben einer Bindung kann der Socket an dieselbe Adresse erneut gebunden werden. int fdSock; /*File Deskriptor des Sockets */ ... int iOpt=1; setsockopt(fdSock, SOL_SOCKET, SO_REUSEADDR, &iOpt, sizeof(iOpt));

int setsockopt(int sock, int level, int option, const void* val, socklen_t vallen);


LINUX Socket-API-Funktion sendto

•••• Funktionalität : Senden von Daten von einem Quell-Socket zu einem Ziel-Socket. Da der Funktion u.a. auch ein Pointer auf die Adresse des Ziel-Sockets übergeben werden muss, lässt sie sich vor allem für eine verbindungslose (aber auch eine verbindungsorientierte) Kommunikation einsetzen. Die Funktion überträgt mit den Daten auch die lokale Adresse des Quell-Sockets zum Ziel- Socket. Ist der Quell-Socket zum Zeitpunkt des Funktionsaufrufs noch nicht an eine lokale Adresse gebunden, so führt die Funktion ein implizites Binden durch. •••• Interface :


▫ Parameter : sockfd File-Deskriptor , der Quell-Socket referiert msg Pointer auf Buffer mit den zu sendenden Daten len Anzahl der zu sendenden Bytes flags bitweise Oder-Verknüpfung mehrerer möglicher Flags zur Beeinflussung der Arbeitsweise der Funktion. für den normalen Datenverkehr üblicherweise auf 0 gesetzt to Pointer auf die Adresse des Ziel-Sockets Art und Aufbau der Adresse sind abhängig von der Protokoll-Familie (Adress-Familie) des Sockets. Der Pointer auf die tatsächliche Adresse muss in struct sockaddr* gecastet werden. tolen Länge der durch to referierten Adresse in Bytes

▫ Rückgabewert : - Anzahl der gesendeten Bytes bei Erfolg - -1 im Fehlerfall, errno wird entsprechend gesetzt •••• Implementierung : mittels System Call Nr. 102 (socketcall()), Unterfunktion Nr. 11 �� sys_socketcall(...) (in net/socket.c) � sys_sendto(...) (in net/socket.c) •••• Anmerkungen: 1. Der Datentyp socklen_t ist in der Headerdatei <sys/socket.h> definiert als unsigned int. 2. Der Datentyp size_t ist in der von <sys/socket.h> eingebundenen ANSI-C-Header-Datei <stddef.h> definiert als unsigned int.

int sendto(int sockfd, const void* msg, size_t len, int flags,

const struct sockaddr* to, socklen_t tolen);


LINUX Socket-API-Funktion recvfrom

•••• Funktionalität : Empfangen von Daten aus einem Ziel-Socket. Die Funktion lässt sich für eine verbindungslose (aber auch eine verbindungsorientierte) Kommunikation einsetzen. Bei verbindungsloser Kommunikation gibt die Funktion die Adresse des Quell-(Sende-) Sockets über einen Parameter an den aufrufenden Prozess zurück. •••• Interface :


▫ Parameter : sockfd File-Deskriptor , der den Ziel-Socket referiert msg Pointer auf Buffer, in dem die Empfangs-Daten abgelegt werden len Größe des Buffers für die Empfangs-Daten flags bitweise Oder-Verknüpfung mehrerer möglicher Flags zur Beeinflussung der Arbeitsweise der Funktion. für den normalen Datenverkehr i.a. auf 0 gesetzt. u.a. ist das folgende Flag definiert : MSG_PEEK die empfangenen Daten werden nicht aus dem Socket entfernt, ein erneuter Aufruf von recvfrom() liefert dieselben Daten noch einmal from Pointer auf Struktur, in der – falls !=NULL – bei verbindungsloser Kommu- nikation die Adresse des Quell-(Sende-)Sockets abgelegt wird Art und Aufbau der tatsächlichen Adresse sind abhängig von der Protokoll- Familie (Adress-Familie) des Sockets. fromlen Pointer auf Variable, die beim Aufruf mit der Größe der durch from referierten Adressstruktur zu initialisieren ist. Nach Rückkehr der Funktion enthält sie die tatsächliche Größe der unter from abgelegten Adresse (in Bytes).

▫ Rückgabewert : - Anzahl der empfangenen Bytes bei Erfolg - -1 im Fehlerfall, errno wird entsprechend gesetzt •••• Implementierung : mittels System Call Nr. 102 (socketcall()), Unterfunktion Nr. 12 �� sys_socketcall(...) (in net/socket.c) � sys_recvfrom(...) (in net/socket.c) •••• Anmerkungen: 1. Der Datentyp socklen_t ist in der Headerdatei <sys/socket.h> definiert als unsigned int. 2. Der Datentyp size_t ist in der von <sys/socket.h> eingebundenen ANSI-C-Header-Datei <stddef.h> definiert als unsigned int.

int recvfrom(int sockfd, void* msg, size_t len, int flags,

struct sockaddr* from, socklen_t* fromlen);


UNIX-Domain-Sockets in LINUX

•••• Allgemeines

◇ Die Protokollfamilie PF_UNIX (==PF_LOCAL) ist die einfachste Protokollfamilie innerhalb des Socket-APIs. Sie stellt die UNIX-Domain-Sockets zur Verfügung. Diese Sockets ermöglichen keine echte Netzwerkkommunikation sondern eine Kommunikation zwischen beliebigen Prozessen des gleichen Rechners (lokale Interprozess-Kommunikation). Die miteinander kommunizierenden Prozesse müssen weder miteinander verwandt sein noch die gleiche EUID besitzen.

◇ UNIX-Domain-Sockets sind – im Unterschied zu Named Pipes - immer verbindungsorientiert. Zwischen zwei Prozessen wird ein privater Kommunikationskanal eingerichtet, in den kein dritter Prozess eindringen kann. Ein Server-Prozess, der gleichzeitig Verbindungen zu mehreren Clients unterhält, verwendet für jede Verbindung einen eigenen Socket-Deskriptor.

◇ Gültige Protokoll-Typen sind : SOCK_STREAM und SOCK_DGRAM. Dabei arbeitet SOCK_DGRAM ebenfalls verbindungsorientiert und gewährleistet Sequencing und eine Fehlerkontrolle (zuverlässige Verbindung).

•••• UNIX-Domain-Adressen

◇ Die Adressen von UNIX-Domain-Sockets sind Dateipfade im Dateisystem (Adress-Familie AF_UNIX bzw AF_LOCAL) Hierfür existiert ein eigener Dateityp "Socket". Durch das Binden einer Adresse an einen Socket (mittels bind()) wird ein neuer Eintrag im Dateisystem vom Typ "Socket" erzeugt. Falls bereits ein Eintrag des angegebenen Pfadnamens existiert (egal welchen Dateityps), endet bind() mit dem Fehler EADDRINUSE.

◇ Damit ein (Client-)Prozess eine Verbindung zu einem existierenden (Server-)Socket aufnehmen kann ( mittels API- Funktion connect()) muss er Lese- und Schreibrechte zu der entsprechenden "Socket-Datei" besitzen.

◇ Nach Beendigung der Verwendung eines Sockets sollte dieser wieder aus dem Dateisystem entfernt werden (� System Call unlink()).

•••• Structure-Datentyp struct sockaddr_un

◇ Dieser in <sys/un.h> definierte Datentyp dient zur Darstellung von UNIX-Domain-Adressen.

◇ Die für diesen Adresstyp anzugebende Länge (als Parameter in API-Funktionen) ergibt sich als Summe der Länge der Adress-Familien-Komponente (sun_family) und der tasächlichen Länge des Dateipfades.

◇ Beispiel : struct sockaddr_un my_addr; socklen_t addrlen; ... addrlen = sizeof(my_addr->sun_family) + strlen(my_addr->sun_path);

◇ Achtung : Bei der Übergabe eines Pointers auf diese Adress-Struktur in den API-Funktionen ist ein Cast in einen Pointer auf den generischen Socket-Adresstyp struct sockaddr* notwendig.

struct sockaddr_un { unsigned short sun_family; /* Address family, hier AF_UNIX */ char sun_path[108]; /* Address Data : Dateipfad */ };


Beispiel zu UNIX-Domain-Sockets (1) : Serverprozess

/* ------------------------------------------------------------------------------- */ /* C-Quelldatei locserver_m.c */ /* Modul mit main()-Funktion fuer das Programm locserver */ /* ------------------------------------------------------------------------------- */ /* Beispiel fuer Unix Domain Sockets */ /* Einfacher Serverprozess, */ /* - der auf einen Verbindungswunsch durch einen Clientprozess wartet, */ /* - einen Verbindungswunsch akzeptiert */ /* - und die ihm vom Clientprozess geschickten Daten an die Standardausgabe ausgibt*/ /* Wenn der Clientprozess die Kommunikation durch Senden von EOF (=CTRL-D) beendet,*/ /* wartet er auf den naechsten Verbindungswunsch */ /* ------------------------------------------------------------------------------- */ #include <stdio.h> #include <unistd.h> #include <sys/socket.h> #include <sys/un.h> #include <string.h> #define SOCKET_PATH "/home/thomas/mysocket" #define FD_STDOUT 1 void errorExit(char* msg); void copyData(int iDest, int iSrc); int main(int argc, char *argv[]) { struct sockaddr_un strAddr; socklen_t lenAddr; int fdSock; int fdConn; if ((fdSock=socket(PF_UNIX, SOCK_STREAM, 0)) < 0) errorExit("socket"); unlink(SOCKET_PATH); /* Sicherstellung, dass SOCKET_PATH nicht existiert */ strAddr.sun_family=AF_UNIX; /* Unix Domain */ strcpy(strAddr.sun_path, SOCKET_PATH); lenAddr=sizeof(strAddr.sun_family)+strlen(strAddr.sun_path); if (bind(fdSock, (struct sockaddr*)&strAddr, lenAddr) != 0) errorExit("bind"); if (listen(fdSock, 5) != 0) errorExit("listen"); while ((fdConn=accept(fdSock, (struct sockaddr*)&strAddr, &lenAddr)) >= 0) { printf("\nConnection !!! receiving data ...\n"); copyData(FD_STDOUT, fdConn); printf("\n... finished\n"); close (fdConn); } close(fdSock); unlink(SOCKET_PATH); return 0; }


Beispiel zu UNIX-Domain-Sockets (2) : Clientprozess

/* ------------------------------------------------------------------------------- */ /* C-Quelldatei locclient_m.c */ /* Modul mit main()-Funktion fuer das Programm locclient */ /* ------------------------------------------------------------------------------- */ /* Beispiel fuer Unix Domain Sockets */ /* Einfacher Clientprozess, */ /* - der versucht, eine Socket-Verbindung zu einem Serverprozess herzustellen */ /* - und bei Erfolg fortlaufend Zeichen von der Standardeingabe einliest */ /* - und diese über den Socket an den Serverprozess sendet. */ /* Der Prozess endet, wenn EOF (==CTRL-D) eingegeben wird */ /* ------------------------------------------------------------------------------- */ #include <stdio.h> #include <unistd.h> #include <sys/socket.h> #include <sys/un.h> #include <string.h> #define SOCKET_PATH "/home/thomas/mysocket" #define FD_STDIN 0 void errorExit(char* msg); void copyData(int iDest, int iSrc); int main(int argc, char *argv[]) { struct sockaddr_un strAddr; socklen_t lenAddr; int fdSock; if ((fdSock=socket(PF_UNIX, SOCK_STREAM, 0)) < 0) errorExit("socket"); strAddr.sun_family=AF_UNIX; /* Unix domain */ strcpy(strAddr.sun_path, SOCKET_PATH); lenAddr=sizeof(strAddr.sun_family)+strlen(strAddr.sun_path); if (connect(fdSock, (struct sockaddr*)&strAddr, lenAddr) !=0 ) errorExit("connect"); printf("\nConnected to Server ... sending data ...\n"); copyData(fdSock, FD_STDIN); printf("\nready !\n"); close(fdSock); return 0; }


Beispiel zu UNIX-Domain-Sockets (3) : Hilfsfunktionen für Server und Client

/* ------------------------------------------------------------------------------ */ /* C-Quell-Modul com_util.c */ /* ------------------------------------------------------------------------------ */ /* Hilfsfunktionen, die in den Programmen locserver und locclient */ /* eingesetzt werden */ /* ------------------------------------------------------------------------------ */ #include <unistd.h> #include <stdio.h> /* ------------------------------------------------------------------------------ */ /* Ausgabe einer Meldung msg, gefolgt von der Fehlermeldung, die dem in errno */ /* gespeicherten Fehlercode entspricht */ /* anschließende Beendigung des Programms */ void errorExit(char* msg) { perror(msg); exit(1); } /* ------------------------------------------------------------------------------ */ /* Kopieren von Bytefolgen von einem Quell-File-Deskriptor zu einem Ziel-File- */ /* Deskriptor */ /* Das Kopieren endet, wenn keine Bytes mehr vom Ziel-Deskriptor gelesen werden */ #define BUFFLEN 1024 void copyData(int iDest, int iSrc) { static char acBuff[BUFFLEN]; int iCount; while ((iCount=read(iSrc, acBuff, sizeof(acBuff)))>0) { if (write(iDest, acBuff, iCount)!=iCount) errorExit("write"); } if (iCount<0) errorExit("read"); return; } /* ------------------------------------------------------------------------------ */


INET - Sockets in LINUX (1)

•••• Allgemeines

◇ Sockets der Protokoll-Familie PF_INET (INET-Sockets) ermöglichen eine Netzwerkkommunikation unter Verwen- dung der im Internet eingesetzten TCP/IP-Protokolle (Internet-Protokoll Version 4, das neue Internet-Protokoll Version 6 wird durch Sockets der Protokoll-Familie PF_INET6 realisiert).

◇ Gültige Angaben für den Protokoll-Typ (Parameter type der API-Funktion socket()) sind : - SOCK_STREAM (� TCP-Socket) - SOCK_DGRAM (� UDP-Socket) - SOCK_RAW (� Raw-Socket, IP-Protokoll)

◇ Zulässige Werte für den Parameter protocol der API-Funktion socket() (definiert. in <netinet/in.h>) sind : - TCP-Sockets : 0 oder IPPROTO_TCP (def. in <netinet/in.h>) - UDP-Sockets : 0 oder IPPROTO_UDP (def. in <netinet/in.h>) - Raw-Sockets : eine der in RFC1700 den definierten IANA IP-Protokollen zugeordnete Protokoll-Nr.

◇ Eine lokale Adresse, die an einen TCP-Socket gebunden war, ist nach dem Schließen des Socket-Deskriptors für eine gewisse Zeit für eine erneute Bindung nicht verfügbar (es sei denn die Option SA_REUSEADDR ist gesetzt gewesen) •••• INET-Adressen (IP-Socket-Adressen)

◇ Die Adressen, an die INET-Sockets gebunden werden (Adress-Familie AF_INET), bestehen aus - einer IP-Adresse (Adresse des Rechners im Netzwerk) - einer Port-Nummer (eindeutige Identifikation einer auf dem Rechner laufenden TCP/IP-Applikation)

◇ IP-Adressen sind – im gesamten Netzwerk eindeutige – 32-Bit-Werte (4 Bytes). Üblicherweise werden die 4 Bytes durch je einen Punkt getrennt in Dezimaldarstellung angegeben (Dotted DecimalNotation) : aaa.bbb.ccc.ddd Beispiel : 192.168.206.52

◇ Portnummern liegen im Bereich 0 ... 65535 (16-Bit-Werte). Die Portnummern 0 ... 1023 (well known ports) sind reserviert für Prozesse mit Root-Rechten. Hierzu gehören i.a. die "Internet-Standard-Dienste", wie z.B. ftp (Nr. 21) , http (Nr. 80) usw. (s. Datei /etc/services").

◇ Eine TCP/IP-Verbindung wird durch zwei Endpunkte festgelegt, die jeweils durch eine IP-Adresse und eine Port-Nummer gekennzeichnet sind. •••• Structure-Datentyp struct sockadr_in

◇ Dieser in <netinet/in.h> definierte Datentyp dient zur Darstellung von INET-Adressen.

◇ Für Server-Prozesse ist i.a. die lokale IP-Adresse uninteressant (das bedeutet, sie nehmen Verbindungswünsche auf jeder IP-Adresse, die der Rechner hat, entgegen) � für die Komponente sin_addr können dann (bei bind()) 00-Bytes angegeben werden ("don't care"), in <netinet/in.h> ist hierfür die symbolische Konstante INADDR_ANY definiert

◇ Die Angabe von 0 für sin_port (Port-Nr. 0) bewirkt, dass der Server auf jedem Port auf Verbindungswünsche "lauscht".

struct in_addr { /* Typ zur Darstellung von IP-Adressen */ unsigned int s_addr; /* in Network Byte Order */ } struct sockaddr_in { unsigned short sin_family; /* Address family, hier AF_INET */ unsigned short sin_port; /* Port-Nr. (in Network Byte Order) */ struct in_addr sin_addr; /* IP-Adresse (in Network Byte Order) */ };



•••• Darstellungsformate von IP-Adressen und Port-Nummern IP-Socket-Adressen (IP-Adressen und Port-Nummern) werden über das Netzwerk übertragen. Da Sende- und Empfangs- Rechner unterschiedliche Darstellungsformate für Mehrbyte-Werte haben können (Little Endian, BigEndian), hat man ein einheitliches Übertragungsformat für Mehrbyte-Protokollinformationen festgelegt : Network Byte Order (Big Endian). (Big Endian : das höchstwertigste Byte wird an der niedrigsten Adresse abgelegt bzw als erstes übertragen). � Sowohl IP-Adressen als auch Port-Nummern müssen gegebenenfalls zwischen der vom jeweiligen Rechner verwendeten Darstellungsart (Host Byte Order) und der Network Byte Order umgewandelt werden. Um dies transparent – ohne Kenntnis der jeweiligen Host Byte Order – durchführen zu können, stehen in der C-Bibliothek geeignete Funktionen zur Verfügung.

•••• C-Bibliotheksfunktionen zur Konvertierung zwischen Network Byte Order und Host Byte Order

◇ Alle Funktionen sind in der Headerdatei <netinet/in.h> deklariert.

◇ Umwandlung eines 32-Bit-Wertes (in LINUX int == long) von Host Byte Order in Network Byte Order

Parameter : hostlong umzuwandelnder 32-Bit-Wert in Host Byte Order Funktionswert : Umgewandelter 32-Bit-Wert in Network Byte Oder

◇ Umwandlung eines 16-Bit-Wertes (in LINUX short) von Host Byte Order in Network Byte Order

Parameter : hostshort umzuwandelnder 16-Bit-Wert in Host Byte Order Funktionswert : Umgewandelter 16-Bit-Wert in Network Byte Oder

◇ Umwandlung eines 32-Bit-Wertes (in LINUX int == long) von Network Byte Order in Host Byte Order Parameter : netlong umzuwandelnder 32-Bit-Wert in Network Byte Order Funktionswert : Umgewandelter 32-Bit-Wert in Host Byte Oder

◇ Umwandlung eines 16-Bit-Wertes (in LINUX short) von Network Byte Order in Host Byte Order Parameter : netshort umzuwandelnder 16-Bit-Wert in Network Byte Order Funktionswert : Umgewandelter 16-Bit-Wert in Host Byte Oder

unsigned int htonl(unsigned int hostlong);

unsigned short htons(unsigned short hostshort);

unsigned int ntohl(unsigned int netlong);

unsigned short ntohs(unsigned short netshort);



•••• C-Bibliotheks-Funktionen zur Umwandlung der Darstellungsart von IP-Adressen

◇ IP-Adressen werden häufig als Strings in Dotted Decimal Notation angegeben. Andererseits werden sie zur Verwendung für die Socket-API-Funktionen in der struct in_addr in interner Binärdarstellung (32-Bit-Wert) benötigt. Zur Umwandlung zwischen diesen beiden Darstellungsarten stellt die C-Bibliothek geeignete Umwandlungsfunktio- nen zur Verfügung.

◇ Diese Umwandlungsfunktionen sind in der Headerdatei <arpa/inet.h> deklariert.

◇ Umwandlung einer IP-Adresse aus der String-Darstellung (Dotted Decimal Notation) in die 32-Bit-Binärdarstellung Parameter : cp Pointer auf IP-Adresse in String-Darstellung inp Pointer auf Structure-Variable, in der die umgewandelte Binärdarstellung (in Network Byte Order) abgelegt wird. Funktionswert : != 0, wenn durch cp eine gültige IP-Adresse referiert wird 0, wenn keine gültige IP-Adresse referiert wird

◇ Umwandlung einer IP-Adresse aus der 32-Bit-Binärdarstellung in die String-Darstellung (Dotted Decimal Notation) Parameter : in IP-Adresse in Binärdarstellung (Network Byte Order) Funktionswert : Pointer auf einen String, der die IP-Adresse in Dotted Decimal Notation enthält. Anmerkung : Der zurückgegebene String befindet sich in einem statisch allozierten Buffer, der beim nächsten Aufruf der Funktion überschrieben wird.

int inet_aton(const char* cp, struct in_addr* inp);

char* inet_ntoa(struct in_addr in);

Documents

Betriebssysteme Kapitel 11 - pc01-lsw.ee.hm.eduthomas/Vorlesung/VBS/vbsbx.pdfSockets in LINUX – Grundlagen (1) ... PF_IPX Novell Internet-Protokolle (IPX) PF_NETLINK "Kernel User