public UILServerIL(InetAddress addr,
    int port,
    String socketFactoryName,
    boolean enableTcpNoDelay,
    int bufferSize,
    int chunkSize,
    int soTimeout,
    String connectAddress,
    int connectPort) throws Exception 
{
         
      this.addr = addr;
      this.port = port;
      this.socketFactoryName = socketFactoryName;
      this.enableTcpNoDelay = enableTcpNoDelay;
      this.bufferSize = bufferSize;
      this.chunkSize = chunkSize;
      this.soTimeout = soTimeout;
      this.connectAddress = connectAddress;
      this.connectPort = connectPort;
}

 public  void acknowledge(ConnectionToken dc,
    AcknowledgementRequest item) throws Exception, JMSException 
{
      AcknowledgementRequestMsg msg = new AcknowledgementRequestMsg(item);
      if (item.isAck())
         getSocketMgr().sendMessage(msg);
      else
         getSocketMgr().sendOneWay(msg);
}

 public  void addMessage(ConnectionToken dc,
    SpyMessage val) throws Exception 
{
      AddMsg msg = new AddMsg(val);
      getSocketMgr().sendMessage(msg);
}

 public String authenticate(String username,
    String password) throws Exception, JMSException 
{
      CheckUserMsg msg = new CheckUserMsg(username, password, true);
      getSocketMgr().sendMessage(msg);
      String sessionID = msg.getID();
      return sessionID;
}

 public SpyMessage[] browse(ConnectionToken dc,
    Destination dest,
    String selector) throws Exception, JMSException 
{
      BrowseMsg msg = new BrowseMsg(dest, selector);
      getSocketMgr().sendMessage(msg);
      SpyMessage[] msgs = msg.getMessages();
      return msgs;
}

 protected  void checkConnection() throws Exception 
{
      if (socketMgr == null)
      {
         createConnection();
      }
}

 public  void checkID(String id) throws Exception, JMSException 
{
      CheckIDMsg msg = new CheckIDMsg(id);
      getSocketMgr().sendMessage(msg);
}

 public String checkUser(String username,
    String password) throws Exception, JMSException 
{
      CheckUserMsg msg = new CheckUserMsg(username, password, false);
      getSocketMgr().sendMessage(msg);
      String clientID = msg.getID();
      return clientID;
}

 public Object clone() throws CloneNotSupportedException 
{
      return super.clone();
}

 public ServerIL cloneServerIL() throws Exception 
{
      return (ServerIL)clone();
}

 public  void connectionClosing(ConnectionToken dc) throws Exception, JMSException 
{
      CloseMsg msg = new CloseMsg();
      try
      {
         getSocketMgr().sendMessage(msg);
      }
      catch (IOException ignored)
      {
      }
      destroyConnection();
}

 protected  void createConnection() throws Exception 
{
      boolean tracing = log.isTraceEnabled();
      /** Attempt to load the socket factory and if this fails, use the
       * default socket factory impl.
       */
      SocketFactory socketFactory = null;
      if( socketFactoryName != null )
      {
         try
         {
            ClassLoader loader = Thread.currentThread().getContextClassLoader();
            Class factoryClass = loader.loadClass(socketFactoryName);
            socketFactory = (SocketFactory) factoryClass.newInstance();
         }
         catch(Exception e)
         {
            log.debug("Failed to load socket factory: "+socketFactoryName, e);
         }
      }
      // Use the default socket factory
      if( socketFactory == null )
      {
         socketFactory = SocketFactory.getDefault();
      }
      // Look for a local address and port as properties
      String tmp = getProperty(LOCAL_ADDR);
      if( tmp != null )
         this.localAddr = InetAddress.getByName(tmp);
      tmp = getProperty(LOCAL_PORT);
      if( tmp != null )
         this.localPort = Integer.parseInt(tmp);
      // Look for client side overrides of the server address/port
      InetAddress serverAddr = addr;
      int serverPort = port;
      tmp = getProperty(SERVER_ADDR);
      if (tmp == null)
         tmp = connectAddress;
      if( tmp != null )
         serverAddr = InetAddress.getByName(tmp);
      tmp = getProperty(SERVER_PORT);
      if( tmp != null )
         serverPort = Integer.parseInt(tmp);
      else if (connectPort != 0)
         serverPort = connectPort;
      String useHostNameProp = getProperty(USE_SERVER_HOST);
      String serverHost = serverAddr.getHostAddress();
      if (Boolean.valueOf(useHostNameProp).booleanValue())
         serverHost = serverAddr.getHostName();
      int retries = 0;
      // Default to 10 retries, no delay in the absence of user override
      int maxRetries = 10;
      tmp = getProperty(RETRY_COUNT);
      if( tmp != null )
         maxRetries = Integer.parseInt(tmp);
      long retryDelay = 0;
      tmp = getProperty(RETRY_DELAY);
      if( tmp != null )
      {
         retryDelay = Long.parseLong(tmp);
         if( retryDelay <  0 )
            retryDelay = 0;
      }
      if( tracing )
         log.trace("Begin connect loop, maxRetries="+maxRetries+", delay="+retryDelay);
      while (true)
      {
         try
         {
            if( tracing )
            {
               log.trace("Connecting with addr="+serverHost+", port="+serverPort
                  + ", localAddr="+localAddr+", localPort="+localPort
                  + ", socketFactory="+socketFactory
                  + ", enableTcpNoDelay="+enableTcpNoDelay
                  + ", bufferSize="+bufferSize
                  + ", chunkSize="+chunkSize
                  );
            }
            if( localAddr != null )
               socket = socketFactory.createSocket(serverHost, serverPort, localAddr, localPort);
            else
               socket = socketFactory.createSocket(serverHost, serverPort);
            break;
         }
         catch (ConnectException e)
         {
            if (++retries  > maxRetries)
               throw e;
            if( tracing )
               log.trace("Failed to connect, retries="+retries, e);
         }
         try
         {
            Thread.sleep(retryDelay);
         }
         catch(InterruptedException e)
         {
            break;
         }
      }
      socket.setTcpNoDelay(enableTcpNoDelay);
      if (soTimeout != 0)
         socket.setSoTimeout(soTimeout);
      socketMgr = new SocketManager(socket);
      socketMgr.setBufferSize(bufferSize);
      socketMgr.setChunkSize(chunkSize);
      socketMgr.start(Connection.getThreadGroup());
}

