Ejemplo n.º 1
0
  /**
   * @param dn to search on.
   * @param filter to search with.
   * @throws Exception On test failure.
   */
  @Parameters({"dsmlSearchDn", "dsmlSearchFilter"})
  @Test(groups = {"dsml"})
  public void searchAndCompareDsmlv1(final String dn, final String filter) throws Exception {
    final Connection conn = TestUtils.createConnection();
    try {
      conn.open();
      final SearchOperation search = new SearchOperation(conn);

      final SearchRequest request = new SearchRequest(dn, new SearchFilter(filter));
      if (TestControl.isActiveDirectory()) {
        request.setBinaryAttributes("objectSid", "objectGUID", "jpegPhoto");
      } else {
        request.setBinaryAttributes("jpegPhoto");
      }
      final SearchResult result1 = search.execute(request).getResult();

      final StringWriter writer = new StringWriter();
      final Dsmlv1Writer dsmlWriter = new Dsmlv1Writer(writer);
      dsmlWriter.write(result1);

      final StringReader reader = new StringReader(writer.toString());
      final Dsmlv1Reader dsmlReader = new Dsmlv1Reader(reader);
      final SearchResult result2 = dsmlReader.read();

      TestUtils.assertEquals(result2, result1);
    } finally {
      conn.close();
    }
  }
Ejemplo n.º 2
0
 /**
  * Returns an array of attribute names expected from the search request. Uses the '1.1' special
  * attribute name if no attributes are requested.
  *
  * @param sr containing return attributes
  * @return attribute names for JLDAP
  */
 protected String[] getReturnAttributes(final SearchRequest sr) {
   String[] returnAttrs = null;
   if (sr.getReturnAttributes() != null) {
     if (sr.getReturnAttributes().length == 0) {
       returnAttrs = new String[] {"1.1"};
     } else {
       returnAttrs = sr.getReturnAttributes();
     }
   }
   return returnAttrs;
 }
 /** {@inheritDoc} */
 @Override
 protected void finalize() throws Throwable {
   try {
     shutdown();
   } finally {
     super.finalize();
   }
 }
  /** {@inheritDoc} */
  @Override
  public Collection<Response<SearchResult>> search(
      final PooledConnectionFactory[] factories,
      final SearchFilter[] filters,
      final String[] attrs,
      final SearchEntryHandler... handlers)
      throws LdapException {
    final CompletionService<Response<SearchResult>> searches =
        new ExecutorCompletionService<Response<SearchResult>>(getExecutorService());
    final List<Future<Response<SearchResult>>> futures =
        new ArrayList<Future<Response<SearchResult>>>(factories.length * filters.length);
    for (ConnectionFactory factory : factories) {
      for (SearchFilter filter : filters) {
        final SearchRequest sr = newSearchRequest(this);
        if (filter != null) {
          sr.setSearchFilter(filter);
        }
        if (attrs != null) {
          sr.setReturnAttributes(attrs);
        }
        if (handlers != null) {
          sr.setSearchEntryHandlers(handlers);
        }

        final Connection conn = factory.getConnection();
        final SearchOperation op = createSearchOperation(conn);
        futures.add(searches.submit(createCallable(conn, op, sr)));
      }
    }

    final List<Response<SearchResult>> responses =
        new ArrayList<Response<SearchResult>>(factories.length * filters.length);
    for (Future<Response<SearchResult>> future : futures) {
      try {
        responses.add(future.get());
      } catch (ExecutionException e) {
        logger.debug("ExecutionException thrown, ignoring", e);
      } catch (InterruptedException e) {
        logger.warn("InterruptedException thrown, ignoring", e);
      }
    }
    return responses;
  }
