Mi is az a Socket?

Azt már hallhattuk, hogy a Unix rendszereken gyakorlatilag minden egy fájl. Amikor valamilyen I/O műveletet szeretnénk csinálni, például írni vagy olvasni egy fájlt, akkor azt egy fájlleírón (file descriptor) keresztül tudjuk megtenni. A file descriptor egyszerűen egy nyitott fájlhoz társított egész szám. Viszont ez a nyitott fájl lehet egy pipe, sor, hálózati kapcsolat, terminál vagy a valódi lemezen tárolt fájl is. Amikor kommunikálni szeretnénk a hálózaton keresztül, egyszerűen egy socket() rendszerhívást kell meghívni, ami visszatér egy socket leíróval, amellyel már tudunk is a hálózatra írni vagy olvasni.

Példák:

Nézzünk pár példát, hogy miket is lehet csinálni a socket könyvtárral, mielőtt belemennénk, a socketek típusaiba:

import socket

hostname = socket.gethostname()
print(hostname)

addr = socket.gethostbyname('www.example.org')
print(addr)

hostname, aliases, addrs = socket.gethostbyname_ex('www.example.org')
print(hostname, aliases, addrs)

hostname, aliases, addrs = socket.gethostbyaddr('157.181.161.79')
print(hostname, aliases, addrs)

A gethostname() függvénnyel visszakaphatjuk a rendszerünk nevét. A gethostbyname() függvény segítségével megkaphatjuk egy host ip címét. Jelen esetben a www.example.org szerver ip címét kérjük le. A gethostbyname_ex() függvény egy tuple-ben visszaadja a host nevét, ha vannak alias nevei a hostnak, akkor azt is és az összes interface-ének a címét. Hasonlóan működik a gethostbyaddr() is, csak ip cím alapján szerzi meg ezeket az információkat.

Példa:

Az eddig megszerzett tudással megtudhatjuk, akár a saját gépünk összes interface-ének ip címét is.

import socket

my_host = socket.gethostname()
hostname, aliases, addrs = socket.gethostbyname_ex(my_host)
print(hostname, aliases, addrs)

Output:

DESKTOP-SRVB84Z [] ['172.21.30.1', '192.168.46.1', '192.168.0.88']

Az ip link (Linux) vagy ipconfig (Window) parancsot kiadva leellenőrizhetjük, hogy valóban ezek az ip címeink vannak-e a számítógépünkön.

Ethernet adapter vEthernet (Default Switch):

   IPv4 Address. . . . . . . . . . . : 172.21.30.1
   Subnet Mask . . . . . . . . . . . : 255.255.240.0
   Default Gateway . . . . . . . . . :

Ethernet adapter VirtualBox Host-Only Network:

   IPv4 Address. . . . . . . . . . . : 192.168.46.1
   Subnet Mask . . . . . . . . . . . : 255.255.255.0
   Default Gateway . . . . . . . . . :

Wireless LAN adapter Wi-Fi:

   IPv4 Address. . . . . . . . . . . : 192.168.0.88
   Subnet Mask . . . . . . . . . . . : 255.255.255.0
   Default Gateway . . . . . . . . . : 192.168.0.1

Cél azonosítása:

Mielőtt belemennénk a socketek típusaiba, előtte tisztáznunk kell, hogy hogyan is azonosítjuk, hogy kinek is küldjük az adatokat. Nyilván az ip címmel be tudjuk azonosítani, viszont a cél gép még nem fogja tudni ennyiből, hogy melyik alkalmazásnak/folyamatnak kell küldeni a csomagokat. Ezért használjuk a szállítási réteg portjait. Tehát a végpontok azonosításához 5 dolog kell: forrás ip, forrás port, cél ip, cél port, (szállítási rétegbeli) protokoll (TCP/UDP).

Milyen portjaink vannak?

Vannak a jól ismert portok: 0-1023 és a dinamikus vagy privát portok: 1024-65535. A getservbyport() függvény visszaadja annak a szolgáltatásnak/alkalmazásnak a nevét, amelyet azonosít a portszám. Irassuk ki, hogy melyik portszámhoz, milyen szolgáltatás/alkalmazás tartozik:

