Lecture #16

OSSF

• IPv4: 32-bit addresses

• IPv5: 128-bit addresses

• DNS system

  • distributed hierarchical database
  • maps domain names to IP addresses

• network OS

  • networking applications

• distributed OS

  • resource allocation across entire datacenter
  • distributed lock service

• sockets: "high-level" abstraction

  • once network connection is opened, can use read & write system calls
  • socket descriptor: specialized file descriptor

Endianness (Byte Order)

• #include <arpa/inet.h>
  • htons: host to network short (16 bits)
  • ntohs: network to host short (16 bits)
  • htonl: host to network long (32 bits)
  • ntohl: network to host long (32 bits)

IP Address Manipulation

• text format to 32-bit number
  • host byte order (little endian on Intel)
  • network byte order (big endian)

```

include

include

include

typedef unint32t inaddrt; struct inaddr { inaddrt s_addr }; ```

• string rep (dotted notation) to 32-bit int: inet_aton(char *cp, struct in_addr_t *inp);

• number to dotted string: inet_ntoa

Network Programming API

• API design constrained by limited hardware resources of the 1970s & 1980s

  • more useable API if designed today would be namespace oriented, e.g
    • open("/net/10.138.56.18/80")
    • open("/net/10.138.56.18/tcp/80")
    • open("http://microservice.local:80/path")
      • i.e. like some sort of resource identifier with a uniform pattern
        • looks like we just "invented" the URI

• still need to translate the high-level notation into wire format (protocol)

• text-based URI: easier on the eyes, harder on the computer

  • good tradeoff these days (programmers are expensive)

• but here we're staring into the nitty gritty

• given hostname, get IP address (library call):

  • looks up system configuration files
    • /etc/hosts
    • /etc/host.conf
    • /etc/nsswitch.conf

• obsolete: struct hostent *gethostbyname(char *name)

  • returns pointer to 4 bytes (IP address)

• modern: getaddrinfo

  • more complelx API
  • returns struct addrinfo *

• after name lookup, hostname is not used: all connections via IP address

• HTTP: higher-level protocol

  • since multiple hostnames can map to a single IP, hostname is an optional field in HTTP
    • "virtual" host

Sockets

• socket: (Unix) abstraction for all networking

  • incorporated into MS Windows
  • AKA "Berkeley sockets"
  • Mostly TCP & UDP protocols, but not exclusively
    • Unix-domain sockets: interprocess communication
    • X.25 (obsolete) packet-switching (all but gone except perhaps for some niche legacy applications)

• create socket: socket(2)

  • returns socket descriptor
    • small integer, same namespace as file descriptor
      • in modern terms, socket descriptor is subclass of file descriptor
  • after setup, may use read/write/close on open socket descriptors
  • may also use send/recv
    • better control over message-oriented protocols (e.g. UDP)
  • additional system calls to set up connections
  • acts like a file, but not completely transparent
    • different "constructor"

• header files (#include):

  • sys/types.h
  • sys/socket.h

• socket(2) returns a freshly-allocated socket object (socket descriptor, file descriptor)

  • not yet tied to connection (no associated port)

• sd = socket(int domain, int type, int protocol)

  • domain (address family):
    • AF_UNIX (IPC)
    • AF_INET (internet protocol--IP)
  • type
    • SOCK_RAW (raw IP packets)
    • SOCK_DATATGRAM (UDP)
    • SOCK_STREAM (TCP)
  • protocol
    • 0 (unused) for AF_INET

• 2 operating modes: passive (server) & active (client)

  • difference between client & server: who initiates the connection

• server

  • TCP
    • bind(): associate socket with port#
    • listen(): specify operating mode
    • accept(): return new socket descriptor for each opened connection
  • UDP
    • bind()
    • recvfrom(fd, buf, size, flags, sockaddr, addrlen)

• client

  • TCP
    • bind() (optional: if not used, port is assignened by system)
    • connect()
  • UDP
    • bind() (optional: use to get return address)
    • sendto() 1.
      • connect()
      • send()

• bind()

  • creates assoiation socket & address (host, port)
  • `int bind(int sd, const struct sockaddr *addr, socklen_t addrlen)
    • addr is local address

• sockaddr: essentially a base type

  • protocol-specific address structs are cast to sockaddr*
    • e.g. internet socket: sockaddr_in

• int accept(int sd, struct sockaddr *addr, socklen_t *addrlen);

  • addr & `addrlen are out parameters, filled in with remote address
  • addr may be NULL if you don't care
  • returns new socket desciptor for communication
    • original sd remains open for additional connections

• listen(2): set size of backlog for passive sockets

• may have multiple concurrent open connections for a given address

  • each connection gets its own sd

Addressing

• text: host:port

  • test processing:
    • relatively expensive (1970s/1980s era computing)
    • only have to do it once

• address data structure: struct sockaddr

  • but addressing is dependent on the protocol
    • internet address: struct sockaddr_in
      • overlay: 1st field is family (AF_INET) (acts as tag on variant record
      • sin_family: AF_INET
      • sin_port
      • sin_addr: struct sin_addr {uint32_t s_addr;};
  • must construct IP address object (type struct struct sockaddr_in) & cast to struct sockaddr

• internet address (TCP/IP or UDP/IP) use struct sockaddr_in

  • sin_family = AF_INET (tag field)
  • sin_addr.s_addr = ip_address (32 bits)
  • sin_port = port (16 bits)

• for server, use s_addr = htonl(INADDR_ANY)

  • use any network interface on machine
    • computer may have multiple NICs (for bandwidth, routing, priority)

• use port = 0 for randomly-assigned unused port

  • ephemeral ports
  • single namespace shared between servers (assigned port#s) & clients (ephemeral ports)

• connect(int sd, const struct sockaddr *addr, socklen_t addrlen)

  • connect to remote address addr

UDP (User Datagram Protocol)

• client

  • socket()
  • bind() (if response is wanted)
  • either:
    1. sendto()' &recvfrom()`
    2. connect() followed by send() & recv()

• server

  • socket()
  • bind()
  • recvfrom() & sendto()

• UDP sockets are

  • connectionless
  • unreliable: packets may be
    • lost
    • arrive out of order

• either you don't care if some data is lost or you have your own homebrew error recovery scheme

• applications:

  • TFTP/BOOTP
  • NFS
  • DNS
  • media streaming
  • sensor data (IOT)

• multicast: TODO: details

• client (connectionless)

  • create socket
  • sendto(sd, msg, len, flags, addr, addrlen)

• RTFM for details

• TODO: live coding

Sockets & Concurrency

• threads

• like all file descriptors, socket descriptor stays open across fork & exec

  • unless you explicitly set close-on-exec flag