Used to establish a new connection to the server

 public Queue createQueue(ConnectionToken dc,
    String destName) throws Exception, JMSException 
{
      CreateDestMsg msg = new CreateDestMsg(destName, true);
      getSocketMgr().sendMessage(msg);
      Queue dest = msg.getQueue();
      return dest;
}

 public Topic createTopic(ConnectionToken dc,
    String destName) throws Exception, JMSException 
{
      CreateDestMsg msg = new CreateDestMsg(destName, false);
      getSocketMgr().sendMessage(msg);
      Topic dest = msg.getTopic();
      return dest;
}

 public  void deleteTemporaryDestination(ConnectionToken dc,
    SpyDestination dest) throws Exception, JMSException 
{
      DeleteTemporaryDestMsg msg = new DeleteTemporaryDestMsg(dest);
      getSocketMgr().sendMessage(msg);
}

 protected  void destroyConnection() 
{
      try
      {
        if( socket != null )
        {
           try
           {
              socketMgr.stop();
           }
           finally
           {
              socket.close();
           }
        }
      }
      catch(IOException ignore)
      {
      }
}

Used to close the current connection with the server

 public  void destroySubscription(ConnectionToken dc,
    DurableSubscriptionID id) throws Exception, JMSException 
{
      DeleteSubscriptionMsg msg = new DeleteSubscriptionMsg(id);
      getSocketMgr().sendMessage(msg);
}

 public String getID() throws Exception 
{
      GetIDMsg msg = new GetIDMsg();
      getSocketMgr().sendMessage(msg);
      String id = msg.getID();
      return id;
}

 final SocketManager getSocketMgr() throws Exception 
{
      if( socketMgr == null )
         createConnection();
      return socketMgr;
}

 public TemporaryQueue getTemporaryQueue(ConnectionToken dc) throws Exception, JMSException 
{
      TemporaryDestMsg msg = new TemporaryDestMsg(true);
      getSocketMgr().sendMessage(msg);
      TemporaryQueue dest = msg.getQueue();
      return dest;
}

 public TemporaryTopic getTemporaryTopic(ConnectionToken dc) throws Exception, JMSException 
{
      TemporaryDestMsg msg = new TemporaryDestMsg(false);
      getSocketMgr().sendMessage(msg);
      TemporaryTopic dest = msg.getTopic();
      return dest;
}

 public  void ping(ConnectionToken dc,
    long clientTime) throws Exception 
{
      PingMsg msg = new PingMsg(clientTime, true);
      msg.getMsgID();
      getSocketMgr().sendReply(msg);
}

 public SpyMessage receive(ConnectionToken dc,
    int subscriberId,
    long wait) throws Exception 
{
      ReceiveMsg msg = new ReceiveMsg(subscriberId, wait);
      getSocketMgr().sendMessage(msg);
      SpyMessage reply = msg.getMessage();
      return reply;
}

 public Xid[] recover(ConnectionToken dc,
    int flags) throws Exception 
{
      RecoverMsg msg = new RecoverMsg(flags);
      getSocketMgr().sendMessage(msg);
      Xid[] reply = msg.getXids();
      return reply;
}

 public  void setConnectionToken(ConnectionToken dest) throws Exception 
{
      ConnectionTokenMsg msg = new ConnectionTokenMsg(dest);
      getSocketMgr().sendMessage(msg);
}

 public  void setEnabled(ConnectionToken dc,
    boolean enabled) throws Exception, JMSException 
{
      EnableConnectionMsg msg = new EnableConnectionMsg(enabled);
      getSocketMgr().sendMessage(msg);
}

 public  void subscribe(ConnectionToken dc,
    Subscription s) throws Exception, JMSException 
{
      SubscribeMsg msg = new SubscribeMsg(s);
      getSocketMgr().sendMessage(msg);
}

 public  void transact(ConnectionToken dc,
    TransactionRequest t) throws Exception, JMSException 
{
      TransactMsg msg = new TransactMsg(t);
      getSocketMgr().sendMessage(msg);
}

 public  void unsubscribe(ConnectionToken dc,
    int subscriptionID) throws Exception, JMSException 
{
      UnsubscribeMsg msg = new UnsubscribeMsg(subscriptionID);
      getSocketMgr().sendMessage(msg);
}