import socket

for port_num in range(1024):
    try:
        service = socket.getservbyport(port_num)
        print(port_num, service)
    except OSError:
        pass

Socket típusai:

Alapvetően kettő olyan socket típus van, amelyet szoktak használni (SOCK_STREAM, SOCK_DGRAM), de több típusa is van (SOCK_RAW, SOCK_RDM, SOCK_SEQPACKET, SOCK_DCCPSOCK_PACKET), de ezeket nagyon ritkán szokás csak használni. Sőt ezek akár operációs rendszer függőek is lehetnek. Az egyik típus, amivel foglalkozni fogunk, azok a Stream Socketek (SOCK_STREAM), a másik a Datagram Socketek (SOCK_DGRAM). A Datagram Socketeket gyakran hívják kapcsolat nélküli socketeknek, mivel nem szükséges a kapcsolat kiépülése küldés előtt. A Stream Socketek TCP protokollt használnak, hogy biztosítsák a sorrendhelyességet, a duplikátumok elkerülését és azt, hogy a csomagok garantáltan megérkezzenek. Míg a Datagram Socketek UDP protokollt használnak, ezáltal nincs garantálva a sorrendhelyesség, nem biztos, hogy megérkeznek a csomagok és duplikátumok is lehetnek. TCP-t használnak fájl letöltésnél és web böngészésnél is. Például a HTTP protokoll is TCP felett van megvalósítva. Ezzel szemben UDP-t használnak a videók, hangok küldésénél, ezért is lehet az, hogy hirtelen megáll, felgyorul vagy leromlik a képminősége a videónak, amit éppen nézünk.

TCP socket:

Ahhoz, hogy tudjunk kommunikálni két végpont között, létre kell hoznunk a kliensnél és a szervernél is egy-egy socketet, ugyanazon paraméterekkel.

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

A socket első paramétere az address family, ami lehet AF_INET, ami azt jelenti, hogy IPv4 címekket fog használni, AF_INET6, ami azt jelenti, hogy IPv6 címekket fog használni. Más dolgok is lehetnek itt, de ezekkel most nem foglalkozunk. A második paramétere a socket típusa, amelyekről már korábban esett szó.

Ha megnézzük az ábrát, azt láthatjuk az alsó részén, hogy a csomag mely részéhez férünk hozzá adott address family és socket type beállítások mellett. A zöld szín azt jelenti, hogy nekünk kell beállítanunk a csomag ezen részét. A kék azt jelenti, hogy a socket állítja be ezt a részt és nekünk nem kell ezzel foglalkoznunk. Ha megnézzük a fentebbi kódot, ahol Stream Socketet hoztunk létre, akkor láthatjuk, hogy nekünk csak a csomag üzenet részével kell foglalkoznunk, mert a socket mindent be fog állítani helyettünk.

A fenti ábrán azt láthatjuk, hogy a TCP-nél hogyan is működik a kommunikáció. Először létre kell hozni mindkét félnél a socketet, hogy tudjanak majd kommunikálni ezen keresztül. Ezt fentebb már láthattuk, hogy hogyan kell. Ezek után a szerveren a socketet hozzá kell bind-oljuk egy porthoz, amelyen keresztül tudja az operációs rendszer, hogy a mi alkalmazásunknak szólnak a csomagok. Fontos, hogy a bind mindig tuple-t vár el, ami úgy néz ki, hogy az első paramétere egy IP cím vagy host név, második paramétere egy port.

addr = ("127.0.0.1", 8000)
sock.bind(addr)

Ezek után a szerveren el kell kezdenünk figyelni a csatlakozni akaró kliensekre. Ezt a listen() függvénnyel tudjuk megtenni. A paraméterében egy számot kell megadnunk, ami azt jelenti, hogy hány kapcsolat várakozhat, amikor a szerver elfoglalt, mielőtt visszautasítja a kapcsolatot.

