Socket Programming - EE&T Lecture Notes

The Sockets API 

TELE3118 lecture notes 

© by Tim Moors, April 6, 2011 

Copyright © 06/04/11, Tim Moors

2 

Resources 

2 books: 

• Short & sweet (147 pages) 

o 

o 

o 

M. Donahoo and K. Calvert: 

TCP/IP Sockets in C: Practical Guide for Programmers 

, Elsevier, 2001 

Click on title for free online access from within UNSW 

Code etc: http://cs.baylor.edu/~donahoo/#series 

• Definitive & exhaustive (991 pages) 

o 

W. Stevens et al: Unix Network Programming, Vol. 

1: The Sockets Networking API, 3 rd ed., Addison- 

Wesley 2004 


3 

Transport layer (in 1 crowded slide) 

Many apps need more than network layer 

packet delivery service. 

Transport protocols fix the mismatch, e.g. 

port #s to distinguish multiple processes 

• Services need ‘well known’ port #s 

(e.g. http=80, dns=53, ntp=123) 

• Clients can let operating system choose 

arbitrary “ephemeral” port # = return address, 

e.g. which web browser window 

Reliability 

• check integrity of received info 

(What if router mangles payload held in its network layer buffer?) 

o One transport protocol, UDP, only does this. 

• recover from loss 

o 

o 

o 

Another transport protocol, TCP, also does this. 

TCP’s mechanism involves 2 ends agreeing on transfer state 

• TCP is “connection-oriented” (UDP “connectionless”) 

• TCP can only unicast (UDP can multicast/broadcast) 

Flow control avoids loss due to excess speed, 

but may involve sending smaller data units 

=> TCP may alter message boundaries 

(e.g. app writes “TELE3118”, TCP might send “TELE” “31” “18”) 

=> TCP STREAM service vs UDP DGRAM service 

Copyright © 06/04/11, Tim Moors 

web app 

http dns 

tcp 

ip 

udp 

clock 

ntp 

port 

protocol

4 

Sockets history 

Operating System (OS) should abstract 

away details of hardware devices 

e.g. Unix provides consistent file interface 

for disk & keyboard & screen I/O 

1983: 4.2BSD Unix extended I/O to 

support network access via “sockets” 

1983: Before IP won over OSI, SNA etc 

=> “multiprotocol” (but small addresses) 

1983+Unix: C interface, e.g. pass 

pointers & typecast rather than 

overload functions. 

(e.g. (sockaddr*)sock_in) 

user 

space 

OS 

hardware 

web app clock 

http dns ntp 

sockets 

tcp udp 

ip 

1992: Microsoft Windows Sockets (“Winsock”) v1.0 simplifies 

porting network apps to Windows, with slight differences since 

Windows ≠ Unix. 

1999: IPv6 requires sockets extensions [RFC 3493] 

Bottom line: We want to write portable modern apps, not to read 

all apps using varied functions from past 25 years. 

For simplicity, we’ll omit error checking! 

The sockets API faces challenges from modern systems, as described in 

G. Neville-Neil: “Whither Sockets?”, ACM Queue Magazine, 7(4):34-5, May 2009 


5 

Web client 

// Web client. Copyright (C) 2009, Tim Moors. 

// Compile with tim_sockets.cpp & link in Ws2_32.lib (Windows), libnsl (Unix) 

#include "tim_sockets.h" 

#include 

#ifdef _WIN32 

# define snprintf _snprintf 

#endif 

