Pipes & Sockets

1
 Pipes
• Pipes are a way to allow processes to
communicate with each other
– Pipes implement one form of IPC (Inter process
Communication)
– This allows synchronization of process execution
• There are two kinds of pipes
– named pipes
– unnamed pipes
• Pipes are uni-directional
– They can only transfer data in one direction
– If you want two processes to have a two-way conversation,
you must use two pipes
2
 Pipes Implement a FIFO
• A FIFO (First In, First Out) buffer is like a
queue or a line at a movie theater
• Elements are added at one end of the queue and
exit the other end in the same order
• There is no way for any individual element to
move ahead of another

3
• Traditional implementation of pipes uses
the file system for storage
– This allows processes to communicate even
though they don’t know what processes are at
the other end of the pipe
• Unnamed pipes can only be used between
processes that are children of the process
that initiated the pipe
• Named pipes solve this problem - any
process can communicate with another
using named pipes
4
 Unnamed Pipes

• Unnamed pipes are used as we saw in Unix

cat myfile | grep key | sort | lpr

• The parent process (the shell or shell script

that creates the pipes) also spawns the child
processes that access the pipe
– cat, grep, sort, and lpr in this case

5
 Named Pipes

• Named pipes can be accessed by any

process that “knows the name”

• Named pipes appear in the user’s directory

list
$ls -l
pwr_r__r__ 1 krf 0 Mar 27 19:33 mypipe

6
 Named Pipe Creation

• Named pipes are created using the mknod or

the mkfifo commands
$ mkfifo name
$ mknod name p
• Make sure you remove (rm) your pipes after
use!

7
 Using Named Pipes
• First, create your pipes
$ mknod pipe1
$ mknod pipe2
$ mknod pipe3
• Then, attach a data source to your pipes
$ ls -l >> pipe1 &
$ cat myfile >> pipe2 &
$ who >> pipe3 &
• Then, read from the pipes with your reader process
$ cat < pipe1 | lpr
$ spell < pipe2
$ sort < pipe3
 Finally, delete your pipes
$ rm pipe[1-3]

8
 UNIX Pipes
• The pipe interface is intended to look like a
file interface
– Analog of open is to create the pipe
– File read/write system calls are used to
send/receive information on the pipe
• What is going on here?
– Kernel creates a buffer when pipe is created
– Processes can read/write into/out of their
address spaces from/to the buffer
– Processes just need a handle to the buffer
 UNIX Pipes

Address Space for p1

Info to be
Info copy
shared
write(pipe[1], …); read(pipe[0]);
System Call Interface

pipe for p1 and p2

write function read function

 UNIX Pipes (cont)
• File handles are copied on fork
int pipeID[2];
. . .
pipe(pipeID);
. . .
if(fork() == 0) { /* the child */
. . .
read(pipeID[0], childBuf, len);
<process the message>;
. . .
} else { /* the parent */
. . .
write(pipeID[1], msgToChild, len);
. . .
}
int pipe(int fd[2]) -- creates a pipe and returns two file descriptors,
fd[0], fd[1]. fd[0] is opened for reading, fd[1] for writing
 Code fragment: Named Pipes
Char string[]=“Hello”;
main(int argc, char* argv)
int fd;
char buf[256];

fd = mknod(“fifo”,010777,0) /* Create Pipe

RW=all*/

for (;;)
if (argc==2)
write (fd, string, 6);
else
read (fd, buf, 6);
SOCKETS
Why do we need sockets?
Provides an abstraction for
interprocess communication
Socket model
• Sockets
– a socket is an IPC mechanism for transmitting
data from one process to another both within a
single machine and between machines
– a socket is a bi-directional IPC channel
– Domains for sockets - a domain is the space from
which an address is drawn for a socket
• UNIX domain(AF_UNIX)
– uses the UNIX file system name space
– used for local IPC
• Internet domain(AF_INET)
– uses Internet address plus a port number
– used for local and remote IPC
A server accepting a call
 Functions
–Define an “end- point” for
communication
–Initiate and accept a connection
–Send and receive data
–Terminate a connection
gracefully
Examples

File transfer apps (FTP), Web browsers

(HTTP), Email (SMTP/ POP3), etc…
 3 Types of Socket

• Stream sockets interface to the TCP

(transport connect protocol).
• Datagram sockets interface to the UDP
(user datagram protocol).
• Raw sockets interface to the IP (Internet
protocol).

19
Addresses, Ports and Sockets
• Like apartments and mailboxes
– You are the application
– Your apartment building address is the address
– Your mailbox is the port
– The post-office is the network
– The socket is the key that gives you access to the
right mailbox
 Sockets and ports

agreed port
socket any port socket

message
client server
other ports

Internet address = 138.37.94.248 Internet address = 138.37.88.249

21
 Sockets used for streams

Requesting a connection Listening and accepting a connec

s = socket(AF_INET, SOCK_STREAM,0) s = socket(AF_INET, SOCK_STREAM,0)

bind(s, ServerAddress);
listen(s,5);
connect(s, ServerAddress)
sNew = accept(s, ClientAddress);

write(s, "message", length) n = read(sNew, buffer, amount)

 socket() TCP Server
bind() Well-known port

TCP Client listen()

Socket() accept()
blocks until connection from client
connect() Connection establishment

write()
read()

process request
write()
read()

close()
read()

close()
Server process in unix system
A client process