sock.listen(0)
print(f"Server is listening on {addr[0]}:{addr[0]}")

Most pedig a szerveren jön egy kicsit trükkös rész. Amikor elfogadjuk accept() függvénnyel a kapcsolatot, létrejön egy új socket, amellyel tudunk küldeni és fogadni adatokat a klienstől. Ez egy másik socket, mint amit eddig létrehoztunk. A korábban létrehozott socket arra kell, hogy az új kapcsolatokat fogadni tudjuk.

connection_sock, client_address = sock.accept()
with connection_sock:
    print(f"Connection from {client_address}")

Most pedig jöhet a küldés és a fogadás. Itt mi döntjük el, hogy a szerver és a kliens milyen sorrendben küld és fogad adatot. Lehet, hogy a szerver csak foad, de lehet, hogy felváltva küldenek stb. Teljes mértékben ránk van bízva.

data = connection_sock.recv(16).decode()
print(f"Data: {data}")

Végezetül pedig le kell zárnunk a socketet, feltéve hogy nem with-et használtunk. Fontos megjegyezni, hogy Stream Socket esetében, amikor valaki bezárja a socketet egy utolsó üzenet elküldésre kerül, aminek nincs tartalma. Gyakorlatilag egy üres string. Ez egy jelzés a másik félnek, hogy részünkről véget ért a kommunikáció.

sock.close()

Most térjünk át a kliens oldalra. Itt egyszerűen csak csatlakoznunk kell a szerverre az IP címe és a port száma alapján.

addr = ("127.0.0.1", 8000)
sock.connect(addr)

Ezek után pedig küldhetünk is adatokat a szervernek vagy akár fogadhatunk is. Küldés során használhatjuk a struct-ot vagy ha csak simán string-et küldünk elég az encode() is.

sock.send("Hello".encode())
print("Message sent.")

Hibakezelés:

• A fájl neve ne socket legyen, mert a python előbb a saját mappájából importál!

• A port már használatban van. Ekkor használjunk másik portot vagy írjunk be egy extra sort a szerver kódba:

sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

• Nem fut a szerver!

• Nem megfelelő üzenet érkezett! Hiba van a szerveren, emiatt 0 byte-os csomag érkezett!

Teljes kód egy TCP szerverre:

(Windows-nál a végtelen ciklusban futó szervert sima „Ctrl+C”-vel nem tudjuk kilőni parancssorban, hanem „Ctrl+Break” billentyűkombinációval lehet. A „Break” billentyű helye laptoponként eltérhet: pl. Ctrl+Fn+Pause, Ctrl+Fn+B stb.)

import socket

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    addr = ("127.0.0.1", 8000)
    sock.bind(addr)
    
    sock.listen(1)
    print(f"Server is listening on {addr[0]}:{addr[1]}")

    connection_sock, client_address = sock.accept()
    with connection_sock:
        print(f"Connection from {client_address}")
        
        data = connection_sock.recv(16).decode()
        print(f"Data: {data}")

Teljes kód egy TCP kliensre:

import socket

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    addr = ("127.0.0.1", 8000)
    sock.connect(addr)
    sock.send("Hello".encode())
    print("Message sent.")

Socket beállításai:

Amikor létrehoztuk a szerverünket láthattuk, hogy az accept() műveletnél megakadt a kódunk futása egészen addig, amíg nem érkezett egy klienstől kapcsolat. Ez azért van, mert vannak úgynevezett blokkoló műveletek. Ilyenek például az accept(), recv(), send(), connect() stb. Ezek megállítják a programunk futását. Ennek elkerülése végett be tudjuk állítani a socketet olyan módba, hogy ezen műveletei ne blokkolják a program futását.

sock.setblocking(0) # or sock.setblocking(False) or sock.settimeout(0.0) or sock.settimeout(1.0)
sock.setblocking(1) # or sock.setblocking(True) or sock.settimeout(None)

