docs: @Override
      public synchronized void authenticate() throws PortalSecurityException {
          this.isauth = false;
          ILdapServer ldapConn;
  
          ldapConn = LdapServices.getDefaultLdapServer();
  
          String creds = new String(this.myOpaqueCredentials.credentialstring);
          if (this.myPrincipal.UID != null
                  && !this.myPrincipal.UID.trim().equals("")
                  && this.myOpaqueCredentials.credentialstring != null
                  && !creds.trim().equals("")) {
              DirContext conn = null;
              NamingEnumeration results = null;
              StringBuffer user = new StringBuffer("(");
              String first_name = null;
              String last_name = null;
  
              user.append(ldapConn.getUidAttribute()).append("=");
              user.append(this.myPrincipal.UID).append(")");
              log.debug("SimpleLdapSecurityContext: Looking for {}", user.toString());
  
              try {
                  conn = ldapConn.getConnection();
  
                  // set up search controls
                  SearchControls searchCtls = new SearchControls();
                  searchCtls.setReturningAttributes(attributes);
                  searchCtls.setSearchScope(SearchControls.SUBTREE_SCOPE);
  
                  // do lookup
                  if (conn != null) {
                      try {
                          results = conn.search(ldapConn.getBaseDN(), user.toString(), searchCtls);
                          if (results != null) {
                              if (!results.hasMore()) {
                                  log.error(
                                          "SimpleLdapSecurityContext: user not found: {}",
                                          this.myPrincipal.UID);
                              }
                              while (results != null && results.hasMore()) {
                                  SearchResult entry = (SearchResult) results.next();
                                  StringBuffer dnBuffer = new StringBuffer();
                                  dnBuffer.append(entry.getName()).append(", ");
                                  dnBuffer.append(ldapConn.getBaseDN());
                                  Attributes attrs = entry.getAttributes();
                                  first_name = getAttributeValue(attrs, ATTR_FIRSTNAME);
                                  last_name = getAttributeValue(attrs, ATTR_LASTNAME);
                                  // re-bind as user
                                  conn.removeFromEnvironment(javax.naming.Context.SECURITY_PRINCIPAL);
                                  conn.removeFromEnvironment(
                                          javax.naming.Context.SECURITY_CREDENTIALS);
                                  conn.addToEnvironment(
                                          javax.naming.Context.SECURITY_PRINCIPAL,
                                          dnBuffer.toString());
                                  conn.addToEnvironment(
                                          javax.naming.Context.SECURITY_CREDENTIALS,
                                          this.myOpaqueCredentials.credentialstring);
                                  searchCtls = new SearchControls();
                                  searchCtls.setReturningAttributes(new String[0]);
                                  searchCtls.setSearchScope(SearchControls.OBJECT_SCOPE);
  
                                  String attrSearch = "(" + ldapConn.getUidAttribute() + "=*)";
                                  log.debug(
                                          "SimpleLdapSecurityContext: Looking in {} for {}",
                                          dnBuffer.toString(),
                                          attrSearch);
                                  conn.search(dnBuffer.toString(), attrSearch, searchCtls);
  
                                  this.isauth = true;
                                  this.myPrincipal.FullName = first_name + " " + last_name;
                                  log.debug(
                                          "SimpleLdapSecurityContext: User {} ({}) is authenticated",
                                          this.myPrincipal.UID,
                                          this.myPrincipal.FullName);
  
                                  // Since LDAP is case-insensitive with respect to uid, force
                                  // user name to lower case for use by the portal
                                  this.myPrincipal.UID = this.myPrincipal.UID.toLowerCase();
                              } // while (results != null && results.hasMore())
                          } else {
                              log.error(
                                      "SimpleLdapSecurityContext: No such user: {}",
                                      this.myPrincipal.UID);
                          }
                      } catch (AuthenticationException ae) {
                          log.info(
                                  "SimpleLdapSecurityContext: Password invalid for user: "
                                          + this.myPrincipal.UID);
                      } catch (Exception e) {
                          log.error(
                                  "SimpleLdapSecurityContext: LDAP Error with user: "
                                          + this.myPrincipal.UID
                                          + "; ",
                                  e);
                          throw new PortalSecurityException(
                                  "SimpleLdapSecurityContext: LDAP Error"
                                          + e
                                          + " with user: "
                                          + this.myPrincipal.UID);
                      } finally {
                          ldapConn.releaseConnection(conn);
                      }
                  } else {
                      log.error("LDAP Server Connection unavailable");
                  }
              } catch (final NamingException ne) {
                  log.error("Error getting connection to LDAP server.", ne);
              }
          } else {
              // If the principal and/or credential are missing, the context authentication
              // simply fails. It should not be construed that this is an error. It happens for guest
              // access.
              log.info("Principal or OpaqueCredentials not initialized prior to authenticate");
          }
          // Ok...we are now ready to authenticate all of our subcontexts.
          super.authenticate();
          return;
      }