Source code: rcs/nml/NMLConnection.java

   package rcs.nml;
   
   
   import java.net.*;
   import java.io.*;
   import java.util.*;
   import rcs.utils.*;
   import rcs.nml.NMLFormatConverter;
   import rcs.nml.NMLFormatConverterBase;
  import rcs.nml.XDRFormatConverter;
  import rcs.nml.DISPFormatConverter;
  import rcs.utils.jcrypt;
  import rcs.utils.URL_and_FileLoader;
  import rcs.nml.NMLException;
  
  class NMLBufferConfigInfo
  {
    String buffer_name = null;
    String buffer_line = null;
    Hashtable process_lines = new Hashtable();
  };
  
  class NMLConfigInfo
  {
    String file_name = null;
    Hashtable buffer_configurations = new Hashtable();
    //Vector lines_vector;
    URL_and_FileLoader loader = null;
  //  int lines_read = 0;
  }
  
  /**
  * Class for connecting to NML buffers, ussually via network sockets.<br>
  * <pre>
  * Related Documentation: 
  * <A HREF="http://isd.cme.nist.gov/proj/rcs_lib">RCS Library</a>, <A HREF="http://isd.cme.nist.gov/proj/rcs_lib/NMLjava.html">NML Programmers Guide (Java Version)</a>
  *
  * Source Code:
  * <A HREF="NMLConnection.java">NMLConnection.java</a>
  * 
  * </pre>
  *
  * @author  Will Shackleford -- <A HREF="mailto:shackle@cme.nist.gov">shackle@cme.nist.gov</a>
  *
  */
  public class NMLConnection
  {
    static protected Hashtable previously_read_nml_configurations = null;
  
    /** 
     * This variable can be set to true by some other thread to 
     * stop the login.
     *
     * @see rcs.nml.NMLConnection#login(java.lang.String,java.lang.String)
     */
    public static boolean interrupt_login = false;
  
    protected NMLFormatConverterBase format_converter = null;
    protected NMLMessageDictionary message_dictionary = null;
    public String BufferLine = null;
  
    // Protocol Options
    protected static final int NML_STCP_PROTOCOL_TYPE = 1;
    protected static final int NML_TCP_PROTOCOL_TYPE = 2;
    protected static final int NML_UDP_PROTOCOL_TYPE = 3;
    public int protocol_option = NML_STCP_PROTOCOL_TYPE;
    
    // Data format Options
    protected static final int NML_ASCII_ENCODING_TYPE = 4;
    protected static final int NML_DISP_ENCODING_TYPE = 5;
    protected static final int NML_XDR_ENCODING_TYPE = 6;
    private int data_format_option =NML_DISP_ENCODING_TYPE;
    
  
    private int serial_number = 0;
    private int last_id_read = 0;
    private int max_tries = 20;
    
    // REMOTE_CMS_REQUEST_TYPE's
    protected static final int REMOTE_CMS_READ_REQUEST_TYPE = 1;
    protected static final int REMOTE_CMS_WRITE_REQUEST_TYPE = 2;
    protected static final int REMOTE_CMS_GET_KEYS_REQUEST_TYPE = 7;
    protected static final int REMOTE_CMS_LOGIN_REQUEST_TYPE = 8;
    protected static final int REMOTE_CMS_SET_SUBSCRIPTION_REQUEST_TYPE = 9;
    protected static final int REMOTE_CMS_READ_COMBINED_REQUEST_TYPE =10;
    protected static final int REMOTE_CMS_BLOCKING_READ_REQUEST_TYPE =11;
    protected static final int REMOTE_CMS_GET_BUF_NAME_REQUEST_TYPE=12;
    protected static final int REMOTE_CMS_CANCEL_SUBSCRIPTION_REQUEST_TYPE=13;
    protected static final int REMOTE_CMS_SET_DIAG_INFO_REQUEST_TYPE=14;
    protected static final int REMOTE_CMS_GET_DIAG_INFO_REQUEST_TYPE=15;
    protected static final int REMOTE_CMS_GET_MSG_COUNT_REQUEST_TYPE=16;
  
    private int request_type = REMOTE_CMS_READ_REQUEST_TYPE;
  
    // CMS_REMOTE_SUBSCRIPTION_REQUEST_TYPE's
    public static final int CMS_POLLED_SUBSCRIPTION = 1;
    public static final int CMS_NO_SUBSCRIPTION =2;
    public static final int CMS_VARIABLE_SUBSCRIPTION =3;
  
   // CMS_INTERNAL_ACCESS_TYPE's
   protected static final int CMS_READ_ACCESS = 1;
   protected static final int CMS_CHECK_IF_READ_ACCESS = 2;
   protected static final int CMS_PEEK_ACCESS = 3;
   protected static final int CMS_WRITE_ACCESS = 4;
   protected static final int CMS_WRITE_IF_READ_ACCESS = 5;
   private int access_type = CMS_READ_ACCESS;
   private int remote_status = 0;
   private int message_size = 0;
   private int was_read = 0;
   private int input_bytes_read = 0;
   private boolean reply_header_received = false;
   private boolean write_reply_received = true;
   private boolean input_buffer_ready = false;
   protected int output_data_size = 0;
   public double min_compatible_version = 0.0;
   public boolean confirm_write = false;
   public boolean use_subscription=false;
   public int subscription_id = 0;
   public double subscription_period = 0.0;
   public boolean poll = false;
   public static boolean default_poll_state = false;
   public boolean diag_enabled=false;
   public int connection_number=0;
 
   protected NMLmsg last_msg_read = null;
   /**
    * Set config_debug_on to true to print out additional information
    * while reading the NML Congiguration file.
    */
   static public boolean config_debug_on = false;
   /**
    * Set read_debug_on to true to print out additional information
    * while reading.
    */
   static public boolean read_debug_on = false;
   /**
    * Set write_debug_on to true to print out additional information
    * while writing.
    */
   static public boolean write_debug_on = false;
   private String input_string = "";
     
   /**
    * Name of buffer to connect to. (used in configuration file)
    */
   public String buffer_name = null;
   
   /**
    * Name of this process as used in configuration file.
    */
   public String process_name = null;
   
     
   /**
    * Name/URL the configuration file to read.
    */
   public  String configuration_file = null;
   private int input_buffer_offset = 0;
   private int input_bytes_ready = 0;
   private byte input_buffer[];
   private byte output_buffer[];
 
   private static final int NML_DEFAULT_BUFFER_SIZE=2048;
   private int buffer_size;
   /** 
    * TCP port of NML server.
    */
   public int port = 0;
   /**
    * buffer_number from NML configuration file.
    */
   public int buffer_number = 0;
 
   /**
    * name of the computer the NML server runs on.
    */
   public String host = "";
   protected boolean read_request_sent = false;
   private boolean null_error_reported = false;
   private DataInputStream m_InputStream = null;
   private DataOutputStream m_OutputStream = null;
   private Socket m_Socket = null;
   private NonBlockingDatagramSocket udpSocket = null;
   private InetAddress udpServerAddress = null;
   private ByteArrayOutputStream baOutputStream = null;
   private ByteArrayInputStream baInputStream = null;
   private DatagramPacket udpInputPacket = null;
   private long udpRetryTimeoutMillis = 30;
   private long lastUdpRequestTime = 0;
   private int broadcast_port = 0;
   
   
   /**
    * True when this object is connected to the NML server.
    * All reads and writes will fail when this is false.
    */
   public boolean connected = false;
 
 
   /**
    * This constructs an NMLConnection which will not work until
    * the host and port are set manually or 
    * by reading the NML configuration file with   ReadNMLConfigurationFile().
    * Most users should use the other constructor with several parameters.
    *
    * @see rcs.nml.NMLConnection#NMLConnection(rcs.nml.NMLMessageDictionary, java.lang.String, java.lang.String, java.lang.String)
    * @see rcs.nml.NMLConnection#ReadNMLConfigurationFile(java.lang.String, java.lang.String, java.lang.String)
    *
    */
   public NMLConnection()
   {
     //  System.out.print("\r\nconstructing NMLConnection\r\n");
     try
       {
   input_buffer = new byte[NML_DEFAULT_BUFFER_SIZE];
   output_buffer = new byte[NML_DEFAULT_BUFFER_SIZE];
   buffer_size = NML_DEFAULT_BUFFER_SIZE;
   interrupt_login = false;
   poll = default_poll_state;
   SetFormatConverter(new XDRFormatConverter());
       }
     catch(Exception e)
       {
   e.printStackTrace();
       }
   }
 
   /** 
    * This functions sets the NMLMessageDictionary for this connection.
    * The purpose of the NMLMessageDictionary is to provide a means
    * for the NMLConnection to determine the structure of messages being
    * sent or received using a message type. (An integer passed within
    * all NML messages.)
    *
    * @param new_dict the NMLMessageDictionary for this NMLConnection to use.
    * @see rcs.nml.NMLMessageDictionary
    */
   public void SetMessageDictionary(NMLMessageDictionary new_dict) throws NMLException
   {
     message_dictionary = new_dict;
     if(null != format_converter)
       {
   format_converter.SetMessageDictionary(new_dict);
       }
   }
   
   /**
    * This functions gets the NMLMessageDictionary for this connection.
    *
    * @return the implementation of NMLMessageDictionary used by this 
    * NMLConnection
    *
    * @see rcs.nml.NMLConnection#SetMessageDictionary(rcs.nml.NMLMessageDictionary)
    * @see rcs.nml.NMLMessageDictionary
    */
   public NMLMessageDictionary GetMessageDictionary() throws NMLException
   {
     if(null != format_converter)
       {
   message_dictionary = format_converter.GetMessageDictionary();
       }
     return message_dictionary;
   }
 
   
   /**
    * This functions sets the NMLFormatConverter for this connection.
    * The NMLFormatConverter is resposible for converting each of 
    * the basic data types to some neutral format that can be 
    * used on many different platforms. Most users should either accept
    * the default (XDRFormatConverter) or allow the format to be specified
    * in the NML configuration file rather than calling this function 
    * directly.
    *
    * @param new_fc the NMLFormatConverter for this Connection to use.
    *
    * @see rcs.nml.NMLFormatConverter
    */
   public void SetFormatConverter(NMLFormatConverter new_fc) throws NMLException
   {
     try
       {
   format_converter = (NMLFormatConverterBase) new_fc;
       }
     catch(ClassCastException e)
       {
   System.err.println("This NMLFormatConverter is not a subclass of NMLFormatConverterBase.");
   e.printStackTrace();
   throw new NMLException("This NMLFormatConverter is not a subclass of NMLFormatConverterBase.",buffer_name, configuration_file,e);
       }
     if(null != message_dictionary && null != format_converter)
       {
   format_converter.SetMessageDictionary(message_dictionary);
       }
   }
     
   /**
    * This functions gets the NMLFormatConverter for this connection.
    *
    * @return the NMLFormatConverter for this connection
    *
    * @see rcs.nml.NMLConnection#SetFormatConverter(rcs.nml.NMLFormatConverter)
    */
   public NMLFormatConverter GetFormatConverter() throws NMLException
   {
     return format_converter;
   }
     
 
   /**
    * This constuctor creates a fully functional NML Connection 
    * using the application defined NMLMessageDictionary,  read
    * the NML configuration file,  and connects immediately.
    * This is the constructor most users should use.
    * 
    * @param msg_dict the NMLMessageDictionary for this connection to use (the NMLMessageDictionary allows this Connection to determine the message structure from the message type)
    * @param BufferName the name of the buffer to connect to, (must match one of the buffers in the configuration file.)
    * @param ProcessName the name of the process that will use this connection (must match one of the process names in the configuration file)
    * @param ConfigurationFile the file name or URL of an NML configuration file (URL's should either be complete, or they can be relative to 
    rcs.utils.URL_and_FileLoader.current_directory)
    * @exception  rcs.nml.NMLException 
    *    If the configuration file can not be read, the file is improperly formatted or the buffer or process can
    *    can not be found in it.
    *
    */
   public NMLConnection(NMLMessageDictionary msg_dict, String BufferName, String ProcessName, String ConfigurationFile)  throws NMLException
   {
     this();
     ReadNMLConfigurationFile(BufferName, ProcessName, ConfigurationFile);
     SetMessageDictionary(msg_dict);
   }
 
 
   /**
    * This function reads configuration information from the NML configuration file.
    * 
    * @param BufferName the name of the buffer to connect to, (must match one of the buffers in the configuration file.)
    * @param ProcessName the name of the process that will use this connection (must match one of the process names in the configuration file)
    * @param ConfigurationFile the file name or URL of an NML configuration file (URL's should either be complete, or they can be relative to 
    rcs.utils.URL_and_FileLoader.current_directory)
    * @exception  rcs.nml.NMLException 
    *    If the configuration file can not be read, the file is improperly formatted or the buffer or process can
    *    can not be found in it.
    *
    */
   public void ReadNMLConfigurationFile(String BufferName, String ProcessName, String ConfigurationFile)  throws NMLException
   {
     buffer_name = BufferName;
     process_name = ProcessName;
     configuration_file = ConfigurationFile;
     ReadNMLConfigurationFile();
     connect();
   }
   
   /**
    * Clear any data saved from previously read configuration files.
    */
   public static void ClearStaticData()
   {
     previously_read_nml_configurations = null;
   }
 
   protected void LoadConfigurationFileData(String configuration_file) throws Exception
   {
     NMLConfigInfo config_info = new NMLConfigInfo();
     NMLBufferConfigInfo bufferConfigInfo = null;
     config_info.file_name= configuration_file;
     URL_and_FileLoader loader = null;
     String current_line = null;
     String buffer_name = null;
     String process_name = null;
     loader = new URL_and_FileLoader(configuration_file);
     while(true)
       {
   current_line = loader.readLine();
   if(current_line == null)
     {
       break;
     }
   if(config_debug_on)
     {
       System.out.println(current_line);
     }
   if(current_line.length() < 3)
     {
       continue;
     }
   if(current_line.startsWith("#"))
     {
       continue;
     }
   if(current_line.startsWith("B"))
     {
       StringTokenizer tokenizer = new StringTokenizer(current_line," \t");
       if(null == tokenizer)
         {
     continue;
         }
       int token_number = 0;
       while(tokenizer.hasMoreTokens())
         {
     String token = tokenizer.nextToken();
     if(null == token)
       {
         break;
       }
     if(config_debug_on)
       {
         System.out.println("token "+token_number+" = "+token);
       }
     if(token_number == 1)
       {
         buffer_name = token;
         bufferConfigInfo = (NMLBufferConfigInfo) config_info.buffer_configurations.get(buffer_name);
         if(bufferConfigInfo == null)
           {
       bufferConfigInfo = new NMLBufferConfigInfo();
       bufferConfigInfo.buffer_name = buffer_name;
       bufferConfigInfo.buffer_line = current_line;
       config_info.buffer_configurations.put(buffer_name,bufferConfigInfo);
           }
         else
           {
       if(null == bufferConfigInfo.buffer_line)
         {
           bufferConfigInfo.buffer_line = current_line;
         }
           }
         break;
       }
     token_number++;
         }
     }
   if(current_line.startsWith("P"))
     {
       StringTokenizer tokenizer = new StringTokenizer(current_line," \t");
       if(null == tokenizer)
         {
     continue;
         }
       int token_number = 0;
       while(tokenizer.hasMoreTokens())
         {
     String token = tokenizer.nextToken();
     if(null == token)
       {
         break;
       }
     if(config_debug_on)
       {
         System.out.println("token "+token_number+" = "+token);
       }
     if(token_number == 1)
       {
         process_name = token;
       }
     if(token_number == 2)
       {
         buffer_name = token;
         bufferConfigInfo = (NMLBufferConfigInfo) config_info.buffer_configurations.get(buffer_name);
         if(bufferConfigInfo == null)
           {
       bufferConfigInfo = new NMLBufferConfigInfo();
       bufferConfigInfo.buffer_name = buffer_name;
       config_info.buffer_configurations.put(buffer_name,bufferConfigInfo);
           }
         bufferConfigInfo.process_lines.put(process_name, current_line);
         break;
       }
     token_number++;
         }
     }
       }
     previously_read_nml_configurations.put(configuration_file,config_info);
   }
 
   /** 
    * Read preset configuration file.
    * @exception  rcs.nml.NMLException 
    *    If the configuration file can not be read, the file is improperly formatted or the buffer or process can
    *    can not be found in it.
    */
   public void ReadNMLConfigurationFile() throws NMLException
   {    
     String current_line = null;
     boolean BufferLineFound = false;
     boolean ProcessLineFound = false;
     boolean ConfigurationFileRead = false;
     NMLConfigInfo config_info = null;
     int lines_parsed = 0;
     try
       {
   if(config_debug_on)
     {
       System.out.println("ReadNMLConfigurationFile(): buffer_name = "+buffer_name+", process_name = "+process_name+", configuration_file = "+configuration_file+",");
     }
       
       
   if(null == previously_read_nml_configurations)
     {
       previously_read_nml_configurations = new Hashtable();
     }
   else
     {
       config_info = (NMLConfigInfo) previously_read_nml_configurations.get(configuration_file);
     }
       
   boolean buffer_line_in_hashtable = false;
   if(null == config_info)
     {
       LoadConfigurationFileData(configuration_file);
       config_info = (NMLConfigInfo) previously_read_nml_configurations.get(configuration_file);
     }
   
   NMLBufferConfigInfo buf_info = (NMLBufferConfigInfo) config_info.buffer_configurations.get(buffer_name);
   if(null == buf_info)
     {
       throw new NMLException("Can't find buffer line.", buffer_name, configuration_file);
     }
   String buffer_line = buf_info.buffer_line;
   String process_line = (String) buf_info.process_lines.get(process_name);
 
   data_format_option =NML_XDR_ENCODING_TYPE;
   ConfigurationFileRead = true;
   if(config_debug_on)
     {
       System.out.println("buffer_line="+buffer_line);
       System.out.println("process_line="+process_line);
     }
   if(null != process_line)
     {
       current_line = process_line;
       if(current_line.startsWith("P"))
         {
     StringTokenizer tokenizer = new StringTokenizer(current_line," \t");
     int token_number = 0;
     while(tokenizer.hasMoreTokens() && token_number < 10)
       {
         String token = tokenizer.nextToken();
         if(config_debug_on)
           {
       System.out.println("token "+token_number+" = "+token);
           }
         if(token_number == 1 && !token.equals(process_name))
           {
       break;
           }
         if(token_number == 2 && token.equals(buffer_name))
           {
       ProcessLineFound = true;
           }
         if(token_number == 7 && ProcessLineFound)
           {
       try
         {
           double timeout_d = Double.valueOf(token).doubleValue();
           if(timeout_d > 0.01)
             {
         max_tries = (int) (timeout_d * 100.0);
             }
           else
             {
         max_tries = 1;
         poll = true;
             }
         }
       catch(Exception e)
         {
         }
       if(token.toUpperCase().startsWith("INF"))
         {
           max_tries = -1;
         }
       if(config_debug_on)
         {
           System.out.println("max_tries="+max_tries+", token = "+token);
         }
           }
         if(token_number == 9 && ProcessLineFound)
           {
       connection_number = Integer.valueOf(token).intValue();
       if(config_debug_on)
         {
           System.out.println("connection_number="+connection_number+", token = "+token);
         }
           }
         token_number++;
       }
     int poll_index = current_line.toUpperCase().indexOf("POLL");
     if(poll_index >= 0)
       {
         poll = true;
       }
     int sub_index = current_line.toUpperCase().indexOf("SUB=");
     if(sub_index >= 0)
       {
         poll = true;
         String sub_period_string = current_line.substring(sub_index+4);
         if(config_debug_on)
           {
       System.out.println("sub_period_string ="+sub_period_string );
           }
         StringTokenizer t2 = new StringTokenizer(sub_period_string,"\r\n \t");
         String token2 = t2.nextToken();
         subscription_period = Double.valueOf(token2).doubleValue();
         if(config_debug_on)
           {
       System.out.println("subscription_period ="+subscription_period );
           }
       }
         } // current_line.startsWith("P")
     } // process_line != null
 
   current_line = buffer_line;
   StringTokenizer tokenizer = new StringTokenizer(current_line," \t");
   BufferLine = current_line;
   int token_number = 0;
   while(tokenizer.hasMoreTokens())
     {
       String token = tokenizer.nextToken();
       if(null == token)
         {
     break;
         }
       if(config_debug_on)
         {
     System.out.println("token "+token_number+" = "+token);
         }
       if(token_number == 1)
         {
     if(token.equals(buffer_name))
       {
         BufferLineFound = true;
       }
     else
       {
         break;
       }
         }
       if(token_number == 3)
         {
     host = token;
     if(config_debug_on)
       {
         System.out.println("host = "+host);
       }
         }
       if(token_number == 4)
         {
     try
       {
         buffer_size = (int) (StrToLong.convert(token))*4;
       }
     catch(Exception e)
       {
         System.err.println("Invalid buffer size token ("+token+") in "+configuration_file+" for "+buffer_name);
         System.err.println("Using default buffer size.");
         e.printStackTrace();
         buffer_size = NML_DEFAULT_BUFFER_SIZE;
       }
     if(buffer_size <= 0)
       {
         buffer_size = NML_DEFAULT_BUFFER_SIZE;
       }
     if(config_debug_on)
       {
         System.out.println("buffer_size = "+buffer_size);
       }
         }
       if(token_number == 7)
         {
     try
       {
         buffer_number = (((new Integer(0)).valueOf(token)).intValue());
       }
     catch(Exception e)
       {
         System.err.println("Invalid buffer number token ("+token+") in "+configuration_file+" for "+buffer_name);
         e.printStackTrace();
       }
     if(config_debug_on)
       {
         System.out.println("buffer_number = "+buffer_number);
       }
         }
       int port_index = -1;
       if(-1 != (port_index = token.indexOf("TCP=")))
         {
     protocol_option = NML_TCP_PROTOCOL_TYPE;
     String port_string = token.substring(port_index+4);
     if(config_debug_on)
       {
         System.out.println("Setting port number: port_string = "+port_string);
       }
     try
       {
         port = (((new Integer(0)).valueOf(port_string)).intValue());
       }
     catch(Exception e)
       {
         System.err.println("Invalid port token ("+token+") in "+configuration_file+" for "+buffer_name);
         e.printStackTrace();
       }
     if(config_debug_on)
       {
         System.out.println("port = "+port);
       }
         }
       if(-1 != (port_index = token.indexOf("diag")))
         {
     diag_enabled = true;
         }
       if(-1 != (port_index = token.indexOf("DIAG")))
         {
     diag_enabled = true;
         }
       if(-1 != (port_index = token.indexOf("STCP=")))
         {
     protocol_option = NML_STCP_PROTOCOL_TYPE;
         }
       if(-1 != (port_index = token.indexOf("UDP=")))
         {
     protocol_option = NML_UDP_PROTOCOL_TYPE;
     String port_string = token.substring(port_index+4);
     if(config_debug_on)
       {
         System.out.println("Setting port number: port_string = "+port_string);
       }
     try
       {
         port = (((new Integer(0)).valueOf(port_string)).intValue());
       }
     catch(Exception e)
       {
         System.err.println("Invalid port token ("+token+") in "+configuration_file+" for "+buffer_name);
         e.printStackTrace();
       }
     if(config_debug_on)
       {
         System.out.println("port = "+port);
       }
         }
       if(-1 != (port_index = token.indexOf("ascii")))
         {
     data_format_option = NML_ASCII_ENCODING_TYPE;
         }
       if(-1 != (port_index = token.indexOf("disp")))
         {
     data_format_option = NML_DISP_ENCODING_TYPE;
         }
       int version_index = token.toUpperCase().indexOf("VERSION=");
       if(version_index >= 0)
         {
     try
       {
         String version_string = token.substring(version_index+8);
         min_compatible_version = Double.valueOf(version_string).doubleValue();
       }
     catch(Exception e)
       {
         e.printStackTrace();
       }
         }
       int confirm_write_index = token.toUpperCase().indexOf("CONFIRM_WRITE");
       if(confirm_write_index >= 0)
         {
     confirm_write = true;
         }
       token_number++;
           
     } 
   int broadcast_port_index = current_line.toUpperCase().indexOf("BROADCAST_PORT=");
   if(broadcast_port_index >= 0)
     {
       String broadcast_port_string = current_line.substring(broadcast_port_index+15);
       if(config_debug_on)
         {
     System.out.println("broadcast_port_string ="+broadcast_port_string );
         }
       StringTokenizer t2 = new StringTokenizer(broadcast_port_string,"\r\n \t");
       String token2 = t2.nextToken();
       broadcast_port = Integer.valueOf(token2).intValue();
       if(config_debug_on)
         {
     System.out.println(" ="+broadcast_port);
         }
     }// end while loop parsing tokens on on line  
   if(BufferLineFound)
     {
       if(buffer_size > 0)
         {
     input_buffer = new byte[buffer_size];
     output_buffer = new byte[buffer_size];
         }
       switch(data_format_option)
         {
         case NML_XDR_ENCODING_TYPE:
     SetFormatConverter(new XDRFormatConverter());
     break;
 
         case NML_DISP_ENCODING_TYPE:
     SetFormatConverter(new DISPFormatConverter());
     break;
 
         default:
     System.err.println("Invalid data_format_option.");
     SetFormatConverter(new XDRFormatConverter());
     break;
         }
     }
   else
     {
       if(!ConfigurationFileRead)
         {
     System.err.println("Can not read configuration file "+configuration_file);
         }
       else
         {
     System.err.println("Can not find line for "+buffer_name+" in "+configuration_file);
         }
     }
       }
     catch(NMLException nml_e)
       {
   throw nml_e;
       }
     catch(Exception e)
       {
   System.err.println("Error reading NML configuration file "+configuration_file);
   System.err.println("BufferName = "+buffer_name);
   System.err.println("ProcessName = "+process_name);
   if(null != current_line)
     {
       System.err.println("last line read = "+current_line);
     }
   e.printStackTrace();
   throw new NMLException("Misc. Error",buffer_name,configuration_file,e);
       }
     if(!ConfigurationFileRead)
       {
   throw new NMLException("Can not open configuration file.", buffer_name,configuration_file);
       }
     if(!BufferLineFound)
       {
   throw new NMLException("Can not find buffer line.", buffer_name,configuration_file);
       }
     if(!ProcessLineFound)
       {
   System.err.println("NMLConnection : Can not find process line for "+process_name+" connecting to "+buffer_name+" in "+configuration_file);
       }
   }
 
   protected void finalize()
   {
     disconnect();
   }
 
   
 
   /** 
    * This function connects this NMLConnection object to a server.
    * All attempts to read or write will fail while the object is 
    * disconnected.
    *
    * Since the NMLConnection(NMLMessageDictionary, String, String,String)
    * 
    */
   public int connect() throws NMLException 
   {
     try {
       
       /* 
    FIXME: Netscape classes incompatible with newest JDK java.lang
    try
    {
    if(rcs.utils.BrowserInfo.IsNetscapeFourOrLater())
    {
    try
    {
    netscape.security.PrivilegeManager.enablePrivilege("UniversalConnect");
    }
    catch(Exception e) 
    {
    System.err.println("Netscape denied this applet permission for  connecting to other computers. ("+e.getMessage()+")");
    }
    catch(LinkageError le)
    {
    le.printStackTrace();
    }
    }
    } catch(Exception e)
    {
    }
    */
 
       read_request_sent = false;
       if(port <= 0)
   {
     return -1;
   }
       if(connected)
   {
     disconnect();
   }
       if(config_debug_on)
   {
     System.out.println("");
     System.out.println("Connecting (port="+port+", protocol_option="+protocol_option+", host = "+host+") . . .");
     System.out.println("");
   }
 
       /* ****************************************************************** */
       // javac now gives a warning if this Socket constructor is used,
       // saying the method has been deprecated.
       //m_Socket = new Socket(host,port,true);
       /* ******************************************************************* */
 
       switch(protocol_option)
   {
   case NML_TCP_PROTOCOL_TYPE:
   case NML_STCP_PROTOCOL_TYPE:
     m_Socket = new Socket(host,port);
     m_OutputStream = new DataOutputStream(m_Socket.getOutputStream());
     m_InputStream = new DataInputStream(m_Socket.getInputStream());
     break;
     
   case NML_UDP_PROTOCOL_TYPE:
     if(broadcast_port > 0 && subscription_period > 1E-4 && subscription_period < 600.0)
       {
         udpSocket  = new NonBlockingDatagramSocket(broadcast_port);
       }
     else
       {
         udpSocket  = new NonBlockingDatagramSocket();
       }
     udpServerAddress = InetAddress.getByName(host);
     baOutputStream = new ByteArrayOutputStream();
     baInputStream = new ByteArrayInputStream(input_buffer);
     m_OutputStream = new DataOutputStream(baOutputStream);
     m_InputStream = new DataInputStream(baInputStream);
     udpInputPacket = new DatagramPacket(input_buffer, buffer_size);
     break;
 
   default:
     return -1;
   }
       write_reply_received = true;
       read_request_sent = false;
       input_buffer_ready = false;
       input_bytes_read = 0;
       last_msg_read = null;
       interrupt_login = false;
       message_size = 0;
       serial_number = 0;
 
       /*set = new SocketSet();
   set.port = port;
   set.m_Socket = m_Socket;
   set.m_OutputStream = m_OutputStream;
   set.m_InputStream = m_InputStream;
   set.count = 1;
   m_socketSetHashtable.put(portInteger, set); */
       connected = true;
       if(read_debug_on || write_debug_on || config_debug_on)
   {
     System.out.print("Socket openned to "+host+":"+port+".\r\n");
   }
       if(diag_enabled)
   {
     if(setDiagInfo() < 0)
       {
         throw new NMLException("Couldn't send diagnostics info",buffer_name, configuration_file);
       }
   }
       if(subscription_period > 1E-4 && subscription_period < 600.0)
   {
     if(setSubscriptionPeriod(subscription_period) < 0)
       {
         throw new NMLException("Subscription error",buffer_name, configuration_file);
       }
   }
       
     } 
     catch(NMLException nml_e)
       {
   throw nml_e;
       } 
     catch(Exception e)
       {
   System.err.println("\r\nCan't connect to port "+port+" on host "+host+"\r\n");
   throw new NMLException("Connect error",buffer_name, configuration_file, e);
       } 
     return 0;
   }
 
   /** 
    * Disconnect this object from the NML server. This
    * allows the NML server to shutdown and come back up 
    * while preserving the configuration information in this
   * object.  
   *
   * All reads and writes will fail while the object is disconnected.
   */
  public void disconnect()
  {
    try{
      read_request_sent = false;
      /* SocketSet set;
   Integer portInteger = new Integer(port);
   set = (SocketSet) m_socketSetHashtable.get(portInteger);
   if(null != set)
   {
   set.count--;
   if(set.count <= 0)
   { 
   if(set.m_OutputStream != null)
   {
   set.m_OutputStream.close();
   set.m_OutputStream = null;
   }
   if(set.m_InputStream != null);
   {
   set.m_InputStream.close();
   set.m_InputStream = null;
   }
   if(set.m_Socket != null)
   {
   set.m_Socket.close();
   set.m_Socket = null;
   }
   m_socketSetHashtable.remove(portInteger);
   m_OutputStream = null;
   m_InputStream = null;
   m_Socket = null;
   System.out.print("\r\n Socket "+set.port+" closed. \r\n");
   return;
   }
         
   System.out.print("\r\n Socket "+port+" closed.\r\n");  
   return;
   }
   */
        
      if(protocol_option == NML_UDP_PROTOCOL_TYPE &&
   use_subscription && subscription_id > 0)
  {
    cancelUDPSubscription();
  }

      if(connected)
  {
    if(m_OutputStream != null)
      {
        m_OutputStream.close();
        m_OutputStream = null;
      }
    if(m_InputStream != null);
    {
      m_InputStream.close();
      m_InputStream = null;
    }
    if(m_Socket != null)
      {
        m_Socket.close();
        m_Socket = null;
      }
    if(udpSocket != null)
      {
        udpSocket.close();
        udpSocket = null;
      }
    if(null != baOutputStream)
      {
        baOutputStream.reset();
      }
    baOutputStream = null;
    baInputStream = null;
    if(read_debug_on || write_debug_on || config_debug_on)
      {
        System.out.print("Socket "+port+" closed.\r\n");  
      }
  }
      connected = false;
    }
    catch(Exception e)
      {
  if(null != e.getMessage())
    {
      System.err.print("\r\n"+e.getMessage()+"\r\n");
    }
  e.printStackTrace();
      } 
  }

  /**
   * This function allows the application to gain access to 
   * NML servers with security enabled.
   *
   * @param name the login name of the user running the client program
   * @param passwd the passwd of the user to login as.
   * @exception  rcs.nml.NMLException 
   *    If the login could not be attempted because the connection to the 
   *    NML server failed. (If the passwd is wrong it returns false.)
   *
   * @return true if login was successful
   */
  public boolean login(String name, String passwd)   throws NMLException
  {
    switch(protocol_option)
      {
      case NML_TCP_PROTOCOL_TYPE:
  return loginTCP(name, passwd);  

      case NML_UDP_PROTOCOL_TYPE:
  return true;
      
      case NML_STCP_PROTOCOL_TYPE:
  return true;
  
      default:
  System.err.println("NMLConnection.read(): Invalid protocol_option = "+protocol_option+" -- buffer_name = "+buffer_name);
  return false;
      }  
      
  }

  /** 
   * Read a NMLmsg.
   *
   * @return null if the message in the
   * buffer has already been read by this NMLConnection, otherwise it
   * returns the NMLmsg read.
   *
   * @exception  rcs.nml.NMLException 
   *    The read failed (ussually because of some network error).
   *    
   */
  public NMLmsg read()  throws NMLException
  {
    if(read_debug_on)
      {
  System.out.println("NMLConnection.peek() called for buffer ("+buffer_name+")");
      }
    switch(protocol_option)
      {
      case NML_TCP_PROTOCOL_TYPE:
  return readTCP();  

      case NML_UDP_PROTOCOL_TYPE:
  return readUDP();
      
      case NML_STCP_PROTOCOL_TYPE:
  if(null == format_converter)
    {  
      return null;
    }
  NMLmsg temp = format_converter.convertStringToMsg(readSTCPDataString());
  if(format_converter.error_in_update)
    {
      throw new NMLException("Format Error",buffer_name, configuration_file);
    }
  return temp;

      default:
  System.err.println("NMLConnection.read(): Invalid protocol_option = "+protocol_option+" -- buffer_name = "+buffer_name);
  return null;
      }  
    //    return null;
  }
   
  public int setDiagInfo()
  {
    switch(protocol_option)
      {
      case NML_TCP_PROTOCOL_TYPE:
  return setTCPDiagInfo();  

      default:
  break;
      }
    return -1;
  }

  protected int setTCPDiagInfo()
  {
    try
      {
  if(null == m_OutputStream || null == m_InputStream)
    {
      return -1;
    }
  m_OutputStream.writeInt(serial_number);
  serial_number++;
  request_type = REMOTE_CMS_SET_DIAG_INFO_REQUEST_TYPE;
  m_OutputStream.writeInt(request_type);
  m_OutputStream.writeInt(buffer_number);
  int pad=0;
  m_OutputStream.writeInt(pad);
  m_OutputStream.writeInt(pad);
  byte bname[] = new byte[32];
  String temp_process_name = process_name;
  if(temp_process_name.length() > 15)
    {
      temp_process_name = temp_process_name.substring(0,15);
    }
  m_OutputStream.writeBytes(temp_process_name);
  
  int extra_bytes = 16-temp_process_name.length();
  if(config_debug_on)
    {
      System.out.println("setTCPDiagInfo(): temp_process_name="+temp_process_name+", extra_bytes="+extra_bytes);
    }
  if(extra_bytes > 0)
    {
      m_OutputStream.write(bname,0,extra_bytes);
    }
  String host_sysinfo = "";
  try
    {
      InetAddress local_host = InetAddress.getLocalHost();
      if(null != local_host)
        {
    String host_name = local_host.getHostName();
    if(null != host_name)
      {
        host_sysinfo += host_name+", ";
      }
        }
    }
  catch(Exception e)
    {
      e.printStackTrace();
    }
  try
    {
      String java_version = System.getProperty("java.version");
      if(null != java_version)
        {
    if(Character.isDigit(java_version.charAt(0)))
      {
        java_version = "Java "+java_version;
      }
    host_sysinfo += java_version+", ";
        }
      String os_name = System.getProperty("os.name");
      if(null != os_name)
        {
    host_sysinfo += os_name+" ";
        }
      String os_version = System.getProperty("os.version");
      if(null != os_version)
        {
    host_sysinfo += os_version+", ";
        }
      String os_arch = System.getProperty("os.arch");
      if(null != os_arch)
        {
    host_sysinfo += os_arch;
        }
    }
  catch(Exception e)
  {
    e.printStackTrace();
  }
  if(host_sysinfo.length() > 31)
    {
      host_sysinfo = host_sysinfo.substring(0,31);
    }
  m_OutputStream.writeBytes(host_sysinfo);
  if(host_sysinfo.length() < 32)
    {
      m_OutputStream.write(bname,host_sysinfo.length(),32-host_sysinfo.length());
    }

  int pid = 0;
  m_OutputStream.writeInt(pid);
  m_OutputStream.writeInt(connection_number);
  double rcslib_ver = 0.0;
  try 
    {
      rcslib_ver = Double.valueOf(rcs.RCS_VERSION.version_string).doubleValue();
    }
  catch(Exception e)
    {
      e.printStackTrace();
    }
  m_OutputStream.writeDouble(rcslib_ver);
  int reverse_flag = 0x01020304;
  m_OutputStream.writeInt(reverse_flag);
  m_OutputStream.flush();
  return 0;
      }
    catch(Exception e)
      {
  e.printStackTrace();
  return -1;
      }
  }


  public int setSubscriptionPeriod( double period)
  {

    switch(protocol_option)
      {
      case NML_TCP_PROTOCOL_TYPE:
  return setTCPSubscriptionPeriod(period);  

      case NML_UDP_PROTOCOL_TYPE:
  return setUDPSubscriptionPeriod(period);
  
      default:
  System.err.println("No subscriptions allowed for protocol_option "+protocol_option);
  break;
      }
    return -1;
  }

  protected int setUDPSubscriptionPeriod(double period)
  {
    if(min_compatible_version < 3.13 && min_compatible_version >  1e-6)
      {
  return 0;
      }
    boolean subscription_set = false;
    int subscription_interval_millis = (int) (period*1000);
    long start_set_subscription_interval = System.currentTimeMillis();
    reply_header_received = false;
    try
      {
  while(!subscription_set)
    {
      if(!udpSocket.ready((int) udpRetryTimeoutMillis))
        {
    input_buffer_ready = false;
    m_OutputStream.flush();
    baOutputStream.reset();
    request_type = REMOTE_CMS_SET_SUBSCRIPTION_REQUEST_TYPE;
    m_OutputStream.writeInt(request_type);
    m_OutputStream.writeInt(buffer_number);
    if(reply_header_received)
      {
        serial_number++;
      }
    m_OutputStream.writeInt(serial_number);
    m_OutputStream.writeInt(CMS_POLLED_SUBSCRIPTION);
    m_OutputStream.writeInt(subscription_interval_millis);
    m_OutputStream.writeInt(last_id_read);
    read_request_sent = true;
    reply_header_received = false;
    if(read_debug_on)
      {
        System.out.println("UDP setSubscription request sent.");
        System.out.println("serial_number = "+serial_number+", request_type = "+request_type+", buffer_number = "+buffer_number);
        System.out.println("access_type = "+access_type+", last_id_read = "+last_id_read+" -- buffer_name = "+buffer_name);
        System.out.println("lastUdpRequestTime = "+lastUdpRequestTime);
      }   
    m_OutputStream.flush();
    byte ba[] = baOutputStream.toByteArray();
    int request_length = 24;
    if(ba.length < request_length)
      {
        throw new NMLException("Insufficient output byte array size.",buffer_name, configuration_file);
      }
    DatagramPacket dp = new DatagramPacket(ba,request_length,udpServerAddress, port);
    udpSocket.send(dp);
    if(null == udpSocket.currentPacket)
      {
        udpInputPacket = new DatagramPacket(input_buffer, buffer_size);
        udpSocket.receive(udpInputPacket);
      }
    lastUdpRequestTime = System.currentTimeMillis();
        }
      else
        {
    baInputStream.reset();
    int returned_serial_number = m_InputStream.readInt();
    if(read_debug_on)
      {
        System.out.println("UDP setSubscription reply received.");
        System.out.println("returned_serial_number = "+returned_serial_number);
      }
    if(returned_serial_number != serial_number)
      {
        serial_number_repeats++;
        if(read_debug_on)
          {
      System.out.println("serial_number="+serial_number+", returned_serial_number="+returned_serial_number+",serial_number_repeats ="+serial_number_repeats);
          }
        udpInputPacket = new DatagramPacket(input_buffer, buffer_size);
        udpSocket.receive(udpInputPacket);
        continue;
      }
    reply_header_received = true;
    remote_status = m_InputStream.readInt();
    subscription_id =  m_InputStream.readInt();
    if(read_debug_on)
      {
        System.out.println("remote_status = "+remote_status+", buffer_number = "+buffer_number);
        System.out.println(" -- buffer_name = "+buffer_name);
      }   
    udpSocket.lastPacket = null;
    subscription_set = true;
    use_subscription = true;
    continue;
        }
    }
  Thread.sleep(10);
  if(start_set_subscription_interval - System.currentTimeMillis() > 3000)
    {
      System.err.println("Timed out trying to setup the subscription.");
      return -1;
    }
      }
    catch(Exception e)
      {
  e.printStackTrace();
  return -1;
      }
    return 0;
  }

 protected int cancelUDPSubscription()
  {
    if(min_compatible_version < 3.13 && min_compatible_version >  1e-6)
      {
  return 0;
      }
    boolean subscription_set = false;
    long start_set_subscription_interval = System.currentTimeMillis();
    reply_header_received = false;
    try
      {
  while(!subscription_set)
    {
      if(!udpSocket.ready((int) udpRetryTimeoutMillis))
        {
    input_buffer_ready = false;
    m_OutputStream.flush();
    baOutputStream.reset();
    request_type = REMOTE_CMS_CANCEL_SUBSCRIPTION_REQUEST_TYPE;
    m_OutputStream.writeInt(request_type);
    m_OutputStream.writeInt(buffer_number);
    if(reply_header_received)
      {
        serial_number++;
      }
    m_OutputStream.writeInt(serial_number);
    m_OutputStream.writeInt(subscription_id);
    m_OutputStream.writeInt(0);
    m_OutputStream.writeInt(0);
    read_request_sent = true;
    reply_header_received = <