home *** CD-ROM | disk | FTP | other *** search
/ Popular Software (Premium Edition) / mycd.iso / INTERNET / NETSCAP4.06 / CP32E406.EXE / nav40.z / ldap10.jar / netscape / ldap / LDAPConnection.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-08-13  |  25.0 KB  |  1,203 lines
  1. package netscape.ldap;
  2.  
  3. import java.lang.reflect.Method;
  4. import java.util.Enumeration;
  5. import java.util.Hashtable;
  6. import java.util.StringTokenizer;
  7. import java.util.Vector;
  8. import netscape.ldap.client.JDAPAVA;
  9. import netscape.ldap.client.JDAPMessage;
  10. import netscape.ldap.client.opers.JDAPAbandonRequest;
  11. import netscape.ldap.client.opers.JDAPAddRequest;
  12. import netscape.ldap.client.opers.JDAPBindRequest;
  13. import netscape.ldap.client.opers.JDAPCompareRequest;
  14. import netscape.ldap.client.opers.JDAPDeleteRequest;
  15. import netscape.ldap.client.opers.JDAPExtendedRequest;
  16. import netscape.ldap.client.opers.JDAPExtendedResponse;
  17. import netscape.ldap.client.opers.JDAPModifyRDNRequest;
  18. import netscape.ldap.client.opers.JDAPModifyRequest;
  19. import netscape.ldap.client.opers.JDAPProtocolOp;
  20. import netscape.ldap.client.opers.JDAPResult;
  21. import netscape.ldap.client.opers.JDAPSearchRequest;
  22.  
  23. public class LDAPConnection implements LDAPv3, Cloneable {
  24.    public static final int LDAP_VERSION = 2;
  25.    public static final String LDAP_PROPERTY_SDK = "version.sdk";
  26.    public static final String LDAP_PROPERTY_PROTOCOL = "version.protocol";
  27.    public static final String LDAP_PROPERTY_SECURITY = "version.security";
  28.    private static final String defaultFilter = "(objectClass=*)";
  29.    private static final LDAPSearchConstraints readConstraints = new LDAPSearchConstraints();
  30.    private transient LDAPSearchConstraints defaultConstraints = new LDAPSearchConstraints();
  31.    private transient Vector responseListeners;
  32.    private transient Vector searchListeners;
  33.    private transient boolean bound;
  34.    private transient String host;
  35.    private transient String[] m_hostList;
  36.    private transient int port = -1;
  37.    private transient int[] m_portList;
  38.    private transient int m_defaultPort;
  39.    private transient String prevBoundDN;
  40.    private transient String prevBoundPasswd;
  41.    private transient String boundDN;
  42.    private transient String boundPasswd;
  43.    private transient int protocolVersion = 2;
  44.    private transient LDAPSocketFactory m_factory;
  45.    // $FF: renamed from: th netscape.ldap.LDAPConnThread
  46.    private transient LDAPConnThread field_0;
  47.    private transient Vector m_attachedList = new Vector();
  48.    private transient Hashtable m_responseControlTable = new Hashtable();
  49.    private transient LDAPCache m_cache;
  50.    private transient boolean needAuthenticate = false;
  51.    static Hashtable m_threadConnTable = new Hashtable();
  52.    private static final Float SdkVersion = new Float(3.01F);
  53.    private static final Float ProtocolVersion = new Float(3.0F);
  54.    private static final String SecurityVersion = new String("none,simple");
  55.    private static final Float MajorVersion = new Float(0.9F);
  56.    private static final Float MinorVersion = new Float(0.1F);
  57.    private static final String DELIM = "#";
  58.    private static final String PersistSearchPackageName = "netscape.ldap.controls.LDAPPersistSearchControl";
  59.    private static boolean isCommunicator = checkCommunicator();
  60.    private static final boolean debug = false;
  61.  
  62.    public LDAPConnection() {
  63.       this.m_factory = null;
  64.    }
  65.  
  66.    public LDAPConnection(LDAPSocketFactory var1) {
  67.       this.m_factory = var1;
  68.    }
  69.  
  70.    public void finalize() throws LDAPException {
  71.       if (this.field_0 != null) {
  72.          this.disconnect();
  73.       }
  74.  
  75.    }
  76.  
  77.    public void setCache(LDAPCache var1) {
  78.       this.m_cache = var1;
  79.    }
  80.  
  81.    public LDAPCache getCache() {
  82.       return this.m_cache;
  83.    }
  84.  
  85.    public Object getProperty(String var1) throws LDAPException {
  86.       if (var1.equals("version.sdk")) {
  87.          return SdkVersion;
  88.       } else if (var1.equals("version.protocol")) {
  89.          return ProtocolVersion;
  90.       } else if (var1.equals("version.security")) {
  91.          return SecurityVersion;
  92.       } else if (var1.equals("version.major")) {
  93.          return MajorVersion;
  94.       } else {
  95.          return var1.equals("version.minor") ? MinorVersion : null;
  96.       }
  97.    }
  98.  
  99.    public void setProperty(String var1, Object var2) throws LDAPException {
  100.    }
  101.  
  102.    private void setProtocolVersion(int var1) {
  103.       this.protocolVersion = var1;
  104.    }
  105.  
  106.    public String getHost() {
  107.       return this.host;
  108.    }
  109.  
  110.    public int getPort() {
  111.       return this.port;
  112.    }
  113.  
  114.    public String getAuthenticationDN() {
  115.       return this.boundDN;
  116.    }
  117.  
  118.    public String getAuthenticationPassword() {
  119.       return this.boundPasswd;
  120.    }
  121.  
  122.    public LDAPSocketFactory getSocketFactory() {
  123.       return this.m_factory;
  124.    }
  125.  
  126.    public void setSocketFactory(LDAPSocketFactory var1) {
  127.       this.m_factory = var1;
  128.    }
  129.  
  130.    public boolean isConnected() {
  131.       return this.field_0 != null;
  132.    }
  133.  
  134.    public boolean isAuthenticated() {
  135.       return this.bound;
  136.    }
  137.  
  138.    public void connect(String var1, int var2) throws LDAPException {
  139.       this.connect(var1, var2, (String)null, (String)null);
  140.    }
  141.  
  142.    public void connect(String var1, int var2, String var3, String var4) throws LDAPException {
  143.       if (this.field_0 != null) {
  144.          this.disconnect();
  145.       }
  146.  
  147.       if (var1 == null) {
  148.          throw new LDAPException("no host for connection", 89);
  149.       } else {
  150.          this.m_defaultPort = var2;
  151.          StringTokenizer var5 = new StringTokenizer(var1);
  152.          this.m_hostList = new String[var5.countTokens()];
  153.          this.m_portList = new int[var5.countTokens()];
  154.  
  155.          for(int var6 = 0; var5.hasMoreTokens(); ++var6) {
  156.             String var7 = var5.nextToken();
  157.             int var8 = var7.indexOf(58);
  158.             if (var8 > 0) {
  159.                this.m_hostList[var6] = var7.substring(0, var8);
  160.                this.m_portList[var6] = Integer.parseInt(var7.substring(var8 + 1));
  161.             } else {
  162.                this.m_hostList[var6] = var7;
  163.                this.m_portList[var6] = this.m_defaultPort;
  164.             }
  165.          }
  166.  
  167.          LDAPException var11 = null;
  168.  
  169.          for(int var10 = 0; var10 < this.m_hostList.length; ++var10) {
  170.             try {
  171.                this.host = this.m_hostList[var10];
  172.                this.port = this.m_portList[var10];
  173.                this.connect();
  174.                var11 = null;
  175.                break;
  176.             } catch (LDAPException var9) {
  177.                var11 = var9;
  178.             }
  179.          }
  180.  
  181.          if (var11 != null) {
  182.             this.host = this.m_hostList[0];
  183.             this.port = this.m_defaultPort;
  184.             throw var11;
  185.          } else {
  186.             if (var3 != null && var4 != null) {
  187.                this.authenticate(var3, var4);
  188.             }
  189.  
  190.          }
  191.       }
  192.    }
  193.  
  194.    public void connect(int var1, String var2, int var3, String var4, String var5) throws LDAPException {
  195.       this.setProtocolVersion(var1);
  196.       this.connect(var2, var3, var4, var5);
  197.    }
  198.  
  199.    private synchronized void connect() throws LDAPException {
  200.       if (this.field_0 == null) {
  201.          if (this.host != null && this.port >= 0) {
  202.             this.field_0 = this.getNewThread(this.host, this.port, this.m_factory, this.m_cache);
  203.          } else {
  204.             throw new LDAPException("no connection parameters", 89);
  205.          }
  206.       }
  207.    }
  208.  
  209.    private synchronized LDAPConnThread getNewThread(String var1, int var2, LDAPSocketFactory var3, LDAPCache var4) throws LDAPException {
  210.       LDAPConnThread var5 = null;
  211.       Vector var6 = null;
  212.       Hashtable var7 = m_threadConnTable;
  213.       synchronized(var7){}
  214.  
  215.       try {
  216.          Enumeration var9 = m_threadConnTable.keys();
  217.          boolean var10 = false;
  218.  
  219.          while(var9.hasMoreElements()) {
  220.             LDAPConnThread var11 = (LDAPConnThread)var9.nextElement();
  221.             Vector var12 = (Vector)m_threadConnTable.get(var11);
  222.             Enumeration var13 = var12.elements();
  223.  
  224.             while(var13.hasMoreElements()) {
  225.                LDAPConnection var14 = (LDAPConnection)var13.nextElement();
  226.                if (var14.equals(this)) {
  227.                   var10 = true;
  228.                   if (!((Thread)var11).isAlive()) {
  229.                      try {
  230.                         var5 = new LDAPConnThread(var1, var2, var3, var4);
  231.                         var6 = (Vector)m_threadConnTable.remove(var11);
  232.                      } catch (Exception var19) {
  233.                         throw new LDAPException("unable to establish connection", 52);
  234.                      }
  235.                   }
  236.                   break;
  237.                }
  238.             }
  239.  
  240.             if (var10) {
  241.                break;
  242.             }
  243.          }
  244.  
  245.          if (!var10) {
  246.             try {
  247.                var5 = new LDAPConnThread(var1, var2, var3, var4);
  248.                var6 = new Vector();
  249.                var6.addElement(this);
  250.             } catch (Exception var18) {
  251.                throw new LDAPException("unable to establish connection", 52);
  252.             }
  253.          }
  254.  
  255.          if (var5 != null) {
  256.             m_threadConnTable.put(var5, var6);
  257.             int var21 = 0;
  258.  
  259.             for(int var22 = var6.size(); var21 < var22; ++var21) {
  260.                LDAPConnection var23 = (LDAPConnection)var6.elementAt(var21);
  261.                var5.register(var23);
  262.                var23.field_0 = var5;
  263.             }
  264.          }
  265.       } catch (Throwable var20) {
  266.          throw var20;
  267.       }
  268.  
  269.       return var5;
  270.    }
  271.  
  272.    public void abandon(LDAPSearchResults var1) throws LDAPException {
  273.       if (this.field_0 != null && var1 != null) {
  274.          var1.abandon();
  275.          int var2 = var1.getID();
  276.  
  277.          for(int var3 = 0; var3 < 3; ++var3) {
  278.             try {
  279.                this.field_0.abandon(var2);
  280.                this.field_0.sendRequest(new JDAPAbandonRequest(var2), (LDAPResponseListener)null, this.defaultConstraints);
  281.                break;
  282.             }
  283.          }
  284.  
  285.          if (this.field_0 == null) {
  286.             throw new LDAPException("Failed to send abandon request to the server.", 80);
  287.          }
  288.       }
  289.    }
  290.  
  291.    public void authenticate(String var1, String var2) throws LDAPException {
  292.       this.authenticate(this.protocolVersion, var1, var2);
  293.    }
  294.  
  295.    public void authenticate(int var1, String var2, String var3) throws LDAPException {
  296.       this.prevBoundDN = this.boundDN;
  297.       this.prevBoundPasswd = this.boundPasswd;
  298.       this.boundDN = var2;
  299.       this.boundPasswd = var3;
  300.       this.needAuthenticate = true;
  301.       this.bind(var1);
  302.       this.needAuthenticate = false;
  303.    }
  304.  
  305.    private void bind(int var1) throws LDAPException {
  306.       if (this.field_0 == null) {
  307.          this.connect();
  308.       }
  309.  
  310.       if (this.bound && this.needAuthenticate) {
  311.          if (this.protocolVersion == var1) {
  312.             if (this.field_0.getClientCount() == 1 && this.boundDN == null) {
  313.                LDAPResponseListener var22 = this.getResponseListener();
  314.  
  315.                try {
  316.                   this.sendRequest(new JDAPBindRequest(this.protocolVersion, this.boundDN, this.boundPasswd), var22, this.defaultConstraints);
  317.                   JDAPMessage var23 = var22.getResponse();
  318.                   this.checkMsg(var23);
  319.                   this.bound = false;
  320.                } finally {
  321.                   this.releaseResponseListener(var22);
  322.                }
  323.  
  324.                return;
  325.             }
  326.  
  327.             if (this.boundDN != null && this.boundPasswd != null && this.boundDN.equals(this.prevBoundDN) && this.boundPasswd.equals(this.prevBoundPasswd)) {
  328.                return;
  329.             }
  330.          }
  331.  
  332.          if (this.field_0.getClientCount() > 1) {
  333.             this.disconnect();
  334.             this.connect();
  335.          }
  336.       }
  337.  
  338.       if (!this.bound) {
  339.          this.protocolVersion = var1;
  340.          if (this.boundDN == null) {
  341.             this.bound = false;
  342.          } else {
  343.             LDAPResponseListener var2 = this.getResponseListener();
  344.  
  345.             try {
  346.                this.sendRequest(new JDAPBindRequest(this.protocolVersion, this.boundDN, this.boundPasswd), var2, this.defaultConstraints);
  347.                JDAPMessage var3 = var2.getResponse();
  348.                this.checkMsg(var3);
  349.             } finally {
  350.                this.releaseResponseListener(var2);
  351.             }
  352.  
  353.             Hashtable var4 = m_threadConnTable;
  354.             synchronized(var4){}
  355.  
  356.             try {
  357.                if (m_threadConnTable.containsKey(this.field_0)) {
  358.                   Vector var6 = (Vector)m_threadConnTable.get(this.field_0);
  359.                   int var7 = 0;
  360.  
  361.                   for(int var8 = var6.size(); var7 < var8; ++var7) {
  362.                      LDAPConnection var9 = (LDAPConnection)var6.elementAt(var7);
  363.                      var9.bound = true;
  364.                   }
  365.                } else {
  366.                   printDebug("Thread table does not contain the specified thread");
  367.                }
  368.             } catch (Throwable var21) {
  369.                throw var21;
  370.             }
  371.  
  372.          }
  373.       }
  374.    }
  375.  
  376.    private void sendRequest(JDAPProtocolOp var1, LDAPResponseListener var2, LDAPSearchConstraints var3) throws LDAPException {
  377.       for(int var4 = 0; var4 < 3; ++var4) {
  378.          try {
  379.             this.field_0.sendRequest(var1, var2, var3);
  380.             break;
  381.          }
  382.       }
  383.  
  384.       if (this.field_0 == null) {
  385.          throw new LDAPException("The connection is not available", 80);
  386.       }
  387.    }
  388.  
  389.    private void bind() throws LDAPException {
  390.       this.bind(this.protocolVersion);
  391.    }
  392.  
  393.    public synchronized void disconnect() throws LDAPException {
  394.       if (this.field_0 == null) {
  395.          throw new LDAPException("unable to disconnect() without connecting", 80);
  396.       } else {
  397.          if (this.m_cache != null) {
  398.             this.m_cache.cleanup();
  399.             this.m_cache = null;
  400.          }
  401.  
  402.          this.deleteThreadConnEntry();
  403.          this.deregisterConnection();
  404.       }
  405.    }
  406.  
  407.    private void deleteThreadConnEntry() {
  408.       Hashtable var1 = m_threadConnTable;
  409.       synchronized(var1){}
  410.  
  411.       try {
  412.          Enumeration var3 = m_threadConnTable.keys();
  413.  
  414.          while(var3.hasMoreElements()) {
  415.             LDAPConnThread var4 = (LDAPConnThread)var3.nextElement();
  416.             Vector var5 = (Vector)m_threadConnTable.get(var4);
  417.             Enumeration var6 = var5.elements();
  418.  
  419.             while(var6.hasMoreElements()) {
  420.                LDAPConnection var7 = (LDAPConnection)var6.nextElement();
  421.                if (var7.equals(this)) {
  422.                   var5.removeElement(var7);
  423.                   return;
  424.                }
  425.             }
  426.          }
  427.  
  428.       } catch (Throwable var9) {
  429.          throw var9;
  430.       }
  431.    }
  432.  
  433.    synchronized void deregisterConnection() {
  434.       this.field_0.deregister(this);
  435.       this.field_0 = null;
  436.       this.bound = false;
  437.    }
  438.  
  439.    public LDAPEntry read(String var1) throws LDAPException {
  440.       return this.read(var1, (String[])null);
  441.    }
  442.  
  443.    public LDAPEntry read(String var1, String[] var2) throws LDAPException {
  444.       return this.read(var1, var2, this.defaultConstraints);
  445.    }
  446.  
  447.    private LDAPEntry read(String var1, String[] var2, LDAPSearchConstraints var3) throws LDAPException {
  448.       LDAPSearchResults var4 = this.search(var1, 0, "(objectClass=*)", var2, false, var3);
  449.       return var4 == null ? null : var4.next();
  450.    }
  451.  
  452.    public static LDAPEntry read(LDAPUrl var0) throws LDAPException {
  453.       String var1 = var0.getHost();
  454.       int var2 = var0.getPort();
  455.       if (var1 == null) {
  456.          throw new LDAPException("no host for connection", 89);
  457.       } else {
  458.          String[] var3 = var0.getAttributeArray();
  459.          String var4 = var0.getDN();
  460.          LDAPConnection var6 = new LDAPConnection();
  461.          var6.connect(var1, var2);
  462.          LDAPEntry var5 = var6.read(var4, var3);
  463.          var6.disconnect();
  464.          return var5;
  465.       }
  466.    }
  467.  
  468.    public static LDAPSearchResults search(LDAPUrl var0) throws LDAPException {
  469.       return search(var0, (LDAPSearchConstraints)null);
  470.    }
  471.  
  472.    public static LDAPSearchResults search(LDAPUrl var0, LDAPSearchConstraints var1) throws LDAPException {
  473.       String var2 = var0.getHost();
  474.       int var3 = var0.getPort();
  475.       if (var2 == null) {
  476.          throw new LDAPException("no host for connection", 89);
  477.       } else {
  478.          String[] var4 = var0.getAttributeArray();
  479.          String var5 = var0.getDN();
  480.          String var6 = var0.getFilter();
  481.          if (var6 == null) {
  482.             var6 = "(objectClass=*)";
  483.          }
  484.  
  485.          int var7 = var0.getScope();
  486.          LDAPConnection var8 = new LDAPConnection();
  487.          var8.connect(var2, var3);
  488.          LDAPSearchResults var9;
  489.          if (var1 != null) {
  490.             var9 = var8.search(var5, var7, var6, var4, false, var1);
  491.          } else {
  492.             var9 = var8.search(var5, var7, var6, var4, false);
  493.          }
  494.  
  495.          var9.closeOnCompletion(var8);
  496.          return var9;
  497.       }
  498.    }
  499.  
  500.    public LDAPSearchResults search(String var1, int var2, String var3, String[] var4, boolean var5) throws LDAPException {
  501.       return this.search(var1, var2, var3, var4, var5, this.defaultConstraints);
  502.    }
  503.  
  504.    public LDAPSearchResults search(String var1, int var2, String var3, String[] var4, boolean var5, LDAPSearchConstraints var6) throws LDAPException {
  505.       LDAPSearchResults var7 = new LDAPSearchResults();
  506.       Object var8 = null;
  507.       Long var9 = null;
  508.       boolean var10 = true;
  509.  
  510.       try {
  511.          if (this.m_cache != null) {
  512.             var9 = this.m_cache.createKey(this.host, this.port, var1, var3, var2, var4, this.boundDN, var6);
  513.             Vector var65 = (Vector)this.m_cache.getEntry(var9);
  514.             if (var65 != null) {
  515.                return new LDAPSearchResults(var65);
  516.             }
  517.          }
  518.       } catch (LDAPException var56) {
  519.          var10 = false;
  520.          System.out.println("Exception: " + var56);
  521.       }
  522.  
  523.       this.bind();
  524.       LDAPSearchListener var11 = this.getSearchListener();
  525.       int var12 = var6.getDereference();
  526.       JDAPSearchRequest var13 = new JDAPSearchRequest(var1, var2, var12, var6.getMaxResults(), var6.getTimeLimit(), var5, var3, var4);
  527.       synchronized(var11){}
  528.  
  529.       try {
  530.          boolean var16 = false;
  531.  
  532.          try {
  533.             this.sendRequest(var13, var11, var6);
  534.             var16 = true;
  535.          } finally {
  536.             if (!var16) {
  537.                this.releaseSearchListener(var11);
  538.             }
  539.  
  540.          }
  541.  
  542.          if (this.m_cache != null && var10) {
  543.             var11.setKey(var9);
  544.          }
  545.       } catch (Throwable var58) {
  546.          throw var58;
  547.       }
  548.  
  549.       if (var6.getBatchSize() == 0) {
  550.          LDAPSearchResults var67;
  551.          try {
  552.             LDAPSearchResults[] var18;
  553.             try {
  554.                JDAPMessage var17 = ((LDAPResponseListener)var11).getResponse();
  555.                Enumeration var70 = var11.getSearchResults();
  556.                if (!var70.hasMoreElements()) {
  557.                   this.checkMsg(var17);
  558.                }
  559.  
  560.                while(var70.hasMoreElements()) {
  561.                   var7.add(((JDAPMessage)var70.nextElement()).getProtocolOp());
  562.                }
  563.  
  564.                return var7;
  565.             } catch (LDAPReferralException var59) {
  566.                var18 = new LDAPSearchResults[1];
  567.                this.performReferrals(var59, var6, 3, var1, var2, var3, var4, var5, (LDAPModification[])null, (LDAPEntry)null, (LDAPAttribute)null, var18, (boolean[])null);
  568.                if (var18[0] == null) {
  569.                   var18[0] = new LDAPSearchResults();
  570.                }
  571.             } catch (LDAPException var60) {
  572.                throw var60;
  573.             }
  574.  
  575.             var67 = var18[0];
  576.          } finally {
  577.             this.releaseSearchListener(var11);
  578.          }
  579.  
  580.          return var67;
  581.       } else {
  582.          JDAPMessage var14 = var11.nextResult();
  583.          if (var14 == null) {
  584.             var14 = ((LDAPResponseListener)var11).getResponse();
  585.  
  586.             LDAPSearchResults var68;
  587.             try {
  588.                LDAPSearchResults[] var19;
  589.                try {
  590.                   this.checkMsg(var14);
  591.                   return var7;
  592.                } catch (LDAPReferralException var62) {
  593.                   var19 = new LDAPSearchResults[1];
  594.                   this.performReferrals(var62, var6, 3, var1, var2, var3, var4, var5, (LDAPModification[])null, (LDAPEntry)null, (LDAPAttribute)null, var19, (boolean[])null);
  595.                   if (var19[0] == null) {
  596.                      var19[0] = new LDAPSearchResults();
  597.                   }
  598.                } catch (LDAPException var63) {
  599.                   throw var63;
  600.                }
  601.  
  602.                var68 = var19[0];
  603.             } finally {
  604.                this.releaseSearchListener(var11);
  605.             }
  606.  
  607.             return var68;
  608.          } else {
  609.             var7.add(var14.getProtocolOp());
  610.             LDAPControl[] var15 = (LDAPControl[])getOption(12, var6);
  611.             if (var15 != null && var15.length > 0) {
  612.                for(int var69 = 0; var69 < var15.length; ++var69) {
  613.                   if (var15[var69].getClass().getName().equals("netscape.ldap.controls.LDAPPersistSearchControl")) {
  614.                      var7.associatePersistentSearch(var11);
  615.                      return var7;
  616.                   }
  617.                }
  618.             }
  619.  
  620.             var7.associate(var11);
  621.             return var7;
  622.          }
  623.       }
  624.    }
  625.  
  626.    public boolean compare(String var1, LDAPAttribute var2) throws LDAPException {
  627.       return this.compare(var1, var2, this.defaultConstraints);
  628.    }
  629.  
  630.    private boolean compare(String var1, LDAPAttribute var2, LDAPSearchConstraints var3) throws LDAPException {
  631.       this.bind();
  632.       LDAPResponseListener var4 = this.getResponseListener();
  633.       Enumeration var5 = var2.getByteValues();
  634.       byte[] var6 = (byte[])var5.nextElement();
  635.       String var7 = "";
  636.  
  637.       try {
  638.          var7 = new String(var6, "UTF8");
  639.       } catch (Throwable var18) {
  640.       }
  641.  
  642.       JDAPAVA var8 = new JDAPAVA(var2.getName(), var7);
  643.  
  644.       boolean var21;
  645.       try {
  646.          this.sendRequest(new JDAPCompareRequest(var1, var8), var4, var3);
  647.          JDAPMessage var9 = var4.getResponse();
  648.          int var13 = ((JDAPResult)var9.getProtocolOp()).getResultCode();
  649.          if (var13 != 5) {
  650.             if (var13 == 6) {
  651.                var21 = true;
  652.                return var21;
  653.             }
  654.  
  655.             this.checkMsg(var9);
  656.             return false;
  657.          }
  658.  
  659.          var21 = false;
  660.       } catch (LDAPReferralException var19) {
  661.          boolean[] var14 = new boolean[1];
  662.          this.performReferrals(var19, var3, 14, var1, 0, (String)null, (String[])null, false, (LDAPModification[])null, (LDAPEntry)null, var2, (LDAPSearchResults[])null, var14);
  663.          var21 = var14[0];
  664.          return var21;
  665.       } finally {
  666.          this.releaseResponseListener(var4);
  667.       }
  668.  
  669.       return var21;
  670.    }
  671.  
  672.    public void add(LDAPEntry var1) throws LDAPException {
  673.       this.add(var1, this.defaultConstraints);
  674.    }
  675.  
  676.    private void add(LDAPEntry var1, LDAPSearchConstraints var2) throws LDAPException {
  677.       this.bind();
  678.       LDAPResponseListener var3 = this.getResponseListener();
  679.       LDAPAttributeSet var4 = var1.getAttributeSet();
  680.       LDAPAttribute[] var5 = new LDAPAttribute[var4.size()];
  681.  
  682.       for(int var6 = 0; var6 < var4.size(); ++var6) {
  683.          var5[var6] = var4.elementAt(var6);
  684.       }
  685.  
  686.       try {
  687.          this.sendRequest(new JDAPAddRequest(var1.getDN(), var5), var3, var2);
  688.          JDAPMessage var7 = var3.getResponse();
  689.          this.checkMsg(var7);
  690.       } catch (LDAPReferralException var13) {
  691.          this.performReferrals(var13, var2, 8, (String)null, 0, (String)null, (String[])null, false, (LDAPModification[])null, var1, (LDAPAttribute)null, (LDAPSearchResults[])null, (boolean[])null);
  692.       } finally {
  693.          this.releaseResponseListener(var3);
  694.       }
  695.  
  696.    }
  697.  
  698.    public LDAPExtendedOperation extendedOperation(LDAPExtendedOperation var1) throws LDAPException {
  699.       this.bind();
  700.       LDAPResponseListener var2 = this.getResponseListener();
  701.       Object var3 = null;
  702.       Object var4 = null;
  703.       LDAPSearchConstraints var6 = this.defaultConstraints;
  704.  
  705.       LDAPExtendedOperation var7;
  706.       try {
  707.          this.sendRequest(new JDAPExtendedRequest(var1.getID(), var1.getValue()), var2, var6);
  708.          JDAPMessage var15 = var2.getResponse();
  709.          this.checkMsg(var15);
  710.          JDAPExtendedResponse var10 = (JDAPExtendedResponse)var15.getProtocolOp();
  711.          byte[] var16 = var10.getValue();
  712.          String var5 = var10.getID();
  713.          return new LDAPExtendedOperation(var5, var16);
  714.       } catch (LDAPReferralException var13) {
  715.          var7 = this.performExtendedReferrals(var13, var6, var1);
  716.       } finally {
  717.          this.releaseResponseListener(var2);
  718.       }
  719.  
  720.       return var7;
  721.    }
  722.  
  723.    public void modify(String var1, LDAPModification var2) throws LDAPException {
  724.       this.modify(var1, var2, this.defaultConstraints);
  725.    }
  726.  
  727.    private void modify(String var1, LDAPModification var2, LDAPSearchConstraints var3) throws LDAPException {
  728.       LDAPModification[] var4 = new LDAPModification[]{var2};
  729.       this.modify(var1, var4, var3);
  730.    }
  731.  
  732.    public void modify(String var1, LDAPModificationSet var2) throws LDAPException {
  733.       this.modify(var1, var2, this.defaultConstraints);
  734.    }
  735.  
  736.    private void modify(String var1, LDAPModificationSet var2, LDAPSearchConstraints var3) throws LDAPException {
  737.       LDAPModification[] var4 = new LDAPModification[var2.size()];
  738.  
  739.       for(int var5 = 0; var5 < var2.size(); ++var5) {
  740.          var4[var5] = var2.elementAt(var5);
  741.       }
  742.  
  743.       this.modify(var1, var4, var3);
  744.    }
  745.  
  746.    private void modify(String var1, LDAPModification[] var2) throws LDAPException {
  747.       this.modify(var1, var2, this.defaultConstraints);
  748.    }
  749.  
  750.    private void modify(String var1, LDAPModification[] var2, LDAPSearchConstraints var3) throws LDAPException {
  751.       this.bind();
  752.       LDAPResponseListener var4 = this.getResponseListener();
  753.       Object var5 = null;
  754.  
  755.       try {
  756.          this.sendRequest(new JDAPModifyRequest(var1, var2), var4, var3);
  757.          JDAPMessage var13 = var4.getResponse();
  758.          this.checkMsg(var13);
  759.       } catch (LDAPReferralException var11) {
  760.          this.performReferrals(var11, var3, 6, var1, 0, (String)null, (String[])null, false, var2, (LDAPEntry)null, (LDAPAttribute)null, (LDAPSearchResults[])null, (boolean[])null);
  761.       } finally {
  762.          this.releaseResponseListener(var4);
  763.       }
  764.  
  765.    }
  766.  
  767.    public void delete(String var1) throws LDAPException {
  768.       this.delete(var1, this.defaultConstraints);
  769.    }
  770.  
  771.    private void delete(String var1, LDAPSearchConstraints var2) throws LDAPException {
  772.       this.bind();
  773.       LDAPResponseListener var3 = this.getResponseListener();
  774.  
  775.       try {
  776.          this.sendRequest(new JDAPDeleteRequest(var1), var3, var2);
  777.          JDAPMessage var4 = var3.getResponse();
  778.          this.checkMsg(var4);
  779.       } catch (LDAPReferralException var10) {
  780.          this.performReferrals(var10, var2, 10, var1, 0, (String)null, (String[])null, false, (LDAPModification[])null, (LDAPEntry)null, (LDAPAttribute)null, (LDAPSearchResults[])null, (boolean[])null);
  781.       } finally {
  782.          this.releaseResponseListener(var3);
  783.       }
  784.  
  785.    }
  786.  
  787.    public void rename(String var1, String var2, boolean var3) throws LDAPException {
  788.       this.rename(var1, var2, (String)null, var3);
  789.    }
  790.  
  791.    public void rename(String var1, String var2, String var3, boolean var4) throws LDAPException {
  792.       this.rename(var1, var2, var3, var4, this.defaultConstraints);
  793.    }
  794.  
  795.    private void rename(String var1, String var2, String var3, boolean var4, LDAPSearchConstraints var5) throws LDAPException {
  796.       this.bind();
  797.       LDAPResponseListener var6 = this.getResponseListener();
  798.  
  799.       try {
  800.          Object var10 = null;
  801.          JDAPModifyRDNRequest var15;
  802.          if (var3 != null) {
  803.             var15 = new JDAPModifyRDNRequest(var1, var2, var4, var3);
  804.          } else {
  805.             var15 = new JDAPModifyRDNRequest(var1, var2, var4);
  806.          }
  807.  
  808.          this.sendRequest(var15, var6, var5);
  809.          JDAPMessage var7 = var6.getResponse();
  810.          this.checkMsg(var7);
  811.       } catch (LDAPReferralException var13) {
  812.          this.performReferrals(var13, var5, 12, var1, 0, var2, (String[])null, var4, (LDAPModification[])null, (LDAPEntry)null, (LDAPAttribute)null, (LDAPSearchResults[])null, (boolean[])null);
  813.       } finally {
  814.          this.releaseResponseListener(var6);
  815.       }
  816.  
  817.    }
  818.  
  819.    public Object getOption(int var1) throws LDAPException {
  820.       return var1 == 17 ? new Integer(this.protocolVersion) : getOption(var1, this.defaultConstraints);
  821.    }
  822.  
  823.    private static Object getOption(int var0, LDAPSearchConstraints var1) throws LDAPException {
  824.       switch (var0) {
  825.          case 2:
  826.             return new Integer(var1.getDereference());
  827.          case 3:
  828.             return new Integer(var1.getMaxResults());
  829.          case 4:
  830.             return new Integer(var1.getTimeLimit());
  831.          case 8:
  832.             return new Boolean(var1.getReferrals());
  833.          case 9:
  834.             return var1.getRebindProc();
  835.          case 10:
  836.             return new Integer(var1.getHopLimit());
  837.          case 11:
  838.             return var1.getClientControls();
  839.          case 12:
  840.             return var1.getServerControls();
  841.          case 20:
  842.             return new Integer(var1.getBatchSize());
  843.          default:
  844.             throw new LDAPException("invalid option", 89);
  845.       }
  846.    }
  847.  
  848.    public void setOption(int var1, Object var2) throws LDAPException {
  849.       if (var1 == 17) {
  850.          this.setProtocolVersion((Integer)var2);
  851.       } else {
  852.          setOption(var1, var2, this.defaultConstraints);
  853.       }
  854.    }
  855.  
  856.    private static void setOption(int var0, Object var1, LDAPSearchConstraints var2) throws LDAPException {
  857.       try {
  858.          switch (var0) {
  859.             case 2:
  860.                var2.setDereference((Integer)var1);
  861.                return;
  862.             case 3:
  863.                var2.setMaxResults((Integer)var1);
  864.                return;
  865.             case 4:
  866.                var2.setTimeLimit((Integer)var1);
  867.                return;
  868.             case 8:
  869.                var2.setReferrals((Boolean)var1);
  870.                return;
  871.             case 9:
  872.                var2.setRebindProc((LDAPRebind)var1);
  873.                return;
  874.             case 10:
  875.                var2.setHopLimit((Integer)var1);
  876.                return;
  877.             case 11:
  878.                if (var1 == null) {
  879.                   var2.setClientControls((LDAPControl[])null);
  880.                   return;
  881.                } else if (var1 instanceof LDAPControl) {
  882.                   var2.setClientControls((LDAPControl)var1);
  883.                   return;
  884.                } else {
  885.                   if (var1 instanceof LDAPControl[]) {
  886.                      var2.setClientControls((LDAPControl[])var1);
  887.                      return;
  888.                   }
  889.  
  890.                   throw new LDAPException("invalid LDAPControl", 89);
  891.                }
  892.             case 12:
  893.                if (var1 == null) {
  894.                   var2.setServerControls((LDAPControl[])null);
  895.                   return;
  896.                } else if (var1 instanceof LDAPControl) {
  897.                   var2.setServerControls((LDAPControl)var1);
  898.                   return;
  899.                } else {
  900.                   if (var1 instanceof LDAPControl[]) {
  901.                      var2.setServerControls((LDAPControl[])var1);
  902.                      return;
  903.                   }
  904.  
  905.                   throw new LDAPException("invalid LDAPControl", 89);
  906.                }
  907.             case 20:
  908.                var2.setBatchSize((Integer)var1);
  909.                return;
  910.             default:
  911.                throw new LDAPException("invalid option", 89);
  912.          }
  913.       } catch (ClassCastException var3) {
  914.          throw new LDAPException("invalid option value", 89);
  915.       }
  916.    }
  917.  
  918.    public LDAPControl[] getResponseControls() {
  919.       LDAPControl[] var1 = null;
  920.       Hashtable var3 = this.m_responseControlTable;
  921.       synchronized(var3){}
  922.  
  923.       LDAPControl[] var2;
  924.       try {
  925.          var2 = (LDAPControl[])this.m_responseControlTable.get(Thread.currentThread());
  926.       } catch (Throwable var5) {
  927.          throw var5;
  928.       }
  929.  
  930.       if (var2 != null && var2.length > 0) {
  931.          var1 = new LDAPControl[var2.length];
  932.  
  933.          for(int var6 = 0; var6 < var2.length; ++var6) {
  934.             var1[var6] = (LDAPControl)var2[var6].clone();
  935.          }
  936.       }
  937.  
  938.       return var1;
  939.    }
  940.  
  941.    public LDAPSearchConstraints getSearchConstraints() {
  942.       return this.defaultConstraints;
  943.    }
  944.  
  945.    private synchronized LDAPResponseListener getResponseListener() {
  946.       if (this.responseListeners == null) {
  947.          this.responseListeners = new Vector(5);
  948.       }
  949.  
  950.       LDAPResponseListener var1;
  951.       if (this.responseListeners.size() < 1) {
  952.          var1 = new LDAPResponseListener(this);
  953.       } else {
  954.          var1 = (LDAPResponseListener)this.responseListeners.elementAt(0);
  955.          this.responseListeners.removeElementAt(0);
  956.       }
  957.  
  958.       var1.setThread();
  959.       return var1;
  960.    }
  961.  
  962.    private synchronized LDAPSearchListener getSearchListener() {
  963.       if (this.searchListeners == null) {
  964.          this.searchListeners = new Vector(5);
  965.       }
  966.  
  967.       LDAPSearchListener var1;
  968.       if (this.searchListeners.size() < 1) {
  969.          var1 = new LDAPSearchListener(this);
  970.       } else {
  971.          var1 = (LDAPSearchListener)this.searchListeners.elementAt(0);
  972.          this.searchListeners.removeElementAt(0);
  973.       }
  974.  
  975.       ((LDAPResponseListener)var1).setThread();
  976.       return var1;
  977.    }
  978.  
  979.    private synchronized void releaseResponseListener(LDAPResponseListener var1) {
  980.       if (this.responseListeners == null) {
  981.          this.responseListeners = new Vector(5);
  982.       }
  983.  
  984.       var1.reset();
  985.       this.responseListeners.addElement(var1);
  986.    }
  987.  
  988.    private synchronized void releaseSearchListener(LDAPSearchListener var1) {
  989.       if (this.searchListeners == null) {
  990.          this.searchListeners = new Vector(5);
  991.       }
  992.  
  993.       var1.reset();
  994.       this.searchListeners.addElement(var1);
  995.    }
  996.  
  997.    private void checkMsg(JDAPMessage var1) throws LDAPException {
  998.       if (var1.getProtocolOp() instanceof JDAPResult) {
  999.          JDAPResult var2 = (JDAPResult)var1.getProtocolOp();
  1000.          int var3 = var2.getResultCode();
  1001.          if (var3 != 0) {
  1002.             if (var3 == 10) {
  1003.                throw new LDAPReferralException("referral", var2.getResultCode(), var2.getReferrals());
  1004.             } else if (var3 == 9) {
  1005.                throw new LDAPReferralException("referral", var2.getResultCode(), var2.getErrorMessage());
  1006.             } else {
  1007.                throw new LDAPException("error result", var2.getResultCode(), var2.getErrorMessage(), var2.getMatchedDN());
  1008.             }
  1009.          }
  1010.       }
  1011.    }
  1012.  
  1013.    void setResponseControls(Thread var1, LDAPControl[] var2) {
  1014.       Hashtable var3 = this.m_responseControlTable;
  1015.       synchronized(var3){}
  1016.  
  1017.       try {
  1018.          if (var2 != null) {
  1019.             this.m_responseControlTable.put(var1, var2);
  1020.          } else {
  1021.             this.m_responseControlTable.remove(var1);
  1022.          }
  1023.  
  1024.          Enumeration var5 = this.m_attachedList.elements();
  1025.  
  1026.          while(var5.hasMoreElements()) {
  1027.             Thread var6 = (Thread)var5.nextElement();
  1028.             if (!var6.isAlive()) {
  1029.                this.m_responseControlTable.remove(var6);
  1030.                this.m_attachedList.removeElement(var6);
  1031.             }
  1032.          }
  1033.       } catch (Throwable var8) {
  1034.          throw var8;
  1035.       }
  1036.  
  1037.       if (this.m_attachedList.indexOf(var1) < 0) {
  1038.          this.m_attachedList.addElement(var1);
  1039.       }
  1040.  
  1041.    }
  1042.  
  1043.    private LDAPConnection prepareReferral(LDAPUrl var1, LDAPSearchConstraints var2) throws LDAPException {
  1044.       LDAPConnection var3 = new LDAPConnection(this.getSocketFactory());
  1045.       var3.setOption(8, new Boolean(true));
  1046.       var3.setOption(9, var2.getRebindProc());
  1047.       var3.setOption(10, new Integer(var2.getHopLimit() - 1));
  1048.       var3.connect(var1.getHost(), var1.getPort());
  1049.       if (var2.getRebindProc() == null) {
  1050.          var3.authenticate((String)null, (String)null);
  1051.       } else {
  1052.          LDAPRebindAuth var4 = var2.getRebindProc().getRebindAuthentication(var1.getHost(), var1.getPort());
  1053.          var3.authenticate(var4.getDN(), var4.getPassword());
  1054.       }
  1055.  
  1056.       return var3;
  1057.    }
  1058.  
  1059.    private void performReferrals(LDAPReferralException var1, LDAPSearchConstraints var2, int var3, String var4, int var5, String var6, String[] var7, boolean var8, LDAPModification[] var9, LDAPEntry var10, LDAPAttribute var11, LDAPSearchResults[] var12, boolean[] var13) throws LDAPException {
  1060.       if (var2.getHopLimit() < 0) {
  1061.          throw new LDAPReferralException("exceed hop limit", ((LDAPException)var1).getLDAPResultCode(), ((LDAPException)var1).getLDAPErrorMessage());
  1062.       } else if (!var2.getReferrals()) {
  1063.          throw var1;
  1064.       } else {
  1065.          LDAPUrl[] var14 = var1.getURLs();
  1066.          if (var14 != null) {
  1067.             for(int var15 = 0; var15 < var14.length; ++var15) {
  1068.                try {
  1069.                   LDAPConnection var16 = this.prepareReferral(var14[var15], var2);
  1070.                   switch (var3) {
  1071.                      case 3:
  1072.                         LDAPSearchConstraints var17 = (LDAPSearchConstraints)var2.clone();
  1073.                         var17.setHopLimit(var2.getHopLimit() - 1);
  1074.                         var12[0] = var16.search(var4, var5, var6, var7, var8, var17);
  1075.                         if (var12[0] != null) {
  1076.                            var12[0].closeOnCompletion(var16);
  1077.                         }
  1078.  
  1079.                         return;
  1080.                      case 6:
  1081.                         var16.modify(var4, var9);
  1082.                         break;
  1083.                      case 8:
  1084.                         var16.add(var10);
  1085.                         break;
  1086.                      case 10:
  1087.                         var16.delete(var4);
  1088.                         break;
  1089.                      case 12:
  1090.                         var16.rename(var4, var6, var8);
  1091.                         break;
  1092.                      case 14:
  1093.                         var13[0] = var16.compare(var4, var11);
  1094.                   }
  1095.  
  1096.                   var16.disconnect();
  1097.                   return;
  1098.                }
  1099.             }
  1100.  
  1101.          }
  1102.       }
  1103.    }
  1104.  
  1105.    private LDAPExtendedOperation performExtendedReferrals(LDAPReferralException var1, LDAPSearchConstraints var2, LDAPExtendedOperation var3) throws LDAPException {
  1106.       if (var2.getHopLimit() < 0) {
  1107.          throw new LDAPReferralException("exceed hop limit", ((LDAPException)var1).getLDAPResultCode(), ((LDAPException)var1).getLDAPErrorMessage());
  1108.       } else if (!var2.getReferrals()) {
  1109.          throw var1;
  1110.       } else {
  1111.          LDAPUrl[] var4 = var1.getURLs();
  1112.          if (var4 == null) {
  1113.             return null;
  1114.          } else {
  1115.             for(int var5 = 0; var5 < var4.length; ++var5) {
  1116.                try {
  1117.                   LDAPConnection var6 = this.prepareReferral(var4[var5], var2);
  1118.                   LDAPExtendedOperation var7 = var6.extendedOperation(var3);
  1119.                   var6.disconnect();
  1120.                   return var7;
  1121.                }
  1122.             }
  1123.  
  1124.             return null;
  1125.          }
  1126.       }
  1127.    }
  1128.  
  1129.    public synchronized Object clone() {
  1130.       try {
  1131.          LDAPConnection var1 = (LDAPConnection)super.clone();
  1132.          var1.defaultConstraints = (LDAPSearchConstraints)this.defaultConstraints.clone();
  1133.          var1.responseListeners = null;
  1134.          var1.searchListeners = null;
  1135.          var1.bound = this.bound;
  1136.          var1.host = this.host;
  1137.          var1.port = this.port;
  1138.          var1.boundDN = this.boundDN;
  1139.          var1.boundPasswd = this.boundPasswd;
  1140.          var1.m_factory = this.m_factory;
  1141.          var1.field_0 = this.field_0;
  1142.          Hashtable var3 = m_threadConnTable;
  1143.          synchronized(var3){}
  1144.  
  1145.          label47: {
  1146.             Object var2;
  1147.             try {
  1148.                Vector var5 = (Vector)m_threadConnTable.get(this.field_0);
  1149.                if (var5 != null) {
  1150.                   var5.addElement(var1);
  1151.                   break label47;
  1152.                }
  1153.  
  1154.                printDebug("Failed to clone");
  1155.                var2 = null;
  1156.             } catch (Throwable var8) {
  1157.                throw var8;
  1158.             }
  1159.  
  1160.             return var2;
  1161.          }
  1162.  
  1163.          var1.field_0.register(var1);
  1164.          return var1;
  1165.       } catch (Exception var9) {
  1166.          return null;
  1167.       }
  1168.    }
  1169.  
  1170.    private static boolean checkCommunicator() {
  1171.       try {
  1172.          Method var0 = LDAPCheckComm.getMethod("netscape.security.PrivilegeManager", "enablePrivilege");
  1173.          if (var0 == null) {
  1174.             printDebug("Method is null");
  1175.             return false;
  1176.          }
  1177.  
  1178.          Object[] var1 = new Object[]{new String("UniversalConnect")};
  1179.          var0.invoke((Object)null, var1);
  1180.          printDebug("UniversalConnect enabled");
  1181.          return true;
  1182.       } catch (LDAPException var2) {
  1183.          printDebug("Exception: " + var2.toString());
  1184.       } catch (Exception var3) {
  1185.          printDebug("Exception on invoking enablePrivilege: " + ((Throwable)var3).toString());
  1186.       }
  1187.  
  1188.       return false;
  1189.    }
  1190.  
  1191.    public static boolean isNetscape() {
  1192.       return isCommunicator;
  1193.    }
  1194.  
  1195.    private static void printDebug(String var0) {
  1196.    }
  1197.  
  1198.    public static void main(String[] var0) {
  1199.       System.out.println("LDAP SDK Version is " + SdkVersion);
  1200.       System.out.println("LDAP Protocol Version is " + ProtocolVersion);
  1201.    }
  1202. }
  1203.