TCP/IP: ano ito, stack ng mga protocol at paghahatid ng data

Ano ang TCP/IP?

TCP/IP (Transmission Control Protocol / Internet Protocol) ay isang stack ng mga protocol na binuo noong 1970s para sa ARPANET at naging de facto na pamantayan para sa pandaigdigang internet network. Tinutukoy nito kung paano hinahati ang data sa mga packet, ina-address, ipinapadala, at binubuo sa panig ng tumatanggap.

Ang arkitektura ng TCP/IP ay binuo sa multi-layer na prinsipyo, kung saan ang bawat layer ay nag-aabstrak ng mga partikular na function. Ang application layer ay gumagana sa data ng application, ang transport layer ay nagbibigay ng pagiging maaasahan, ang network layer ay humahawak ng routing, at ang link layer ay humahawak ng paghahatid sa pamamagitan ng pisikal na medium. Modularity ay nagpapahintulot sa pagpapalit ng mga protocol sa loob ng isang layer nang hindi binabago ang mga katabing layer.

Sa mobile development, ang TCP/IP ay ginagamit ng bawat application na nagsasagawa ng mga network request. Ang mga library na URLSession, OkHttp, AFNetworking, at Alamofire ay gumagana sa ibabaw ng stack na ito, na nagtatago mula sa developer ng mga detalye ng pag-pack at routing ng packet. Gayunpaman, ang pag-unawa sa TCP/IP ay kinakailangan para sa pag-optimize ng pagganap: ang pag-configure ng mga parameter ng TCP sa pamamagitan ng URLSessionConfiguration ay nagbibigay-daan sa pamamahala ng mga time-out, pagpapanatili ng HTTP Persistent Connections, at pag-set up ng proxy para sa mga corporate environment.

Ang pag-unawa sa TCP/IP ay kinakailangan para sa pag-diagnose ng mga problema sa network: kung ang application ay hindi makakonekta sa server, ang problema ay maaaring nasa anumang layer ng stack — mula sa pisikal na channel hanggang sa application protocol. Ang mga tool tulad ng tcpdump, Wireshark, at Charles Proxy ay nagbibigay-daan sa pagsusuri ng trapiko sa bawat layer at paghahanap ng mga bottleneck. Para sa mga mobile developer, ang Xcode ay nagbibigay ng Network Debug Dashboard, at ang Android Studio ay nagbibigay ng Network Inspector para sa real-time na pagsusuri ng mga TCP connection.

Mga layer ng modelo ng TCP/IP

Ang modelo ng TCP/IP ay may kasamang apat na layer, bawat isa ay gumaganap ng mahigpit na tinukoy na mga function kapag nagpapadala ng data. Ang pag-unawa sa hierarchy na ito ay kinakailangan para sa pag-diagnose ng mga problema sa network at pag-optimize ng mga application.

Application layer

Sa application layer gumagana ang mga protocol na direktang nakikipag-ugnayan sa mga application: HTTP, HTTPS, FTP, SMTP, DNS, WebSocket. Ang layer na ito ay bumubuo ng data sa format na naiintindihan ng application at ipinapasa ito sa transport layer. Ang mga developer ng mobile application ay nagtatrabaho sa layer na ito sa pamamagitan ng mga network library.

Transport layer

Ang transport layer ay nagbibigay ng paghahatid ng data sa pagitan ng mga application sa iba't ibang device. Mga pangunahing protocol: TCP (maaasahang paghahatid na may pagkilala) at UDP (mabilis na paghahatid nang walang garantiya). TCP ay nagdaragdag sa data ng port ng nagpadala at tumanggap, namamahala sa pagkakasunud-sunod ng packet, at kumokontrol sa pagsisikip ng network.

Network at link layer

Ang network layer ay ipinatupad ng IP protocol, na tumutukoy sa pag-address (IPv4, IPv6) at routing ng packet. Ang bawat packet ay naglalaman ng IP address ng nagpadala at tumanggap, at ang mga router sa landas ng paghahatid ay nagpapasya sa susunod na node batay sa mga routing table. Ang IPv4 ay gumagamit ng 32-bit na mga address (mga 4.3 bilyon), at ang IPv6 ay gumagamit ng 128-bit na mga address, na lumulutas sa problema ng pagkaubos ng address.

Ang link layer ay gumagana sa pisikal na medium ng paghahatid: Ethernet, Wi-Fi, Bluetooth. Ang layer na ito ay nagko-convert ng mga packet sa mga signal at vice versa, namamahala ng access sa transmission medium sa pamamagitan ng MAC address, at nakakakita ng mga error sa pisikal na layer gamit ang frame checksums (FCS).

Sa link layer gumagana ang mga protocol tulad ng ARP (Address Resolution Protocol), na nagko-convert ng mga IP address sa MAC address ng mga device sa lokal na network, at PPP (Point-to-Point Protocol), na ginagamit sa mga VPN connection at mobile data transmission network.

Paano gumagana ang protocol ng TCP

TCP (Transmission Control Protocol) ay isa sa mga pangunahing protocol ng transport layer. Nagbibigay ito ng maaasahan, nakaayos, at nabe-verify na paghahatid ng byte stream sa pagitan ng mga application. Bago ang paghahatid ng data, ang TCP ay nagtatag ng isang koneksyon sa pamamagitan ng three-way handshake.