Ejemplo n.º 5
0
  /**
   * Performs a search operation with the {@link DirSyncControl}. The supplied request is modified
   * in the following way:
   *
   * <ul>
   *   <li>{@link SearchRequest#setControls( org.ldaptive.control.RequestControl...)} is invoked
   *       with {@link DirSyncControl}, {@link ShowDeletedControl}, and {@link ExtendedDnControl}
   * </ul>
   *
   * <p>The cookie is extracted from the supplied response and replayed in the request.
   *
   * @param request search request to execute
   * @param response of a previous dir sync operation
   * @return search operation response
   * @throws LdapException if the search fails
   */
  public Response<SearchResult> execute(
      final SearchRequest request, final Response<SearchResult> response) throws LdapException {
    final byte[] cookie = getDirSyncCookie(response);
    if (cookie == null) {
      throw new IllegalArgumentException("Response does not contain a dir sync cookie");
    }

    final SearchOperation search = new SearchOperation(connection);
    request.setControls(createRequestControls(null));
    return search.execute(request);
  }
  /**
   * Recursively gets the attribute(s) {@link #mergeAttributes} for the supplied dn and adds the
   * values to the supplied attributes.
   *
   * @param conn to perform search operation on
   * @param dn to get attribute(s) for
   * @param entry to merge with
   * @param searchedDns list of DNs that have been searched for
   * @throws LdapException if a search error occurs
   */
  private void recursiveSearch(
      final Connection conn, final String dn, final LdapEntry entry, final List<String> searchedDns)
      throws LdapException {
    if (!searchedDns.contains(dn)) {

      LdapEntry newEntry = null;
      try {
        final SearchOperation search = new SearchOperation(conn);
        final SearchRequest sr = SearchRequest.newObjectScopeSearchRequest(dn, retAttrs);
        final SearchResult result = search.execute(sr).getResult();
        newEntry = result.getEntry(dn);
      } catch (LdapException e) {
        logger.warn("Error retrieving attribute(s): {}", Arrays.toString(retAttrs), e);
      }
      searchedDns.add(dn);

      if (newEntry != null) {
        // recursively search new attributes
        readSearchAttribute(conn, newEntry, searchedDns);

        // merge new attribute values
        for (String s : mergeAttributes) {
          final LdapAttribute newAttr = newEntry.getAttribute(s);
          if (newAttr != null) {
            final LdapAttribute oldAttr = entry.getAttribute(s);
            if (oldAttr == null) {
              entry.addAttribute(newAttr);
            } else {
              if (newAttr.isBinary()) {
                for (byte[] value : newAttr.getBinaryValues()) {
                  oldAttr.addBinaryValue(value);
                }
              } else {
                for (String value : newAttr.getStringValues()) {
                  oldAttr.addStringValue(value);
                }
              }
            }
          }
        }
      }
    }
  }
Ejemplo n.º 7
0
 /**
  * Returns an ldap search constraints object configured with the supplied search request.
  *
  * @param sr search request containing configuration to create search constraints
  * @return ldap search constraints
  */
 protected LDAPSearchConstraints getLDAPSearchConstraints(final SearchRequest sr) {
   LDAPSearchConstraints constraints = connection.getSearchConstraints();
   if (constraints == null) {
     constraints = new LDAPSearchConstraints();
   }
   constraints.setServerTimeLimit(Long.valueOf(sr.getTimeLimit()).intValue());
   constraints.setMaxResults(Long.valueOf(sr.getSizeLimit()).intValue());
   if (sr.getDerefAliases() != null) {
     if (sr.getDerefAliases() == DerefAliases.ALWAYS) {
       constraints.setDereference(LDAPSearchConstraints.DEREF_ALWAYS);
     } else if (sr.getDerefAliases() == DerefAliases.FINDING) {
       constraints.setDereference(LDAPSearchConstraints.DEREF_FINDING);
     } else if (sr.getDerefAliases() == DerefAliases.NEVER) {
       constraints.setDereference(LDAPSearchConstraints.DEREF_NEVER);
     } else if (sr.getDerefAliases() == DerefAliases.SEARCHING) {
       constraints.setDereference(LDAPSearchConstraints.DEREF_SEARCHING);
     }
   }
   constraints.setReferralFollowing(sr.getFollowReferrals());
   return constraints;
 }
Ejemplo n.º 8
0
 /**
  * Performs a search operation with the {@link DirSyncControl}. The supplied request is modified
  * in the following way:
  *
  * <ul>
  *   <li>{@link SearchRequest#setControls( org.ldaptive.control.RequestControl...)} is invoked
  *       with {@link DirSyncControl}, {@link ShowDeletedControl}, and {@link ExtendedDnControl}
  * </ul>
  *
  * <p>This method will continue to execute search operations until all dir sync search results
  * have been retrieved from the server. The returned response contains the response data of the
  * last dir sync operation plus the entries and references returned by all previous search
  * operations.
  *
  * @param request search request to execute
  * @return search operation response of the last dir sync operation
  * @throws LdapException if the search fails
  */
 public Response<SearchResult> executeToCompletion(final SearchRequest request)
     throws LdapException {
   Response<SearchResult> response = null;
   final SearchResult result = new SearchResult();
   final SearchOperation search = new SearchOperation(connection);
   byte[] cookie = null;
   long flags;
   do {
     if (response != null && response.getResult() != null) {
       result.addEntries(response.getResult().getEntries());
       result.addReferences(response.getResult().getReferences());
     }
     request.setControls(createRequestControls(cookie));
     response = search.execute(request);
     flags = getDirSyncFlags(response);
     cookie = getDirSyncCookie(response);
   } while (flags != 0);
   response.getResult().addEntries(result.getEntries());
   response.getResult().addReferences(result.getReferences());
   return response;
 }