Más dolgokat is be lehet állítani a socketen. Ezt a következő paranccsal lehet megtenni: sock.setsockopt(level, optname, value). Az általunk használt level értékek az alábbiak lesznek: socket.IPPROTO_IP, ami azt jelzi, hogy IP szintű beállításról van szó, socket.SOL_SOCKET, ami azt jelzi, hogy socket API szintű beállításról van szó. Az optname a beállítandó paraméter neve, például socket.SO_REUSEADDR, ami azt jelenti, hogy a kapcsolat bontása után a portot hasznosítsa újra. A value lehet sztring vagy egész szám. Az előbbi esetén biztosítani kell a hívónak, hogy a megfelelő biteket tartalmazza (struct segítségével). A socket.SO_REUSEADDR esetén ha 0, akkor lesz hamis a „tulajdonság”, egyébként igaz.

sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)

Select:

Select segítségével több nyitott fájlon, pipe-on vagy socketen egyszerre is tudunk figyelni. Visszatér, amint egy valamelyik írható, olvasható, vagy error történt. Miért is jó ez nekünk? Select segítségével egyszerre több kapcsolatot is kezelni tudunk. Így akár egyszerre több klienst is ki tud szolgálni egy szerver egyidejűleg.

A select() blokkoló művelet, addig vár, amíg legalább 1 socket készen nem áll a feldolgozásra vagy le nem jár az idő (timeout).

A select() három listával tér vissza. Az elsőben azok a socketek vannak, amelyeknél van bejövő adat, amely olvasható. A második azokat a socketeket tartalmazzák, amelyeknek van szabad helyük adatok írására. A harmadikban azok vannak, amelyeknél error történt.

import select

...
inputs = [server] # sockets from which we expect to read
outputs = [] # sockets to which we expect to write
timeout = 1

# Wait for at least one of the sockets to be ready for processing
readable, writable, exceptional = select.select(inputs, outputs, inputs, timeout)
for s in readable:
    if s is server: # new client connect
        ...
    else:
        ... # handle client

Teljes kód egy TCP számológép szerverre:

import socket
import select
import struct

packer = struct.Struct('iic')
server_addr = ('127.0.0.1', 8000)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
    server.bind(server_addr)
    server.listen(1)
    print("Listening for new connections...")

    inputs = [server]
    timeout = 1
    
    try:
        while True:
            readable, writeable, exceptional = select.select(inputs, inputs, inputs, timeout)
            
            if not (readable or writeable or exceptional):
                continue
            
            for sock in readable:
                if sock is server: # new connection
                    client, client_addr = sock.accept()
                    inputs.append(client)
                    print("Connected: ", client_addr)
                else: # an existing connection is readable
                    data = sock.recv(packer.size)
                    if not data:
                        print("Logout: ", sock)
                        inputs.remove(sock)
                        sock.close()
                    else:
                        a, b, c = packer.unpack(data)
                        res = eval(str(a) + c.decode() + str(b))
                        sock.send(str(res).encode())
    except KeyboardInterrupt:
        print("Closing the server...")

Teljes kód egy TCP számológép kliensére:

import socket
import struct

server_addr = ('127.0.0.1', 8000)
packer = struct.Struct('iic')
    
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as client:
    try:
        a = input("Give me a number: ")
        b = input("Give me an operator: ")
        c = input("Give me a number: ")
        
        if len(b) > 1:
            print("Operator should be only 1 character!")
            exit(1)

        if b not in "+-*/%":
            print(f"This is not an operator: {b}")
            exit(1)

        packed_data = packer.pack(int(a), int(c), b.encode())
        client.connect(server_addr)
        
        client.send(packed_data)
        data = client.recv(200)
        print("Result: ", data.decode())
    except ValueError:
        print("Please use numbers!")
    except KeyboardInterrupt:
        print("\nInterrupted")

UDP socket:

