Initial commit

1 files changed, 768 insertions, 0 deletions

diff --git a/NET/worlds/network/Galaxy.java b/NET/worlds/network/Galaxy.java
new file mode 100644
index 0000000..5d00115
--- /dev/null
+++ b/NET/worlds/network/Galaxy.java
@@ -0,0 +1,768 @@
+package NET.worlds.network;
+
+import NET.worlds.console.Console;
+import NET.worlds.console.DialogReceiver;
+import NET.worlds.console.InternetConnectionDialog;
+import NET.worlds.console.LoginWizard;
+import NET.worlds.core.IniFile;
+import java.util.Enumeration;
+import java.util.Hashtable;
+
+public class Galaxy implements DialogReceiver {
+   private static Hashtable<String, Galaxy> _galaxyHash = new Hashtable<String, Galaxy>();
+   private static boolean _globalUserAllowsOnline = true;
+   private boolean _localUserAllowsOnline = true;
+   private ServerURL _serverURL;
+   private int _serverType;
+   private int _worldCount;
+   private Hashtable<String, NetworkObject> _nFlongID;
+   private ServerTracker _serverTracker;
+   private RoomMgr _roomTable;
+   private String _channel;
+   private String _username;
+   private String _usernameU;
+   private String _password;
+   private String _serial;
+   private String _newUsername;
+   private String _newPassword;
+   private int _mode;
+   private NetworkMulti _consoleList;
+   private int _retriesLeft = 2;
+   private InternetConnectionDialog _icd;
+   private LoginWizard _wizard;
+   private Object _wizardMutex = new Object();
+   private static int _debugLevel = IniFile.gamma().getIniInt("netdebug", 0);
+   private WaitList _waiters;
+   private boolean _relogin;
+   private boolean _onlineEnabled;
+   private boolean _online;
+   private boolean sentFriendsList;
+   private int protocolLevel;
+
+   static {
+      if (_debugLevel > 0) {
+         System.out.println("NETWORK DEBUGGING LEVEL = " + _debugLevel);
+      }
+   }
+
+   private Galaxy(ServerURL serverURL) {
+      this._serverURL = serverURL;
+      this._serverType = 0;
+      this._nFlongID = new Hashtable<String, NetworkObject>();
+      this._worldCount = 0;
+      this._channel = "";
+      this._serverTracker = new ServerTracker(this);
+      this._waiters = new WaitList(this);
+      this._username = "";
+      this._usernameU = "";
+      this._consoleList = new NetworkMulti(this._username, this);
+      this.regObject(this._username, this._consoleList);
+      if (serverURL == null) {
+         this._onlineEnabled = false;
+         this._online = false;
+      } else {
+         this._onlineEnabled = true;
+         this._online = false;
+      }
+
+      this.setOnlineState(this._onlineEnabled, this._online);
+   }
+
+   private synchronized void incWorldCount() {
+      this._worldCount++;
+   }
+
+   public synchronized void decWorldCount() {
+      this._worldCount--;
+
+      assert this._worldCount >= 0;
+
+      if (this._worldCount <= 0) {
+         if (this._serverURL != null) {
+            _galaxyHash.remove(this._serverURL.getHost());
+         }
+
+         this._waiters.clear();
+         this._serverTracker = new ServerTracker(this);
+      }
+   }
+
+   public static Galaxy getGalaxy(String strServerURL) throws InvalidServerURLException {
+      ServerURL serverURL = new ServerURL(strServerURL);
+      String serverHost = serverURL.getHost();
+      Galaxy reqGal = _galaxyHash.get(serverHost);
+      if (reqGal == null) {
+         reqGal = new Galaxy(serverURL);
+         _galaxyHash.put(serverHost, reqGal);
+      }
+
+      assert reqGal != null;
+
+      reqGal.incWorldCount();
+      return reqGal;
+   }
+
+   public static Galaxy getGalaxy(URL serverURL) throws InvalidServerURLException {
+      return getGalaxy(serverURL.unalias());
+   }
+
+   public static Galaxy getAnonGalaxy() {
+      Galaxy reqGal = new Galaxy(null);
+      reqGal.incWorldCount();
+      return reqGal;
+   }
+
+   public boolean isAnonymous() {
+      return this._serverURL == null;
+   }
+
+   public WorldServer getServer(String StrServerURL) throws InvalidServerURLException {
+      if (this._serverURL == null) {
+         return null;
+      } else if (!_globalUserAllowsOnline) {
+         return null;
+      } else if (!this._localUserAllowsOnline) {
+         return null;
+      } else if (this._icd != null) {
+         return null;
+      } else {
+         synchronized (this._wizardMutex) {
+            if (this._wizard != null && !this._wizard.waitingForConnection() && !this._wizard.safeToQueryServer()) {
+               return null;
+            }
+         }
+
+         return this._serverTracker.getServer(StrServerURL);
+      }
+   }
+
+   public WorldServer getServer(URL serverURL) throws InvalidServerURLException {
+      return this.getServer(serverURL.unalias());
+   }
+
+   public boolean isActive() {
+      return this._serverTracker.isActive();
+   }
+
+   protected boolean addPendingServer(WorldServer ws) {
+      assert ws != null;
+
+      boolean firstOnline = this._serverTracker.addPendingServer(ws);
+      if (firstOnline) {
+         this._retriesLeft = 2;
+         this.setOnlineState(true, true);
+         synchronized (this) {
+            this._roomTable = new RoomMgr();
+         }
+      }
+
+      return firstOnline;
+   }
+
+   void addActiveServer(WorldServer ws) {
+      boolean firstActive = this._serverTracker.addActiveServer(ws);
+      if (firstActive) {
+         this._waiters.notify(true);
+         if (this._wizard != null) {
+            System.out.println("LWDB: calling " + this._wizard + " setConnected");
+            this._wizard.setConnected();
+         }
+      }
+   }
+
+   boolean addClosingServer(WorldServer ws) {
+      assert this._nFlongID != null;
+
+      assert ws != null;
+
+      boolean lastActive = this._serverTracker.addClosingServer(ws);
+      if (lastActive) {
+         this.forceDisconnect();
+      }
+
+      return lastActive;
+   }
+
+   void markClosedServer(WorldServer ws) {
+      this._serverTracker.markClosedServer(ws);
+   }
+
+   void killServer(WorldServer serv) {
+      this._serverTracker.killServer(serv);
+   }
+
+   protected void noteServerDeath(VarErrorException lastError) {
+      synchronized (this._serverTracker) {
+         if (!this._serverTracker.isActive()) {
+            synchronized (this) {
+               this._roomTable = null;
+            }
+
+            this.setOnlineState(false, false);
+            if (this.getProtocol() == 0) {
+               this._icd = new InternetConnectionDialog(this, lastError);
+            } else {
+               if (lastError != null && (!lastError.getStatusFlag() || this._relogin)) {
+                  _globalUserAllowsOnline = true;
+                  boolean tryBackup = false;
+                  synchronized (this._serverTracker) {
+                     Enumeration<WorldServer> list = this._serverTracker.getAllServers();
+
+                     while (list.hasMoreElements()) {
+                        WorldServer ws = list.nextElement();
+                        if (ws.useBackupServer()) {
+                           tryBackup = true;
+                        }
+                     }
+                  }
+
+                  if (tryBackup) {
+                     System.out.println("Server death noted, trying alternate.");
+                     this.setChatname(this._username);
+                     this.goOnline();
+                  } else {
+                     System.out.println("Server death noted, no more alternates. How sad.");
+                     if (this._retriesLeft <= 0 || !this._relogin && !lastError.getRetryFlag()) {
+                        this.setChatname("");
+                        this.killZombies();
+                        if (this._wizard == null) {
+                           this._wizard = new LoginWizard(this, this.getIniSection(), lastError.getMsg());
+                           System.out.println("LWDB: brought up " + this._wizard + " error " + lastError.getMsg());
+                        } else {
+                           System.out.println("LWDB: reporting error " + lastError.getMsg() + " to " + this._wizard);
+                           this._wizard.loginError(lastError.getMsg());
+                        }
+                     } else {
+                        System.out.println(this + ": doing retry on " + lastError);
+                        this._retriesLeft = this._retriesLeft - lastError.getRetryCount();
+                        this.setChatname(this._username);
+                        this.goOnline();
+                     }
+                  }
+
+                  this._relogin = false;
+               } else {
+                  this.setOnlineState(true, false);
+               }
+            }
+         }
+      }
+   }
+
+   public void waitForConnection(ConnectionWaiter cw) {
+      this._waiters.addWaiter(cw);
+   }
+
+   public void goOffline(boolean relogin) {
+      this._relogin = relogin;
+      if (!this._serverTracker.isActive()) {
+         this._relogin = false;
+      }
+
+      synchronized (this._serverTracker) {
+         Enumeration<WorldServer> list = this._serverTracker.getAllServers();
+
+         while (list.hasMoreElements()) {
+            WorldServer ws = list.nextElement();
+            ws.forceOffline();
+         }
+      }
+   }
+
+   private void killZombies() {
+      synchronized (this._serverTracker) {
+         Enumeration<WorldServer> list = this._serverTracker.getAllServers();
+
+         while (list.hasMoreElements()) {
+            list.nextElement().killZombies();
+         }
+      }
+   }
+
+   void goOnline() {
+      synchronized (this._serverTracker) {
+         Enumeration<WorldServer> list = this._serverTracker.getAllServers();
+
+         while (list.hasMoreElements()) {
+            WorldServer ws = list.nextElement();
+            ws.goOnline();
+         }
+      }
+
+      this.reacquireServer(null);
+   }
+
+   public static synchronized void forceOffline(boolean relogin) {
+      if (_globalUserAllowsOnline) {
+         _globalUserAllowsOnline = false;
+         synchronized (_galaxyHash) {
+            Enumeration<Galaxy> list = _galaxyHash.elements();
+
+            while (list.hasMoreElements()) {
+               Galaxy g = list.nextElement();
+               g.goOffline(relogin);
+            }
+         }
+      }
+   }
+
+   public void localForceOnline() {
+      _globalUserAllowsOnline = true;
+      this._relogin = false;
+      if (!this.isActive()) {
+         this.setOnlineState(false, false);
+         this._localUserAllowsOnline = true;
+         if (this.getGalaxyType() != 0) {
+            this.setChatname("");
+            this._wizard = new LoginWizard(this, this.getIniSection());
+            System.out.println("LWDB: brought up " + this._wizard + " in localForceOnline");
+         } else {
+            this.reacquireServer(null);
+         }
+      }
+   }
+
+   public static int getDebugLevel() {
+      return _debugLevel;
+   }
+
+   public static void printDebugging() {
+      System.out.println("----GALAXY DEBUGGING-------");
+      Enumeration<Galaxy> e = _galaxyHash.elements();
+
+      while (e.hasMoreElements()) {
+         Galaxy g = e.nextElement();
+         System.out.println(g + " : ");
+         System.out.println(g._serverTracker);
+      }
+
+      System.out.println("---------------------------");
+   }
+
+   public String getChannel() {
+      return this._channel;
+   }
+
+   void setChannel(String channel) {
+      this.changeChannel(channel, false);
+   }
+
+   public void changeChannel(String channel) {
+      if (channel == null) {
+         channel = "";
+      }
+
+      channel = channel.replace(' ', '_');
+      channel = channel.replace('<', '{');
+      channel = channel.replace('>', '}');
+      this.changeChannel(channel, true);
+   }
+
+   private void changeChannel(String channel, boolean sendMsg) {
+      if (!channel.equals(this._channel)) {
+         String oldChannel = this._channel;
+         this._channel = channel;
+         Hashtable<String, NetworkObject> tmpIDtable = (Hashtable<String, NetworkObject>)this._nFlongID.clone();
+         Enumeration<NetworkObject> e = tmpIDtable.elements();
+
+         while (e.hasMoreElements()) {
+            NetworkObject no = e.nextElement();
+
+            assert no != null;
+
+            no.changeChannel(this, oldChannel, this._channel);
+         }
+
+         if (sendMsg) {
+            WorldServer ws = this._serverTracker.getActive(this);
+            if (ws != null) {
+               ws.tmpRefCnt(this);
+
+               try {
+                  ws.sendNetworkMsg(new ChannelCmd(channel));
+               } catch (PacketTooLargeException var8) {
+                  assert false;
+               } catch (InfiniteWaitException var9) {
+               }
+            }
+         }
+      }
+   }
+
+   public ServerURL getServerURL() {
+      return this._serverURL;
+   }
+
+   @Override
+   public String toString() {
+      return this._serverURL == null ? "AnonGalaxy=" + super.toString() : "Galaxy[" + this._serverURL + "]";
+   }
+
+   void swapServer(WorldServer oldServ, WorldServer newServ) {
+      if ((_debugLevel & 8192) > 0) {
+         System.out.println(this + ".swapServer(" + oldServ + ", " + newServ + ")");
+      }
+
+      this._serverTracker.swapServer(oldServ, newServ);
+      this.reacquireServer(oldServ);
+   }
+
+   void reacquireServer(WorldServer oldServ) {
+      if ((_debugLevel & 8192) > 0) {
+         System.out.println(this + ".reacquireServer(" + oldServ + ")");
+      }
+
+      Enumeration<NetworkObject> e = this._nFlongID.elements();
+
+      while (e.hasMoreElements()) {
+         e.nextElement().reacquireServer(oldServ);
+      }
+   }
+
+   public void regObject(String longID, NetworkObject obj) {
+      if ((_debugLevel & 8192) > 0) {
+         System.out.println(this + ".regObject(" + longID + ", " + obj + ")");
+      }
+
+      this._nFlongID.put(longID, obj);
+   }
+
+   public NetworkObject getObject(String longID) {
+      return this._nFlongID.get(longID);
+   }
+
+   public void delObject(String longID) {
+      if ((_debugLevel & 8192) > 0) {
+         System.out.println(this + ".delObject(" + longID + ")");
+      }
+
+      this._nFlongID.remove(longID);
+   }
+
+   public void forceObjectRereg() {
+      if ((_debugLevel & 8192) > 0) {
+         System.out.println(this + ".forceObjectRereg()");
+      }
+
+      Hashtable<String, NetworkObject> oldTable = this._nFlongID;
+      this._nFlongID = new Hashtable<String, NetworkObject>();
+      Enumeration<NetworkObject> e = oldTable.elements();
+
+      while (e.hasMoreElements()) {
+         e.nextElement().register();
+      }
+   }
+
+   private void forceDisconnect() {
+      if ((_debugLevel & 8192) > 0) {
+         System.out.println(this + ".forceDisconnect()");
+      }
+
+      Enumeration<NetworkObject> e = this._nFlongID.elements();
+
+      while (e.hasMoreElements()) {
+         NetworkObject no = e.nextElement();
+
+         assert no != null;
+
+         no.galaxyDisconnected();
+      }
+   }
+
+   void addRoomRequest(String roomName, NetworkRoom room) {
+      assert this._roomTable != null;
+
+      this._roomTable.addRequest(roomName, room);
+   }
+
+   void delRoomRequest(String roomName) {
+      if (this._roomTable != null) {
+         this._roomTable.delRequest(roomName);
+      }
+   }
+
+   NetworkRoom regRoomID(int roomID, String roomName) {
+      assert this._roomTable != null;
+
+      NetworkRoom room = this._roomTable.getRequest(roomName);
+      if (roomID != 0 && room != null) {
+         this._roomTable.regRoomID(roomID, room);
+      }
+
+      return room;
+   }
+
+   public void setRoomID(int roomID, NetworkRoom room) {
+      assert this._roomTable != null;
+
+      assert roomID != 0;
+
+      assert room != null;
+
+      this._roomTable.regRoomID(roomID, room);
+   }
+
+   void delRoomID(int roomID, NetworkRoom room) {
+      if (this._roomTable != null) {
+         this._roomTable.delRoomID(roomID, room);
+      }
+   }
+
+   NetworkRoom getRoom(int roomID) {
+      return this._roomTable == null ? null : this._roomTable.getRoom(roomID);
+   }
+
+   void setGalaxyType(int type) {
+      this._serverType = type;
+      if (_globalUserAllowsOnline) {
+         this.setOnlineState(false, this._online);
+         this.setChatname("");
+         this._wizard = new LoginWizard(this, this.getIniSection());
+         System.out.println("LWDB: brought up " + this._wizard + " in setGalaxyType");
+      }
+   }
+
+   public int getGalaxyType() {
+      return this._serverType;
+   }
+
+   public synchronized void setAuthInfo(String usernm, String newUsernm, String passwd, String newPasswd, String serial, int mode) {
+      _globalUserAllowsOnline = true;
+      this._localUserAllowsOnline = true;
+
+      assert this._serverType != 0;
+
+      this.setUsernameU(usernm);
+      this.setChatname(usernm);
+      this._newUsername = newUsernm;
+      this._password = passwd;
+      this._newPassword = newPasswd;
+      this._serial = serial;
+      this._mode = mode;
+      switch (this._serverType) {
+         case 1:
+            switch (this._mode) {
+               case 1:
+               default:
+                  break;
+               case 2:
+                  this._serial = null;
+                  break;
+               case 3:
+                  this._password = null;
+                  this._serial = null;
+            }
+
+            assert this._mode != 4;
+            break;
+         case 3:
+            assert false;
+            break;
+         case 4:
+            assert this._mode == 2;
+         case 2:
+            assert this._mode != 1;
+
+            assert this._mode != 4;
+
+            if (this._password != null && this._password.length() != 0) {
+               System.out.println(this + ": Password shouldn't be specified.");
+            }
+
+            this._password = null;
+            if (this._serial != null && this._serial.length() != 0) {
+               System.out.println(this + ": Serial number shouldn't be specified.");
+            }
+
+            this._serial = null;
+      }
+
+      this.goOnline();
+   }
+
+   public String getSerialNum() {
+      return this._serial;
+   }
+
+   public String getPassword() {
+      return this._password;
+   }
+
+   String getNewPassword() {
+      return this._newPassword;
+   }
+
+   public String getChatname() {
+      return this._username;
+   }
+
+   String getNewChatname() {
+      return this._newUsername;
+   }
+
+   String getGuestExpiration() {
+      assert false;
+
+      return null;
+   }
+
+   public int getLoginMode() {
+      return this._mode;
+   }
+
+   void setOnlineState(boolean enabled, boolean online) {
+      synchronized (this) {
+         this._onlineEnabled = enabled;
+         this._online = online;
+      }
+
+      synchronized (this._consoleList) {
+         Enumeration<NetworkObject> cList = this.getConsoles();
+
+         while (cList.hasMoreElements()) {
+            Console c = (Console)cList.nextElement();
+            c.setOnlineState(enabled, online);
+         }
+      }
+   }
+
+   public boolean getOnlineEnabled() {
+      return this._onlineEnabled;
+   }
+
+   public boolean getOnline() {
+      return this._online;
+   }
+
+   void setPassword(String password) {
+      this._password = password;
+   }
+
+   void setNewPassword(String password) {
+      this._newPassword = password;
+   }
+
+   void setNewChatname(String chatname) {
+      this._newUsername = chatname;
+   }
+
+   void setSerialNum(String sn) {
+      this._serial = sn;
+   }
+
+   public void setUsernameU(String username) {
+      this._usernameU = username;
+   }
+
+   public String getUsernameU() {
+      return this._usernameU;
+   }
+
+   void setChatname(String newname) {
+      synchronized (this) {
+         this._consoleList = new NetworkMulti(newname, this._consoleList, this);
+         if (this._username != null) {
+            this.delObject(this._username);
+         }
+
+         this.regObject(newname, this._consoleList);
+         this._username = newname;
+      }
+
+      synchronized (this._consoleList) {
+         Enumeration<NetworkObject> cList = this.getConsoles();
+
+         while (cList.hasMoreElements()) {
+            Console c = (Console)cList.nextElement();
+            c.setChatname(this._username);
+         }
+      }
+
+      synchronized (this._serverTracker) {
+         Enumeration<WorldServer> list = this._serverTracker.getAllServers();
+
+         while (list.hasMoreElements()) {
+            WorldServer ws = list.nextElement();
+            ws.regShortID(1, this._username);
+         }
+      }
+   }
+
+   public IniFile getIniSection() {
+      if (this._serverURL == null) {
+         return new IniFile("UNSHARED");
+      } else {
+         if (this._serverURL.getHost().equals("www.3dcd.com:6650")) {
+            IniFile i = new IniFile("209.240.84.122:6650");
+            if (i.getIniString("User0", "").length() != 0) {
+               return i;
+            }
+         }
+
+         return new IniFile(this._serverURL.getHost());
+      }
+   }
+
+   @Override
+   public void dialogDone(Object who, boolean confirmed) {
+      if (who instanceof LoginWizard) {
+         synchronized (this._wizardMutex) {
+            System.out.println("LWDB: setting who " + who + " wiz " + this._wizard + " to null");
+            this._wizard = null;
+         }
+
+         if (!confirmed) {
+            this.setOnlineState(true, false);
+            this._localUserAllowsOnline = false;
+         } else {
+            this._localUserAllowsOnline = true;
+            _globalUserAllowsOnline = true;
+         }
+      } else if (who instanceof InternetConnectionDialog) {
+         this._icd = null;
+         if (!confirmed) {
+            this.setOnlineState(true, false);
+            this._localUserAllowsOnline = false;
+         } else {
+            this._localUserAllowsOnline = true;
+            _globalUserAllowsOnline = true;
+            this.reacquireServer(null);
+         }
+      } else {
+         assert false;
+      }
+   }
+
+   public void addConsole(Console c) {
+      assert this._consoleList != null;
+
+      this._consoleList.addObject(c);
+      this.setOnlineState(this._onlineEnabled, this._online);
+   }
+
+   public void delConsole(Console c) {
+      assert this._consoleList != null;
+
+      this._consoleList.delObject(c);
+   }
+
+   public Enumeration<NetworkObject> getConsoles() {
+      return this._consoleList.elements();
+   }
+
+   public void sentFriendsList(boolean state) {
+      this.sentFriendsList = state;
+   }
+
+   public boolean sentFriendsList() {
+      return this.sentFriendsList;
+   }
+
+   public int getProtocol() {
+      return this.protocolLevel;
+   }
+
+   void setProtocol(int level) {
+      this.protocolLevel = level;
+   }
+}