The document discusses different types of servers, including concurrent, iterative, connection-oriented, and connection-less servers, detailing their characteristics and use cases. It highlights the performance differences between stateful and stateless servers, as well as the complexity involved in implementing connection-less servers with adaptive retransmission techniques. Furthermore, it outlines algorithms for handling concurrent connections and provides coding examples for process creation using fork and exec functions.

1. PRESENTATION ON:-
SERVERS
o CONCURRENT SERVER
• CONNECTION LESS
• CONNECTION ORIENTED
o ITERATIVE SERVER
• CONNECTION LESS
• CONNECTION ORIENTED

2. SERVERS
CONCURRENT SERVER ITERATIVE SERVER
• It is the server that handles
multiple request at a time
• However it’s implementation
may not be required if the apptn.
p/l handles it with ease
• If the server is defined for a
single process & if it perform
lesser and of I/O options ,then
also Concurrency is not desired
• It is a server that processes
one request at at time
• Although , it may cause
unnecessary delays in
distributed n/ws & become
performance bottlenecks
• comparatively , they are easier
to design & build & resulting
code is simple & easy to modify

3. CONNECTION-ORIENTED SERVER
• These servers use TCP as the transport layer p/l.
• Here, TCP handles packets loss (error control),flow
control & out of order delivery problems
• Here , 3 ways handshake is used is used to establish &
terminate a connection and whole data is transferred
through communication
• These servers provide reliability for data transmission

4. CONNECTION-LESS SERVERS
• These servers use UDP as their transport layer protocol
• These server avoid overhead of communication establishment &
termination.
• They do not suffer from resources depletion problem
• They permit communication with multiple hosts (multiple connection)
from a single socket
• They do not provide reliability & usually clients take responsibility for
retansmitting request in case of no. response or faulty response from
server
• It is usually duty of appltn. Layer p/l to provide reliability with the
help of a complex sophisticated technique known as
‘adaptive retransmission’

5. • TCP offers point to point communication, while UDP offers
TCP offers point to point communication, while UDP offers
broadcasting & multicasting. All the future applications depend
broadcasting & multicasting. All the future applications depend
more on multicasting . Hence connectionless servers will be popular
more on multicasting . Hence connectionless servers will be popular
in future.
in future.
• Connectionless servers that use ‘ adaptive retransmission’ have
Connectionless servers that use ‘ adaptive retransmission’ have
complex programming
complex programming

6. SERVERS
Stateful Stateless
• Stateful Servers maintain the
status of ongoing interactions
with clients.
• Usually that use TCP are
stateful servers
• Stateless Servers do not maintain
the states of current intraction
with client
• Usually these servers use UDP
• Issue of statelessness arises from
a need to ensure reliability,
• Especially when using
connectionless transport

7. Concurrent vs. iterative servers
 Iterative server
 process one request at a time
 Easy to build
 Unnecessary delay
 Concurrent server handles multiple requests at
one time.
 More difficult to design and build
 Better performance

8. Fork and exec functions
 #include<unistd.h>
 int fork();
 Return 0 in child, process ID of child in parent –1
on error
 There are two typical uses of fork
1. A process makes a copy of itself so that one copy
handle one operation while the other copy does
another task.
2. A process wants to execute another program.
Since the only way to create a new process is by
calling fork, the process first calls fork to make a
copy of itself, and then one of the copies(child)
calls exec to replace itself with the new program

9. exec
 #include<unistd.h>
 int execl(const char *pathname, const char *arg0,…);
 int execv(const char *pathname, char *const argv[]);
 int execle(const char *pathname, const char *arg0,…,
);
 int execve(const char *pathname, char *constargv[],
char *constenvp[]);
 int execlp(const char *filename, const char *arg0,…);
 int execvp(const char *filename, char *const argv[]);
 All sizr return –1 on error, no return on sucess

10. Outline for typical concurrent server
int pid,s, conn;
S = Socket( .. );
// fill in server address
Bind(s, ..);
Listen(s, LISTNQ);
while(1){
conn = Accept(s, ..);
if( (pid = fork()) ==0)
{ close (s);
doit( conn);
close(conn);
exit(0);
} // end of if
close(conn);
}// end of while loop

11. Concurrent, connection-oriented
 Connection-oriented servers implement
concurrency among connections rather than
among individual requests.
 Connection between client-server handle more
than a single request: The protocol allow a client
to repeatedly send requests and receive
responses without terminating the connection or
creating a new one.

12. Algorithm-parent,madter
1. Create a socket and bind to the well-known
address for the service being offered. Leave
the socket unconnected
2. Place the socket in passive mode, making it
ready for use by a server.
3. Repeatedly call accept to receive the next
request from a client, and create a new process
to handle the response

13. Algorithm-child,slave
1. Begin with a connection passed from the
master(I.e. a socket for the connection)
2. Interact with the client using the connection:
read request(s) and send back response(s)
3. Close the connection and exit. The slave exits
after handling all requests from one client

14. Apparent concurrency using a
single thread
1. Create a socket and bind to the well-known port
for the service.add socket to the list of those on
which I/O is possible.
2. Use select to wait for I/O on existing sockets
3. If original socket is ready, use accept to obtain the
next connection, and add the new socket to the list
of those on which I/O is possible.
4. If some socket other than the original is ready, use
recv and read to obtain the next request, forma
response, and use send or write to send the
response back to the client
5. Continue processing with step 2.