View
31
Download
0
Category
Tags:
Preview:
DESCRIPTION
Part 4: Network Applications. Client-server interaction, example applications. Client-Server Interaction. The client-server paradigm, characteristics of clients and servers, dynamic server creation, complex client-server interactions. Application software issues. - PowerPoint PPT Presentation
Citation preview
Part 4: Network Applications
Client-server interaction, example applications
Client-Server Interaction
The client-server paradigm, characteristics of clients and servers,
dynamic server creation, complex client-server interactions
Application software issues
• Transport layer software supports the reliable transfer of data between applications
• Application layer software supports:– initiating connections– an application programming interface (API)– encoding data– user friendly naming– definition of specific applications
The client server paradigm• A widely used form of communication• Server application waits passively for contact
from clients• A server provides a specific service• Client application actively initiates contact
with the server• Information can flow in both directions• Typical situation is many clients interacting
with each server
Characteristics of clients• General application that becomes a client
when remote access is needed, but that performs other computation locally
• Invoked by the user • Executes for one session• Runs on users local computer• Actively initiates contact with the server• Can access multiple services as needed, but
only one at a time
Characteristics of servers• Special purpose program to provide one
service• can handle multiple clients at one time• invoked when the system boots• runs through many sessions• runs on a relatively powerful shared computer• waits passively for contact from various kinds
of client, but only provides one service
Transport protocols and client-server interaction
• Clients and servers communicate using a transport protocol - unaware of underlying layers
Server class computers
• Often a single server class computer runs several servers
Identifying a particular service
• Transport protocols assign a unique identifier to each service– server registers its ID with protocol software when
it boots– client specifies the desired ID when it makes a
connection
• TCP uses protocol port numbers
Concurrency and servers• Concurrent server offers supports multiple clients
at the same time• Uses multiple threads of control• Core part of server accepts new requests and
dynamically creates new servers as separate threads to handle them
• Each thread deals with its client’s requests• N concurrent clients => N + 1 threads• TCP uses a combination of destination port and
source port to identify the right thread
Complex client-server interactions
• A client is not restricted to accessing a single service
• A client does not have to use a single server for a given service
• A server can itself become a client of another server
• Watch out for circular dependencies
Distributed programming• Extend client-server paradigm to more general
distributed programming• Provide greater transparency for programmers
– remote procedure calls (RPC)– distributed objects and components
• Provide standard services for locating and manufacturing other services– traders– factories
Traders
trader
serviceclient
1. export service offer
2. Request service
3. use service
Factories
trader
serviceclient
1. Request service
4. use service
factory
2. request create service
3. create service
Other forms of communication
peer
peer
peer
peer
Peer to peercommunication
The Socket Interface
Socket API overview
Socket system calls
Example client and server programs
Application Programming Interface
• The API is the interface that the application uses to communicate with transport protocol software - usually a set of functions or classes
• Socket API is the de facto standard for TCP/IP
• Originated on UNIX but now available for other operating systems (e.g., Windows)
Sockets and descriptors
• Application requests the operating system to create a socket– systems returns descriptor - small integer– application then specifies details such as transport
protocol, protocol addresses, specify if client or server using further functions
– application then uses the descriptor as an argument to functions that “read” and “write” data
– application then closes the socket
Server Client
socket
bind
listen
accept
recv/send
close
socket
connect
send/recv
close
Creating a socket
• First create a socket with descriptor = socket(protofamily,type,protocol) – protofamily specifies the protocol family to be
used, e.g., PF_INET or PF_APPLETALK– type specifies the type of communication, e.g.,
SOCK-STREAM or SOCK_DGRAM– protocol specifies a specific protocol
• Function close ( socket ) terminates a socket
Binding a socket
• bind(socket,localaddr,addrlen)
associates a socket with a protocol port number– socket is a socket descriptor– localaddr is a structure that contains a local address– addrlen specifies the length of the address
Servers and connections
• Server uses listen(socket,queuesize) to put a socket in passive mode. Queuesize is the length of a request queue.
• Server uses newsock = accept(socket, caddress, caddresslen) to accept a new connection from a client. Creates a new socket for this client and fills in the client address.
Clients and connections
• A client uses connect (socket, saddress, saddresslen) to connect to server– socket is the local socket for the client– saddress contains the server’s address and
protocol port number– saddresslen is the length of the server’s
address
Sending data
• send (socket, data, length, flags)– socket is a connected socket– data is a pointer to the data– length is the length of the data– flags enable debugging options
• sendto and sendmsg are used with connectionless communication
Receiving data• recv(socket, buffer, length, flags) is used to receive data– socket is a connected socket– buffer is a pointer to allocated memory– length is the size of the buffer – flags controls additional details
• recvfrom and recvmsg support connectionless communication
• versions of the standard read and write functions are also available
Other useful functions
• After accepting, a server can use getpeername to get the complete address of the initiating client
• client or server can use gethostbyname to obtain information (e.g., IP address) about the host on which it is running
• gethostbyaddrr maps an IP address back to a host name
Sockets, threads and inheritance
• Each new thread initially inherits all existing sockets from its parent
• A thread typically closes sockets that it doesn’t need, removing them from its local list
• The system maintains a reference count for each socket- how many threads are using it - and terminates the socket when this reaches 0
Example
• Comer’s book (chapter 23 3rd ed.) includes simple examples of a client and a server– server sends a message to the client saying
how many times it has been contacted– server command line argument is a protocol
port number– client command line arguments are a protocol
port number and the name of the host on which the server is running
Networking in Java
• Package java.net provides the classes for implementing networking applications
• Using the socket classes you can implement client and server applications – ServerSocket – implements server sockets – Socket – implements client sockets – DatagramSocket – for sending and receiving
datagram packets (UDP)– MulticastSocket – for sending and receiving IP
multicast packets
Java Examples
• From the Java Developers Almanac 1.4 (http://javaalmanac.com/) – Creating a Client Socket– Creating a Server Socket – Reading Text from a Socket– Writing Text to a Socket
• For further info – Java Networking Tutorial http://java.sun.com/docs/books/tutorial/networking
Clientimport java.net.*;import java.io.*;
public class Client { public static void main( String[] args) {
Socket sock; InetSocketAddress address; String host = "localhost"; int port = 9101; DataInputStream is; PrintStream ps;
try { // SOCKET sock = new Socket(); address = new InetSocketAddress(host, port);
// CONNECT sock.connect(address);
ps = new PrintStream(sock.getOutputStream());
// SEND ps.println("something or another...");
BufferedReader br = new BufferedReader ( new InputStreamReader( sock.getInputStream() ) );
// RECV String str = br.readLine(); System.out.println(str); // CLOSE sock.close(); } catch ( Exception e ) { System.err.println(e); } }}
Server
import java.net.*;import java.io.*;
public class Server { public static void main( String[] args) {
ServerSocket SSock; Socket conn; InetSocketAddress address; String host = "localhost"; int port = 9101; PrintStream ps;
try { // SOCKET SSock = new ServerSocket(); address = new InetSocketAddress(host, port);
// BIND & LISTEN SSock.bind(address);
while (true) { // ACCEPT conn = SSock.accept();
BufferedReader br = new BufferedReader ( new InputStreamReader ( conn.getInputStream() ) );
ps = new PrintStream(conn.getOutputStream());
String str;
// RECV while ( (str = br.readLine()) != null ) { System.out.println("CLIENT WROTE: " + str); // SEND ps.println("YOU WROTE: " + str); }
// CLOSE conn.close(); } } catch ( Exception e ) { System.err.println(e); } }}
Recommended