It is easier to demonstrate the functioning of a server socket, because we have a ready made client using a web browser. Unlike the previous tutorials, this one, ServerSocketSample.cpp, is console based. Let us examine the creation of the sockets:
00006: void main() 00007: { 00008: char buf[15] = {0}; //Data received buffer. 00009: int msgsize = 0; //Message size 00010: 00011: //Create a server socket that will listen on port 8080 00012: ServerSocket ss( 8080 ); 00013: Socket& s = ss.accept(); //Accept a conection
The parameter passed to ServerSocket's constructor is an integer that represents the port that the server will listen in on for a connection. To accept a connection you call the accept() method. This method returns a Socket object. To save on memory and time you should decare the variable that will catch it as a reference, which I have done in line 13. If there was an error, accept() will return an unconnected socket. So simply check to see if the socket is connectd like so:
00015: //Make sure the connection is valid 00016: if ( !s.isConnected() ) 00017: { 00018: cout << Socket::getLastError() << endl; 00019: 00020: //If it is a bad connection 00021: //close the server socket 00022: //and return. 00023: ss.close(); 00024: return; 00025: }
Since we are only going to process one connection, if we encounter an error we output it and close the server socket. The method getLastError() is a static method that returns a string that contains a verbose error message pertaining to the last error that occured. If the client connected okay, then the next thing we do is process the data sent by the client.
00027: //While we are not at the end of the header 00028: do 00029: { 00030: //Set the buffer to NULL 00031: memset( buf, NULL, 15 ); 00032: msgsize = s.recv( buf, 14 ); //Recieve a portion of the message 00033: if ( msgsize < 0 ) //Make sure there was no error 00034: { 00035: cout << "\n\n" << Socket::getLastError() << endl; 00036: break; 00037: } 00038: else 00039: cout << buf; //Output the message 00040: } while ( strcmp( &buf[msgsize - 4], "\r\n\r\n" ) != 0 ); 00041: cout << endl; //Flush the output buffer.
There are several key things to note about the way we handled the receiving of the data. First, notice on line 32 that we cut the buffer size by one. We do this becuase if we passed in 15, the recv() method would have filled up all fifteen bytes with data. That means we would not have had a null terminated string for outputing on line 36. Secondly, recv() returns the number of bytes placed into the buffer or a negative number representing an error code. Notice our check on line 33. All methods of ServerSocket and Socket return a negitive integer when there is an error. So you can check for errors by examining the return value for a number less than zero. Thirdly, you are probably wondering about that strange check done by the while loop. Well HTTP requests terminate in "\r\n\r\n". So we take the size of our message and move back four places and compare. The important thing to note is that if the client is done sending data recv() will still attempt to receive data, in essence it will block indefinitly. So when receiving data you should always check for some kind of terminater character or sequence of characters. Now we can send data to the client like so,
00044: //Send a message to the client 00045: s << "Received Header Information.";
This will send to the client the string "Received Header Information." To send non-null terminated data you can use send() method. It looks the same as recv() It just sends the buffer to the client.
Lets run the example to give you a concrete understanding. Compile and execute the example
program. Then using Internet Explorer® type in the address bar http://localhost:8080 and
press ENTER. The console should output something like this.
And Internet Explorer® should display this.
Finally you should close the sockets like this.
00047: //Close the sockets. 00048: s.close(); 00049: ss.close();
It is important that you explicitly close every socket that gets opened. Windows does not automatically close a socket when your program exits. So those sockets stay opened until you restart the computer.