1 #! /usr/bin/env python
   2 # -*- encoding: latin1 -*-
   3 
   4 # Dieser TCP-Server sendet alle Daten, die er empfängt, an den
   5 # Client als Antwort zurück
   6 
   7 from socket import *
   8 
   9 # Der Standard-Echo-Port ist nicht sehr nützlich, da er root
  10 # Rechte erfordert. Wir nehmen den Port 50007
  11 ECHO_PORT = 50007
  12 BUFSIZE = 1024
  13 
  14 def main():
  15     # TCP-Socket erstellen und an Port binden
  16     s = socket(AF_INET, SOCK_STREAM)
  17     s.bind(('', ECHO_PORT))
  18     s.listen(1)
  19 
  20     print "Server gestartet"
  21 
  22     # Warte auf eine Verbindung zum Server
  23     conn, (remotehost, remoteport) = s.accept()
  24     print 'Verbunden mit %s:%s' % (remotehost, remoteport)
  25 
  26     while 1:
  27         # Empfange daten vom Client
  28         data = conn.recv(BUFSIZE)
  29         print "Echo: %s" % (data)
  30         if not data:
  31             # Die Verbindung wurde getrennt
  32             # Abbruch
  33             break
  34 
  35         # Sende die Daten zurück zum client
  36         conn.send(data)
  37 
  38     # Socket schließen
  39     s.close()
  40 
  41 if __name__ == '__main__':
  42     main()

   1 #! /usr/bin/env python
   2 # -*- encoding: latin1 -*-
   3 
   4 # Dieser TCP-Client sendet eine Nachricht an einen Server und
   5 # wartet auf eine Antwort.
   6 
   7 from socket import *
   8 
   9 SERVER_PORT = 50007
  10 BUFSIZE = 1024
  11 
  12 def main():
  13     print "Serveradresse: "
  14     host = raw_input()
  15 
  16     print
  17     print "Nachricht: "
  18     msg = raw_input()
  19 
  20     # Ein INet Streaming (TCP/IP) Socket erzeugen
  21     s = socket(AF_INET, SOCK_STREAM)
  22 
  23     # Zum Server verbinden
  24     s.connect((host, SERVER_PORT))
  25 
  26     # Unsere Nachricht senden
  27     s.send(msg)
  28 
  29     # Auf Daten vom Server warten
  30     data = s.recv(BUFSIZE)
  31 
  32     # Daten anzeigen
  33     print
  34     print "Daten: %s" % (data)
  35 
  36     # Socket schließen
  37     s.close()
  38 
  39 if __name__ == '__main__':
  40     main()

   1 #! /usr/bin/env python
   2 # -*- encoding: latin1 -*-
   3 """
   4       EINFACHER UDP-SERVER
   5       ====================
   6 
   7       Dieser UDP (user datagram protocol) Server ermöglicht
   8       eine verbindungslose Netzwerkkommunikation. Der
   9       Server sendet alle Daten, die er empfängt, an den
  10       Client als Antwort zurück. Durch eine ".stop" Nachricht
  11       kann der Server ordnungsgemäss beendet werden.
  12 
  13 """
  14 
  15 from socket import *
  16 
  17 # Server Port
  18 PORT = 50007
  19 # Maximale Grösse der zu lesenden Daten am Socket
  20 BUFSIZE = 1024
  21 
  22 def main():
  23     # Bindung des Servers an einen UDP-Socket
  24     s = socket(AF_INET, SOCK_DGRAM)
  25     s.bind(("", PORT))
  26     print "UDP-Server gestartet..."
  27 
  28     while 1:
  29         # Lesen der Daten am Socket
  30         data, (client_ip,client_port) = s.recvfrom(BUFSIZE)
  31         # Anzeige der Client-Adresse und der Daten
  32         print "[%s %s]: %s" % (client_ip,client_port,data)
  33         # Reaktion auf Daten
  34         if data == "":
  35            s.sendto("keine Daten",(client_ip,client_port))
  36         elif data == ".stop":
  37            s.sendto("Server beendet",(client_ip,client_port))
  38            break
  39         else:
  40            s.sendto(data,(client_ip,client_port))
  41 
  42 
  43     #Socket schliessen
  44     s.close()
  45 
  46 if __name__ == '__main__':
  47    main()

   1 #! /usr/bin/env python
   2 # -*- encoding: latin1 -*-
   3 """
   4       EINFACHER UDP-CLIENT
   5       ====================
   6 
   7       Der UDP-Client sendet Daten an den Server, die er als
   8       Antwort wieder empfängt. Durch den ".stop" Befehl wird der
   9       Server ordnungsgemäss beendet. Mit ".quit" wird der
  10       Client beendet.
  11 
  12 """
  13 
  14 from socket import *
  15 
  16 SERVER_IP   = "127.0.0.1"
  17 SERVER_PORT = 50007
  18 CLIENT_PORT = 50008
  19 # Maximale Grösse der zu lesenden Daten am Socket
  20 BUFSIZE = 1024
  21 
  22 def main():
  23     # Bindung des Clients an einen UDP-Socket
  24     s = socket(AF_INET, SOCK_DGRAM)
  25     s.bind(("", CLIENT_PORT))
  26 
  27     while 1:
  28         # Benutzereingabe
  29         msg_out = raw_input("CLI>: ")
  30         if msg_out==".quit":
  31            s.close()
  32            break
  33         # Senden der Daten an den Server
  34         s.sendto(msg_out, (SERVER_IP, SERVER_PORT))
  35         # Lesen der Daten am Socket
  36         msg_in, (client_ip, client_port) = s.recvfrom(BUFSIZE)
  37         print msg_in
  38 
  39 if __name__ == '__main__':
  40    main()