TCP/IP UDP

From Medien Wiki

IPs

IP steht für Internet Protocol und bezeichnet eine Adresse eines Teilnehmers in einem Netzwerk. Aktuell sind noch IPv4-Adressen im Einsatz, aufgrund der rasant ansteigenden Zahlen vorhandener Computer stößt man auch mit Konzepten wie dynamisch vergebenen IP-Adressen langsam an die Grenzen der maximalen Anzahl zu vergebender Nummern. In Zukunft wird jeder Rechner eine IPv6-Adresse haben. 

127.0.0.1:4444 // Eigener Rechner (IP 127.0.0.1), Port# 4444
192.168.1.11:5555 // IP im lokalen Netzwerk 192.168.1.11, Port# 5555
0.0.0.0:45678 // Aktuelle Netzadresse, Port#45678. 
// Bei UDP kann diese Adresse für einen Broadcast im lokalen Netzwerk genutzt werden.
255.255.255.255:2222 // Broadcast (z.B. von DHCP oder BOOTP genutzt) auf Port#2222
2001:0db8:85a3:08d3:1319:8a2e:0370:7344 // Bsp. einer IPv6 Adresse in hexadezimal-Notierung (ohne Port)

IP-Adressen sind für Menschen schwer zu merken, deshalb gibt es für Menschen lesbare Adressen (Hostnamen). Ein DNS (Domain Name Server) hilft dabei, eine Adresse wie uni-weimar.de in eine IP Adresse aufzulösen.

Weiterführende Links:

Ports

Jeder Rechner verfügt über Ports, sozusagen Postfächer, an denen verschiedene Programme lauschen, ob für sie eine Nachricht eintrifft. Eigene Ports sollten am besten im Bereich von 49152 bis 65535 vergeben werden; eine Übersicht vergebener TCP und UDP Port Nummern findet man auf Wikipedia. Übliche Ports sind z.B. 80 für http, 21 für ftp, 110 für POP3, 5190 für ICQ usw...

  • 0-255: TCP/IP-Anwendungen (System, reserviert)
  • 256-1023: Unix-Anwendungen (System, reserviert)
  • 1024-49151: Von der IANA verwaltete Port-Nummern
  • 49152-65535: Dynamische Port-Nummern für den "privaten" Gebrauch

Weiterführende Links:

TCP

TCP ist (v.a. im Unterschied zu UDP) ein verbindungsorientiertes Transportprotokoll. D.h. es wird zuerst eine Verbindung aufgebaut, bevor der eigentliche Datentransfer beginnt. Dies ist zwar sicher (damit ist nicht sicher im Sinne von verschlüsselt oder abhörsicher gemeint!), aber bringt auch einen gewissen Overhead mit.

Weiterführende Links:

UDP

UDP (User Datagram Protocol), auch oft scherzhaft mit Unreliable Data Protocol übersetzt ist ein verbindungsloses Transportprotokoll. D.h. es wird keine Verbindung aufgebaut, sondern die Datenpakete werden ins Blaue geschickt. Es gibt keine Garantie, dass das Paket auch ankommt! Tatsächlich sollte man sich in der Praxis nicht sonderlich wundern, wenn eines von 10 Paketen nicht ankommt, auch wenn ein Verlust von 1:100 vermutlich der "normalere" Wert ist.

Der Empfänger kann dem Sender antworten, da die Absenderadresse mit übertragen wird.

Man kann ein Datenpaket z.B. an eine bekannte IP Adresse und einen bestimmten Port im lokalen (oder globalen) Netzwerk senden. Eine Besonderheit bei UDP ist die Möglichkeit Nachrichten an die IP 0.0.0.0 zu senden, was einer "Rundmail" gleichkommt. Natürlich empfangen nur Rechner diese Nachricht, auf denen ein Programm läuft, das auf Nachrichten an dem entsprechenden Port wartet (Port-Listener). 

127.0.0.1:4444 // Eigener Rechner (IP 127.0.0.1), Port# 4444
192.168.1.11:5555 // IP im lokalen Netzwerk 192.168.1.11, Port# 5555
0.0.0.0:45678 // UDP-Broadcast im lokalen Netzwerk auf Port#45678

Achtung: Eigene Ports sollten am besten im Bereich von 49152-65535 vergeben werden; eine Übersicht vergebener TCP und UDP Port Nummern findet man auf Wikipedia.

Weiterführende Links UDP

APIs

Sockets

Protokolle wie TCP und UDP sind abstrakte Dienste, die die Struktur von Computer-Kommunikation definieren. Programmierer benutzen für TCP und UDP Operationen Sockets, manchmal auch BSD-Sockets genannt. Sockets sind in jedem Betriebssystem zu finden.


