/** {@inheritDoc} */
  public LDAPConnection getConnection() throws LDAPException {

    if (M_log.isDebugEnabled()) {
      M_log.debug("getConnection()");
    }
    LDAPConnection conn = newConnection();

    if (config.isAutoBind()) {
      if (M_log.isDebugEnabled()) {
        M_log.debug("getConnection(): auto-binding");
      }
      try {
        bind(conn, config.getLdapUser(), config.getLdapPassword());
      } catch (LDAPException ldape) {
        if (ldape.getResultCode() == LDAPException.INVALID_CREDENTIALS) {
          M_log.warn(
              "Failed to bind against: "
                  + conn.getHost()
                  + " with user: "******" password: "******".", "*"));
        }
        throw ldape;
      }
    }

    return conn;
  }
Beispiel #2
0
  public boolean checkLdapLoginCredential(String userName, String userPassword) throws Exception {
    LDAPConnection lc = new LDAPConnection();
    int ldapVersion = LDAPConnection.LDAP_V3;
    boolean ritorno = false;

    try {
      // check for required data
      if (isNullValue(ApplicationConfigurator.HOST)
          || (isNullValue(ApplicationConfigurator.PORT)
              && isNullValue(ApplicationConfigurator.PORT_SSL))
      /*
      || isNullValue(ApplicationConfigurator.SEARCH_PATH)
      || isNullValue(ApplicationConfigurator.USER_DN_ATTRIBUTE_NAME)
       */ ) {
        throw new Exception("Dati obbligatori per la connessione ad LDAP non presenti.");
      }

      // Connect to the server
      try {
        lc.connect(ApplicationConfigurator.HOST, Integer.parseInt(ApplicationConfigurator.PORT));
      } catch (Exception e) {
        e.printStackTrace();
        throw e;
      }

      // Try login with user credential
      try {
        if (isNullValue(userName) || isNullValue(userPassword)) return false;

        userName =
            isNullValue(ApplicationConfigurator.USER_DN_ATTRIBUTE_NAME)
                ? userName
                : ApplicationConfigurator.USER_DN_ATTRIBUTE_NAME + "=" + userName;
        userName +=
            isNullValue(ApplicationConfigurator.SEARCH_PATH)
                ? ""
                : "," + ApplicationConfigurator.SEARCH_PATH;

        lc.bind(ldapVersion, userName, userPassword);
      } catch (Exception e) {
        // Se si verifica un eccezione in questo punto significa che l'utente non è stato
        // trovato, per questo motivo risollevo l'eccezione con il messaggio standard di
        // utente e/o password errati.
        e.printStackTrace();
        throw new Exception(ApplicationConfigurator.LanguageManager.getString("LDAP.Msg4"));
      }
      ritorno = true;
    } finally {
      // disconnect with the server
      lc.disconnect();
      return ritorno;
    }
  }
 public void disconnect() {
   try {
     connection.disconnect();
   } catch (LDAPException e) {
     e.printStackTrace();
   }
 }
  private Vector getAttribute(String entryDN, String attr) {
    Vector v = new Vector();
    LDAPSearchResults searchResults;
    LDAPEntry entry = null;
    try {
      searchResults = connection.search(entryDN, LDAPConnection.SCOPE_BASE, "", null, false);
      entry = searchResults.next();
    } catch (LDAPException e) {
      // e.printStackTrace();
      return v;
    }

    // System.out.println(entry);
    LDAPAttributeSet attributeSet = entry.getAttributeSet();
    // System.out.println(attributeSet);
    Iterator allAttributes = attributeSet.iterator();

    while (allAttributes.hasNext()) {
      LDAPAttribute attribute = (LDAPAttribute) allAttributes.next();
      String attributeName = attribute.getName();
      if (attributeName.equalsIgnoreCase(attr)) {
        Enumeration en = attribute.getStringValues();
        for (; en.hasMoreElements(); ) {
          v.add(en.nextElement());
        }
      }
    }
    return v;
  }
 /** {@inheritDoc} */
 public void returnConnection(LDAPConnection conn) {
   try {
     if (conn != null) conn.disconnect();
   } catch (LDAPException e) {
     M_log.error("returnConnection(): failed on disconnect: ", e);
   }
 }
  /**
   * Connects the specified <code>LDAPConnection</code> to the currently configured host and port.
   *
   * @param conn an <code>LDAPConnection</code>
   * @throws LDAPConnection if the connect attempt fails
   */
  protected void connect(LDAPConnection conn) throws LDAPException {
    if (M_log.isDebugEnabled()) {
      M_log.debug("connect()");
    }

    conn.connect(config.getLdapHost(), config.getLdapPort());

    try {
      postConnect(conn);
    } catch (LDAPException e) {
      M_log.error(
          "Failed to completely initialize a connection [host = "
              + config.getLdapHost()
              + "][port = "
              + config.getLdapPort()
              + "]",
          e);
      try {
        conn.disconnect();
      } catch (LDAPException ee) {
      }

      throw e;
    } catch (Throwable e) {
      M_log.error(
          "Failed to completely initialize a connection [host = "
              + config.getLdapHost()
              + "][port = "
              + config.getLdapPort()
              + "]",
          e);
      try {
        conn.disconnect();
      } catch (LDAPException ee) {
      }

      if (e instanceof Error) {
        throw (Error) e;
      }
      if (e instanceof RuntimeException) {
        throw (RuntimeException) e;
      }

      throw new RuntimeException("LDAPConnection allocation failure", e);
    }
  }
 /** {@inheritDoc} */
 @Override
 public void abandon(final int messageId, final RequestControl[] controls) throws LdapException {
   try {
     connection.abandon(messageId, getLDAPConstraints(controls));
   } catch (LDAPException e) {
     processLDAPException(e);
   }
 }
 /**
  * Returns an ldap constraints object configured with the supplied controls.
  *
  * @param controls to sets in the constraints
  * @return ldap constraints
  */
 protected LDAPConstraints getLDAPConstraints(final RequestControl[] controls) {
   LDAPConstraints constraints = connection.getConstraints();
   if (constraints == null) {
     constraints = new LDAPConstraints();
   }
   if (controls != null) {
     constraints.setControls(config.getControlProcessor().processRequestControls(controls));
   }
   return constraints;
 }
  private void bind(LDAPConnection conn, String dn, String pw) throws LDAPException {

    if (M_log.isDebugEnabled()) {
      M_log.debug("bind(): binding [dn = " + dn + "]");
    }

    try {
      conn.bind(LDAPConnection.LDAP_V3, dn, pw.getBytes("UTF8"));
    } catch (UnsupportedEncodingException e) {
      throw new RuntimeException("Failed to encode user password", e);
    }
  }
 /**
  * Returns an ldap constraints object configured with the supplied request.
  *
  * @param request request containing configuration to create constraints
  * @return ldap constraints
  */
 protected LDAPConstraints getLDAPConstraints(final Request request) {
   LDAPConstraints constraints = connection.getConstraints();
   if (constraints == null) {
     constraints = new LDAPConstraints();
   }
   if (request.getControls() != null) {
     constraints.setControls(
         config.getControlProcessor().processRequestControls(request.getControls()));
   }
   constraints.setReferralFollowing(request.getFollowReferrals());
   return constraints;
 }
 /** {@inheritDoc} */
 @Override
 public void close(final RequestControl[] controls) throws LdapException {
   try {
     if (connection != null) {
       connection.disconnect(getLDAPConstraints(controls));
     }
   } catch (LDAPException e) {
     throw new LdapException(e, ResultCode.valueOf(e.getResultCode()));
   } finally {
     connection = null;
   }
 }
 /** {@inheritDoc} */
 @Override
 public Response<Void> delete(final DeleteRequest request) throws LdapException {
   Response<Void> response = null;
   try {
     final LDAPResponseQueue queue =
         connection.delete(request.getDn(), (LDAPResponseQueue) null, getLDAPConstraints(request));
     final LDAPResponse lr = (LDAPResponse) queue.getResponse();
     response = createResponse(request, null, lr);
   } catch (LDAPException e) {
     processLDAPException(e);
   }
   return response;
 }
  protected void postConnect(LDAPConnection conn) throws LDAPException {

    if (M_log.isDebugEnabled()) {
      M_log.debug("postConnect()");
    }

    if (config.isSecureConnection() && isTlsSocketFactory()) {
      if (M_log.isDebugEnabled()) {
        M_log.debug("postConnect(): starting TLS");
      }
      conn.startTLS();
    }
  }
 /**
  * Applies <code>LDAPConstraints</code> to the specified <code>LDAPConnection</code>. Implemented
  * to assign <code>timeLimit</code> and <code>referralFollowing</code> constraint values retrieved
  * from the currently assigned {@link LdapConnectionManagerConfig}.
  *
  * @param conn
  */
 protected void applyConstraints(LDAPConnection conn) {
   int timeout = config.getOperationTimeout();
   boolean followReferrals = config.isFollowReferrals();
   if (M_log.isDebugEnabled()) {
     M_log.debug(
         "applyConstraints(): values [timeout = "
             + timeout
             + "][follow referrals = "
             + followReferrals
             + "]");
   }
   LDAPConstraints constraints = new LDAPConstraints();
   constraints.setTimeLimit(timeout);
   constraints.setReferralFollowing(followReferrals);
   conn.setConstraints(constraints);
 }
 /** {@inheritDoc} */
 @Override
 public Response<?> extendedOperation(final ExtendedRequest request) throws LdapException {
   Response<?> response = null;
   try {
     final LDAPExtendedResponse ldapExtRes =
         connection.extendedOperation(
             new LDAPExtendedOperation(request.getOID(), request.encode()),
             getLDAPConstraints(request));
     final ExtendedResponse<?> extRes =
         ExtendedResponseFactory.createExtendedResponse(
             request.getOID(), ldapExtRes.getID(), ldapExtRes.getValue());
     response = createResponse(request, extRes.getValue(), ldapExtRes);
   } catch (LDAPException e) {
     processLDAPException(e);
   }
   return response;
 }
 /** {@inheritDoc} */
 @Override
 public Response<Void> add(final AddRequest request) throws LdapException {
   Response<Void> response = null;
   try {
     final JLdapUtils bu = new JLdapUtils();
     final LDAPResponseQueue queue =
         connection.add(
             new LDAPEntry(request.getDn(), bu.fromLdapAttributes(request.getLdapAttributes())),
             (LDAPResponseQueue) null,
             getLDAPConstraints(request));
     final LDAPResponse lr = (LDAPResponse) queue.getResponse();
     response = createResponse(request, null, lr);
   } catch (LDAPException e) {
     processLDAPException(e);
   }
   return response;
 }
 /**
  * Executes an ldap search.
  *
  * @param conn to search with
  * @param sr to read properties from
  * @return ldap search queue
  * @throws LDAPException if an error occurs
  */
 protected LDAPSearchQueue search(final LDAPConnection conn, final SearchRequest sr)
     throws LDAPException {
   final LDAPSearchConstraints constraints = getLDAPSearchConstraints(sr);
   final LDAPControl[] lc =
       config.getControlProcessor().processRequestControls(sr.getControls());
   if (lc != null) {
     constraints.setControls(lc);
   }
   return conn.search(
       sr.getBaseDn(),
       getSearchScope(sr.getSearchScope()),
       sr.getSearchFilter() != null ? sr.getSearchFilter().format() : null,
       getReturnAttributes(sr),
       sr.getTypesOnly(),
       (LDAPSearchQueue) null,
       constraints);
 }
 /**
  * Performs a simple bind.
  *
  * @param request to bind with
  * @return bind response
  * @throws LdapException if an error occurs
  */
 protected Response<Void> simpleBind(final BindRequest request) throws LdapException {
   Response<Void> response = null;
   try {
     final LDAPResponseQueue queue =
         connection.bind(
             LDAPConnection.LDAP_V3,
             request.getDn(),
             request.getCredential().getBytes(),
             (LDAPResponseQueue) null,
             getLDAPConstraints(request));
     final LDAPResponse lr = (LDAPResponse) queue.getResponse();
     response = createResponse(request, null, lr);
   } catch (LDAPException e) {
     processLDAPException(e);
   }
   return response;
 }
 /**
  * Performs an anonymous bind.
  *
  * @param request to bind with
  * @return bind response
  * @throws LdapException if an error occurs
  */
 protected Response<Void> anonymousBind(final BindRequest request) throws LdapException {
   Response<Void> response = null;
   try {
     final LDAPResponseQueue queue =
         connection.bind(
             LDAPConnection.LDAP_V3,
             (String) null,
             (byte[]) null,
             (LDAPResponseQueue) null,
             getLDAPConstraints(request));
     final LDAPResponse lr = (LDAPResponse) queue.getResponse();
     response = createResponse(request, null, lr);
   } catch (LDAPException e) {
     processLDAPException(e);
   }
   return response;
 }
 /** {@inheritDoc} */
 @Override
 public Response<Boolean> compare(final CompareRequest request) throws LdapException {
   Response<Boolean> response = null;
   try {
     final JLdapUtils bu = new JLdapUtils();
     final LDAPResponseQueue queue =
         connection.compare(
             request.getDn(),
             bu.fromLdapAttribute(request.getAttribute()),
             (LDAPResponseQueue) null,
             getLDAPConstraints(request));
     final LDAPResponse lr = (LDAPResponse) queue.getResponse();
     response = createResponse(request, lr.getResultCode() == ResultCode.COMPARE_TRUE.value(), lr);
   } catch (LDAPException e) {
     processLDAPException(e);
   }
   return response;
 }
  /**
   * Performs a sasl bind.
   *
   * @param request to bind with
   * @return bind response
   * @throws LdapException if an error occurs
   */
  protected Response<Void> saslBind(final BindRequest request) throws LdapException {
    try {
      final SaslConfig sc = request.getSaslConfig();
      switch (sc.getMechanism()) {
        case EXTERNAL:
          throw new UnsupportedOperationException("SASL External not supported");
          /* current implementation appears to be broken
           * see http://tinyurl.com/7ojdzlz
           * connection.bind(
           * (String) null,
           * sc.getAuthorizationId(),
           * new String[] {"EXTERNAL"},
           * null,
           * (Object) null);
           * break;
           */

        case DIGEST_MD5:
          connection.bind(
              (String) null,
              request.getDn(),
              new String[] {"DIGEST-MD5"},
              null,
              new SaslCallbackHandler(
                  null,
                  request.getCredential() != null ? request.getCredential().getString() : null));
          break;

        case CRAM_MD5:
          throw new UnsupportedOperationException("CRAM-MD5 not supported");

        case GSSAPI:
          throw new UnsupportedOperationException("GSSAPI not supported");

        default:
          throw new IllegalArgumentException(
              "Unknown SASL authentication mechanism: " + sc.getMechanism());
      }
    } catch (LDAPException e) {
      processLDAPException(e);
    }
    return new Response<Void>(null, ResultCode.SUCCESS);
  }
  /**
   * Sends the LDAPExtendedRequest to the ldap server using the specified, connection and registers
   * the listener with the parent polling thread.
   *
   * @param conn LDAPConnection for sending LDAPOperation.
   * @param requestoperation LDAPExtendedOperation to be send as LDAPExtendedRequest.
   * @param alistener The LDAPListener to be registered.
   * @throws LDAPException When the underlying operations on connection fails.
   */
  private void sendExtendedRequest(
      final LDAPConnection conn,
      final LDAPExtendedOperation requestoperation,
      final LDAPEventListener alistener)
      throws LDAPException {
    LDAPResponseQueue queue = conn.extendedOperation(requestoperation, null, null);
    EdirEventsGenerator eventgenerator = null;
    int[] ids = queue.getMessageIDs();

    if (ids.length == 1) {
      eventgenerator = new EdirEventsGenerator(alistener);

      super.pollforevents(queue, conn, eventgenerator, ids[0], this);
    } else {
      /// CLOVER:OFF
      throw new LDAPException(null, LDAPException.LOCAL_ERROR, "Unable to Obtain Message Id");

      /// CLOVER:ON
    }
  }
 /** {@inheritDoc} */
 @Override
 public Response<Void> modifyDn(final ModifyDnRequest request) throws LdapException {
   Response<Void> response = null;
   try {
     final String[] dn = request.getNewDn().split(",", 2);
     final LDAPResponseQueue queue =
         connection.rename(
             request.getDn(),
             dn[0],
             dn[1],
             request.getDeleteOldRDn(),
             (LDAPResponseQueue) null,
             getLDAPConstraints(request));
     final LDAPResponse lr = (LDAPResponse) queue.getResponse();
     response = createResponse(request, null, lr);
   } catch (LDAPException e) {
     processLDAPException(e);
   }
   return response;
 }