int main(int argc, char **argv) { 

if (argc != 3) { 

fprintf(stderr, "Usage: %s server-addr filename", argv[0]); 

exit(EXIT_FAILURE); 

} 

SOCKET s = socket(PF_INET, SOCK_STREAM, 0); 

struct sockaddr_in server; 

server.sin_family = AF_INET; 

server.sin_addr.s_addr = inet_addr(argv[1]); 

server.sin_port = htons(80); 

if(connect(s, (struct sockaddr *)&server, sizeof(server))==0) { 

#define MAX_REQ_LEN 1000 

char request[MAX_REQ_LEN]; 

snprintf(request, MAX_REQ_LEN, "GET %s HTTP/1.1\nHost: %s\n\n", argv[2], argv[1]); 

send(s, request, strlen(request), 0); 

// receive file and write to stdout 

while (1) { 

#define BUF_SIZE 1234 

char buf[BUF_SIZE]; 

int bytes = recv(s, buf, BUF_SIZE, 0); 

if (bytes

6 

Web server 

// Web server. Copyright (C) 2009, Tim Moors. 

// Compile with tim_sockets.cpp & link in Ws2_32.lib (Windows), libnsl (Unix) 

#include "tim_sockets.h" 

#include 

#define BUF_SIZE 3118 

int main(int argc, char *argv[]) 

{ 

SOCKET s = socket(PF_INET, SOCK_STREAM, 0); 

struct sockaddr_in endpoint; 

endpoint.sin_family = AF_INET; 

endpoint.sin_addr.s_addr = htonl(INADDR_ANY); 

endpoint.sin_port = htons(80); 

bind(s, (struct sockaddr*)&endpoint, sizeof(endpoint)); 

listen(s, 5); 

while(1) { 

FILE* f; 

SOCKET new_client = accept(s, 0, 0); 

char buf[BUF_SIZE]; 

recv(new_client, buf, BUF_SIZE, 0); 

char* method = strtok(buf, " "); // method 

char* status; 

char OK[] = "HTTP/1.1 200 OK\n\n"; 

if(strncmp(method, "GET", 3)!=0) 

status = "HTTP/1.1 405 Method not allowed"; 

else { 

char* uri = strtok(NULL, " "); 

f = fopen(uri, "r"); 

if(f==NULL) 

status = "HTTP/1.1 404 Not found\n\n"; 

else 

status = OK; 

} 

send(new_client, status, strlen(status), 0); 

if(status == OK) { 

while(!feof(f)) { 

int len = fread(buf, sizeof(char), BUF_SIZE, f); 

send(new_client, buf, len, 0); 

} 

fclose(f); 

} 

close(new_client); 

} 

} 

int main(int argc, char *argv[]) 

{ 

SOCKET s = socket(PF_INET, SOCK_STREA 

bind(s, (struct sockaddr*)&endpoint, sizeof 

listen(s, 5); 

while(1) { 

SOCKET new_client = accept(s, 0, 0); 

recv(new_client, buf, BUF_SIZE, 0); 

f = fopen(uri, "r"); 

send(new_client, status, strlen(status), 0) 

if(status == OK) { 

while(!feof(f)) { 

int len = fread(buf, sizeof(char), BUF_S 

send(new_client, buf, len, 0); 

} 

} 

close(new_client); 

} 

} 


7 

Building sockets applications 

Headers: 

• Windows: 

for *info() and types 

• Unix: 

 

 

for *info() and types 

Functions/types vary with operating system. 

Masked here in purple. 

Here Linux Windows 

SOCKET int SOCKET 

close close closesocket 

ioctl ioctl ioctlsocket 

inet_ntop inet_ntop InetNtop (Vista or later) 

SHUT_RD SHUT_RD SD_RECEIVE 

SHUT_WR SHUT_WR SD_SEND 

SHUT_RDWR SHUT_RDWR SD_BOTH 

Link in: 

• Windows: Ws2_32.lib 

& remember to call WSAStartup()/WSACleanup() 

• Unix: libnsl, e.g. “gcc –lnsl foo.c” 


8 

Outline: 8 essentials 

Creation: 

socket(), setsockopt() 

Communication: send(), recv() 

sendto(), recvfrom() 

Addressing: 

sockaddr, sockaddr_storage 

Specifying addrs: bind(), connect() 

Serving clients: 

Converting #s: 

Names↔Addr: 

Cleaning up: 

listen(), accept() 

htonl(), ntohl() 

htons(), ntohs() 

getaddrinfo() 

shutdown(), close() 



9

10 

socket() 

Provides a context (protocol & other info bound to socket) 

SOCKET socket(int socket_family, e.g. PF_INET, AF_INET6 

int socket_type, e.g. SOCK_STREAM or SOCK_DGRAM 

int protocol 0 lets OS choose; or IPPROTO_TCP etc 

); 

Returns: SOCKET that can be used in later I/O to identify which 

socket is being accessed 

get/setsockopt() controls socket options 

int setsockopt(SOCKET s, 

int level, e.g. SOL_SOCKET or IP_PROTOTCP 

int optname, e.g. SO_REUSEADDR, IP_ADD_MEMBERSHIP 

const void *optval, socklen_t optlen); 


11 

Communicating through sockets 

Linux apps can apply standard file I/O to sockets: 

ssize_t write(int fd, const void *buf, size_t count); 

ssize_t read(int fd, void *buf, size_t count); 

But Windows doesn’t support read()/write() 

By default, sockets I/O functions block: Don’t return until action done. 

• write/send: buf passed to transport layer 

• read/recv: new data available 

Specialist socket functions give flags control & Windows compat.: 

ssize_t send(SOCKET s,const void *buf,size_t len,int 

flags); 

ssize_t recv(SOCKET s, void *buf, size_t len, int 

flags); 

e.g. MSG_DONTWAIT flag to prevent this function call from blocking 

But with which endpoint (address+port) are we talking to/from? 

• SOCK_DGRAM can specify/ID endpoints for individual datagrams: 

ssize_t sendto(SOCKET s, const void *buf, size_t len, int 

flags, const struct sockaddr *to, socklen_t tolen); 

ssize_t recvfrom(SOCKET s, void *buf, size_t len, int 

flags, struct sockaddr *from, socklen_t *fromlen); 

• SOCK_STREAM: bind() can specify local end & 

connect() specify server end. (more to come) 


Identifying endpoints with sockaddr 

12 

Must identify 

“local” end (on computer running this process) and 

“remote” end (on other computer). 

Either may be client/server or source/destination. 

Do so with sockaddr struct. Aims to be protocol independent=> 

1 st member IDs family & rest IDs endpoint. 

Functions defined in generic terms => typecast: (sockaddr*)&sin 

struct sockaddr { 

unsigned short sa_family; 

char sa_data[14]; 

}; 

in_addr gives access to IPv4 

address, most usefully as a 

32b word .sin_addr.s_addr 

14B data is too small for IPv6=>generalise to sockaddr_storage 

large enough to hold any address that the host supports. 

struct sockaddr_storage { 

struct sockaddr_in6 { 

short ss_family; 

short sin6_family; 

char __ss_pad1[_SS_PAD1SIZE]; u_short sin6_port; 

__int64 __ss_align; 

u_long sin6_flowinfo; 

char __ss_pad2[_SS_PAD2SIZE]; struct in6_addr sin6_addr; 

}; 

u_long sin6_scope_id; }; 


struct sockaddr_in{ 

short sin_family; 

unsigned short sin_port; 

struct in_addr sin_addr; 

char sin_zero[8]; 

};

13 

bind() 

int bind(SOCKET s, const struct sockaddr 

*my_addr, socklen_t addrlen); 

• Specifies the local sockaddr 

o Port: When app (e.g. client) doesn’t care about 

o 

value, 0 asks OS to choose an ephemeral port 

IP address: App that doesn’t know local address or 

doesn’t care which interface can specify INADDR_ANY 

(IN6ADDR_ANY_INIT for IPv6) 

• Interface may matter for multihomed machines (e.g. 

WiFi+Eth; firewall) 

• bind() fails if sockaddr is in use. 

o 

o 

e.g. bind() may fail when restarting program just 

after it closed since TCP conn. is in TIME_WAIT state. 

Solve with SO_REUSEADDR socket option. 


14 

connect() 

Specifies remote end. Informs OS of destination address 

for sending, and how to filter/route incoming packets. 

int connect(SOCKET s, const struct sockaddr 

*serv_addr, socklen_t addrlen); 

Typically used with SOCK_STREAM 

• Starts TCP handshake with remote end (in addition to 

informing local OS). Returns when handshake is 

finished (e.g. may be ECONNREFUSED or ENETUNREACH) 

• If client didn’t set local endpoint (e.g. with bind()) then 

OS will set it like INADDR_ANY & use ephemeral port 

Sometimes used with SOCK_DGRAM: 

• Specifies default destination for send() & 

• Restricts recv() to remote. 

• Can change remote end by calling connect() again. 

• Yes, connectionless UDP can connect()!: UDP is 

connectionless at the transport layer, but connect() can be 

used to set state info for the sockets API 


15 

listen()ing for connections 

By default, sockets support clients that initiate, rather 

than respond to, connection requests 

TCP: If receive SYN (= start handshake request) then send RST 

listen() tells OS that app is a server & specifies backlog 

TCP: If receive SYN then send SYN+ACK 

int listen(SOCKET s, int backlog); 

• Servers usually call bind() before listen() to specify 

well known port. 

• OS queues clients when multiple try to connect 

=> “backlog” = max # of ”pending connections” = 

handshake in progress or complete. 

Backlog numerology: Often 5 (max for 4.2BSD). OS may 

add a fudge factor (Linux: +3) to include handshakes in 

progress when app treats backlog as handshakes 

complete. Hard to set properly [Stevens UNP pp. 106-7] 

• listen() returns promptly, when OS is ready; 

accept() indicates when clients are ready 


16 

accept()ing connections 

accept(): Respond to handshake request 

from client. 

To concurrently serve multiple clients, 

must distinguish communication with 

each => create a new socket for each. 

SOCKET accept(SOCKET s, struct 

sockaddr *addr, socklen_t 

*addrlen); 

o addr identifies client 

o Return value = new socket 


17 

Number conversion 

• In Jonathan Swift’s “Gulliver’s Travels”, 

Lilliputians and Blefuscudians fight a 

war over the (trivial) issue of which end 

to break their eggs at (big or small) 

• Computing: When storing integers, 

which byte to store in lower address? 

A1: Intel et al: Little Endian (least significant) 

A2: IBM et al: Big Endian 

• Networking: Send big or little end of integer first? 

A: Must standardise: Big Endian. 

• Sockets uses Big Endian network format, which may differ 

from host format. 

=> functions to convert hton or ntoh for short (port) or 

long (32b IPv4 address) integers 

htonl(), ntohl(), htons(), ntohs() 

• Be careful: Compiler doesn’t usually type check, e.g. 

sa.sin_port=0xCAFE = 0xCAFE or 0xFECA depending on 

machine. Use sa.sin_port=htons(0xCAFE) 

Image from www.laputan.org/ 

images/pictures/little-endian.jpg 

Similarly, be careful with structs, since different hosts/compilers may align members 

differently. Write functions to send/receive all member values, rather than directly transferring 

memory occupied by struct. Copyright © 06/04/11, Tim Moors

18 

Presenting addr’s to humans (1) 

• sockaddr stores addresses in numeric (binary) form. 

Want to present sin*_addr members in humanreadable 

form, e.g. “dotted decimal” for IPv4. 

(sin_port #s are readily presented as integers.) 

inet_[np]to[pn](): (n = numeric, p = presentable/printable) 

Protocol-independent & available under Linux and 

Windows Vista 

const char *inet_ntop(int af, const void *src, 

char *dst, socklen_t cnt); 

o src points to in_addr or in6_addr 

o Return value (points to dst if successful) useful when 

including as an argument, e.g. in printf 

o Capitalised as “InetNtop()” under Windows Vista 

int inet_pton(int af, const char *src, void 

*dst); 

Windows also has its own functions, e.g. WSAStringToAddress() is analogous to inet_pton() 


19 

Presenting addr’s to humans (2) 

inet_[na]to[an](): Earlier IPv4 functions (a = 

ASCII) 

char *inet_ntoa(struct in_addr in); 

int inet_aton(const char *cp, struct 

in_addr *inp); // Not avail for Windows 

inet_addr(): Predates inet_aton() but 

available under Windows 

in_addr_t inet_addr(const char *cp); 

• Deprecated because it can return -1 either 

because of error or successful conversion of 

broadcast address 255.255.255.255 = (int32) -1 


20 

Using names 

Textual names are even more “presentable” than addresses 

(e.g. example.com vs 208.77.188.166) 

• See lecture on Domain Name System (DNS) 

• Sockets names services (e.g. “http”=80) as well as devices; 

ignore service name by passing NULL for serv(ice) 

int getaddrinfo(const char *node, const char 

*service, const struct addrinfo *hints, struct 

addrinfo **res); 

struct addrinfo { 

• Maps name to address 

• hints: e.g. to request IPv4 or IPv6 

• Release res with freeaddrinfo() 

int getnameinfo( 

const struct sockaddr *sa, 

socklen_t salen, 

int ai_flags; e.g. AI_NUMERICHOS 

int ai_family; //\ 

int ai_socktype; //|-ala socket() 

int ai_protocol; /// 

size_t ai_addrlen; 

struct sockaddr *ai_addr; 

char *ai_canonname; Canonical 

struct addrinfo *ai_next; // Allo 

char *host, size_t hostlen, }; 

char *serv, size_t servlen, int flags); 

• Maps address to “name” 

• flags: e.g. NI_NUMERICHOST for printable addr not DNS name 

Before IPv6 and Windows XP, apps used gethostbyname() & gethostbyaddr() 


21 

Broadcast and multicast 

Use SOCK_DGRAM to broadcast or multicast, since SOCK_STREAM 

connects to a single endpoint 

Broadcast needs deliberate setup (to protect against mistake in 

address spamming network), through “setsockopt(s, 

SOL_SOCKET, SO_BROADCAST” 

Multicast doesn’t spread everywhere. 

• Receivers must tell routers to add/drop membership: 

App tells OS which uses IGMP † to tell routers: 

ip_mreq † struct identifies multicast address & interface 

setsockopt(s, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void*)&mreq, 

sizeof(mreq)); 

Then IP_DROP_MEMBERSHIP when done 

• Sender may want to further limit propagation (TTL) 

“setsockopt(… IP_MULTICAST_TTL” 

• Control whether you receive what you send to a multicast 

group that you’re a member of with “setsockopt(… 

IP_MULTICAST_LOOP” 

† IPv6 uses ICMPv6, rather than IGMP, and ipv6_mreq 


22 

Cleaning up 

close() tells the OS that the app is finished with a socket. 

• For TCP sockets, OS usually † closes connection by sending 

FIN. 

• Important for servers that create new socket when 

accept()ing each new client. Without closing, socket 

resources would get used up. 

• close() stops both send & recv to/from socket 

o Info in queue to be sent will still be sent 

SO_LINGER option => Whether TCP lingers after close() to 

ensure reliable transfer (e.g. wait for acks & retransmit) 

shutdown(SOCKET s, int how) is like close, but 

• allows specific types of access to be shut down 

how: SHUT_RD, SHUT_WR, SHUT_RDWR 

e.g. client stops writing to indicate end of request, but waits 

to read reply. 

• Forces closure 

o close() maintains socket if still used by another process, server may 

fork() after accept() & one process close()s but other hasn’t finished 


23 

Summary (for reference) 

SOCKET socket(int socket_family, int socket_type, int protocol); 

int setsockopt(SOCKET s,int level,int optname,const void *optval,socklen_t optlen); 

ssize_t send(SOCKET s,const void *buf,size_t len,int flags); 

ssize_t recv(SOCKET s, void *buf, size_t len, int flags); 

ssize_t sendto(SOCKET s,const void *buf,size_t len,int flags,const struct sockaddr 

*to,socklen_t tolen); 

ssize_t recvfrom(SOCKET s,void *buf,size_t len,int flags,struct sockaddr 

*from,socklen_t *fromlen); 

int bind(SOCKET s, const struct sockaddr *my_addr, socklen_t addrlen); 

int connect(SOCKET s, const struct sockaddr *serv_addr, socklen_t addrlen); 

int listen(SOCKET s, int backlog); 

SOCKET accept(SOCKET s, struct sockaddr *addr, socklen_t *addrlen); 

htonl(), ntohl(), htons(), ntohs() 

const char *inet_ntop(int af, const void *src, char *dst, socklen_t cnt); 

int inet_pton(int af, const char *src, void *dst); 

int getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct 

addrinfo **res); 

int getnameinfo(const struct sockaddr *sa, socklen_t salen, char *host, size_t hostlen, 

char *serv, size_t servlen, int flags); 

close() 

shutdown(SOCKET s, int how) 

struct sockaddr { 

unsigned short sa_family; 

char sa_data[14]; 

}; 


struct sockaddr_in{ 

short sin_family; 

unsigned short sin_port; 

struct in_addr sin_addr; 

char sin_zero[8]; 

};

24 

Links 

• Socket options give control of TCP/IP, 

e.g. Nagle algorithm, IP TTL, IGMP etc 

• Framing: Apps that use SOCK_STREAM 

must often frame their data; e.g. using 

length fields

Socket Programming - EE&T Lecture Notes

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?