home *** CD-ROM | disk | FTP | other *** search
/ Late Night VRML 2.0 with Java CD-ROM / code.zip / Ch19 / registry / RegistryMessage.java < prev    next >
Encoding:
Java Source  |  1997-02-16  |  10.3 KB  |  496 lines

  1. // Simple Multiuser Server
  2. // (c) Copyright Justin Couch   justin@vlc.com.au
  3. // The Virtual Light Company 1996
  4. //
  5. // From Chapter 20: Late Night VRML 2.0 and java
  6. //
  7. // This is the Registry message handler class. The real work of parsing an
  8. // individual message is done here and sending out messages to the other
  9. // users based on whatever filtering parameters are needed.
  10.  
  11. package registry;
  12.  
  13. import java.net.*;
  14. import java.io.*;
  15. import java.util.*;
  16. import registry.RegistryServer;
  17.  
  18. class RegistryMessage extends Thread
  19. {
  20.     private static int    msg_number = 0;
  21.     private boolean debug = false;
  22.  
  23.     private int sequence_num;
  24.     private int text_id;
  25.     private int msg_type;
  26.     private int msg_length;
  27.     private String msg;
  28.     private RegistryServer _server;
  29.     private Socket _socket;
  30.     private String nickname;
  31.     private String identity;
  32.  
  33.     private DataInputStream    in;
  34.     private PrintStream    out;
  35.  
  36.     private Vector    entity_list;
  37.  
  38.     // all that gets done here is to copy over the packet into the internal
  39.     // reference. We leave all the real work to the run method because that
  40.     // allows java's thread handling system to share the workload much better
  41.     // If we didn't then the whole chat Server thread would block until we have
  42.     // dealt with the response here.
  43.     public RegistryMessage(Socket s, ThreadGroup tg, RegistryServer server, boolean debug)
  44.     {
  45.         super(tg, "Registry Connection " + msg_number++);
  46.  
  47.         setPriority(5);
  48.  
  49.         this.debug = debug;
  50.         _socket = s;
  51.         _server = server;
  52.  
  53.         System.out.print("New connection from ");
  54.         System.out.println(_socket.getInetAddress().getHostName());
  55.  
  56.         entity_list = new Vector(10, 5);
  57.  
  58.         nickname = "Guest";
  59.         identity = "Guest";
  60.     }
  61.  
  62.     // analyse the packet and send out the text to the other users.
  63.     public void run()
  64.     {
  65.         String    input = null;
  66.  
  67.         try
  68.         {
  69.             in  = new DataInputStream(_socket.getInputStream());
  70.             out = new PrintStream(_socket.getOutputStream());
  71.         }
  72.         catch(IOException e)
  73.         {
  74.             System.err.println("Registry Server: error getting I/O streams " + e.getMessage());
  75.         }
  76.  
  77.         while(true)
  78.         {
  79.             try
  80.             {
  81.                 input = in.readLine();
  82.                 if((input != null) && (!processCommand(input)))
  83.                     break;
  84.  
  85.                 Thread.yield();
  86.             }
  87.             catch(IOException e)
  88.             {
  89.                 System.err.println("Registry Message error " + e.getMessage());
  90.             }
  91.  
  92.         }
  93.  
  94.         try
  95.         {
  96.             in.close();
  97.             out.close();
  98.             _socket.close();
  99.         }
  100.         catch(IOException e)
  101.         {
  102.             System.err.println("Registry Message error " + e.getMessage());
  103.         }
  104.  
  105.         System.out.print("closing registry connection from ");
  106.         System.out.println(_socket.getInetAddress().getHostName());
  107.     }
  108.  
  109.     private boolean processCommand(String command)
  110.         throws IOException
  111.     {
  112.         StringTokenizer    strtok;
  113.         String    token;
  114.         int    entid;
  115.         int    i;
  116.         boolean    set_ok;
  117.  
  118.         if(debug)
  119.             System.out.println("command recieved: " + command);
  120.  
  121.         strtok = new StringTokenizer(command);
  122.  
  123.         try
  124.         {
  125.             token = strtok.nextToken();
  126.         }
  127.         catch(NoSuchElementException e1)
  128.         {
  129.             out.println("REFUSED invalid character in command");
  130.             return true;
  131.         }
  132.  
  133.         if(token.equals("HELLO"))
  134.             out.println("WELCOME");
  135.         else if(token.equals("LIST"))
  136.         {
  137.             _server.printList(out);
  138.             out.println(".");
  139.         }
  140.         else if(token.equals("GETINFO"))
  141.         {
  142.             try
  143.             {
  144.                 entid = Integer.parseInt(strtok.nextToken());
  145.             }
  146.             catch(NoSuchElementException e1)
  147.             {
  148.                 out.println("REFUSED incomplete command");
  149.                 return true;
  150.             }
  151.             catch(NumberFormatException e2)
  152.             {
  153.                 out.println("REFUSED incorrect entity ID format");
  154.                 return true;
  155.             }
  156.  
  157.             _server.printInfo(entid, out);
  158.             out.println(".");
  159.         }
  160.         else if(token.equals("GETENTITY"))
  161.         {
  162.             try
  163.             {
  164.                 entid = Integer.parseInt(strtok.nextToken());
  165.             }
  166.             catch(NoSuchElementException e1)
  167.             {
  168.                 out.println("REFUSED no entity ID given");
  169.                 return true;
  170.             }
  171.             catch(NumberFormatException e2)
  172.             {
  173.                 out.println("REFUSED incorrect entity ID format");
  174.                 return true;
  175.             }
  176.  
  177.             _server.printEntityInfo(entid, out, nickname);
  178.             out.println(".");
  179.         }
  180.         else if(token.equals("INFO"))
  181.         {
  182.             try
  183.             {
  184.                 entid = Integer.parseInt(strtok.nextToken());
  185.             }
  186.             catch(NoSuchElementException e1)
  187.             {
  188.                 out.println("REFUSED no entity ID given");
  189.                 return true;
  190.             }
  191.             catch(NumberFormatException e2)
  192.             {
  193.                 out.println("REFUSED incorrect entity ID format");
  194.                 return true;
  195.             }
  196.  
  197.             // check the ownership of the object
  198.             if(!_server.isOwner(entid, identity))
  199.             {
  200.                 out.println("REFUSED not owner");
  201.                 return true;
  202.             }
  203.  
  204.             // ok, so we own it, lets continue.
  205.             out.println("OKAY");
  206.  
  207.             Vector info_list = new Vector(5,2);
  208.             String tmp;
  209.  
  210.             // first read in all the data to a buffer.
  211.             while(true)
  212.             {
  213.                 tmp = in.readLine();
  214.                 if(tmp.equals("."))
  215.                     break;
  216.                 info_list.addElement(tmp);
  217.             }
  218.     
  219.             // now copy it over to a string array.    
  220.             String[] str_list = new String[info_list.size()];
  221.  
  222.             for(i = 0; i < info_list.size(); i++)
  223.                 str_list[i] = (String)info_list.elementAt(i);
  224.  
  225.             _server.set_info(entid, identity, str_list);
  226.         }
  227.         else if(token.equals("GOODBYE"))
  228.         {
  229.             // first, clean up all the entities that belong to this
  230.             // client. Just loop and instruct the server to delete
  231.             // every one of them. 
  232.             for(i = 0; i < entity_list.size(); i++)
  233.                 _server.delete(
  234.                     (int)((Integer)entity_list.elementAt(i)).intValue(),
  235.                      identity);
  236.             entity_list = null;    
  237.  
  238.             return false;
  239.         }
  240.         else if(token.equals("ALLOC"))
  241.         {
  242.             String name;
  243.             try
  244.             {
  245.                 name = strtok.nextToken();
  246.             }
  247.             catch(NoSuchElementException e1)
  248.             {
  249.                 out.println("REFUSED entity cname not given");
  250.                 return true;
  251.             }
  252.  
  253.             if(identity.equals("Guest"))
  254.             {
  255.                 out.println("REFUSED No ident set");
  256.                 return true;
  257.             }
  258.  
  259.             // now that we have passed muster we can allocate something
  260.             entid = _server.allocate(name, identity);
  261.  
  262.             switch(entid)
  263.             {
  264.                 case -1:
  265.                     out.println("REFUSED Entity cname in use");
  266.                     break;
  267.                 case -2:
  268.                     out.println("REFUSED User not identified");
  269.                     break;
  270.                 default:
  271.                     out.println(entid);
  272.                     entity_list.addElement(new Integer(entid));
  273.             }
  274.         }
  275.         else if(token.equals("URL"))
  276.         {
  277.             String    url;
  278.  
  279.             try
  280.             {
  281.                 entid = Integer.parseInt(strtok.nextToken());
  282.                 url = strtok.nextToken();
  283.             }
  284.             catch(NoSuchElementException e1)
  285.             {
  286.                 out.println("REFUSED incomplete command");
  287.                 return true;
  288.             }
  289.             catch(NumberFormatException e2)
  290.             {
  291.                 out.println("REFUSED incorrect entity ID format");
  292.                 return true;
  293.             }
  294.  
  295.             if(_server.set_URL(entid, identity, url))
  296.                 out.println("OKAY");
  297.             else
  298.                 out.println("REFUSED no reason available");
  299.         }
  300.         else if(token.equals("NICKNAME"))
  301.         {
  302.             try
  303.             {
  304.                 entid = Integer.parseInt(strtok.nextToken());
  305.                 nickname = strtok.nextToken();
  306.             }
  307.             catch(NoSuchElementException e1)
  308.             {
  309.                 out.println("REFUSED incomplete command");
  310.                 return true;
  311.             }
  312.             catch(NumberFormatException e2)
  313.             {
  314.                 out.println("REFUSED number format incorrect");
  315.                 return true;
  316.             }
  317.  
  318.             if(_server.set_nickname(entid, identity, nickname))
  319.                 out.println("OKAY");
  320.             else
  321.                 out.println("REFUSED no reason available");
  322.         }
  323.         else if(token.equals("RELEASE"))
  324.         {
  325.             try
  326.             {
  327.                 entid = Integer.parseInt(strtok.nextToken());
  328.             }
  329.             catch(NoSuchElementException e1)
  330.             {
  331.                 out.println("REFUSED no entity ID given");
  332.                 return true;
  333.             }
  334.             catch(NumberFormatException e2)
  335.             {
  336.                 out.println("REFUSED incorrect entity ID format");
  337.                 return true;
  338.             }
  339.  
  340.             if(_server.delete(entid, identity))
  341.                 out.println("OKAY");
  342.             else
  343.                 out.println("REFUSED no reason available");
  344.         }
  345.         else if(token.equals("PERSISTENT"))
  346.         {
  347.             String persist;
  348.  
  349.             try
  350.             {
  351.                 entid = Integer.parseInt(strtok.nextToken());
  352.                 persist = strtok.nextToken();
  353.             }
  354.             catch(NoSuchElementException e1)
  355.             {
  356.                 out.println("REFUSED incomplete command");
  357.                 return true;
  358.             }
  359.             catch(NumberFormatException e2)
  360.             {
  361.                 out.println("REFUSED incorrect entity ID format");
  362.                 return true;
  363.             }
  364.  
  365.             if(persist.equals("true"))
  366.                 set_ok = _server.set_persistent(entid, identity, true);
  367.             else if(persist.equals("false"))
  368.                 set_ok = _server.set_persistent(entid, identity, false);
  369.             else    // barf
  370.             {
  371.                 out.println("REFUSED Incorrect format");
  372.                 return true;
  373.             }
  374.  
  375.             if(set_ok)
  376.                 out.println("OKAY");
  377.             else
  378.                 out.println("REFUSED no reason available");
  379.  
  380.         }
  381.         else if(token.equals("AVATAR"))
  382.         {
  383.             String av;
  384.  
  385.             try
  386.             {
  387.                 entid = Integer.parseInt(strtok.nextToken());
  388.                 av = strtok.nextToken();
  389.             }
  390.             catch(NoSuchElementException e1)
  391.             {
  392.                 out.println("REFUSED incomplete command");
  393.                 return true;
  394.             }
  395.             catch(NumberFormatException e2)
  396.             {
  397.                 out.println("REFUSED incorrect entity ID format");
  398.                 return true;
  399.             }
  400.                         
  401.             if(av.equals("true"))
  402.                 set_ok = _server.set_avatar(entid, identity, true);
  403.             else if(av.equals("false"))
  404.                 set_ok = _server.set_avatar(entid, identity, false);
  405.             else    // barf
  406.             {
  407.                 out.println("REFUSED Incorrect format");
  408.                 return true;
  409.             }
  410.  
  411.             if(set_ok)
  412.                 out.println("OKAY");
  413.             else
  414.                 out.println("REFUSED no reason available");
  415.  
  416.         }
  417.         else if(token.equals("IDENT"))
  418.         {
  419.             String pass;
  420.             String tmp_id = identity;
  421.  
  422.             try
  423.             {
  424.                 tmp_id = strtok.nextToken();
  425.                 pass = strtok.nextToken();
  426.             }
  427.             catch(NoSuchElementException e1)
  428.             {
  429.                 out.println("REFUSED incomplete command");
  430.                 // just in case something screwed up we don't
  431.                 // want to loose their current IDENT
  432.                 return true;
  433.             }
  434.             
  435.             // now verify with the server
  436.             if(_server.verifyIdent(tmp_id, pass))
  437.             {
  438.                 identity = tmp_id;
  439.                 out.println("OKAY");
  440.             }
  441.             else
  442.                 out.println("REFUSED incorrect username or password");
  443.         }
  444.         else if(token.equals("CHOWN"))
  445.         {
  446.             String new_name;
  447.  
  448.             try
  449.             {
  450.                 entid = Integer.parseInt(strtok.nextToken());
  451.                 new_name = strtok.nextToken();
  452.             }
  453.             catch(NoSuchElementException e1)
  454.             {
  455.                 out.println("REFUSED incomplete command");
  456.                 return true;
  457.             }
  458.             catch(NumberFormatException e2)
  459.             {
  460.                 out.println("REFUSED incorrect entity ID format");
  461.                 return true;
  462.             }
  463.  
  464.             if(_server.chown(entid, identity, new_name))
  465.                 out.println("OKAY");
  466.             else
  467.                 out.println("REFUSED not owner");
  468.         }
  469.         else if(token.equals("LISTNEW"))
  470.         {
  471.             int    time;
  472.             try
  473.             {
  474.                 time = Integer.parseInt(strtok.nextToken());
  475.             }
  476.             catch(NoSuchElementException e1)
  477.             {
  478.                 out.println("REFUSED command requires a time to be specified");
  479.                 return true;
  480.             }
  481.             catch(NumberFormatException e2)
  482.             {
  483.                 out.println("REFUSED incorrect time format");
  484.                 return true;
  485.             }
  486.  
  487.             _server.listNew(time, out);
  488.             out.println(".");
  489.         }
  490.         else
  491.             out.println("OKAY");
  492.  
  493.         return true;
  494.     }
  495. }
  496.