echoServer.listen(new EchoServer());
        
        // Now to tell clients how to connect. Since we elected no configuration, Trap will allocate random ports.
        clientConfig = echoServer.getClientConfiguration();
        System.out.println("New clients should connect to the following configuration:");
        System.out.println(echoServer.getClientConfiguration());
    }
    
    public void incomingTrapConnection(TrapEndpoint endpoint, TrapListener listener, Object context)
    {
        // Endpoints received by this method are NOT strongly referenced, and may be GC'd. Thus, we must retain
        clients.add(endpoint);
        
        // We also want feedback from the endpoint.
        endpoint.setDelegate(this, true);
    }
    
    public void trapData(byte[] data, int channel, TrapEndpoint endpoint, Object context)
    {
        // Log!
        System.out.println("Echo Server Got message: [" + StringUtil.toUtfString(data) + "] of length " + data.length);
        
        try
        {
            // Echo the data back with the same parameters.
            endpoint.send(data, channel, false);
        }
        catch (TrapException e)
        {
            e.printStackTrace();
        }
    }
    
    public void trapClose(TrapEndpoint endpoint, Object context)
    {
        // Remove the strong reference to allow garbage collection
        clients.remove(endpoint);
    }
    
}

        }
    }
    
    public TrapMessage peek()
    {
        synchronized (this.messageQueue)
        {
            try
            {
                return this.messageQueue.get(0);
            }
            catch (IndexOutOfBoundsException e)
            {
                return null;
            }
        }
    }
    
    public TrapMessage pop()
    {
        synchronized (this.messageQueue)
        {
            try
            {
                TrapMessage m = this.messageQueue.remove(0);
                this.messageQueue.notifyAll();
                return m;
            }
            catch (IndexOutOfBoundsException e)
            {
                return null;
            }
        }
    }
    
    public long size()
    {
        return this.maxQueueSize;
    }
    
    public void resize(long newSize)
    {
        this.maxQueueSize = newSize;
    }
    
    public String getQueueType()
    {
        return TrapEndpoint.BLOCKING_MESSAGE_QUEUE;
    }
    
    public int length()
    {
        return this.messageQueue.size();
    }
    
    public long blockingTimeout()

        this.client = TrapFactory.createClient(trapCfg, true);
        
        // Tell the client to use us as a delegate.
        // We'll only handle two events this time: open and data
        this.client.setDelegate(this, true);
        
        // Start connecting.
        this.client.open();
    }
    
    // Called when the client is open (=ready to send)
    public void trapOpen(TrapEndpoint endpoint, Object context)
    {
        // Send a message!
        this.sendMessage();
    }
    
    // Called when the client receives data. Since we connect to the echo server, the same message should come back.
    public void trapData(byte[] data, int channel, TrapEndpoint endpoint, Object context)
    {
        System.out.println("Got message: " + StringUtil.toUtfString(data));
        this.sendMessage();
    }
    
    private void sendMessage()
    {
        String message = "Message {" + this.counter++ + "}";
        System.out.println("Now sending: " + message);
        
        try
        {
            this.client.send(StringUtil.toUtfBytes(message));
        }
        catch (TrapException e)
        {
            e.printStackTrace();
        }
    }
    
}

    {
        
        synchronized (this.messagesToSend)
        {
            
            if ((this.getState() != TrapTransportState.CONNECTED) && (this.getState() != TrapTransportState.AVAILABLE) && (this.getState() != TrapTransportState.UNAVAILABLE) && (message.getOp() != TrapMessage.Operation.CLOSE))
                throw new TrapTransportException(message, this.getState());
            
            if (message != null)
            {
                if (this.logger.isTraceEnabled())
                    this.logger.trace("[HTTP] Scheduling message {} with id {}", message.getOp(), message.getMessageId());
                // Don't slam messages yet
                this.messagesToSend.add(message);
            }
            
            if (expectMore)
                return;
            
            this.flushTransport();
            
        }
    }

							WebSocketTransport.this.flushTransport();
						}
					}, 1);
				}
				
				if (expectMore)
				{
					
					if (this.outBuf == null)
						this.outBuf = new ByteArrayOutputStream();
					
					this.outBuf.write(raw);
					return;
				}
				
				this.performSend(raw);
				
			}
		}
		catch (IOException e)
		{
			this.logger.debug(e.toString());
			this.setState(TrapTransportState.ERROR);
			throw new TrapTransportException(message, this.state);
		}
		catch (TrapTransportException e)
		{
			this.setState(TrapTransportState.ERROR);
			throw e;
		}
		catch (Throwable t)
		{
			t.printStackTrace();
		}
	}
	
	private void performSend(byte[] raw) throws IOException
	{

char[] out = new char[oLen];
int ip = iOff;
int iEnd = iOff + iLen;
int op = 0;
while (ip < iEnd) {
   int i0 = in[ip++] & 0xff;
   int i1 = ip < iEnd ? in[ip++] & 0xff : 0;
   int i2 = ip < iEnd ? in[ip++] & 0xff : 0;
   int o0 = i0 >>> 2;
   int o1 = ((i0 &   3) << 4) | (i1 >>> 4);
   int o2 = ((i1 & 0xf) << 2) | (i2 >>> 6);
   int o3 = i2 & 0x3F;
   out[op++] = map1[o0];

	}
	
	public void listen(ListenerTrapTransportDelegate listener, Object context) throws TrapException
	{
		this.listenerDelegate = listener;
		this.listenerContext = context;

		this.delegate = new TrapTransportDelegate() {

			@Override
			public void ttStateChanged(TrapTransportState newState, TrapTransportState oldState, TrapTransport transport, Object context)
			{
				// TODO Auto-generated method stub

			}

			@Override
			public void ttMessageReceived(TrapMessage message, TrapTransport transport, Object context)
			{
				// TODO Auto-generated method stub

			}

			@Override
			public void ttMessageSent(TrapMessage message, TrapTransport transport, Object context)
			{
				// TODO Auto-generated method stub
				
			}

            @Override
            public void ttMessagesFailedSending(Collection<TrapMessage> messages, TrapTransport transport, Object context)
            {
                // TODO Auto-generated method stub
                
            }

            @Override
            public void ttNeedTransport(TrapMessage message, TrapTransport transport, Object context)
            {
                // TODO Auto-generated method stub
                
            }
		};

        try
        {
            Class<TrapTransport>[] transports = TrapTransports.getTransportClasses(this.getClass().getClassLoader());
            
            for (int i = 0; i < transports.length; i++)
            {
                if (!TrapTransport.class.isAssignableFrom(transports[i]) || transports[i].isAssignableFrom(AbstractTransport.class))
                    continue;
                
                TrapTransport t;
                
                try
                {
                    t = transports[i].newInstance();
                }
                catch (Exception e)
                {
                    this.logger.debug("Failed to instantiate {}; Most probably a server transport...", transports[i].getName(), e);
                    continue;
                }
                
                if (!t.canConnect())
                    continue;

        System.out.println(clientConfig);
    }
    
    public void incomingTrapConnection(TrapEndpoint endpoint, TrapListener listener, Object context)
    {
        // Endpoints received by this method are NOT strongly referenced, and may be GC'd. Thus, we must retain
        clients.add(endpoint);
        
        // We also want feedback from the endpoint.
        endpoint.setDelegate(this, true);
    }
    
    public void trapData(byte[] data, int channel, TrapEndpoint endpoint, Object context)
    {
        // Log!
        System.out.println("Echo Server Got message: [" + StringUtil.toUtfString(data) + "] of length " + data.length);
        
        try
        {
            // Echo the data back with the same parameters.
            endpoint.send(data, channel, false);
        }
        catch (TrapException e)
        {
            e.printStackTrace();
        }
    }
    
    public void trapClose(TrapEndpoint endpoint, Object context)
    {
        // Remove the strong reference to allow garbage collection
        clients.remove(endpoint);
    }
    
}

			}
		}
	}
	
	public WSURI getURI() {
		String scheme = (securityContext==null ? "ws" : "wss");

		InetSocketAddress inetAddress = getAddress();
		String host = inetAddress.getAddress().getHostAddress();
		int port = inetAddress.getPort();
		String resource = "ws";
		
		byte[] address = inetAddress.getAddress().getAddress();
		boolean isv6 = address.length > 4;
		
		if (isv6)
			host = "[" + host + "]";

		try {
			return new WSURI(scheme + "://" + host + ":" + port + "/" + resource);
		} catch (IllegalArgumentException e) {

            SSLContext sslc = null;
            
            if (this.getOption(CERT_USE_INSECURE_TEST) != null)
            {
                sslc = SSLUtil.getContext(new SSLMaterial("jks", "trapserver.jks", "Ericsson"), new SSLMaterial("jks", "trapserver.jks", "Ericsson"));
                this.logger.warn("Using insecure SSL context");
            }
            else
            {
                try
                {
                    String keyType = this.getOption(CERT_KEYSTORE_TYPE);
                    String keyName = this.getOption(CERT_KEYSTORE_NAME);
                    String keyPass = this.getOption(CERT_KEYSTORE_PASS);
                    
                    String trustType = this.getOption(CERT_TRUSTSTORE_TYPE);
                    String trustName = this.getOption(CERT_TRUSTSTORE_NAME);
                    String trustPass = this.getOption(CERT_TRUSTSTORE_PASS);

            WSInterface mSock = this.socket;
            
            if (mSock == null)
                throw new TrapTransportException(message, this.getState());
            
            synchronized (mSock)
            {
                
                byte[] raw = message.serialize();
                
                this.delayed |= this.lastSend == System.currentTimeMillis();
                this.delayed &= this.useDelay;
                if (this.delayed && !this.delayQueued)
                {
                    this.delayQueued = true;
                    ThreadPool.executeAfter(new Runnable() {
                        
                        @Override
                        public void run()
                        {
                            WebSocketTransport.this.flushTransport();
                        }
                    }, 1);
                }
                
                if (expectMore || this.delayed)

				throw new WSException("Failed to match origin ("+protocol.origin+" != "+getHeader(WEBSOCKET_ORIGIN_HEADER)+")");
			StringBuffer location = new StringBuffer();
			if(protocol.securityContext!=null)
				location.append(WSS_SCHEMA);
			else
				location.append(WS_SCHEMA);
			location.append(protocol.host);
			if((protocol.securityContext==null && protocol.port != 80) || (protocol.securityContext!=null && protocol.port != 443)) {
				location.append(":");
				location.append(protocol.port);
			}
			location.append(protocol.resource);
			if (!location.toString().equals(getHeader(WEBSOCKET_LOCATION_HEADER)))

        this.delegate = new TrapTransportDelegate() {
            
            @Override
            public void ttStateChanged(TrapTransportState newState, TrapTransportState oldState, TrapTransport transport, Object context)
            {
                // TODO Auto-generated method stub
                
            }
            
            @Override
            public void ttMessageReceived(TrapMessage message, TrapTransport transport, Object context)
            {
                // TODO Auto-generated method stub
                
            }
            
            @Override
            public void ttMessageSent(TrapMessage message, TrapTransport transport, Object context)
            {
                // TODO Auto-generated method stub
                
            }

            @Override
            public void ttMessagesFailedSending(Collection<TrapMessage> messages, TrapTransport transport, Object context)
            {
                // TODO Auto-generated method stub
                
            }

            @Override
            public void ttNeedTransport(TrapMessage message, TrapTransport transport, Object context)
            {
                // TODO Auto-generated method stub
                
            }
        };