Csci 1680 application interface
1 / 35

CSCI-1680 Application Interface - PowerPoint PPT Presentation

  • Uploaded on

CSCI-1680 Application Interface. Rodrigo Fonseca. Based partly on lecture notes by David Mazières , Phil Levis, John Jannotti. Administrivia. Book is ordered on bookstore, you can check later this week Today: C mini course ! Fishbowl, 8-10pm Signup for Snowcast milestone

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about ' CSCI-1680 Application Interface' - donnel

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Csci 1680 application interface

CSCI-1680Application Interface

Rodrigo Fonseca

Based partly on lecture notes by David Mazières, Phil Levis, John Jannotti


  • Book is ordered on bookstore, you can check later this week

  • Today: C mini course ! Fishbowl, 8-10pm

  • Signup for Snowcast milestone

    • Check website for announcements after class, will have a Google spreadsheet link


  • Multiplexing

  • Layering and Encapsulation

  • IP, TCP, UDP

  • Today:

    • Performance Metrics

    • Socket API

    • Concurrent servers

Performance metrics
Performance Metrics

  • Throughput - Number of bits received/unit of time

    • e.g.10Mbps

  • Goodput - Usefulbits received per unit of time

  • Latency – How long for message to cross network

    • Process + Queue + Transmit + Propagation

  • Jitter – Variation in latency


  • Processing

    • Per message, small, limits throughput

    • e.g. or 120μs/pkt

  • Queue

    • Highly variable, offered load vs outgoing b/w

  • Transmission

    • Size/Bandwidth

  • Propagation

    • Distance/Speed of Light

Bandwidth and delay
Bandwidth and Delay

  • How much data can we send during one RTT?

  • E.g., send request, receive file




  • For small transfers, latency more important, for bulk, throughput more important

Maximizing throughput
Maximizing Throughput

  • Can view network as a pipe

    • For full utilization want bytes in flight ≥ bandwidth × delay

    • But don’t want to overload the network (future lectures)

  • What if protocol doesn’t involve bulk transfer?

    • Get throughput through concurrency – service multiple clients simultaneously

Using tcp ip
Using TCP/IP

  • How can applications use the network?

  • Sockets API.

    • Originally from BSD, widely implemented (*BSD, Linux, Mac OS X, Windows, …)

    • Important do know and do once

    • Higher-level APIs build on them

  • After basic setup, much like files

System calls
System Calls

  • Problem: how to access resources other then CPU

    • Disk, network, terminal, other processes

    • CPU prohibits instructions that would access devices

    • Only privileged OS kernel can access devices

  • Kernel supplies well-defined system call interface

    • Applications request I/O operations through syscalls

    • Set up syscall arguments and trap to kernel

    • Kernel performs operation and returns results

  • Higher-level functions built on syscall interface

    • printf, scanf, gets, all user-level code

File descriptors
File Descriptors

  • Most I/O in Unix done through file descriptors

    • Integer handles to per-process table in kernel

  • intopen(char *path, int flags, ...);

  • Returns file descriptor, used for all I/O to file

Error returns
Error Returns

  • What if open fails? Returns -1 (invalid fd)

  • Most system calls return -1 on failure

    • Specific type of error in global interrno

  • #include <sys/errno.h> for possible values

    • 2 = ENOENT “No such file or directory”

    • 13 = EACCES “Permission denied”

  • perror function prints human-readable message

    • perror(“initfile”);

    • initfile: No such file or directory

Some operations on file descriptors
Some operations on File Descriptors

  • ssize_t read (intfd, void *buf, intnbytes);

    • Returns number of bytes read

    • Returns 0 bytes at end of file, or -1 on error

  • ssize_t write (intfd, void* buf, intnbytes);

    • Returns number of bytes written, -1 on error

  • off_tlseek (intfd, off_t offset, int whence);

    • whence: SEEK_SET, SEEK_CUR, SEEK_END

    • returns new offset, or -1 on error

  • int close (intfd);

  • intfsync (intfd);

    • Guarantees that file contents is stably on disk

  • See type.c

