Network Programming 1

Transcription

1 Network Programming 1

2 Network Programming Java and C++ can easily be used for network programming based in the client-server model. The client-server model is probably the most commonly used model for communicating between applications running on different computers. It is also frequently used for establishing communication links between different applications running on the same computer. 2

3 In the client-server model, you may think of a server as a constantly running program that monitors a port for other applications, called clients, wishing to communicate with the server through that port. The server and client roles apply only to individual communication links. That is, an application A can be a server with respect to application B s role as a client for one communication link. Yet, on a different communication link, application A could be a client to application B s role as a server. 3

4 All communication in client-server links takes place through ports. The port numbers 0 through 255 are reserved for standard network services such as TELNET, FTP, FINGER, TFTP, ECHO, etc. But numbers above 255 can be used for more specialized user-created services. 4

5 Telnet service is a common example of client-server model of communication. On the remote machine there is a constantly running program called telnetd (for telnet daemon) that monitors a designated port, port 23, for requests for telnet connections. When a client seeks such a connection, it runs a program called telnet that sends to the server machine a socket number, which is a combination of the IP address of the client machine together with the port number that the client will use for communicating with the server. When the server receives the client socket number, it acknowledges the request by sending back to the client its own socket number, meaning its IP address and the port on which it will communicate with the client. 5

6 Establishing Socket Connections with Existing Servers in Java Let s say that a client seeks to connect to a server on port 80. This port is usually monitored by the HTTPD servers (the HyperText Transmission Protocol Daemon program) on machines on which such servers are installed and running. In response to an appropriately formatted GET request received from a client on port 80, an HTTPD server can send back a web page whose URL is embedded in the request. 6