Ejemplo n.º 9
0
 /**
  * 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);
 }
Ejemplo n.º 10
0
  /** {@inheritDoc} */
  @Override
  protected void processAttributes(
      final Connection conn, final SearchRequest request, final LdapEntry entry)
      throws LdapException {
    final Map<LdapAttribute, Matcher> matchingAttrs = new HashMap<LdapAttribute, Matcher>();
    for (LdapAttribute la : entry.getAttributes()) {
      // Match attribute ID against the pattern
      final Matcher matcher = RANGE_PATTERN.matcher(la.getName());

      // If the attribute ID matches the pattern
      if (matcher.find()) {
        matchingAttrs.put(la, matcher);
      }
    }

    for (Map.Entry<LdapAttribute, Matcher> mEntry : matchingAttrs.entrySet()) {
      final LdapAttribute la = mEntry.getKey();
      final Matcher matcher = mEntry.getValue();
      final String msg = String.format("attribute '%s' entry '%s'", la.getName(), entry.getDn());

      // Determine the attribute name without the range syntax
      final String attrTypeName = matcher.group(1);
      logger.debug("Found Range option {}", msg);
      if (attrTypeName == null || attrTypeName.isEmpty()) {
        logger.error("Unable to determine the attribute type name for {}", msg);
        throw new IllegalArgumentException(
            "Unable to determine the attribute type name for " + msg);
      }

      // Create or update the attribute whose ID has the range syntax removed
      LdapAttribute newAttr = entry.getAttribute(attrTypeName);
      if (newAttr == null) {
        newAttr = new LdapAttribute(la.getSortBehavior(), la.isBinary());
        newAttr.setName(attrTypeName);
        entry.addAttribute(newAttr);
      }

      // Copy values
      if (la.isBinary()) {
        newAttr.addBinaryValues(la.getBinaryValues());
      } else {
        newAttr.addStringValues(la.getStringValues());
      }

      // Remove original attribute with range syntax from returned attributes
      entry.removeAttribute(la);

      // If the attribute ID ends with * we're done, otherwise increment
      if (!la.getName().endsWith(END_OF_RANGE)) {

        // Determine next attribute ID
        // CheckStyle:MagicNumber OFF
        final int start = Integer.parseInt(matcher.group(2));
        final int end = Integer.parseInt(matcher.group(3));
        // CheckStyle:MagicNumber ON
        final int diff = end - start;
        final String nextAttrID =
            String.format(RANGE_FORMAT, attrTypeName, end + 1, end + diff + 1);

        // Search for next increment of values
        logger.debug("Searching for '{}' to increment {}", nextAttrID, msg);

        final SearchOperation search = new SearchOperation(conn);
        final SearchRequest sr =
            SearchRequest.newObjectScopeSearchRequest(entry.getDn(), new String[] {nextAttrID});
        final SearchResult result = search.execute(sr).getResult();

        // Add all attributes to the search result
        entry.addAttributes(result.getEntry().getAttributes());

        // Iterate
        processAttributes(conn, request, entry);
      }
    }
  }
Ejemplo n.º 11
0
 /**
  * Creates a new abstract jldap search.
  *
  * @param sr search request
  */
 public AbstractJLdapSearch(final SearchRequest sr) {
   request = sr;
   util = new JLdapUtils(request.getSortBehavior());
   util.setBinaryAttributes(request.getBinaryAttributes());
 }
Ejemplo n.º 12
0
 /**
  * Performs a search operation with the {@link DirSyncControl}. The supplied request is modified
  * in the following way:
  *
  * <ul>
  *   <li>{@link SearchRequest#setControls( org.ldaptive.control.RequestControl...)} is invoked
  *       with {@link DirSyncControl}, {@link ShowDeletedControl}, and {@link ExtendedDnControl}
  * </ul>
  *
  * @param request search request to execute
  * @return search operation response
  * @throws LdapException if the search fails
  */
 public Response<SearchResult> execute(final SearchRequest request) throws LdapException {
   final SearchOperation search = new SearchOperation(connection);
   request.setControls(createRequestControls(null));
   return search.execute(request);
 }