commsinfrastructureapitest/commsinfrastructuresvs/echoserver/source/EchoServer.java
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/commsinfrastructureapitest/commsinfrastructuresvs/echoserver/source/EchoServer.java Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,466 @@
+/*
+* Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+
+import java.net.*;
+import java.io.*;
+
+public class EchoServer extends Thread{
+
+ // Constants
+
+ // Commands available
+ private final String iCommandShutdown = "Shutdown.";
+ private final String iCommandShutdownNow = "ShutdownNow.";
+ private final String iCommandStopReturning = "StopReturning.";
+ private final String iCommandStartReturning = "StartReturning.";
+ private final String iCommandSleep = "sleep=";
+ private final String iCommandSendBufferSize = "sendbufsize=";
+ private final String iCommandReceiveBufferSize = "recvbufsize=";
+
+ private final int iBufferSize = 256;
+
+ // Static variables
+ private static final int sDefaultTcpPort = 10007;
+ private static int sPort;
+
+ // Member variables
+ private Socket iClientSocket;
+ private boolean iUdpSocket;
+ private int iUdpPort;
+
+ private String iClientHost;
+ private int iClientPort;
+
+ private int iSendBufferLength = 0;
+ private int iReceiveBufferLength = 0;
+
+ private boolean iEchoData = true;
+ private boolean iPortSet = false;
+
+ public static void main(String[] aArgs) throws IOException{
+
+ ServerSocket lServerSocket = null;
+ sPort = sDefaultTcpPort;
+ boolean lUdpSocket = false;
+ if (aArgs.length > 0){
+ try{
+ sPort = Integer.parseInt(aArgs[0]);
+ }
+ catch(NumberFormatException nfe){
+ System.out.println("Usage:\n\tjava EchoServer [port [protocol]]\n\tIf port is not specified, port: " + sDefaultTcpPort + " will be used\n\tProtocol is TCP or UDP if not specified or incorrect TCP is default");
+ System.exit(1);
+ }
+ if (aArgs.length > 1){
+ if (aArgs[1].equalsIgnoreCase("UDP")){
+ lUdpSocket = true;
+ }
+ }
+ }
+ // UDP Version
+ if (lUdpSocket){
+ System.out.println("Connection Socket Created for UDP connection on port: " + sPort);
+ while (true){
+ try{
+ java.lang.Thread.sleep(1000);
+ }
+ catch(java.lang.InterruptedException ie){
+ System.err.println("Sleep inturrupted.");
+ }
+ System.out.println("Waiting for Connection");
+ EchoServer lEchoServer = new EchoServer(sPort);
+ lEchoServer.handleUDP();
+ }
+ }
+
+ // TCP version
+ else{
+
+ try{
+ lServerSocket = new ServerSocket(sPort);
+ System.out.println("Connection Socket Created for TCP connection on port: " + sPort);
+
+ try{
+ while (true){
+ System.out.println("Waiting for Connection");
+ new EchoServer(lServerSocket.accept());
+ }
+ }
+ catch(IOException e){
+ System.err.println("Accept failed.");
+ System.exit(1);
+ }
+ }
+ catch(IOException e){
+ System.err.println("Could not listen on port: " + sPort + ".");
+ System.exit(1);
+ }
+ finally{
+ try{
+ lServerSocket.close();
+ }
+ catch(IOException e){
+ System.err.println("Could not close port: " + sPort + ".");
+ System.exit(1);
+ }
+ }
+ }
+ }
+
+ private EchoServer(Socket aClientSoc){
+
+ iClientSocket = aClientSoc;
+ iUdpSocket = false;
+
+ InetAddress lIpAddress = iClientSocket.getInetAddress();
+ iClientHost = lIpAddress.getHostAddress();
+ System.out.println("Accepted from IP Address: " + iClientHost);
+
+ start();
+ }
+
+ private EchoServer(int aPort){
+
+ iUdpSocket = true;
+ iUdpPort = aPort;
+ }
+
+ // returns true if iClientPort successfully parsed
+ private boolean parsePort(String aMessage){
+
+ // If the text is formatted like this:
+ // [2024]
+ // parse the client port so that connection back to this preference is possible
+ int lFirstIndex = aMessage.indexOf('[');
+ int lSecondIndex = aMessage.indexOf(']');
+
+ if ( (lFirstIndex == 0) && (lSecondIndex > 1) ){
+
+ String lPortString = aMessage.substring(1, lSecondIndex);
+ int lPort = 0;
+
+ try{
+ lPort = Integer.parseInt(lPortString);
+ }
+ catch(NumberFormatException nfe){
+ System.out.println("Failed to parse port to integer");
+ return false;
+ }
+
+ iClientPort = lPort;
+ iPortSet = true;
+ return true;
+ }
+ return false;
+ }
+
+ // returns true if integer successfully parsed
+ private int parseIntCommand(String aMessage, String aCommandName){
+
+ // If the text is formatted like this:
+ // command=x
+ // parse the integer x
+ int lResult = -1;
+
+ if (aMessage.startsWith(aCommandName)){
+
+ int lDotIndex = aMessage.indexOf('.');
+
+ if (lDotIndex < 0){
+ lDotIndex = aMessage.length();
+ }
+
+ String lResultString = aMessage.substring(aCommandName.length(), lDotIndex);
+
+ try{
+ lResult = Integer.parseInt(lResultString);
+ }
+ catch(NumberFormatException nfe){
+ System.out.println("Failed to parse integer");
+ }
+ }
+ return lResult;
+ }
+
+ // TCP Handling
+ public void run(){
+
+ System.out.println("New TCP Communication Thread Started");
+ try{
+
+ PrintWriter lOut = null;
+ Socket lClientSocketConn = null;
+ BufferedReader lIn = new BufferedReader(new InputStreamReader(iClientSocket.getInputStream()));
+ String lInputLine;
+ boolean lExit = false;
+ int lTempResult = -1;
+
+ while (lExit == false){
+
+ char lDataReceived[] = new char[iBufferSize];
+
+ int lLengthOfData = lIn.read(lDataReceived);
+
+ if (lLengthOfData <= 0){
+ lExit = true;
+ continue;
+ }
+
+ lInputLine = new String(lDataReceived, 0, lLengthOfData);
+
+ System.out.println("Server: " + lInputLine);
+
+ lTempResult = parseIntCommand(lInputLine, iCommandReceiveBufferSize);
+ if (lTempResult != -1){ // Message parsed
+ if (lTempResult > 0){
+ iReceiveBufferLength = lTempResult;
+ iClientSocket.setReceiveBufferSize(iReceiveBufferLength);
+ System.out.println("RECEIVE BUFFER LENGTH SET TO " + iClientSocket.getReceiveBufferSize());
+ }
+ else{
+ System.out.println("INVALID RECEIVE BUFFER LENGTH: " + iReceiveBufferLength);
+ }
+ }
+
+ lTempResult = parseIntCommand(lInputLine, iCommandSendBufferSize);
+ if (lTempResult != -1){ // Message parsed
+ if (lTempResult > 0){
+ iSendBufferLength = lTempResult;
+ }
+ else{
+ System.out.println("INVALID SEND BUFFER LENGTH: " + lTempResult);
+ }
+ }
+ if (iSendBufferLength > 0){
+ lClientSocketConn.setSendBufferSize(iSendBufferLength);
+ System.out.println("SEND BUFFER LENGTH SET TO " + lClientSocketConn.getSendBufferSize());
+ }
+
+ if (parsePort(lInputLine)){
+ try{
+ lClientSocketConn = new Socket(iClientHost, iClientPort);
+ lOut = new PrintWriter(lClientSocketConn.getOutputStream(), true);
+ }
+ catch(UnknownHostException e){
+ System.err.println("Don't know about host: " + iClientHost);
+ lExit = true;
+ continue;
+ }
+ catch(IOException e){
+ System.err.println("Couldn't get I/O for the connection to: " + iClientHost);
+ lExit = true;
+ continue;
+ }
+ }
+
+ if (lInputLine.startsWith(iCommandStartReturning)){
+ System.out.println("ECHOING ACTIVATED");
+ iEchoData = true;
+ }
+
+ if (lInputLine.startsWith(iCommandShutdownNow)){
+ System.out.println("SHUTTING DOWN");
+ break;
+ }
+
+ if ( (lOut != null) && iEchoData ){
+ System.out.println("Echo to host: " + iClientHost + ":" + iClientPort);
+ lOut.print(lInputLine);
+ lOut.flush();
+ }
+
+ if (lInputLine.startsWith(iCommandShutdown)){
+ System.out.println("SHUTTING DOWN");
+ break;
+ }
+
+ if (lInputLine.startsWith(iCommandStopReturning)){
+ System.out.println("ECHOING DEACTIVATED");
+ iEchoData = false;
+ }
+
+ int lSleepLength = parseIntCommand(lInputLine, iCommandSleep);
+ if (lSleepLength != -1){ // Message parsed
+ if (lSleepLength > 0){
+ System.out.println("SLEEPING FOR " + lSleepLength + " MILLISECONDS");
+ try{
+ java.lang.Thread.sleep(lSleepLength);
+ }
+ catch(java.lang.InterruptedException ie){
+ System.err.println("Sleep inturrupted.");
+ }
+ }
+ else{
+ System.out.println("INVALID SLEEP LENGTH: " + lSleepLength + " MILLISECONDS");
+ }
+ }
+ }
+
+ if (lOut != null){
+ lOut.close();
+ lClientSocketConn.close();
+ }
+
+ lIn.close();
+ iClientSocket.close();
+ System.out.println("Communication Thread Ended");
+ }
+ catch(IOException e){
+ System.err.println("Problem with Communication Server");
+ }
+ }
+
+ // UDP Handling
+ public void handleUDP(){
+
+ DatagramSocket lSock;
+ try{
+ lSock = new DatagramSocket(iUdpPort);
+ }
+ catch(SocketException e){
+ System.out.println(e);
+ return;
+ }
+ int lTempResult = -1;
+ // echo back everything to new socket
+ while (true){
+
+ try{
+ DatagramPacket lPack = new DatagramPacket(new byte[iBufferSize], iBufferSize);
+
+ lSock.receive(lPack);
+
+ // Set IP address of remote socket
+ InetAddress lIpAddress = lPack.getAddress();
+ iClientHost = lIpAddress.getHostAddress();
+ System.out.println("Received from IP Address: " + iClientHost);
+
+ int lLengthOfData = lPack.getLength();
+
+ if (lLengthOfData <= 0){
+ continue;
+ }
+
+ byte[] lData = lPack.getData();
+ String lMessage = new String(lData, 0, lLengthOfData);
+ System.out.println("Server: " + lMessage);
+
+ lTempResult = parseIntCommand(lMessage, iCommandReceiveBufferSize);
+ if (lTempResult != -1){ // Message parsed
+ if (lTempResult > 0){
+ iReceiveBufferLength = lTempResult;
+ lSock.setReceiveBufferSize(iReceiveBufferLength);
+ System.out.println("RECEIVE BUFFER LENGTH SET TO " + lSock.getReceiveBufferSize());
+ }
+ else{
+ System.out.println("INVALID RECEIVE BUFFER LENGTH: " + iReceiveBufferLength);
+ }
+ }
+
+ lTempResult = parseIntCommand(lMessage, iCommandSendBufferSize);
+ if (lTempResult != -1){ // Message parsed
+ if (lTempResult > 0){
+ iSendBufferLength = lTempResult;
+ }
+ else{
+ System.out.println("INVALID SEND BUFFER LENGTH: " + lTempResult);
+ }
+ }
+
+ parsePort(lMessage);
+
+ if (lMessage.startsWith(iCommandStartReturning)){
+ System.out.println("ECHOING ACTIVATED");
+ iEchoData = true;
+ }
+
+ if (lMessage.startsWith(iCommandShutdownNow)){
+ System.out.println("SHUTTING DOWN");
+ lSock.close();
+ return;
+ }
+
+ if (iPortSet && iEchoData){
+ sendUDP(lMessage);
+ }
+
+ if (lMessage.startsWith(iCommandShutdown)){
+ System.out.println("SHUTTING DOWN");
+ lSock.close();
+ return;
+ }
+
+ if (lMessage.startsWith(iCommandStopReturning)){
+ System.out.println("ECHOING DEACTIVATED");
+ iEchoData = false;
+ }
+
+ int lSleepLength = parseIntCommand(lMessage, iCommandSleep);
+ if (lSleepLength != -1){ // Message parsed
+ if (lSleepLength > 0){
+ System.out.println("SLEEPING FOR " + lSleepLength + " MILLISECONDS");
+ try{
+ java.lang.Thread.sleep(lSleepLength);
+ }
+ catch(java.lang.InterruptedException ie){
+ System.err.println("Sleep inturrupted.");
+ }
+ }
+ else{
+ System.out.println("INVALID SLEEP LENGTH: " + lSleepLength + " MILLISECONDS");
+ }
+ }
+ }
+ catch(IOException ioe){
+ System.out.println(ioe);
+ try{
+ lSock.close();
+ }
+ catch(Exception e){
+ System.err.println(e);
+ }
+ return;
+ }
+ }
+ }
+
+ private void sendUDP(String aMessage){
+
+ try{
+ byte[] lMessage = aMessage.getBytes();
+ System.out.println("Echo to host: " + iClientHost + ":" + iClientPort);
+
+ InetAddress lAddress = InetAddress.getByName(iClientHost);
+ // Initialize a datagram packet with data and address
+ DatagramPacket lPacket = new DatagramPacket(lMessage, lMessage.length, lAddress, iClientPort);
+
+ // Create a datagram socket, send the packet through it, close it.
+ DatagramSocket lDSocket = new DatagramSocket();
+
+ if (iSendBufferLength > 0){
+ lDSocket.setSendBufferSize(iSendBufferLength);
+ System.out.println("SEND BUFFER LENGTH SET TO " + lDSocket.getSendBufferSize());
+ }
+
+ lDSocket.send(lPacket);
+ lDSocket.close();
+ }
+ catch(Exception e){
+ System.err.println(e);
+ }
+ }
+}