7 A client wishing to receive web pages from an HTTPD server that monitors port 80 constructs a socket by Socket t = new Socket( webaddress, 80 ); For example, if we wanted to download the raw ascii of the Purdue University web page, the following invocation in our client program would work: Socket socket = new Socket( " 80 ); The Socket object thus constructed talks to the server on server s port 80 and delivers to it the client s socket number, which consists of the IP address of the client and the port number being used for communicating with the server. The server acknowledges this request by sending back its own socket number, which would be the concatenation of the IP address of the server and the number of the port the server will use for the connection with the client. 7

8 The Socket constructor call is for establishing communication with a server using what s referred to as a reliable, connection-based stream protocol, as in TCP (for Transmission Control Protocol). By appropriate handshaking with the destination machine, TCP ensures that a packet sent over a network was actually received at the destination. If the data was not received, it is re-transmitted. TCP is used by higher-level utility protocols such as Telnet, FTP (for File Transfer Protocol), SMTP (Simple Mail Transfer Protocol), rlogin (for remote log in), etc. 8

9 One can also construct a socket object that would permit communication based on the less reliable but faster datagram protocol, as used in UDP (for User Datagram Protocol). UDP is used by Trivial File Transfer Protocol (TFTP), the Remote Call Procedure (RCP), etc. UDP is particularly suitable for those applications where missing packets can be tolerated, as for example in audio and video transmissions. 9

10 The socket constructor throws the UnknownHostException if it is not able to establish a connection with the server. 10

11 Once a client has established a socket link with the server, the data can be sent to the server and received back from the server on the link using essentially the same methods that are used for reading from files and writing into files on a local machine. 11

12 The Socket class has two methods, getinputstream() and getoutputstream(), that return InputStream and OutputStream objects. OutputStream out = socket.getoutputstream(); PrintStream ps = new PrintStream( os, true ); InputStream in = socket.getinputstream(); InputStreamReader in_reader = new InputStreamReader( in ); BufferedReader br = new BufferedReader( in_reader ); The Reader object in reader turns the bytes output by the InputStream object in into Unicode characters. By feeding these into the BufferedReader object br, we can invoke the efficient readline() method of BufferedReader to output one line of text at a time. 12

13 GET /HTTP/1.1\n\n < chars -----> 13

14 //ClientSocket.java import java.io.*; import java.net.*; class ClientSocket { public static void main( String[] args ) { try { char[] urlarr = new char[256]; String prefix = " String webaddress = args[0]; int i = 0; while ( i < prefix.length() ) { urlarr[ i ] = prefix.charat( i ); i++; while ( i < ( webaddress.length() + prefix.length() ) ) { urlarr[i] = webaddress.charat( i - prefix.length() ); i++; while ( i < 256 ) { urlarr[ i ] = ; i++; String urlstring = new String( urlarr ); Socket socket = new Socket( webaddress, 80 ); 14

15 OutputStream os = socket.getoutputstream(); PrintStream ps = new PrintStream( os, true ); InputStream in = socket.getinputstream(); InputStreamReader in_reader = new InputStreamReader( in ); BufferedReader b_reader = new BufferedReader( in_reader ); ps.print( "GET " + urlstring + " /HTTP/1.1\n\n" ); boolean more = true; while (more) { String str = b_reader.readline(); if (str == null) more = false; else System.out.println(str); catch( IOException e ) {System.out.println( "Error: " + e ); 15

16 When this program is executed by the call java ClientSocket 16

17 HTTP/ OK Date: Mon, 03 Jan :49:15 GMT Server: Apache/1.3.9 (Unix) Connection: close Content-Type: text/html <html> <head> <title>purdue University - West Lafayette, Indiana</title> <meta name= keywords content= Purdue University, Boilermakers, Boilers, Col <meta name= AUTHOR content= Rick DeLucio, Office of Publications, Purdue Un <meta name= ROBOTS content= ALL > <meta name= DESCRIPTION content= This is the official website of Purdue Uni <style type= text/css > <!--.roll { color: black; text-decoration: underline; text-transform: none; lettera.roll:hover { color: gray --> </style> <BASE HREF= > </head> <body bgcolor= white link= black vlink= # alink= #ce9c00 >

18 Server Sockets in Java ServerSocket server = new ServerSocket( int portnumber ); ServerSocket server = new ServerSocket( 5000 ); ServerSocket server = new ServerSocket( 5000, 10 ); 18

19 Socket socket = server.accept(); 19

20 public class ChatServer { public static Vector clientvec = new Vector(); public static void main( String[] args ) { try { ServerSocket server = new ServerSocket( 5000 ); //(A) //(B) for (;;) { Socket socket = server.accept(); System.out.print( "A new client checked in: " ); ClientHandler clh = new ClientHandler( socket ); clientvec.addelement( clh ); clh.start(); catch( Exception e ) { System.out.println( e ); //(C) //(D) //(E) //(F) 20

21 The ClientHandler class has to serve following purposes: 1. Its constructor must first establish the I/O streams and then, for convenience, the Reader and Writer objects for reading information sent by the client and writing information to the client. 2. It must print on the client s terminal a welcome message. 3. It must ask the client for a name that the client would want to use in the chat room for identifying himself/herself. It must pre-pend all the messages from a client with his or her name. 4. It must inform the client to type bye for signing off from the chat room. 5. Upon receiving a bye from a client, it must close the I/O streams associated with that client and also close the thread. When a client signs off, this information must be broadcast to all other clients. 6. When a client first signs in, it must print on the client s terminal all of the chat that has taken place up that point. 7. It must broadcast each client s message on the terminals of all the other clients. 21

22 PrintWriter out = new PrintWriter( sock.getoutputstream() ); InputStream in_stream = sock.getinputstream(); InputStreamReader in_reader = new InputStreamReader( in_stream ); BufferedReader buff_reader = new BufferedReader( in_reader ); 22

23 out.println( "\n\nwelcome to the chat room"); out.println( "Type \"bye\" in a new line to terminate session." out.print( "Please enter your first name: " ); String username = buff_reader.readline(); 23

24 // chatstore is a static data member of type Vector // for the ClientHandler class if ( chatstore.size()!= 0 ) { out.println( "Chat history:\n\n" ); for (int i = 0; i < chatstore.size(); i++ ) out.println( (String) chatstore.elementat( i ) ); 24

25 for ( int i = 0; i < ChatServer.clientVec.size(); i++ ) / { ClientHandler cl = (ClientHandler) ChatServer.clientVec.elementAt( i ) if ( this!= cl ) / { cl.out.println(); cl.out.println( strwithname ); / cl.out.print( cl.username + ": " ); / cl.out.flush(); 25

26 buffered_reader.close(); out.close(); sock.close(); 26

27 java ChatServer telnet RVL2.ecn.purdue.edu

28 //ChatServer.java import java.io.*; import java.net.*; import java.util.*; public class ChatServer { public static Vector clientvec = new Vector(); public static void main( String[] args ) { try { ServerSocket server = new ServerSocket( 5000 ); for (;;) { Socket socket = server.accept(); System.out.print( "A new client checked in: " ); ClientHandler clh = new ClientHandler( socket ); clientvec.addelement( clh ); clh.start(); catch( Exception e ) { System.out.println( e ); ///////// class ClientHandler extends Thread ///////// class ClientHandler extends Thread { private String username; 28

29 private Socket sock; private static Vector chatstore = new Vector(); private BufferedReader buff_reader = null; private PrintWriter out = null; public ClientHandler( Socket s ) { try { sock = s; // out = new PrintWriter( sock.getoutputstream(), true /*autoflush*/ ); out = new PrintWriter( sock.getoutputstream() ); InputStream in_stream = sock.getinputstream(); InputStreamReader in_reader = new InputStreamReader( in_stream ); buff_reader = new BufferedReader( in_reader ); // ask for user name out.println( "\n\nwelcome to Avi Kak s chatroom"); out.println(); out.println( "Type \"bye\" in a new line to terminate session." ); out.println(); out.print( "Please enter your first name: " ); out.flush(); username = buff_reader.readline(); out.print("\n\n"); out.flush(); System.out.print( username + "\n\n" ); // show to new client all the chat that has taken place so far if ( chatstore.size()!= 0 ) { out.println( "Chat history:\n\n" ); for (int i = 0; i < chatstore.size(); i++ ) 29

30 out.println( (String) chatstore.elementat( i ) ); out.print("\n\n"); out.flush(); catch( Exception e ) { public void run() { try { boolean done = false; while (!done ) { out.print( username + ": " ); out.flush(); String str = buff_reader.readline(); if ( str.equals( "bye" ) ) { str = username + " signed off"; done = true; String strwithname = username + ": " + str; chatstore.addelement( strwithname ); for ( int i = 0; i < ChatServer.clientVec.size(); i++ ) { ClientHandler cl = (ClientHandler) ChatServer.clientVec.elementAt( i ); if ( this!= cl ) { cl.out.println(); cl.out.println( strwithname ); cl.out.print( cl.username + ": " ); cl.out.flush(); 30

31 System.out.println( username + " signed off" + "\n\n" ); buff_reader.close(); out.close(); sock.close(); catch ( Exception e ) { 31

32 telnet

33 Establishing Socket Connections with Existing Servers in C++ C++ can be used in object-oriented style for network programming in a manner very similar to Java. 33

34 The Qt library offers several C++ classes with the same high-level functionality as the Java classes we have used so far for network programming. For example, the class QSocket, like the Java class java.net.socket, can be used to create a buffered TCP socket connection with a named server on a designated port. The Qt class QServerSocket can be used to create TCP server sockets, like the java.net.serversocket class. Other Qt class useful for network programming are: QDns for asynchronous DNS lookup; QNetworkProtocol to serve as a base class for implementing new network protocols; QFtp, derived from QNetworkProtocol, that implements the FTP protocol; 34

35 QUrlOperator for operating on hierarchical structures (like file systems) using URL s; etc. 35

36 QSocket* socket = new QSocket(); socket->connecttohost( qstr, 80 ); // asynchronous call 36

37 The function connecttohost, like many other network related functions in the Qt library, works asynchronously, meaning that it returns before the designated operation has been completed. Whether or not a connection was really made and the state of that connection can be checked by trapping the signals emitted by a QSocket object. It is the programmer s job to provide slots for processing these signals and for connecting the signals with their respective slots. 37

38 After connecttohost() is invoked, the signals emitted by a QSocket object are: void hostfound() void connected() void connectionclosed() // host lookup succeeded // connection successfully established // when the host closed the connection void delayedclosedfinished() // if you invoke close() to close // the connection and there is buffered // output data to be written, the socket // object goes into the QSocket::Closing // state and returns immediately from the // call to close(). The data will continue // to be output until done. At that time // this signal is emitted. void readyread() // means there is incoming data to be read; // this signal is issued only once each // time there is fresh incoming data to be // read. void byteswritten( int nbytes) // This signal is emitted when data // is actually written to the network. // The nbytes parameters says how many // bytes were written. void error( int ) // an error occurred 38

39 The state of a QSocket object can be queried by invoking the function state() on the object. A connection can be in one of the following states defined through an enumeration for QSocket: Idle HostLookup Connecting Connection Closing // if there is no connection // during DNS lookup // while a TCP connection is being establis // while there is operational connection // if client has invoked close() on a conne // but there is still data in the output bu 39

40 The program consists of three files: ClientSocket.h ClientSocket.cc Makefile 40

41 //ClientSocket.h #ifndef CLIENTSOCKET_H #define CLIENTSOCKET_H #include <qsocket.h> #include <string> class ClientSocket : public QSocket { Q_OBJECT string wwwname; QSocket* socket; public: ClientSocket( string wwwname ); string constructhttprequest(); void socketclosed(); ~ClientSocket(); public slots: void reportconnected(); void reporthostfound(); void getwebpage(); void socketconnectionclosed(); void reporterror( int ); ; #endif 41

42 //ClientSocket.cc #include "ClientSocket.h" #include <qapplication.h> #include <qsocket.h> #include <string> #include <iostream> using namespace std; ClientSocket::ClientSocket( string sitename ) : QSocket( 0, 0 ) { wwwname = sitename; socket = new QSocket( ); connect( socket, SIGNAL( connected() ), this, SLOT( reportconnected() ) ); connect( socket, SIGNAL( hostfound() ), this, SLOT( reporthostfound() ) ); connect( socket, SIGNAL( readyread() ), this, SLOT( getwebpage() ) ); connect( socket, SIGNAL( connectionclosed() ), this, SLOT( socketconnectionclosed() ) ); connect( socket, SIGNAL( error( int ) ), this, SLOT( reporterror( int ) ) ); QString qstr( wwwname.c_str() ); socket->connecttohost( qstr, 80 ); // asynchronous call 42

43 ClientSocket::~ClientSocket() { string ClientSocket::constructHttpRequest( ) { char urlarr[256]; string prefix = " int i = 0; while ( i < prefix.length() ) { urlarr[ i ] = prefix[ i ]; i++; while ( i < ( wwwname.length() + prefix.length() ) ) { urlarr[i] = wwwname[ i - prefix.length() ]; i++; while ( i < 256 ) { urlarr[ i ] = ; i++; urlarr[255] = 0; string urlstring( urlarr ); string httprequeststring = "GET " + urlstring + " /HTTP/1.1\n\n"; return httprequeststring; void ClientSocket::reportHostFound() { cout << "host found" << endl; 43

44 void ClientSocket::reportConnected() { cout << "connection established" << endl; string httprequest = constructhttprequest(); int len = httprequest.size(); socket->writeblock( httprequest.c_str(), len ); void ClientSocket::getWebPage() { cout << "socket ready to read" << endl; int howmanybytes = socket->bytesavailable(); cout << "bytes available: " << howmanybytes << endl; while ( socket->canreadline() ) cout << socket->readline(); void ClientSocket::socketConnectionClosed() { socket->close(); if ( socket->state() == QSocket::Closing ) { // delayed close connect( socket, SIGNAL( delayedclosefinished() ), this, SLOT( socketclosed() ) ); else { // The socket is really closed socketclosed(); void ClientSocket::reportError( int e ) { cout << "error report from connecttohost" << endl; cout << "error id: " << e; void ClientSocket::socketClosed() { 44

45 cout << "Connection closed" << endl; exit( 0 ); int main( int argc, char* argv[] ) { QApplication app( argc, argv ); ClientSocket* sock = new ClientSocket( argv[1] ); return app.exec(); 45

46 Server Sockets in C++ Qt ChatServer.h ChatServer.cc Makefile_ChatServer 46

47 //ChatServer.h #ifndef CHATSERVER_H #define CHATSERVER_H #include <qserversocket.h> #include <qsocket.h> #include <qtextstream.h> #include <qstring.h> #include <vector> using namespace std; class ChatServer; class ClientHandler : public QObject { Q_OBJECT QSocket* handlersocket; QString* chatname; ChatServer* chatserver; QTextStream* os; public: ClientHandler( QSocket* sock, ChatServer* cserver ); ClientHandler(); ClientHandler( const ClientHandler& cl ); ClientHandler& operator=( const ClientHandler& other ); ~ClientHandler(); private slots: void readfromclient(); void reporterror( int ); ; class ChatServer : public QServerSocket { Q_OBJECT public: 47

48 vector<clienthandler> clientvector; ChatServer( int port ); void newconnection( int socketfd ); ~ChatServer(); ; #endif 48

49 //ChatServer.cc #include "ChatServer.h" #include <qapplication.h> #include <iostream> using namespace std; ChatServer::ChatServer( int port ) : QServerSocket( port ) { cout << "Server monitoring port " << port << endl; if (!ok() ) { qwarning( "Failed to register the server port" ); exit( 1 ); // You must provide an override implementation for // this method. When a client requests a connection, // this method will be called automatically with the // socket argument set to the filedescriptor associated // with the socket. void ChatServer::newConnection( int socketfd ) { // QSocket* socket = new QSocket( this ); QSocket* socket = new QSocket(); socket->setsocket( socketfd ); ClientHandler* clh = new ClientHandler( socket, this ); cout << "A new client checked in on socket FD " << socketfd << endl; ChatServer::~ChatServer(){ 49

50 ClientHandler::ClientHandler() { // Copy constructor is needed since it is the copies of // the ClientHandler objects that will be stored in the // vector clientvector ClientHandler::ClientHandler( const ClientHandler& other ) : handlersocket( other.handlersocket ), chatname( other.chatname ), chatserver( other.chatserver ), os( other.os ) { ClientHandler& ClientHandler::operator=( const ClientHandler& other ) { if ( this == &other ) return *this; cout << "ClientHandler assignment op invoked" << endl; if ( handlersocket!= 0 ) delete handlersocket; handlersocket = other.handlersocket; if ( chatname!= 0 ) delete chatname; chatname = other.chatname; if ( os!= 0 ) delete os; os = other.os; chatserver = other.chatserver; 50

51 ClientHandler::ClientHandler( QSocket* socket, ChatServer* chatserver ) : chatname(0), chatserver( chatserver ), handlersocket( socket ) { os = new QTextStream( handlersocket ); (*os) << "Welcome to a chat room powered by C++\n"; (*os) << ">>>> Enter bye to exit <<<\n"; (*os) << "Enter chat name: "; connect( handlersocket, SIGNAL( readyread() ), this, SLOT( readfromclient() ) ); connect( handlersocket, SIGNAL( error( int ) ), this, SLOT( reporterror( int ) ) ); // The destructor definition intentionally does not invoke the delete // operator on any of the objects pointed to by the data members of a // ClientHandler. In this program, the most frequent invocation of the // destructor is caused by the push_back statement in the // readfromclient() function. The push_back invocation causes the the // vector to be moved to a different location in the memory. The memory // occupied by the ClientHandler objects in the vector is freed by // invoking the destructor. Deleting the memory occupied the socket and // other objects pointed to by the data members of the ClientHandler // objects would lead to disastrous results. ClientHandler::~ClientHandler(){ void ClientHandler::reportError( int e ) { cout << "error report from connecttohost" << endl; cout << "error id: " << e << endl; 51

52 void ClientHandler::readFromClient() { QSocket* sock = (QSocket*) sender(); while ( sock->canreadline() ) { QString qstr = sock->readline(); // This block is for the case when a new chatter has just signed // in and supplied his/her chat name. The block sets the // chatname of the ClientHandler object assigned to this new // user. Next it pushes the ClientHandler object for this new // user in the vector clientvector. Subsequently, The block // informs all other current chatters that this new user has // signed in. if ( chatname == 0 ) { chatname = new QString( qstr.stripwhitespace() ); chatserver->clientvector.push_back( *this ); // now we have all for ( int i=0; i<chatserver->clientvector.size(); i++ ) { if ( *chatserver->clientvector[i].chatname!= *chatname && chatserver->clientvector[i].handlersocket!= 0 ) { QString outgoing = "\nmessage from chat server: " + *chatname + " signed in "; *chatserver->clientvector[i].os << outgoing; // This block treats the case when a chatter wants to sign out // by typing "bye". It broadcasts a message to all the other // chatters that this chatter is signing off. This block than // closes the socket. Note that socket pointer is set to null // in both the ClientHandler object assigned to the exiting // chatter and its copy the vector clientvector. else if ( qstr.stripwhitespace() == "bye" ) { 52

53 for ( int i=0; i<chatserver->clientvector.size(); i++ ) { QString outgoing( "\nmessage from the chat server: " + *chatname + " signed off" ); if ( *chatserver->clientvector[i].chatname!= *chatname && chatserver->clientvector[i].handlersocket!= 0 ) { *chatserver->clientvector[i].os << outgoing; handlersocket->close(); // delete handlersocket; // close connection to client handlersocket = 0; for ( int i=0; i<chatserver->clientvector.size(); i++ ) { if ( *chatserver->clientvector[i].chatname == *chatname ) chatserver->clientvector[i].handlersocket = 0; // This is the normal case encountered during the course of a // chat. The string typed in by a chatter is broadcast to all // the other chatters. The string is pre-pended by the name of // the chatter who typed in the string. else { cout << *chatname << ": " << qstr << endl; qstr.truncate( qstr.length() - 2 ); for ( int i=0; i<chatserver->clientvector.size(); i++ ) { if ( *chatserver->clientvector[i].chatname!= *chatname && chatserver->clientvector[i].handlersocket!= 0 ) { QString outgoing = "\n" + *chatname + ": " + qstr; *chatserver->clientvector[i].os << outgoing; // A chatter s terminal always shows his/her own name at // beginning of a new line. This way, when a chatter types in // his/her own message, it is always on a line that starts with 53

54 // his/her own name. for ( int i=0; i<chatserver->clientvector.size(); i++ ) { if ( chatserver->clientvector[i].handlersocket!= 0 ) { QString outgoing = "\n" + *chatserver->clientvector[i].chatname + ": "; *chatserver->clientvector[i].os << outgoing; int main( int argc, char* argv[] ) { QApplication app( argc, argv ); ChatServer* server = new ChatServer( 5000 ); return app.exec(); 54