Ang three-way handshake ay nagsisimula sa pagpapadala ng SYN packet ng client. Ang server ay tumugon gamit ang isang SYN-ACK packet, na kinukumpirma ang pagtanggap. Kinukumpleto ng client ang handshake gamit ang isang ACK packet, pagkatapos ay magsisimula ang paghahatid ng data. Ginagarantiyahan ng prosesong ito na ang parehong panig ay handa na para sa pagpapalitan at naka-sync ayon sa mga sequence number.

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect(('example.com', 80))
sock.send(b'GET / HTTP/1.1\r\nHost: example.com\r\n\r\n')
response = sock.recv(4096)
print(response.decode())
sock.close()

Sa halimbawa, isang TCP socket ng uri SOCK_STREAM ang ginagawa, na awtomatikong nagsasagawa ng three-way handshake kapag tinawag ang connect. Ang pamamaraang send ay nagpapadala ng HTTP request, ang recv ay tumatanggap ng tugon. Pagkatapos ng pagtatapos, ang close ay nagpapadala ng FIN packet para sa wastong pagsasara ng koneksyon.

TCP server na may pagproseso ng client

Tingnan natin ang isang halimbawa ng TCP server sa Python na tumatanggap ng maraming client sa pamamagitan ng mga thread. Ang bawat koneksyon ay pinoproseso sa isang hiwalay na thread, na nagpapahintulot sa maraming client na maserbisyuhan nang sabay-sabay nang hindi hinaharangan ang pangunahing loop.

import socket
import threading

def handle_client(conn, addr):
    print(f'Client na nakakonekta: {addr}')
    with conn:
        while True:
            data = conn.recv(1024)
            if not data:
                break
            conn.sendall(data.upper())
    print(f'Client {addr} nadiskonekta')

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('0.0.0.0', 9090))
server.listen(5)
print('TCP server ay tumatakbo sa port 9090')

while True:
    conn, addr = server.accept()
    thread = threading.Thread(target=handle_client, args=(conn, addr))
    thread.start()

Ang TCP server ay nagpoproseso ng bawat koneksyon sa isang hiwalay na thread, na tinatawag ang accept sa isang walang katapusang loop. Ang function na handle_client ay tumatanggap ng data, kino-convert ito sa malalaking titik, at ibinabalik ito sa pamamagitan ng sendall. Kapag natapos ang recv loop (kapag isinara ng client ang koneksyon), ang thread ay nagtatapos at ang socket ay awtomatikong nagsasara. Sa mga mobile application, ang ganitong mababang antas na trabaho gamit ang mga socket ay hindi direktang ginagamit — ang mga mobile HTTP library ay namamahala ng mga koneksyon sa pamamagitan ng thread pool at awtomatikong gumagamit muli ng mga TCP connection.

Mga pagkakaiba ng TCP at UDP

Ang pagpili sa pagitan ng TCP at UDP ay isa sa mga pangunahing desisyon sa pagdidisenyo ng network interaction. TCP ay ginagarantiyahan ang paghahatid, pagkakasunud-sunod, at integridad ng data sa halaga ng karagdagang latency. UDP ay isinasakripisyo ang pagiging maaasahan para sa minimal na latency at mas mababang load sa channel.

Para sa mga mobile application, ang pagpili ng protocol ay depende sa senaryo: ang REST-API at pag-download ng data ay nangangailangan ng TCP, habang ang mga video call at online na laro ay nakikinabang mula sa bilis ng UDP. Ang ilang mga application ay pinagsasama ang parehong protocol — TCP para sa kontrol at UDP para sa media stream. Ang modernong QUIC protocol, na gumagana sa ibabaw ng UDP at ginagamit sa HTTP/3, ay pinagsasama ang mga bentahe ng parehong approach at sinusuportahan na sa iOS at Android sa pamamagitan ng URLSession nang awtomatiko.

Mga halimbawa ng code ng TCP/IP

Tingnan natin ang isang halimbawa ng TCP client sa Python na may paghawak ng error at time-out. Ang approach na ito ay ginagamit sa mga mobile application para sa maaasahang koneksyon sa server.

import socket
import sys

def tcp_client(host, port):
    try:
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.settimeout(10)
        sock.connect((host, port))
        print(f'Nakakonekta sa {host}:{port}')
        return sock
    except socket.error as err:
        print(f'Error sa koneksyon: {err}')
        sys.exit(1)

sock = tcp_client('api.example.com', 443)
sock.close()

Ang function na tcp_client ay tumatanggap ng host at port, gumagawa ng socket na may 10 segundong time-out, at sumusubok na kumonekta. Sa kaso ng error sa koneksyon — halimbawa, hindi maabot ang server o na-block ng firewall — isang exception ang ibinabato na may paglalarawan ng problema. Sa mga mobile application, ang time-out ng koneksyon ay kritikal: masyadong maikli ay humahantong sa mga maling error sa mabagal na network, masyadong mahaba ay humahantong sa pag-freeze ng interface. Ang inirerekomendang halaga para sa mga mobile network ay 10–15 segundo para sa timeoutIntervalForRequest at 30–60 segundo para sa timeoutIntervalForResource sa configuration ng URLSession.