Sockets communication between machines
Sockets: Communication Between Machines

  • Network sockets are file descriptors too

  • Datagram sockets: unreliable message delivery

    • With IP, gives you UDP

    • Send atomic messages, which may be reordered or lost

    • Special system calls to read/write: send/recv

  • Stream sockets: bi-directional pipes

    • With IP, gives you TCP

    • Bytes written on one end read on another

    • Reads may not return full amount requested, must re-read

System calls for using tcp
System calls for using TCP


socket – make socket

bind – assign address, port

listen – listen for clients

socket – make socket

bind* – assign address

connect – connect to listening socket

accept – accept connection

  • This call to bind is optional, connect can choose address & port.

Socket naming
Socket Naming

  • Recall how TCP & UDP name communication endpoints

    • IP address specifies host (

    • 16-bit port number demultiplexes within host

    • Well-known services listen on standard ports (e.g.ssh – 22, http – 80, mail – 25, see /etc/services for list)

    • Clients connect from arbitrary ports to well known ports

  • A connection is named by 5 components

    • Protocol, local IP, local port, remote IP, remote port

    • TCP requires connected sockets, but not UDP

Socket address structures
Socket Address Structures

  • Socket interface supports multiple network types

  • Most calls take a generic sockaddr:

    structsockaddr {

    uint16_t sa_family; /* address family */

    char sa_data[14]; /* protocol-specific addr */


  • E.g.intconnect(ints, structsockaddr* srv,


  • Cast sockaddr* from protocol-specific struct, e.g.,

    structsockaddr_in {

    short sin_family; /* = AF_INET */

    u_shortsin_port; /* = htons (PORT) */

    structin_addrsin_addr; /*32-bit IPv4 addr*/

    chars in_zero[8];


Dealing with address types
Dealing with Address Types

  • All values in network byte order (Big Endian)

    • htonl(), htons(): host to network, 32 and 16 bits

    • ntohl(), ntohs(): network to host, 32 and 16 bits

    • Remember to always convert!

  • All address types begin with family

    • sa_family in sockaddr tells you actual type

  • Not all addresses are the same size

    • e.g., struct sockaddr_in6 is typically 28 bytes, yet generic structsockaddr is only 16 bytes

    • So most calls require passing around socket length

    • New sockaddr_storage is big enough

Client skeleton ipv4
Client Skeleton (IPv4)

Looking up a socket address with getaddrinfo
Looking up a socket address with getaddrinfo

structaddrinfo hints, *ai;

int err;

memset (&hints, 0, sizeof (hints));

hints.ai_family= AF_UNSPEC; /* or AF_INET or AF_INET6 */

hints.ai_socktype= SOCK_STREAM;/* or SOCK_DGRAM for UDP */

err = getaddrinfo ("", "http", &hints, &ai);

if (err)

fprintf (stderr, "%s\n", gia_strerror (err));

else {

/* ai->ai_family = address type (AF_INET or AF_INET6) */

/* ai->ai_addr = actual address cast to (sockaddr *) */

/* ai->ai_addrlen = length of actual address */

freeaddrinfo (ai); /* must free when done! */


Getaddrinfo rfc3493
getaddrinfo() [RFC3493]

  • Protocol-independent node name to address translation

    • Can specify port as a service name or number

    • May return multiple addresses

    • You must free the structure with freeaddrinfo

  • Other useful functions to know about

    • getnameinfo – Lookup hostname based on address

    • inet_ntop – Convert IPv4 or 6 address to printable

    • Inet_pton – Convert string to IPv4 or 6 address

A fetch store server
A Fetch-Store Server

  • Client sends command, gets response over TCP

  • Fetch command (“fetch\n”):

    • Response has contents of last stored file

  • Store command (“store\n”):

    • Server stores what it reads in file

    • Returns OK or ERROR

  • What if server or network goes down during store?

    • Don’t say “OK” until data is safely on disk

  • See fetch_store.c

Eof in more detail
EOF in more detail

  • What happens at end of store?

    • Server receives EOF, renames file, responds OK

    • Client reads OK, after sending EOF: didn’t close fd

  • intshutdown(intfd, int how);

    • Shuts down a socket w/o closing file descriptor

    • how: 0 = read, 1 = write, 2 = both

    • Note: applies to socket, not descriptor, so copies of descriptor (through fork or dup affected)

    • Note 2: with TCP, can’t detect if other side shuts for reading

Using udp
Using UDP

  • Call socket with SOCK_DGRAM, bind as before

  • New calls for sending/receiving individual packets

    • sendto(ints, const void *msg, intlen, int flags, const structsockaddr *to, socklenttolen);

    • recvfrom(ints, void *buf, intlen, int flags, structsockaddr *from, socklent *fromlen);

    • Must send/get peer address with each packet

  • Example: udpecho.c

  • Can use UDP in connected mode (Why?)

    • connect assigns remote address

    • send/recvsyscalls, like sendto/recvfrom w/o last two arguments

Uses of udp connected sockets
Uses of UDP Connected Sockets

  • Kernel demultiplexes packets based on port

    • Can have different processes getting UDP packets from different peers

  • Feedback based on ICMP messages (future lecture)

    • Say no process has bound UDP port you sent packet to

    • Server sends port unreachable message, but you will only receive it when using connected socket

Creating monitoring processes
Creating/Monitoring Processes

  • pid_tfork(void);

    • Create new process that is exact copy of current one

    • Returns twice!

    • In parent: process ID of new process

    • In child: 0

  • pid_twaitpid(pid_tpid, int *stat, int opt);

    • pid – process to wait for, or -1 if any

    • stat – will contain status of child

    • opt – usually 0 or WNOHANG

Fork example
Fork example

switch (pid = fork ()) {

case -1:

perror ("fork");


case 0:

doexec ();



waitpid (pid, NULL, 0);


Deleting processes
Deleting Processes

  • void exit(int status);

    • Current process ceases to exist

    • Status shows up on waitpid (shifted)

    • By convention, status of 0 is success, non-zero error

  • int kill (intpid, int sig);

    • Sends signal sig to process pid

    • SIGTERM most common sig, kills process by default (but application can catch it for “cleanup”)

    • SIGKILL stronger, always kills

Serving multiple clients
Serving Multiple Clients

  • A server may block when talking to a client

    • Read or write of a socket connected to a slow client can block

    • Server may be busy with CPU

    • Server might be blocked waiting for disk I/O

  • Concurrency through multiple processes

    • Accept, fork, close in parent; child services request

  • Advantages of one process per client

    • Don’t block on slow clients

    • May use multiple cores

    • Can keep disk queues full for disk-heavy workloads


  • One process per client has disadvantages:

    • High overhead – fork + exit ~100μsec

    • Hard to share state across clients

    • Maximum number of processes limited

  • Can use threads for concurrency

    • Data races and deadlocks make programming tricky

    • Must allocate one stack per request

    • Many thread implementations block on some I/O or have heavy thread-switch overhead

      Rough equivalents to fork(), waitpid(), exit(), kill(), plus locking primitives.

Non blocking i o
Non-blocking I/O

  • fcntl sets O_NONBLOCK flag on descriptor


    if ((n = fcntl(s, F_GETFL)) >= 0)

    fcntl(s, F_SETFL, n|O_NONBLOCK);

  • Non-blocking semantics of system calls:

    • read immediately returns -1 with errno EAGAIN if no data

    • write may not write all data, or may return EAGAIN

    • connect may fail with EINPROGRESS (or may succeed, or may fail with a real error like ECONNREFUSED)

    • accept may fail with EAGAIN or EWOULDBLOCK if no connections present to be accepted

How do you know when to read write
How do you know when to read/write?

  • Entire program runs in an event loop

Event driven servers
Event-driven servers

  • Quite different from processes/threads

    • Race conditions, deadlocks rare

    • Often more efficient

  • But…

    • Unusual programming model

    • Sometimes difficult to avoid blocking

    • Scaling to more CPUs is more complex

Coming up
Coming Up

  • Next class: Physical Layer

  • Fri 04: Milestones due by 6PM