Az UDP-vel a kapcsolat kiépítése nélkül tudunk kommunikálni. Amire szükségünk lesz itt is, hogy létrehozzuk a socketet, amin keresztül kommunikálni fogunk, továbbá hozzá kell bind-olni a porthoz a socketet. Fontos kiemelni, hogy most Datagram típusú socketet hozunk létre (SOCK_DGRAM). Nem lesz szükségünk listen(), accept() és connect() metódusokra. Ami különbség még, hogy nem recv() és send() függvényeket használunk, hanem recvfrom() és sendto() függvényeket. Ez azért van, mert az UDP-nél nem épül ki kapcsolat, így küldésnél meg kell adni paraméterben, hogy kinek küldjük, fogadó oldalon pedig meg kell szerezzük azt az információt, hogy kinek kell esetleg választ küldeni. Érdemes megjegyezni, hogy a TCP-nél egy üres stringet küld, mikor bontja a kapcsolatot. UDP-nél nincs ilyen, ezért ezt mi magunknak kell megcsináljük, hogy miután elküldtünk és fogadtunk minden adatot, a végén érdemes egy üres stringet még elküldeni, jelezve a szervernek, hogy nem kívánunk tovább kommunikálni vele.

Egyszerű UDP szerver:

import socket

server_addr = ('127.0.0.1', 8000)
    
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as server:
    server.bind(server_addr)
    print("Waiting for any data...")
    data, addr = server.recvfrom(1024)
    print("Data:", data.decode())
    print("Address:", addr)

Egyszerű UDP kliens:

import socket

server_addr = ('127.0.0.1', 8000)
    
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as client:
    client.sendto("Hello".encode(), server_addr)
    print("Data sent.")

Teljes kód UDP-n keresztül történő fájlküldés szerverére:

import socket

server_addr = ('127.0.0.1', 8000)

with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as server:
    with open('netNew.jpg', 'wb') as f:
        server.bind(server_addr)

        data, client_addr = server.recvfrom(200)
        while data:
            f.write(data)
            server.sendto('OK'.encode(), client_addr)
            data, client_addr = server.recvfrom(200)
        server.sendto('OK'.encode(), client_addr)

Teljes kód UDP-n keresztül történő fájlküldés kliensére:

import socket

server_addr = ('127.0.0.1', 8000)

with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as client:
    with open('net.jpg', 'rb') as f:
        data = f.read(200)
        while data:
            client.sendto(data, server_addr)
            client.recvfrom(4)
            data = f.read(200)
        client.sendto(''.encode(), server_addr)
        client.recvfrom(4)

Példa kód egy web proxy készítésére:

Az alábbi kód egy web proxy. Miután elindítottuk a proxy szerver, írjuk be a böngészőbe, hogy "localhost:9000". Ennek hatására a böngésző küld egy HTTP GET request-et, amelyet a proxy szerverünk átír. Gyakorlatilag kicseréli a célt és az elérési utat egy másik weboldal elérési címére. Ezáltal a GET request eljut az adott web szerverhez, aki visszaküldi a megfelelő HTML, CSS, JS fájlokat, amelyeket a proxy szerverünk visszajuttat a böngészőnek.

import socket
import select

proxy_addr = ('localhost', 9000)
people_inf_elte_hu_addr = ('people.inf.elte.hu', 80)

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as proxy:
    proxy.bind(proxy_addr)
    proxy.listen(1)
    print("Listening for new connections...")

    inputs = [proxy]
    timeout = 1

    try:
        while True:
            readable, writeable, exceptional = select.select(inputs, inputs, inputs, timeout)
            if not (readable or writeable or exceptional):
                continue
            for sock in readable:
                if sock is proxy: # new connection
                    client, client_addr = sock.accept()
                    inputs.append(client)
                    print("Connected: ", client_addr)
                else: # an existing connection is readable
                    data = sock.recv(65000)
                    if not data:
                        print("Logout: ", sock)
                        inputs.remove(sock)
                        sock.close()
                    else:
                        get_request = str(data.decode()).replace("GET /", "GET /pgm6rw/telkom").replace("localhost:9000", f"{people_inf_elte_hu_addr[0]}:{people_inf_elte_hu_addr[1]}").encode()
                        print(get_request)
                        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as server:
                            server.connect(people_inf_elte_hu_addr)
                            server.send(get_request)
                            html = server.recv(65000)
                            sock.send(html)

    except KeyboardInterrupt:
        print("Closing the server...")