Beispiel #24
0
  public static void main(String[] args) {
    String ldapHost = "192.168.121.130";
    String loginDN = "cn=admin,dc=ucweb,dc=com";
    String password = "******";
    String containerName = "dc=ucweb,dc=com";

    int ldapPort = LDAPConnection.DEFAULT_SSL_PORT;
    int ldapVersion = LDAPConnection.LDAP_V3;

    LDAPJSSESecureSocketFactory ssf =
        new LDAPJSSESecureSocketFactory(TrustManager.createSSLSocketFactory());
    LDAPConnection lc = new LDAPConnection(ssf);

    LDAPAttributeSet attributeSet = new LDAPAttributeSet();

    attributeSet.add(
        new LDAPAttribute("objectclass", new String[] {new String("top"), new String("person")}));
    attributeSet.add(new LDAPAttribute("cn", "17"));
    attributeSet.add(new LDAPAttribute("sn", "17"));
    attributeSet.add(new LDAPAttribute("description", " "));
    //        attributeSet.add(new LDAPAttribute("userPassword", "111111"));
    String dn = "cn=17," + containerName;
    LDAPEntry newEntry = new LDAPEntry(dn, attributeSet);

    try {
      lc.connect(ldapHost, ldapPort);
      lc.bind(ldapVersion, loginDN, password.getBytes("UTF8"));
      System.out.println("login ldap server successfully.");
      lc.add(newEntry);
      System.out.println("Added object: " + dn + " successfully.");

    } catch (LDAPException e) {
      e.printStackTrace();
    } catch (UnsupportedEncodingException e) {
      e.printStackTrace();
    } finally {
      try {
        if (lc.isConnected()) {
          lc.disconnect();
        }
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }
 /**
  * Tests if the allowable lifetime of the given connection has already elapsed. Edge cases:
  *
  * <ol>
  *   <li>Non-{@link PooledLDAPConnection} - returns <code>true</code>
  *   <li><code>maxTtl</code> &lt;= 0 - returns <code>true</code>
  *   <li>Connection birthdate in the future - returns <code>true</code>
  * </ol>
  */
 public boolean isConnectionAlive(LDAPConnection connectionToTest) {
   if (!(connectionToTest instanceof PooledLDAPConnection)) {
     if (log.isDebugEnabled()) {
       log.debug(
           "isConnectionAlive(): connection not of expected type ["
               + (connectionToTest == null ? "null" : connectionToTest.getClass().getName())
               + "], returning true");
     }
     return true;
   }
   if (maxTtl <= 0) {
     if (log.isDebugEnabled()) {
       log.debug("isConnectionAlive(): maxTtl set to infinite [" + maxTtl + "], returning true");
     }
     return true;
   }
   long now = System.currentTimeMillis();
   long then = ((PooledLDAPConnection) connectionToTest).getBirthdate();
   long elapsed = now - then;
   boolean isAlive = elapsed <= maxTtl;
   if (log.isDebugEnabled()) {
     log.debug(
         "isConnectionAlive(): [now = "
             + now
             + "][then = "
             + then
             + "][elapsed = "
             + elapsed
             + "][max TTL = "
             + maxTtl
             + "][isAlive = "
             + isAlive
             + "]");
   }
   return isAlive;
 }
 public LDAPUser login(String aUserName, String aPassword) throws InvalidLoginException {
   LDAPUser onlineUser = null;
   try {
     connection.connect(ldapHost, ldapPort);
     System.out.println("Connect Successfull");
     System.out.println(aUserName);
     LDAPSearchQueue searchResults =
         connection.search(
             "o=Aerothai",
             LDAPConnection.SCOPE_SUB,
             "cn=" + aUserName,
             new String[] {LDAPConnection.NO_ATTRS},
             true,
             (LDAPSearchQueue) null);
     LDAPMessage message;
     message = searchResults.getResponse();
     if (message instanceof LDAPSearchResult) {
       LDAPEntry entry = ((LDAPSearchResult) message).getEntry();
       String dn = entry.getDN();
       String[] userDn = dn.split(",");
       String fullDn = userDn[0] + "," + userDn[1] + "," + userDn[2] + ",o=Aerothai";
       connection.bind(ldapVersion, fullDn, aPassword.getBytes("UTF8"));
       System.out.println("Bind Successfull");
       onlineUser = new LDAPUser();
       try {
         onlineUser.setFirstName((String) getAttribute(fullDn, "givenName").elementAt(0));
         onlineUser.setLastName((String) getAttribute(fullDn, "sn").elementAt(0));
         try {
           Integer.parseInt((String) getAttribute(fullDn, "cn").elementAt(1));
           onlineUser.setEmployeeCode((String) getAttribute(fullDn, "cn").elementAt(1));
         } catch (NumberFormatException e) {
           onlineUser.setEmployeeCode((String) getAttribute(fullDn, "cn").elementAt(0));
         }
         onlineUser.setDepartment((String) getAttribute(fullDn, "ou").elementAt(0));
         onlineUser.setLocation((userDn[2].split("="))[1]);
       } catch (ArrayIndexOutOfBoundsException e1) {
         e1.printStackTrace();
         onlineUser = null;
         throw new InvalidLoginException(
             "à¡Ô´¤ÇÒÁ¼Ô´¾ÅÒ´ÃÐËÇèÒ§¡Òô֧¢éÍÁÙÅ ¡ÃØ³Ò Login ãËÁèÍÕ¡¤ÃÑé§");
       }
     } else {
       disconnect();
       throw new InvalidLoginException(
           "äÁ辺¼Ùéãªé§Ò¹ª×èÍ "
               + aUserName
               + " ¡ÃسÒÅͧÍÕ¡¤ÃÑé§ ËÃ×Í µÔ´µèÍà¨éÒ˹éÒ·Õè¡Í§Ç¤.¾Ç. à¾×è͵ÃǨÊͺ¢éÍÁÙŢͧ·èÒ¹");
     }
     disconnect();
   } catch (LDAPException e) {
     e.printStackTrace();
     throw new InvalidLoginException(
         "ÃËÑʼèÒ¹äÁè¶Ù¡µéͧ ¡ÃسÒÅͧÍÕ¡¤ÃÑé§ ËÃ×Í µÔ´µèÍà¨éÒ˹éÒ·Õè¡Í§Ç¤.¾Ç. à¾×è͵ÃǨÊͺ¢éÍÁÙŢͧ·èÒ¹");
   } catch (UnsupportedEncodingException e) {
     e.printStackTrace();
     throw new InvalidLoginException(e);
   } finally {
     disconnect();
   }
   return onlineUser;
 }
 /**
  * Creates a new jldap connection.
  *
  * @param conn ldap connection
  * @param pc provider configuration
  */
 public JLdapConnection(final LDAPConnection conn, final JLdapProviderConfig pc) {
   connection = conn;
   config = pc;
   connection.addUnsolicitedNotificationListener(notificationListener);
 }