JAVA Socket

ServerSocket serverSocket = new ServerSocket(port);     // Serversocket mit bestimmter Port-Nummer erstellen
while(true) {
   Socket clientSocket = serverSocket.accept();         // auf Anfragen warten
   InputStream input   = clientSocket.getInputStream(); // InputStream-Objekt öffnen
   byte[] data         = new byte[1024];                // Datenpuffer deklarieren (anlegen)
   int NumBytes        = 0;                             // Variable für Anzahl der tatsächlich gelesenen Bytes
   NumBytes            = input.read(data);              // Daten lesen
   /*** gelesene Daten verarbeiten ***/
   clientSocket.close();                                // Verbindung schließen
}



PHP Socket

Beispiel eines ROT13 Servers in PHP (basiert auf java2s.com Beispielcode): 

<?
$socket = socket_create_listen("55555");
if (!$socket) { 
	print "Failed to create socket!\n";
	exit; 
}
while (true) { 
	$client = socket_accept($socket);
	$welcome = "\nHello\n";
	socket_write($client, $welcome);
	while (true) {
		if ($input == '!close') { break; }
		if ($input == '!halt') { 
			socket_close ($client); 
			break;
		}
		$output = str_rot13($input) . "\n";
		socket_write($client, $output);
		print "In: $input, Out: $output\n";
	}
	socket_close ($client); 
}
socket_close ($socket); 
?>

weiterführende Links:

  • BSD Sockets
  • weitere Beispiele (z.B. für Processing) sind unter OSC zu finden!



Datagram

Datagram Socket (JAVA Client/Server)

// code von 
// http://www.java2s.com/Code/Java/Network-Protocol/UseDatagramSockettosendoutandreceiveDatagramPacket.htm

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class ChatClient {

  public static void main(String[] args) throws Exception {
    DatagramSocket s = new DatagramSocket();
    byte[] buf = new byte[1000];
    DatagramPacket dp = new DatagramPacket(buf, buf.length);

    InetAddress hostAddress = InetAddress.getByName("localhost");
    while (true) {
      BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
      String outMessage = stdin.readLine();

      if (outMessage.equals("bye"))
        break;
      String outString = "Client say: " + outMessage;
      buf = outString.getBytes();

      DatagramPacket out = new DatagramPacket(buf, buf.length, hostAddress, 9999);
      s.send(out);

      s.receive(dp);
      String rcvd = "rcvd from " + dp.getAddress() + ", " + dp.getPort() + ": "
          + new String(dp.getData(), 0, dp.getLength());
      System.out.println(rcvd);
    }
  }
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class ChatServer {
  public static void main(String[] args) throws Exception {
    int PORT = 4000;
    byte[] buf = new byte[1000];
    DatagramPacket dgp = new DatagramPacket(buf, buf.length);
    DatagramSocket sk;

    sk = new DatagramSocket(PORT);
    System.out.println("Server started");
    while (true) {
      sk.receive(dgp);
      String rcvd = new String(dgp.getData(), 0, dgp.getLength()) + ", from address: "
          + dgp.getAddress() + ", port: " + dgp.getPort();
      System.out.println(rcvd);
      
      BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
      String outMessage = stdin.readLine();
      buf = ("Server say: " + outMessage).getBytes();
      DatagramPacket out = new DatagramPacket(buf, buf.length, dgp.getAddress(), dgp.getPort());
      sk.send(out);
    }
  }
}

also see:




*nix Tools

Lustige Tools im Terminal bzw. Konsole:

  • arp <hostname.domain>
  • ping -c 3 <ip>
  • host <domain> bzw: host -a <domain>
  • whois <domain>
  • traceroute <domain>
  • netstat -an
  • ifconfig

Pitfalls

  • Firewalls können Anwendungen oder Ports blockieren
  • Firewalls findet man in Computern sowie in Routern
  • Ports können bereits geöffnet und damit belegt sein
  • IP-Adressen können sich ändern; deshalb wenn möglich Hostnamen oder Services wie Bonjour bzw. ZeroConf nutzen

Links

siehe "weiterführende Links" unter den einzelnen Sektionen und:


Diese Seite ist Teil des Werkmoduls Das Netz: Kybernetischer Raum von Michael Markert für Interface Design / Fakultät Medien an der Bauhaus-Universität Weimar.

Retrieved from "https://www.uni-weimar.de/kunst-und-gestaltung/wiki/index.php?title=TCP/IP_UDP&oldid=58672"