CRC hibajelző kód:

Egy Ethernet keret 0-ákból és 1-esekből épül fel. Ezeket fel tudjuk írni egész együtthatós polinomként. Például 1010 -> 1 * x^3 + 0 * x^2 + 1 * x^1 + 0 * x^0 = x^3 + x. Ezen felül lesz egy generátor polinom, amit a protokoll határoz meg és mindkét félnek ismernie kell. Csúsztassuk arrébb a keretet, annyival ahanyadik fokú a generátor polinom. Ezek után, ha leosztjuk a keretet a generátor polinommal, akkor megkapjuk a maradék polinomot, amelyet a keret végére kell rakni, ezért csúsztatuk arrébb. Ha például negyedfokú a generátor polinom, akkor 4 biten ábrázolható a maradék polinom. Mivel hozzáraktuk a maradékot a kerethez, így biztosan osztható lesz a generátor polinommal.

Fogadó oldalon, ha leosztjuk a generátor polinommal, akkor a többszörösét kell kapjuk, azaz a maradéknak 0-nak kell lennie. Ha nem 0, akkor megsérült a keret. Még egy olyan eset is előfordulhat, hogy olyan mértékben sérült a keret, hogy pont 0 lesz a maradék.

import binascii, zlib

test_string = "Fill this with something".encode('utf-8')
print(hex(binascii.crc32(bytearray(test_string))))
print(hex(zlib.crc32(test_string)))

MD5:

Az MD5 ellenőrző összegként használható az fájlok/adatok integritásának ellenőrzésére a nem szándékos sérülés ellen. Valójában nincs mód az adatok sértetlenségének ellenőrzésére a számítógépen lévő hash kiszámítása nélkül. Erre lehet jó az MD5 vagy az SHA1.

import hashlib

test_string = "Fill this with something".encode('utf-8')
m = hashlib.md5()
m.update(test_string)
print(m.hexdigest())

SHA1:

import hashlib

test_string = "Fill this with something".encode('utf-8')
m = hashlib.sha1()
m.update(test_string)
print(m.hexdigest())

Kiegészítő anyag:

Raw socket:

A socket létrehozásától függően lehetőségünk van akár a csomag fejléceit is beállítani. Windowson a Raw Socket limitált, mivel nincs AF_PACKET. Ezért legfeljebb az IP fejlécig van lehetőségünk módosítani a csomagot, az Ethernet keret fejlécéhez nincs hozzáférésünk. Viszont Unix rendszereken a teljes csomagot felépíthetjük, akár bájt szinten.

Az alábbi kód egy példa, hogy hogyan kell összerakni az Ethernet keretet, Vlan fejlécet. Ez a kód csak Unix rendszereken működik!

import socket
import struct

interface = "lo"

# Create a raw socket
sock = socket.socket(socket.AF_PACKET, socket.SOCK_RAW)
sock.bind((interface, 0))

# Convert MAC addresses to binary format
src_mac = "00:0a:95:9d:68:16"
dst_mac = "ff:ff:ff:ff:ff:ff"
src_mac = bytes.fromhex(src_mac.replace(':', ''))
dst_mac = bytes.fromhex(dst_mac.replace(':', ''))

# Construct the Ethernet header
eth_header = struct.pack('!6s6sH', dst_mac, src_mac, 0x8100)

# Construct the VLAN header
vlan_id = 100
tci = (0 << 13) | (0 << 12) | vlan_id
vlan_header = struct.pack('!HH', tci, 0x0800)

# Construct the payload
payload = b'Hello'

# Combine the headers and payload into the complete frame
frame = eth_header + vlan_header + payload

# Send the frame
sock.send(frame)
print(f"Sent Ethernet frame with VLAN ID {vlan_id} on interface {interface}")