I’ve got 1 primary domain with 5 child domains.

In Environment tab, I configured 2 domain controllers from my primary domain.
I put the Base DN to my primary domain root.

In User tab, I added all my account suffix for every domains, last one is the root domain.

Active Directory :
In every Child domain, I configured Global groups where I put all my users from each domain.
I configured Domain local groups in my primary domain where I put every global groups created before for every domains.

When I test the authentication, I can only authenticate correctly with a user from my primary domain.
It does not work with any users from a child domain.

Logs from a working authentication :

[DEBUG] Trying to authenticate user with username ‘xxx’ and account suffix ‘@company.com’
[DEBUG] Authentication successful for username ‘xxx’ and account suffix ‘@company.com’.
[WARN] Can not block or unblock the user because the user login is only simulated.
[WARN] Do not send a notification email and/or do not block the user because the user login is only simulated.
[DEBUG] UserInfo for user ‘xxx’: ………….. many debug Info OK

Logs from a non working authentication :

[DEBUG] Trying to authenticate user with username ‘xxx’ and account suffix ‘@test.company.com’
[DEBUG] Authentication successful for username ‘xxx’ and account suffix ‘@test.company.com’.
[WARN] Can not block or unblock the user because the user login is only simulated.
[WARN] Do not send a notification email and/or do not block the user because the user login is only simulated.
[WARN] Attributes for ‘xxx’: could not be loaded. Does the sAMAccountName or userPrincipalName exist? Is the provided base DN valid?
[ERROR] User ‘xxx’ with GUID: ” is not in an authorization group.

The plugin is not able to see memberships from my user in a child domain.

Someone is able to help me with this ?

We started using the ADI and it’s been great. One thing we’ve noticed is that once a user is disabled it shows they are disabled in the Users group. But we did see that if their cookies haven’t been flushed or account deleted from the system they can still access all of the site.

Example: We took User A and let ADI create the account. We logged into the account without problems. We then disabled the account and let ADI disable it and it showed it disabled the account. But when we refreshed the screen the account was still able to search, view, access all the information.

It wasn’t until we forced the site to logout of all locations or deleted the account that the user was force logged out. Is there an option to do this some where in ADI or add it some where? Feel like if ADI disables the account it should A) Remove all sessions or just B) Delete the account from the Database.

Thanks!

How can i fix this issue?

[DEBUG] Setting local password to the used for this login.
[ERROR] Sorry, that email address is already used!
[NOTICE] – user_id :
[FATAL] Error creating user.
Error creating user!

thanyou

how can i show the information that i extract to AD in the profile page in my site in wordpress?
Thankyou!
regards!

• This topic was modified 8 years ago by luuigi.

I have using this plugin for a couple of years with no issues. One user all of a sudden cannot login and receives the following error:
Error creating user!

Can anyone tell me what is causing this?
All other users can login fine.

I am very very new to wordpress and most importantly to ADI. I need to setup ADI on my wordpress based website but I am unable to setup the Server Information Correctly I assume. Because the test tool gives me Logon Failed error but what can be the possible issues for failed Authentication?
1- Credentials are not correct?
2- DC is not valid? { it says – OK against DC connection which can be seen in the screenshot attached}
3- Base DN is empty. { My supervisor said that you can leave the Base DN address so ADI will lookup to all the Base DNs available under the DC of their organization i.e. ldap://domain.local}

Any help would be greatly appreciated

We’re proud to announce that Next Active Directory Integration is out now. Next ADI is a compelete rewrite of ADI and supports Multisite environments and SSO.

The new Next ADI plugin will always stay free and open source. The development can be tracked on GitHub. Along with Next ADI we also intruduce our professional support for agencys, developers and site owners. Please note that the ADI v1 plugin is now deprecated and will not longer be supported.

• This topic was modified 8 years, 6 months ago by glatze.

I see this in the test tool:

[DEBUG] USER GROUPS:Array
(
[0] => sg-vpn-mis
[1] => sg-wp-admin
[2] => sg-webcf-permitted
[3] => webalerts
[4] => dg-misp
[5] => sg-mis programmer
[6] => sg-okc
[7] => ixrs-sales
[8] => allsubscribers139e0f3b
[9] => allsubscribers1b815efc
[10] => Domain Users
[11] => dg-CORP
[12] => All
[13] => OKC ALL
[14] => Users
[15] => MediasiteUsers
)

Id like to store this array into the user meta table, How?

I haven’t found any good explanation on doing this.

Thanks.

I am wanting to integrate AD with my WordPress user accounts. I have my WordPress site hosted with GoDaddy and was wondering if there is a good solution to implement this tool, while the site is hosted remotely? Do I need to build another trust with GoDaddy? Is their any additional steps need to make the connection secure? Any help would be appreciated.

Hello!
Authorization is working properly, all of the fields I get a username and email
All other fields are empty, and though they have filled in the assets of Directors.
How do I get at least a first and last name?

[NOTICE] Updating user “dserov” with following data:
– email : [email protected]
– first name :
– last name :
– display name : grey4eg
– account suffix:
– role :
[NOTICE] – user_id : 7
[DEBUG] cn is empty. Local value of meta key adi_cn left unchanged.
[DEBUG] givenname is empty. Local value of meta key adi_givenname left unchanged.
[DEBUG] sn is empty. Local value of meta key sn left unchanged.
[DEBUG] displayname is empty. Local value of meta key adi_displayname left unchanged.
[DEBUG] description is empty. Local value of meta key adi_description left unchanged.
[DEBUG] mail is empty. Local value of meta key adi_mail left unchanged.
[DEBUG] samaccountname is empty. Local value of meta key adi_samaccountname left unchanged.
[DEBUG] userprincipalname is empty. Local value of meta key adi_userprincipalname left unchanged.
[DEBUG] useraccountcontrol is empty. Local value of meta key adi_useraccountcontrol left unchanged.
[DEBUG] initials is empty. Local value of meta key adi_initials left unchanged.
[DEBUG] physicaldeliveryofficename is empty. Local value of meta key adi_physicaldeliveryofficename left unchanged.
[DEBUG] telephonenumber is empty. Local value of meta key adi_telephonenumber left unchanged.
[DEBUG] wwwhomepage is empty. Local value of meta key adi_wwwhomepage left unchanged.
[DEBUG] streetaddress is empty. Local value of meta key adi_streetaddress left unchanged.
[DEBUG] postofficebox is empty. Local value of meta key adi_postofficebox left unchanged.
[DEBUG] l is empty. Local value of meta key adi_l left unchanged.
[DEBUG] st is empty. Local value of meta key adi_st left unchanged.
[DEBUG] postalcode is empty. Local value of meta key adi_postalcode left unchanged.
[DEBUG] c is empty. Local value of meta key adi_c left unchanged.
[DEBUG] co is empty. Local value of meta key adi_co left unchanged.
[DEBUG] countrycode is empty. Local value of meta key adi_countrycode left unchanged.
[DEBUG] homephone is empty. Local value of meta key adi_homephone left unchanged.
[DEBUG] otherhomephone is empty. Local value of meta key adi_otherhomephone left unchanged.
[DEBUG] pager is empty. Local value of meta key adi_pager left unchanged.
[DEBUG] otherpager is empty. Local value of meta key adi_otherpager left unchanged.
[DEBUG] mobile is empty. Local value of meta key adi_mobile left unchanged.
[DEBUG] othermobile is empty. Local value of meta key adi_othermobile left unchanged.
[DEBUG] facsimiletelephonenumber is empty. Local value of meta key adi_facsimiletelephonenumber left unchanged.
[DEBUG] otherfacsimiletelephonenumber is empty. Local value of meta key adi_otherfacsimiletelephonenumber left unchanged.
[DEBUG] ipphone is empty. Local value of meta key adi_ipphone left unchanged.
[DEBUG] otheripphone is empty. Local value of meta key adi_otheripphone left unchanged.
[DEBUG] info is empty. Local value of meta key adi_info left unchanged.
[DEBUG] title is empty. Local value of meta key adi_title left unchanged.
[DEBUG] department is empty. Local value of meta key adi_department left unchanged.
[DEBUG] company is empty. Local value of meta key adi_company left unchanged.
[DEBUG] manager is empty. Local value of meta key adi_manager left unchanged.
[DEBUG] directreports is empty. Local value of meta key adi_directreports left unchanged.
[NOTICE] FINISHED

I’m setting up Bulk Import on a new server for testing and have been running into some problems. Let me preface this post by saying I basically copied all of the ADI settings from our production server where ADI is working fine with bulk import.

So, first I was getting an mcrypt error on import saying that the key length wasn’t supported. I updated the AUTH-SALT information in the wp-config.php file and that error went away. Next, ADI started saying the password was incorrect.

I updated the $ad_password line in bulkimport.php to:
$ad_password = ‘passwordvalue’;

After that, I ran the bulk importer and it worked fine. It seems like something is getting lost in the password field now.

This is a brand new Ubuntu 16.04.1 server, so I may be missing something on the server side.

Any ideas?

https://www.ads-software.com/plugins/active-directory-integration/

I’ve seen similar posts but there don’t seem to be any answers. According to the plugin description “It is very easy to set up. Just activate the plugin, type in a domain controller, and you’re done.” I tried that but no dice.

The only [ERROR] is that authentication failed, but I don’t know why. Is there any more information I can get from this test tool? Or does anyone have any suggestions?

Things I’ve tried
– enable/disable TLS
– port 636 (although the response shows port 389 was good)
– prepending domain name i.i “domain\myuser.name”
– including a suffix (which we don’t even use)

Any hints as to WHY authentication is failing?

AD Integration Logon Test
openLDAP installed

[INFO] method authenticate() called
[INFO] ——————————————
PHP version: 5.5.38
WP version: 4.6
ADI version: 1.1.8
OS Info : Windows NT SERVERNAME 6.3 build 9600 (Windows Server 2012 R2 Datacenter Edition) i586
Web Server : cgi-fcgi
adLDAP ver.: 3.3.2 EXTENDED (201302271401)
——————————————
[INFO] LDAP paging: enabled
[NOTICE] username: myuser.name
[NOTICE] password: **not shown**
[INFO] Options for adLDAP connection:
– account_suffix:
– base_dn: dc=mydomain,dc=net
– domain_controllers: DC100
– ad_port: 389
– use_tls: 1
– network timeout: 5
[INFO] Checking domain controller ports:
[INFO] – DC100:389 – OK
[NOTICE] adLDAP object created.
[INFO] max_login_attempts: 3
[INFO] users failed logins: 0
[NOTICE] trying account suffix “”
[ERROR] Authentication failed
[WARN] storing failed login for user “myuser.name”

https://www.ads-software.com/plugins/active-directory-integration/

Plugin in great and does exactly what i need. I am having an issue that it is not pulling all users though. Put it in debug but didn’t give me more information about the 300 or so users it is not seeing….HELP!

[INFO] ————————————-
START OF BULK IMPORT
2016-08-19 / 15:28:08
————————————-

[INFO] Options for adLDAP connection:
– base_dn: OU=a numbered ou,DC=domain,DC=my
– domain_controllers: 10.x.x.x;10.x.x.x
– ad_username: $something
– ad_password: **not shown**
– ad_port: 389
– use_tls: 0
– network timeout: 5
[NOTICE] adLDAP object created.
[INFO] Domain Controller: 10.x.x.x
[WARN] No group. Nothing to do.
[INFO] Number of users to import/update: 1746 (list generated in 0 seconds)
[DEBUG] ATTRIBUTES TO LOAD: Array

.
.
.

[INFO] Enabling user “xxxx”.
[INFO] 0 Users added.
[INFO] 1439 Users updated.
[INFO] In 34 seconds.
[INFO] ————————————-
END OF BULK IMPORT
2016-08-19 / 15:28:42
————————————-

Bulk Import returned no error.

https://www.ads-software.com/plugins/active-directory-integration/

We currently have the Active Directory Integration turned on, in the Woffice theme. Is there a way to synchronize all users instead of them being added once they login?
Thanks.

https://www.ads-software.com/plugins/active-directory-integration/

On a fresh Centos 7 installation with LAMP following these instructions:-
https://www.howtoforge.com/apache_php_mysql_on_centos_7_lamp
https://www.howtoforge.com/centos_wordpress_install
then add the ADI plugin, configure and….

Maybe I missed it somewhere int he installation notes but to save anybody else the time trying to figure it out, here’s how I fixed a problem where my ADI would not work, even with the firewall switched off. I could use ldapsearch at the command line OK but nothing from ADI in the browser.

a comment on this page sorted me out:-

/usr/sbin/setsebool httpd_can_network_connect=1

I didn’t think I was using SELinux but apparently so.
cooking on gas now ??

Previous error message with additional error codes reporting:-

openLDAP installed
[INFO] method authenticate() called
[INFO] ------------------------------------------
PHP version: 5.4.16
WP version: 4.5.3
ADI version: 1.1.8
OS Info : Linux wp.mydomain.co.uk 3.10.0-327.28.2.el7.x86_64 #1 SMP Wed Aug 3 11:11:39 UTC 2016 x86_64
Web Server : apache2handler
adLDAP ver.: 3.3.2 EXTENDED (201302271401)
------------------------------------------
[INFO] LDAP paging: enabled
[NOTICE] username: aUser
[NOTICE] password: **not shown**
[INFO] Options for adLDAP connection:
- account_suffix: @mydomain.myforest
- base_dn: OU=Users,OU=people,DC=mydomain,DC=myforest
- domain_controllers: 192.168.5.5;192.168.5.6
- ad_port: 389
- use_tls: 0
- network timeout: 5
[INFO] Checking domain controller ports:
[ERROR] - 192.168.5.5:389 - FAILED
$errCode = 13
$errStr = Permission denied
[ERROR] - 192.168.5.6:389 - FAILED
$errCode = 13
$errStr = Permission denied
[NOTICE] adLDAP object created.
[INFO] max_login_attempts: 0
[NOTICE] trying account suffix "@mydomain.myforest"
[ERROR] Authentication failed
[WARN] storing failed login for user "aUser"

Logon failed

https://www.ads-software.com/plugins/active-directory-integration/

I update an user info (in particoular adding the nickname) then i re-login with that user and all updates are lost… (nickname is empty)

In ADI settings->user I tried to uncheck “Automatic User Update” and “Auto Update User Description” but the issue persist.

how can I make persistent this changes?

https://www.ads-software.com/plugins/active-directory-integration/

I had a quick question regarding the Sync Back to AD feature.

I was able to set everything up and am able to change certain fields and have them synced back to AD. However, I was hoping to have this capability on the front-end, since non-administrators won’t be able to access the admin section of the site to change their information.

Am I overlooking something really simple or is this not possible?

Thanks for your help!

Mike

https://www.ads-software.com/plugins/active-directory-integration/

I saw an note from another user, but can I get official confirmation one way or other if this plugin supports BIND user and password for querying?

https://www.ads-software.com/plugins/active-directory-integration/

I maintain a multi-site environment. Yesterday morning, all of a sudden the sites became inactive without me doing anything to it. Before I got off the computer the day before, the site was working just fine.

Today, I started going through the plugins and renaming them to see if one was the culprit and it is your plugin version 0.9.9.9

Once I changed the folder name, the site came back up. However, when I went to log into the admin site, I got another error saying that “[the name of my site] refused to connect”

I got curious. I clicked into the adi_multisite_patch and saw two text file. I’m for sure the first file named “ad-integration” is the issue. The file reads:

<?php

/*
Plugin Name: Active Directory Integration
Version: 0.9.9.9
Plugin URI: https://blog.ecw.de/wp-ad-integration
Description: Allows WordPress to authenticate, authorize, create and update users through Active Directory
Author: Christoph Steindorff, ECW GmbH
Author URI: https://blog.ecw.de/

The work is derived from version 1.0.5 of the plugin Active Directory Authentication:
OriginalPlugin URI: https://soc.qc.edu/jonathan/wordpress-ad-auth
OriginalDescription: Allows WordPress to authenticate users through Active Directory
OriginalAuthor: Jonathan Marc Bearak
OriginalAuthor URI: https://soc.qc.edu/jonathan
*/

/*
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.
*/

if (!class_exists('ADIntegrationPlugin')) {

// LOG LEVEL

define('ADI_LOG_DEBUG', 6);
define('ADI_LOG_INFO',  5);
define('ADI_LOG_NOTICE',4);
define('ADI_LOG_WARN',  3);
define('ADI_LOG_ERROR', 2);
define('ADI_LOG_FATAL', 1);
define('ADI_LOG_NONE',  0);

define('ADI_DUPLICATE_EMAIL_ADDRESS_PREVENT', 'prevent');
define('ADI_DUPLICATE_EMAIL_ADDRESS_ALLOW', 'allow');
define('ADI_DUPLICATE_EMAIL_ADDRESS_CREATE', 'create');

class ADIntegrationPlugin {

   // version of needed DB table structure
   const DB_VERSION = "0.9";

   // name of our own table
   const TABLE_NAME = 'adintegration';

   // is the user authenticated?
   public $_authenticated = false;

   protected $_minium_WPMU_version = '2.8';
   protected $_minium_WP_version = '2.8';

   // log level
   protected $_loglevel = ADI_LOG_NONE;

   // adLDAP-object
   protected $_adldap;

   // Should a new user be created automatically if not already in the WordPress database?
   protected $_auto_create_user = false;

   // Should the users be updated in the WordPress database everytime they logon? (Works only if automatic user creation is set.
   protected $_auto_update_user = false;

   // Account Suffix (will be appended to all usernames created in WordPress, as well as used in the Active Directory authentication process
   protected $_account_suffix = '';

   // Should the account suffix be appended to the usernames created in WordPress?
   protected $_append_suffix_to_new_users = false;

   // Domain Controllers (separate with semicolons)
   protected $_domain_controllers = '';

   // LDAP/AD BASE DN
   protected $_base_dn = '';

   // Role Equivalent Groups (wp-role1=ad-group1;wp-role2=ad-group2;...)
   protected $_role_equivalent_groups = '';

   // Default Email Domain (eg. 'domain.tld')
   protected $_default_email_domain = '';

   // Port on which AD listens (default 389)
   protected $_port = 389;

   // Username for non-anonymous requests to AD
   protected $_bind_user = '';

   // Password for non-anonymous requests to AD
   protected $_bind_pwd = '';

   // Secure the connection between the Drupal and the LDAP servers using TLS.
   protected $_use_tls = false;

   // Check Login authorization by group membership
   protected $_authorize_by_group = false;

   // Group name for authorization.
   protected $_authorization_group = '';

   // Maximum number of failed login attempts before the account is blocked
   protected $_max_login_attempts = 3;

   // Number of seconds an account is blocked after the maximum number of failed login attempts is reached.
   protected $_block_time = 30;

   // Send email to user if his account is blocked.
   protected $_user_notification = false;

   // Send email to admin if a user account is blocked.
   protected $_admin_notification = false;

   // Administrator's e-mail address(es) where notifications should be sent to.
   protected $_admin_email = '';

   // Set user's display_name to an AD attribute or to username if left blank
   // Possible values: description, displayname, mail, sn, cn, givenname, samaccountname
   protected $_display_name = '';

   // Enable/Disable password changes
   protected $_enable_password_change = false;

   protected $_duplicate_email_prevention = ADI_DUPLICATE_EMAIL_ADDRESS_PREVENT;

   // All options and its types
   protected $_all_options = array(
         array('name' => 'AD_Integration_account_suffix', 'type' => 'string'),
         array('name' => 'AD_Integration_auto_create_user', 'type' => 'bool'),
         array('name' => 'AD_Integration_auto_update_user', 'type' => 'bool'),
         array('name' => 'AD_Integration_append_suffix_to_new_users', 'type' => 'bool'),
         array('name' => 'AD_Integration_domain_controllers', 'type' => 'string'),
         array('name' => 'AD_Integration_base_dn', 'type' => 'string'),
         array('name' => 'AD_Integration_prefix_dn', 'type' => 'string'),
         array('name' => 'AD_Integration_role_equivalent_groups', 'type' => 'string'),
         array('name' => 'AD_Integration_default_email_domain', 'type' => 'string'),
         array('name' => 'AD_Integration_port', 'type' => 'int'),
         array('name' => 'AD_Integration_bind_user', 'type' => 'string'),
         array('name' => 'AD_Integration_bind_pwd', 'type' => 'string'),
         array('name' => 'AD_Integration_use_tls', 'type' => 'bool'),
         array('name' => 'AD_Integration_authorize_by_group', 'type' => 'bool'),
         array('name' => 'AD_Integration_authorization_group', 'type' => 'string'),
         array('name' => 'AD_Integration_max_login_attempts', 'type' => 'int'),
         array('name' => 'AD_Integration_block_time', 'type' => 'int'),
         array('name' => 'AD_Integration_user_notification', 'type' => 'bool'),
         array('name' => 'AD_Integration_admin_notification', 'type' => 'bool'),
         array('name' => 'AD_Integration_admin_email', 'type' => 'string'),
         array('name' => 'AD_Integration_display_name', 'type' => 'string'),
         array('name' => 'AD_Integration_enable_password_change', 'type' => 'bool'),
         array('name' => 'AD_Integration_duplicate_email_prevention', 'type' => 'string')
      );

   /**
    * Constructor
    */
   public function __construct() {
      global $wp_version, $wpmu_version, $wpdb, $wpmuBaseTablePrefix;

      if (!defined('IS_WPMU')) {
         define('IS_WPMU', ($wpmu_version != ''));
      }

      // define folder constant
      if (!defined('ADINTEGRATION_FOLDER')) {
         define('ADINTEGRATION_FOLDER', basename(dirname(__FILE__)));
      }

      // Load up the localization file if we're using WordPress in a different language
      // Place it in this plugin's folder and name it "ad-auth-[value in wp-config].mo"
      load_plugin_textdomain( 'ad-integration', WP_PLUGIN_URL.'/'.ADINTEGRATION_FOLDER, ADINTEGRATION_FOLDER );
      load_plugin_textdomain( 'ad-integration', ( (IS_WPMU) ? WPMU_PLUGIN_URL : WP_PLUGIN_URL ).'/'.ADINTEGRATION_FOLDER, ADINTEGRATION_FOLDER );

      // Load Options
      $this->_load_options();

      if (isset($_GET['activate']) and $_GET['activate'] == 'true') {
         add_action('init', array(&$this, 'initialize_options'));
      }

      add_action('admin_menu', array(&$this, 'add_options_page'));
      add_filter('contextual_help', array(&$this, 'contextual_help'), 10, 2);

      // DO WE HAVE LDAP SUPPORT?
      if (function_exists('ldap_connect')) {

         // WP 2.8 and above?
         if (version_compare($wp_version, '2.8', '>=')) {
            add_filter('authenticate', array(&$this, 'authenticate'), 10, 3);
         } else {
            add_action('wp_authenticate', array(&$this, 'authenticate'), 10, 2);
         }

         add_action('lost_password', array(&$this, 'disable_function'));
         add_action('retrieve_password', array(&$this, 'disable_function'));
         add_action('password_reset', array(&$this, 'disable_function'));
          add_action('admin_print_styles', array(&$this, 'load_styles'));
          add_action('admin_print_scripts', array(&$this, 'load_scripts'));

         add_filter('check_password', array(&$this, 'override_password_check'), 10, 4);

         // Is local password change disallowed?
         if (!$this->_enable_password_change) {

            // disable password fields
            add_filter('show_password_fields', array(&$this, 'disable_password_fields'));

            // generate a random passwords for manually added users
            add_action('check_passwords', array(&$this, 'generate_password'), 10, 3);
         }

         if (!class_exists('adLDAP')) {
            require 'ad_ldap/adLDAP.php';
         }
      }
   }

   public function load_styles() {

      wp_register_style('adintegration', ( (IS_WPMU) ? WPMU_PLUGIN_URL : WP_PLUGIN_URL ).'/'.ADINTEGRATION_FOLDER.'/css/adintegration.css',false, '1.7.1', 'screen');
      wp_enqueue_style('adintegration');
   }

   public function load_scripts() {
      wp_enqueue_script( 'jquery-ui-tabs' );
   }

   /*************************************************************
    * Plugin hooks
    *************************************************************/

   /**
    * Add options for this plugin to the database.
    */
   public function initialize_options() {

      if (IS_WPMU) {
         if (is_site_admin()) {
            add_site_option('AD_Integration_account_suffix', '', 'Account Suffix (will be appended to all usernames created in WordPress, as well as used in the Active Directory authentication process');
            add_site_option('AD_Integration_auto_create_user', false, 'Should a new user be created automatically if not already in the WordPress database?');
            add_site_option('AD_Integration_auto_update_user', false, 'Should the users be updated in the WordPress database everytime they logon? (Works only if automatic user creation is set.)');
            add_site_option('AD_Integration_append_suffix_to_new_users', '', false, 'Should the account suffix be appended to the usernames created in WordPress?');
            add_site_option('AD_Integration_domain_controllers', '', 'Domain Controllers (separate with semicolons)');
            add_site_option('AD_Integration_base_dn', '', 'Base DN');
            add_site_option('AD_Integration_prefix_dn', '', 'before userid in DN (e.g., CN, UID, ...)');
            add_site_option('AD_Integration_role_equivalent_groups', '', 'Role Equivalent Groups');
            add_site_option('AD_Integration_default_email_domain', '', 'Default Email Domain');
            add_site_option('AD_Integration_port', '389', 'Port on which AD listens (default 389).');
            add_site_option('AD_Integration_bind_user', '', 'Username for non-anonymous requests to AD.');
            add_site_option('AD_Integration_bind_pwd', '', 'Password for non-anonymous requests to AD.');
            add_site_option('AD_Integration_use_tls', false, 'Secure the connection between the Drupal and the LDAP servers using TLS.');
            add_site_option('AD_Integration_authorize_by_group', false, 'Check Login authorization by group membership.');
            add_site_option('AD_Integration_authorization_group', '', 'Group name for authorization.');
            add_site_option('AD_Integration_max_login_attempts', '3', 'Maximum number of failed login attempts before the account is blocked.');
            add_site_option('AD_Integration_block_time', '30', 'Number of seconds an account is blocked after the maximum number of failed login attempts is reached.');
            add_site_option('AD_Integration_user_notification', false, 'Send email to user if his account is blocked.');
            add_site_option('AD_Integration_admin_notification', false, 'Send email to admin if a user account is blocked.');
            add_site_option('AD_Integration_admin_email', '', "Administrator's email address where notifications should be sent to.");
            add_site_option('AD_Integration_display_name', '', "Set user's display_name to an AD attribute or to username if left blank.");
            add_site_option('AD_Integration_enable_password_change', false, 'Enable the ability of the users to change their WP passwords.');
            add_site_option('AD_Integration_duplicate_email_prevention', ADI_DUPLICATE_EMAIL_ADDRESS_PREVENT, 'Prevent duplicate email addresses?');
         }
      } else {
         if (current_user_can('manage_options')) {
            add_option('AD_Integration_account_suffix', '', 'Account Suffix (will be appended to all usernames created in WordPress, as well as used in the Active Directory authentication process');
            add_option('AD_Integration_auto_create_user', false, 'Should a new user be created automatically if not already in the WordPress database?');
            add_option('AD_Integration_auto_update_user', false, 'Should the users be updated in the WordPress database everytime they logon? (Works only if automatic user creation is set.)');
            add_option('AD_Integration_append_suffix_to_new_users', '', false, 'Should the account suffix be appended to the usernames created in WordPress?');
            add_option('AD_Integration_domain_controllers', '', 'Domain Controllers (separate with semicolons)');
            add_option('AD_Integration_base_dn', '', 'Base DN');
            add_option('AD_Integration_prefix_dn', '', 'before userid in DN (e.g., CN, UID, ...)');
            add_option('AD_Integration_role_equivalent_groups', '', 'Role Equivalent Groups');
            add_option('AD_Integration_default_email_domain', '', 'Default Email Domain');
            add_option('AD_Integration_port', '389', 'Port on which AD listens (default 389).');
            add_option('AD_Integration_bind_user', '', 'Username for non-anonymous requests to AD.');
            add_option('AD_Integration_bind_pwd', '', 'Password for non-anonymous requests to AD.');
            add_option('AD_Integration_use_tls', false, 'Secure the connection between the Drupal and the LDAP servers using TLS.');
            add_option('AD_Integration_authorize_by_group', false, 'Check Login authorization by group membership.');
            add_option('AD_Integration_authorization_group', '', 'Group name for authorization.');
            add_option('AD_Integration_max_login_attempts', '3', 'Maximum number of failed login attempts before the account is blocked.');
            add_option('AD_Integration_block_time', '30', 'Number of seconds an account is blocked after the maximum number of failed login attempts is reached.');
            add_option('AD_Integration_user_notification', false, 'Send email to user if his account is blocked.');
            add_option('AD_Integration_admin_notification', false, 'Send email to admin if a user account is blocked.');
            add_option('AD_Integration_admin_email', '', "Administrator's email address where notifications should be sent to.");
            add_option('AD_Integration_display_name', '', "Set user's display_name to an AD attribute or to username if left blank.");
            add_option('AD_Integration_enable_password_change', false, 'Enable or disabled the ability to the change user WP passwords.');
            add_option('AD_Integration_duplicate_email_prevention', ADI_DUPLICATE_EMAIL_ADDRESS_PREVENT, 'Prevent duplicate email addresses?');

         }
      }
   }

   /**
    * Add an options pane for this plugin.
    */
   public function add_options_page() {

      if (IS_WPMU && is_site_admin()) {
         // WordPress MU
         if (function_exists('add_submenu_page')) {
            add_submenu_page('wpmu-admin.php', __('Active Directory Integration'), __('Active Directory Integration'), 'manage_options', __FILE__, array(&$this, '_display_options_page'));
         }
      }

      if (!IS_WPMU) {
         // WordPress Standard
         if (function_exists('add_options_page')) {
            add_options_page('Active Directory Integration', 'Active Directory Integration', 'manage_options', __FILE__, array(&$this, '_display_options_page'));
         }
      }
   }

   /**
    * Wrapper
    *
    * @param $arg1 WP_User or username
    * @param $arg2 username or password
    * @param $arg3 passwprd or empty
    * @return WP_User
    */
   public function authenticate($arg1 = NULL, $arg2 = NULL, $arg3 = NULL) {
      global $wp_version, $wpmu_version;

      $this->_log(ADI_LOG_INFO,'method authenticate() called');

      if (IS_WPMU) {
         $version = $wpmu_version;
      } else {
         $version = $wp_version;
      }

      $this->_log(ADI_LOG_INFO,'WP version: '.$version);

      if (version_compare($version, '2.8', '>=')) {
         return $this->ad_authenticate($arg1, $arg2, $arg3);
      } else {
         return $this->ad_authenticate(NULL, $arg1, $arg2);
      }
   }

   /**
    * If the REMOTE_USER evironment is set, use it as the username.
    * This assumes that you have externally authenticated the user.
    */
   public function ad_authenticate($user = NULL, $username = '', $password = '') {

      $user_id = NULL;

      $this->_authenticated = false;

      // IMPORTANT!
      $username = strtolower($username);

      $this->_log(ADI_LOG_NOTICE,'username: '.$username);
      $this->_log(ADI_LOG_DEBUG,'password: '.$password);

      // Load options from WordPress-DB.
      $this->_load_options();

      // Log informations
      $this->_log(ADI_LOG_INFO,"Options for adLDAP connection:\n".
                 "- account_suffix: $this->_account_suffix\n".
                 "- base_dn: $this->_base_dn\n".
                 "- domain_controllers: $this->_domain_controllers\n".
                 "- ad_username: $this->_bind_user\n".
                 "- ad_password: $this->_bind_pwd\n".
                 "- ad_port: $this->_port\n".
                 "- use_tls: $this->_use_tls");

      // Connect to Active Directory
      try {
         $this->_adldap = @new adLDAP(array(
                  "account_suffix" => $this->_account_suffix,
                  "base_dn" => $this->_base_dn,
                  "domain_controllers" => explode(';', $this->_domain_controllers),
                  "ad_username" => $this->_bind_user,      // AD Bind User
                  "ad_password" => $this->_bind_pwd,       // password
                  "ad_port" => $this->_port,               // AD port
                  "use_tls" => $this->_use_tls             // secure?
                  ));
      } catch (Exception $e) {
          $this->_log(ADI_LOG_ERROR,'adLDAP exception: ' . $e->getMessage());
          return false;
      }

      $this->_log(ADI_LOG_NOTICE,'adLDAP object created.');

      // Check for maximum login attempts
      $this->_log(ADI_LOG_INFO,'max_login_attempts: '.$this->_max_login_attempts);
      if ($this->_max_login_attempts > 0) {
         $failed_logins = $this->_get_failed_logins_within_block_time($username);
         $this->_log(ADI_LOG_INFO,'users failed logins: '.$failed_logins);
         if ($failed_logins >= $this->_max_login_attempts) {
            $this->_authenticated = false;

            $this->_log(ADI_LOG_ERROR,'Authentication failed');
            $this->_log(ADI_LOG_ERROR,"Account '$username' blocked for $this->_block_time seconds");

            // e-mail notfications if user is blocked
            if ($this->_user_notification) {
               $this->_notify_user($username);
               $this->_log(ADI_LOG_NOTICE,"Notification send to user.");
            }
            if ($this->_admin_notification) {
               $this->_notify_admin($username);
               $this->_log(ADI_LOG_NOTICE,"Notification send to admin(s).");
            }

            // Show the blocking page to the user (only if we are not in debug/log mode)
            if ($this->_loglevel == ADI_LOG_NONE) {
               $this->_display_blocking_page($username);
            }
            die(); // important !
         }
      }

      // This is where the action is.
      if ( $this->_adldap->authenticate($username, $password) )
      {
         $this->_log(ADI_LOG_NOTICE,'Authentication successfull');
         $this->_authenticated = true;
      }

      if ( $this->_authenticated == false )
      {
         $this->_log(ADI_LOG_ERROR,'Authentication failed');
         $this->_authenticated = false;
         $this->_store_failed_login($username);
         return false;
      }

      // Cleanup old database entries
      $this->_cleanup_failed_logins($username);

      // Check the authorization
      if ($this->_authorize_by_group) {
         if ($this->_check_authorization_by_group($username)) {
            $this->_authenticated = true;
         } else {
            $this->_authenticated = false;
            return false;
         }
      }

      $ad_username = $username;

      // should the account suffix be used for the new username?
      if ($this->_append_suffix_to_new_users) {
         $username .= $this->_account_suffix;
      }

      // Create new users automatically, if configured
      $user = get_userdatabylogin($username);

      if (!$user OR ($user->user_login != $username)) {
         $user_role = $this->_get_user_role_equiv($ad_username);
         if ($this->_auto_create_user || trim($user_role) != '' ) {
               // create user
               $userinfo = $this->_adldap->user_info($ad_username, array('sn', 'givenname', 'mail', 'displayName', 'description', 'cn'));
               $userinfo = $userinfo[0];
               $email = $userinfo['mail'][0];
               $first_name = $userinfo['givenname'][0];
               $last_name = $userinfo['sn'][0];
               $display_name = $this->_get_display_name_from_AD($username, $userinfo);
               $user_id = $this->_create_user($ad_username, $email, $first_name, $last_name, $display_name, $user_role);
         } else {
            // Bail out to avoid showing the login form
            $this->_log(ADI_LOG_ERROR,'This user exists in Active Directory, but has not been granted access to this installation of WordPress.');
            return new WP_Error('invalid_username', __('<strong>ERROR</strong>: This user exists in Active Directory, but has not been granted access to this installation of WordPress.'));
         }
      } else {

         //  update known users if configured
         if ($this->_auto_create_user AND $this->_auto_update_user) {
            // Update users role
            $user_role = $this->_get_user_role_equiv($ad_username);
            $userinfo = $this->_adldap->user_info($ad_username, array('sn', 'givenname', 'mail', 'displayName', 'description', 'cn'));
            $userinfo = $userinfo[0];

            $email = $userinfo['mail'][0];
            $first_name = $userinfo['givenname'][0];
            $last_name = $userinfo['sn'][0];
            $common_name = $userinfo['cn'][0];
            $display_name = $this->_get_display_name_from_AD($username, $userinfo);
            $user_id = $this->_update_user($ad_username, $email, $first_name, $last_name, $display_name, $user_role);
         }
      }

      // load user object
      if (!$user_id) {
         require_once(ABSPATH . WPINC . DIRECTORY_SEPARATOR .'registration.php');
         $user_id = username_exists($username);
         $this->_log(ADI_LOG_NOTICE,'user_id: '.$user_id);
      }
      $user = new WP_User($user_id);

      $this->_log(ADI_LOG_NOTICE,'FINISHED');
      return $user;
   }

   /*
    * Skip the password check, since we've externally authenticated.
    */
   public function override_password_check($check, $password, $hash, $user_id) {
      if ( $this->_authenticated == true )
      {
         return true;
      }
      else
      {
         return $check;
      }
   }

   /*
    * Generate a password for the user. This plugin does not
    * require the user to enter this value, but we want to set it
    * to something nonobvious.
    */
   public function generate_password($username, $password1, $password2) {
      $password1 = $password2 = $this->_get_password();
   }

   /*
    * Used to disable certain display elements, e.g. password
    * fields on profile screen.
    */
   public function disable_password_fields($show_password_fields) {
      return false;
   }

   /*
    * Used to disable certain login functions, e.g. retrieving a
    * user's password.
    */
   public function disable_function() {
      die('Disabled');
   }

   /**
    * Shows the contexual help on the options/admin screen.
    *
    * @param $help
    * @param $screen
    * @return string help message
    */
   public function contextual_help ($help, $screen) {
      if ($screen == 'settings_page_' . ADINTEGRATION_FOLDER . '/ad-integration'
                       || $screen == 'wpmu-admin_page_' . ADINTEGRATION_FOLDER . '/ad-integration') {
         $help .= '<h5>' . __('Active Directory Integration Help','ad-integration') . '</h5><div class="metabox-prefs">';
         $help .= '<a href="https://blog.ecw.de/wp-ad-integration">'.__ ('Overview','ad-integration').'</a><br/>';
         $help .= '<a href="https://www.ads-software.com/extend/plugins/active-directory-integration/faq/">'.__ ('FAQ', 'ad-integration').'</a><br/>';
         $help .= '<a href="https://www.ads-software.com/extend/plugins/active-directory-integration/changelog/">'.__ ('Changelog', 'ad-integration').'</a><br/>';
         $help .= '<a href="https://www.ads-software.com/tags/active-directory-integration">'.__ ('Support-Forum', 'ad-integration').'</a><br/>';

         $help .= '</div>';
      }
      return $help;
   }

   public function setLogLevel($level = 0) {
      $this->_loglevel = (int)$level;
   }

   public function disableDebug() {
      $this->debug = false;
   }

   /****************************************************************
    * STATIC FUNCTIONS
    ****************************************************************/

   /**
    * Determine global table prefix, usually "wp_".
    *
    * @return string table prefix
    */
   public static function global_db_prefix() {
      global $wpmu_version, $wpdb, $wpmuBaseTablePrefix;

      // define table prefix
      if ($wpmu_version != '') {
         return $wpmuBaseTablePrefix;
      } else {
         return $wpdb->prefix;
      }
   }

   /**
    * Adding the needed table to database and store the db version in the
    * options table on plugin activation.
    */
   public static function activate() {
      global $wpdb, $wpmu_version;

      //$table_name = $wpdb->prefix . ADIntegrationPlugin::TABLE_NAME;
      $table_name = ADIntegrationPlugin::global_db_prefix() . ADIntegrationPlugin::TABLE_NAME;

      if ($wpmu_version != '') {
         $db_version = get_site_option('AD_Integration_db_version');
      } else {
         $db_version = get_option('AD_Integration_db_version');
      }

      if (($wpdb->get_var("show tables like '$table_name'") != $table_name) OR ($db_version != ADIntegrationPlugin::DB_VERSION)) {

          $sql = 'CREATE TABLE ' . $table_name . ' (
                 id bigint(20) NOT NULL AUTO_INCREMENT,
                 user_login varchar(60),
                 failed_login_time bigint(11),
                 UNIQUE KEY id (id)
              );';

         require_once(ABSPATH . 'wp-admin/includes/upgrade.php');
            dbDelta($sql);

            // store db version in the options
            if ($wpmu_version != '') {
               add_site_option('AD_Integration_db_version', ADIntegrationPlugin::DB_VERSION, 'Version of the table structure');
            } else {
               add_option('AD_Integration_db_version', ADIntegrationPlugin::DB_VERSION, 'Version of the table structure');
            }
      }
   }

   /**
    * Delete the table from database and delete the db version from the
    * options table on plugin deactivation.
    */
   public static function deactivate() {
      global $wpdb, $wpmu_version;

      $table_name = ADIntegrationPlugin::global_db_prefix() . ADIntegrationPlugin::TABLE_NAME;

      // drop table
      $wpdb->query('DROP TABLE IF EXISTS '.$table_name);

      // delete option
      if ($wpmu_version != '') {
         delete_site_option('AD_Integration_db_version');
      } else {
         delete_option('AD_Integration_db_version');
      }
   }

   /**
    * removes the plugin options from options table.
    */
   public static function uninstall($echo=false) {
      foreach($this->_all_options as $option) {
         $delete_setting = delete_option($option['name']);
         if ($echo) {
            if($delete_setting) {
               echo '<font color="green">';
               printf(__('Setting Key \'%s\' has been deleted.', 'ad-integration'), "<strong><em>{$option['name']}</em></strong>");
               echo '</font><br />';
            } else {
               echo '<font color="red">';
               printf(__('Error deleting Setting Key \'%s\'.', 'ad-integration'), "<strong><em>{$option['name']}</em></strong>");
               echo '</font><br />';
            }
         }
      }
   }

   /*************************************************************
    * Functions
    *************************************************************/

   /**
    * Loads the options from WordPress-DB
    */
   protected function _load_options() {
      $this->_log(ADI_LOG_INFO,'loading options...');
      if (IS_WPMU) {
         $this->_auto_create_user          = (bool)get_site_option('AD_Integration_auto_create_user');
         $this->_auto_update_user          = (bool)get_site_option('AD_Integration_auto_update_user');
         $this->_account_suffix             = get_site_option('AD_Integration_account_suffix');
         $this->_append_suffix_to_new_users    = get_site_option('AD_Integration_append_suffix_to_new_users');
         $this->_domain_controllers          = get_site_option('AD_Integration_domain_controllers');
         $this->_base_dn                  = get_site_option('AD_Integration_base_dn');
         $this->_prefix_dn                  = get_site_option('AD_Integration_prefix_dn');
         $this->_bind_user                = get_site_option('AD_Integration_bind_user');
         $this->_bind_pwd                = get_site_option('AD_Integration_bind_pwd');
         $this->_port                   = get_site_option('AD_Integration_port');
         $this->_use_tls                = get_site_option('AD_Integration_use_tls');
         $this->_default_email_domain       = get_site_option('AD_Integration_default_email_domain');
         $this->_authorize_by_group          = (bool)get_site_option('AD_Integration_authorize_by_group');
         $this->_authorization_group       = get_site_option('AD_Integration_authorization_group');
         $this->_role_equivalent_groups       = get_site_option('AD_Integration_role_equivalent_groups');
         $this->_max_login_attempts          = (int)get_site_option('AD_Integration_max_login_attempts');
         $this->_block_time                = (int)get_site_option('AD_Integration_block_time');
         $this->_user_notification           = (bool)get_site_option('AD_Integration_user_notification');
         $this->_admin_notification         = (bool)get_site_option('AD_Integration_admin_notification');
         $this->_admin_email               = get_site_option('AD_Integration_admin_email');
         $this->_display_name            = get_site_option('AD_Integration_display_name');
         $this->_enable_password_change      = get_site_option('AD_Integration_enable_password_change');
         $this->_duplicate_email_prevention  = get_site_option('AD_Integration_duplicate_email_prevention');
      } else {
         $this->_auto_create_user          = (bool)get_option('AD_Integration_auto_create_user');
         $this->_auto_update_user          = (bool)get_option('AD_Integration_auto_update_user');
         $this->_account_suffix             = get_option('AD_Integration_account_suffix');
         $this->_append_suffix_to_new_users    = get_option('AD_Integration_append_suffix_to_new_users');
         $this->_domain_controllers          = get_option('AD_Integration_domain_controllers');
         $this->_base_dn                  = get_option('AD_Integration_base_dn');
         $this->_prefix_dn                  = get_option('AD_Integration_prefix_dn');
         $this->_bind_user                = get_option('AD_Integration_bind_user');
         $this->_bind_pwd                = get_option('AD_Integration_bind_pwd');
         $this->_port                   = get_option('AD_Integration_port');
         $this->_use_tls                = get_option('AD_Integration_use_tls');
         $this->_default_email_domain       = get_option('AD_Integration_default_email_domain');
         $this->_authorize_by_group          = (bool)get_option('AD_Integration_authorize_by_group');
         $this->_authorization_group       = get_option('AD_Integration_authorization_group');
         $this->_role_equivalent_groups       = get_option('AD_Integration_role_equivalent_groups');
         $this->_max_login_attempts          = (int)get_option('AD_Integration_max_login_attempts');
         $this->_block_time                = (int)get_option('AD_Integration_block_time');
         $this->_user_notification           = (bool)get_option('AD_Integration_user_notification');
         $this->_admin_notification         = (bool)get_option('AD_Integration_admin_notification');
         $this->_admin_email               = get_option('AD_Integration_admin_email');
         $this->_display_name            = get_option('AD_Integration_display_name');
         $this->_enable_password_change      = get_option('AD_Integration_enable_password_change');
         $this->_duplicate_email_prevention  = get_option('AD_Integration_duplicate_email_prevention');
      }
   }

   /**
    * Saves the options to the sitewide options store. This is only needed for WPMU.
    *
    * @param $arrPost the POST-Array with the new options
    * @return unknown_type
    */
   protected function _save_wpmu_options($arrPost) {
       if (IS_WPMU) {
         if ( !empty( $arrPost['AD_Integration_auto_create_user'] ) )
             update_site_option('AD_Integration_auto_create_user', (bool)$arrPost['AD_Integration_auto_create_user']);

         if ( !empty( $arrPost['AD_Integration_auto_update_user'] ) )
             update_site_option('AD_Integration_auto_update_user', (bool)$arrPost['AD_Integration_auto_update_user']);

         if ( !empty( $arrPost['AD_Integration_account_suffix'] ) )
             update_site_option('AD_Integration_account_suffix', $arrPost['AD_Integration_account_suffix']);

         if ( !empty( $arrPost['AD_Integration_append_suffix_to_new_users'] ) )
             update_site_option('AD_Integration_append_suffix_to_new_users', $arrPost['AD_Integration_append_suffix_to_new_users']);

         if ( !empty( $arrPost['AD_Integration_domain_controllers'] ) )
             update_site_option('AD_Integration_domain_controllers', $arrPost['AD_Integration_domain_controllers']);

         if ( !empty( $arrPost['AD_Integration_base_dn'] ) )
             update_site_option('AD_Integration_base_dn', $arrPost['AD_Integration_base_dn']);

         if ( !empty( $arrPost['AD_Integration_prefix_dn'] ) )
             update_site_option('AD_Integration_prefix_dn', $arrPost['AD_Integration_prefix_dn']);

         if ( !empty( $arrPost['AD_Integration_bind_user'] ) )
             update_site_option('AD_Integration_bind_user', $arrPost['AD_Integration_bind_user']);

         if ( !empty( $arrPost['AD_Integration_bind_pwd'] ) )
             update_site_option('AD_Integration_bind_pwd', $arrPost['AD_Integration_bind_pwd']);

         if ( !empty( $arrPost['AD_Integration_port'] ) )
             update_site_option('AD_Integration_port', $arrPost['AD_Integration_port']);

         if ( !empty( $arrPost['AD_Integration_use_tls'] ) )
             update_site_option('AD_Integration_use_tls', $arrPost['AD_Integration_use_tls']);

         if ( !empty( $arrPost['AD_Integration_default_email_domain'] ) )
             update_site_option('AD_Integration_default_email_domain', $arrPost['AD_Integration_default_email_domain']);

         if ( !empty( $arrPost['AD_Integration_authorize_by_group'] ) )
             update_site_option('AD_Integration_authorize_by_group', (bool)$arrPost['AD_Integration_authorize_by_group']);

         if ( !empty( $arrPost['AD_Integration_authorization_group'] ) )
             update_site_option('AD_Integration_authorization_group', $arrPost['AD_Integration_authorization_group']);

         if ( !empty( $arrPost['AD_Integration_role_equivalent_groups'] ) )
             update_site_option('AD_Integration_role_equivalent_groups', $arrPost['AD_Integration_role_equivalent_groups']);

         if ( !empty( $arrPost['AD_Integration_max_login_attempts'] ) )
             update_site_option('AD_Integration_max_login_attempts', (int)$arrPost['AD_Integration_max_login_attempts']);

         if ( !empty( $arrPost['AD_Integration_block_time'] ) )
             update_site_option('AD_Integration_block_time', (int)$arrPost['AD_Integration_block_time']);

         if ( !empty( $arrPost['AD_Integration_user_notification'] ) )
             update_site_option('AD_Integration_user_notification', (bool)$arrPost['AD_Integration_user_notification']);

         if ( !empty( $arrPost['AD_Integration_admin_notification'] ) )
             update_site_option('AD_Integration_admin_notification', (bool)$arrPost['AD_Integration_admin_notification']);

         if ( !empty( $arrPost['AD_Integration_admin_email'] ) )
             update_site_option('AD_Integration_admin_email', $arrPost['AD_Integration_admin_email']);

         if ( !empty( $arrPost['AD_Integration_display_name'] ) )
             update_site_option('AD_Integration_display_name', $arrPost['AD_Integration_display_name']);

         if ( !empty( $arrPost['AD_Integration_enable_password_change'] ) )
            update_site_option('AD_Integration_enable_password_change', $arrPost['AD_Integration_enable_password_change']);

         // let's load the new values
         $this->_load_options();
      }
   }

   /**
    * Determine the display_name to be stored in WP database.
    * @param $username  the username used to login
    * @param $userinfo  the array with data returned from AD
    * @return string  display_name
    */
   protected function _get_display_name_from_AD($username, $userinfo) {
      if (($this->_display_name == '') OR ($this->_display_name == 'sAMAccountName')) {
         return $username;
      }
      $display_name = $userinfo[$this->_display_name][0];
      if ($display_name == '') {
         return $username;
      } else {
         return $display_name;
      }
   }

   /**
    * Stores the username and the current time in the db.
    *
    * @param $username
    * @return unknown_type
    */
   protected function _store_failed_login($username) {
      global $wpdb;

      $this->_log(ADI_LOG_WARN,'storing failed login for user "'.$username.'"');
      $table_name = ADIntegrationPlugin::global_db_prefix() . ADIntegrationPlugin::TABLE_NAME;

      $sql = "INSERT INTO $table_name (user_login, failed_login_time) VALUES ('" . $wpdb->escape($username)."'," . time() . ")";
      $result = $wpdb->query($sql);

   }

   /**
    * Determines the number of failed login attempts of specific user within a specific time from now to the past.
    *
    * @param $username
    * @param $seconds number of seconds
    * @return number of failed login attempts
    */
   protected function _get_failed_logins_within_block_time($username) {
      global $wpdb;
      $table_name = ADIntegrationPlugin::global_db_prefix() . ADIntegrationPlugin::TABLE_NAME;
      $time = time() - (int)$this->_block_time;

      $sql = "SELECT count(*) AS count from $table_name WHERE user_login = '".$wpdb->escape($username)."' AND failed_login_time >= $time";
      return $wpdb->get_var($sql);
   }

   /**
    * Deletes entries from store where the time of failed logins is more than the specified block time ago.
    * Deletes also all entries of a user, if its username is given .
    *
    * @param $username
    * @return
    */
   protected function _cleanup_failed_logins($username = NULL) {
      global $wpdb;

      $this->_log(ADI_LOG_NOTICE,'cleaning up failed logins for user "'.$username.'"');
      $table_name = ADIntegrationPlugin::global_db_prefix() . ADIntegrationPlugin::TABLE_NAME;
      $time = time() - $this->_block_time;

      $sql = "DELETE FROM $table_name WHERE failed_login_time < $time";
      if ($username != NULL) {
         $sql .= " OR user_login = '".$wpdb->escape($username)."'";
      }

      $results = $wpdb->query($sql);
   }

   /**
    * Get the rest of the time an account is blocked.
    *
    * @param $username
    * @return int seconds the account is blocked, or 0
    */
   protected function _get_rest_of_blocking_time($username) {
      global $wpdb;

      $table_name = ADIntegrationPlugin::global_db_prefix() . ADIntegrationPlugin::TABLE_NAME;

      $sql = "SELECT max(failed_login_time) FROM $table_name WHERE user_login = '".$wpdb->escape($username)."'";
      $max_time = $wpdb->get_var($sql);

      if ($max_time == NULL ) {
         return 0;
      }
      return ($max_time + $this->_block_time) - time();

   }

   /**
    * Generate a random password.
    *
    * @param int $length Length of the password
    * @return password as string
    */
   protected function _get_password($length = 10) {
      return substr(md5(uniqid(microtime())), 0, $length);
   }

   /**
    * Create a new WordPress account for the specified username.
    * @param $username
    * @param $email
    * @param $first_name
    * @param $last_name
    * @param $display_name
    * @param $role
    * @return integer user_id
    */
   protected function _create_user($username, $email, $first_name, $last_name, $display_name = '', $role = '')
   {
      global $wp_version;

      $password = $this->_get_password();

      if ( $email == '' )
      {
         if (trim($this->_default_email_domain) != '') {
            $email = $username . '@' . $this->_default_email_domain;
         } else {
            if (strpos($username, '@') !== false) {
               $email = $username;
            }
         }
      }

      // append account suffix to new users?
      if ($this->_append_suffix_to_new_users) {
         $username .= $this->_account_suffix;
      }

      $this->_log(ADI_LOG_NOTICE,"Creating user '$username' with following data:\n".
                 "- email: $email\n".
                 "- first name: $first_name\n".
                 "- last name: $last_name\n".
                 "- display name: $display_name\n".
                 "- role: $role");

      require_once(ABSPATH . WPINC . DIRECTORY_SEPARATOR . 'registration.php');

      if ($this->_duplicate_email_prevention == ADI_DUPLICATE_EMAIL_ADDRESS_ALLOW) {
         if (!defined('WP_IMPORTING')) {
            define('WP_IMPORTING',true); // This is a dirty hack. See wp-includes/registration.php
         }
      }

      if ($this->_duplicate_email_prevention == ADI_DUPLICATE_EMAIL_ADDRESS_CREATE) {
         $new_email = $this->_create_non_duplicate_email($email);
         if ($new_email !== $email) {
            $this->_log(ADI_LOG_NOTICE, "Duplicate email address prevention: Email changed from $email to $new_email.");
         }
         $email = $new_email;
      }

      // Here we go!
      $return = wp_create_user($username, $password, $email);

      // log errors
      if (is_wp_error($return)) {
            $this->_log(ADI_LOG_ERROR, $return->get_error_message());
      }

      $user_id = username_exists($username);
      $this->_log(ADI_LOG_NOTICE,' - user_id: '.$user_id);
      if ( !$user_id ) {
         $this->_log(ADI_LOG_FATAL,'Error creating user.');
         die("Error creating user!");
      } else {
         if (version_compare($wp_version, '3', '>=')) {
            // WP 3.0 and above
            update_user_meta($user_id, 'first_name', $first_name);
            update_user_meta($user_id, 'last_name', $last_name);
         } else {
            // WP 2.x
            update_usermeta($user_id, 'first_name', $first_name);
            update_usermeta($user_id, 'last_name', $last_name);
         }

         // set display_name
         if ($display_name != '') {
            $return = wp_update_user(array('ID' => $user_id, 'display_name' => $display_name));
         }

         // set role
         if ( $role != '' )
         {
            $return = wp_update_user(array("ID" => $user_id, "role" => $role));
         }
      }

      return $user_id;
   }

   /**
    * Updates a specific WordPress user account
    *
    * @param $username
    * @param $email
    * @param $first_name
    * @param $last_name
    * @param $display_name
    * @param $role
    * @return integer user_id
    */
   protected function _update_user($username, $email, $first_name, $last_name, $display_name='', $role = '')
   {
      global $wp_version;

      if ( $email == '' )
      {
         if (trim($this->_default_email_domain) != '') {
            $email = $username . '@' . $this->_default_email_domain;
         } else {
            if (strpos($username, '@') !== false) {
               $email = $username;
            }
         }
      }

      if ($this->_append_suffix_to_new_users) {
         $username .= $this->_account_suffix;
      }

      $this->_log(ADI_LOG_NOTICE,'Updating user "'.$username."\" with following data:\n".
                 "- email: $email\n".
                 "- first name: $first_name\n".
                 "- last name: $last_name\n".
                 "- display name: $display_name\n".
                 "- role: $role");

      require_once(ABSPATH . WPINC . DIRECTORY_SEPARATOR . 'registration.php');

      $user_id = username_exists($username);
      $this->_log(ADI_LOG_NOTICE,' - user_id: '.$user_id);
      if ( !$user_id ) {
         $this->_log(ADI_LOG_FATAL,'Error updating user.');
         die('Error updating user!');
      } else {
         if (version_compare($wp_version, '3', '>=')) {
            // WP 3.0 and above
            update_user_meta($user_id, 'first_name', $first_name);
            update_user_meta($user_id, 'last_name', $last_name);
         } else {
            // WP 2.x
            update_usermeta($user_id, 'first_name', $first_name);
            update_usermeta($user_id, 'last_name', $last_name);
         }

         // set display_name
         if ($display_name != '') {
            wp_update_user(array('ID' => $user_id, 'display_name' => $display_name));
         }

         // set role
         if ( $role != '' )
         {
            wp_update_user(array('ID' => $user_id, 'role' => $role));
         }

         // set email
         if ( $email != '' )
         {
            $return = wp_update_user(array('ID' => $user_id, 'user_email' => $email));
         }
      }

      // log errors
      if (isset($return)) {
         if (is_wp_error($return)) {
               $this->_log(ADI_LOG_ERROR, $return->get_error_message());
         }
      }

      return $user_id;
   }

   /**
    * Returns the given email address or a newly created so no 2 users
    * can have the same email address.
    *
    * @param $email original email address
    * @return unique email address
    */
   protected function _create_non_duplicate_email($email)
   {
      if (!email_exists($email)) {
         return $email;
      }

      // Ok, lets create a new email address that does not already exists in the database
      $arrEmailParts = split('@',$email);
      $counter = 1;
      $ok = false;
      while ($ok !== true) {
         $email = $arrEmailParts[0].$counter.'@'.$arrEmailParts[1];
         $ok = !email_exists($email);
         $counter++;
      }
      return $email;
   }

   /**
    * Checks if the user is member of the group(s) allowed to login
    *
    * @param $username
    * @return boolean
    */
   protected function _check_authorization_by_group($username) {
      if ($this->_authorize_by_group) {
         $authorization_groups = explode(';', $this->_authorization_group);
         foreach ($authorization_groups as $authorization_group) {
            if ($this->_adldap->user_ingroup($username, $authorization_group, true)) {
               $this->_log(ADI_LOG_NOTICE,'Authorized by membership of group "'.$authorization_group.'"');
               return true;
            }
         }
         $this->_log(ADI_LOG_WARN,'Authorization by group failed. User is not authorized.');
         return false;
      } else {
         return true;
      }
   }

   /**
    * Get the first matching role from the list of role equivalent groups the user belongs to.
    *
    * @param $ad_username
    * @return string matching role
    */
   protected function _get_user_role_equiv($ad_username) {

      $role_equiv_groups = explode(';', $this->_role_equivalent_groups);

      $user_role = '';
      foreach ($role_equiv_groups as $whatever => $role_group)
      {
            $role_group = explode('=', $role_group);
            if ( count($role_group) != 2 )
            {
               continue;
            }
            $ad_group = $role_group[0];

            $corresponding_role = $role_group[1];
            if ( $this->_adldap->user_ingroup($ad_username, $ad_group, true ) )
            {
               $user_role = $corresponding_role;
               break;
            }
      }
      $this->_log(ADI_LOG_INFO,'user role: '.$user_role);
      return $user_role;
   }

   /**
    * Send an email to the user who's account is blocked
    *
    * @param $username string
    * @return unknown_type
    */
   protected function _notify_user($username)
   {
      // if auto creation is enabled look for the user in AD
      if ($this->_auto_create_user) {

         $userinfo = $this->_adldap->user_info($username, array("sn", "givenname", "mail"));
         if ($userinfo) {
            $userinfo = $userinfo[0];
            $email = $userinfo['mail'][0];
            $first_name = $userinfo['givenname'][0];
            $last_name = $userinfo['sn'][0];
         } else {
            return false;
         }
      } else {
         // auto creation is disabled, so look for the user in local database
         require_once(ABSPATH . WPINC . DIRECTORY_SEPARATOR . 'registration.php');
         $user_id = username_exists($username);
         if ($user_id) {
            $user_info = get_userdata($user_id);
            $last_name = $user_info->last_name;
            $first_name = $user_info->first_name;
            $email = $user_info->user_email;
         } else {
            return false;
         }
      }

      // do we have a correct email address?
      if (is_email($email)) {
         $blog_url = get_bloginfo('url');
         $blog_name = get_bloginfo('name');
         $blog_domain = preg_replace ('/^(http:\/\/)(.+)\/.*$/i','$2', $blog_url);

         $subject = '['.$blog_name.'] '.__('Account blocked','ad-integration');
         $body = sprintf(__('Someone tried to login to %s (%s) with your username (%s) - but in vain. For security reasons your account is now blocked for %d seconds.','ad-integration'), $blog_name, $blog_url, $username, $this->_block_time);
         $body .= "\n\r";
         $body .= __('THIS IS A SYSTEM GENERATED E-MAIL, PLEASE DO NOT RESPOND TO THE E-MAIL ADDRESS SPECIFIED ABOVE.','ad-integration');

         $header = 'From: "WordPress" <wordpress@'.$blog_domain.">\r\n";
         return wp_mail($email, $subject, $body, $header);
      } else {
         return false;
      }
   }

   /**
    * Notify administrator(s) by e-mail if an account is blocked
    *
    * @param $username username of the blocked account
    * @return boolean false if no e-mail is sent, true on success
    */
   protected function _notify_admin($username)
   {
      $arrEmail = array(); // list of recipients

      if ($this->_admin_notification) {
         $email = $this->_admin_email;

         // Should we use Blog-Administrator's e-mail
         if (trim($email) == '') {
            // Is this an e-mail address?
            if (is_email($email)) {
               $arrEmail[0] = trim(get_bloginfo('admin_email '));
            }
         } else {
            // Using own list of notification recipients
            $arrEmail = explode(";",$email);

            // remove wrong e-mail addresses from array
            for ($x=0; $x < count($arrEmail); $x++) {
               $arrEmail[$x] = trim($arrEmail[$x]); // remove possible whitespaces
               if (!is_email($arrEmail[$x])) {
                  unset($arrEmail[$x]);
               }
            }

         }

         // Do we have valid e-mail addresses?
         if (count($arrEmail) > 0) {

            if ($this->_auto_create_user) {

               // auto creation is enabled, so look for the user in AD
               $userinfo = $this->_adldap->user_info($username, array("sn", "givenname", "mail"));
               if ($userinfo) {
                  $userinfo = $userinfo[0];
                  $first_name = $userinfo['givenname'][0];
                  $last_name = $userinfo['sn'][0];
               } else {
                  return false;
               }
            } else {

               // auto creation is disabled, so look for the user in local database
               require_once(ABSPATH . WPINC . DIRECTORY_SEPARATOR . 'registration.php');
               $user_id = username_exists($username);
               if ($user_id) {
                  $user_info = get_userdata($user_id);
                  $last_name = $user_info->last_name;
                  $first_name = $user_info->first_name;
               } else {
                  return false;
               }
            }

            $blog_url = get_bloginfo('url');
            $blog_name = get_bloginfo('name');
            $blog_domain = preg_replace ('/^(http:\/\/)(.+)\/.*$/i','$2', $blog_url);

            $subject = '['.$blog_name.'] '.__('Account blocked','ad-integration');
            $body = sprintf(__('Someone tried to login to %s (%s) with the username "%s" (%s %s) - but in vain. For security reasons this account is now blocked for %d seconds.','ad-integration'), $blog_name, $blog_url, $username, $first_name, $last_name, $this->_block_time);
            $body .= "\n\r";
            $body .= sprintf(__('The login attempt was made from IP-Address: %s','ad-integration'), $_SERVER['REMOTE_ADDR']);
            $body .= "\n\r";
            $body .= __('THIS IS A SYSTEM GENERATED E-MAIL, PLEASE DO NOT RESPOND TO THE E-MAIL ADDRESS SPECIFIED ABOVE.','ad-integration');
            $header = 'From: "WordPress" <wordpress@'.$blog_domain.">\r\n";

            // send e-mails
            $blnSuccess = true;
            foreach($arrEmail AS $email)  {
               $blnSuccess = ($blnSuccess AND wp_mail($email, $subject, $body, $header));
            }
            return $blnSuccess;

         } else {
            return false;
         }
      } else {
         return false;
      }

      return true;
   }

   /**
    * Output debug informations
    *
    * @param integer level
    * @param string $notice
    */
   protected function _log($level = 0, $info = '') {
      if ($level <= $this->_loglevel) {
         echo '[' .$level . '] '.$info."\n\r";
      }
   }

   /**
    * Show a blocking page for blocked accounts.
    *
    * @param $username
    */
   protected function _display_blocking_page($username) {
      $seconds = $this->_get_rest_of_blocking_time($username);

            ?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="https://www.w3.org/1999/xhtml" <?php language_attributes(); ?>>
<head>
   <title><?php bloginfo('name'); ?> &rsaquo; <?php echo $title; ?></title>
   <meta http-equiv="Content-Type" content="<?php bloginfo('html_type'); ?>; charset=<?php bloginfo('charset'); ?>" />
   <script type="text/javascript">
   var seconds = <?php echo $seconds;?>;
   function setTimer()   {
      var aktiv = window.setInterval("countdown()", 1000);
   }

   function countdown() {
      seconds = seconds - 1;
      if (seconds > 0) {
         document.getElementById('secondsleft').innerHTML = seconds;
      } else {
         window.location.hre

Does this plugin allow a user to reset their AD password. Or does the password reset only support WordPress password resets?

https://www.ads-software.com/plugins/active-directory-integration/

Our FS server requires the username to be the email address and not the AD CN. Simply using the CN with the domain suffix will not work as we have several CN names in an older format. Is it possible to set ADI to use a different attribute (mail) in the AD as the username?

https://www.ads-software.com/plugins/active-directory-integration/

Is there a parameter I am missing?
I want to bulk import my AD users I followed the instructions and set up the url in my task scheduler with wget. I, however, have not been able to import any AD users.

https://www.ads-software.com/plugins/active-directory-integration/

Hi,

I use this plugin (1.1.6) on wordpres 4.3.5, and when i connect on my website, I have 20 seconds latency, it’s normal ?
Do you think the problem comes from this plugin or our AD ?

AD Integration Logon Test : https://merial.ng-agency.com/test/test.png

Thank you very much

https://www.ads-software.com/plugins/active-directory-integration/

Hello Everyone,

I just noticed that the active-directory-integration plugin (while being logged in) does many get_option calls on every page request.

**Both in frontend and when is_admin() is true**

Its not a matter of performance yet, but just wanted to let you know:

the call comes from the constructor (see below):

get_option()
 /var/lib/wordpress/wp-includes/option.php:86-
ADIntegrationPlugin->_load_options()
 wp-content/plugins/active-directory-integration/ad-integration.php:1935
ADIntegrationPlugin->__construct()
 wp-content/plugins/active-directory-integration/ad-integration.php:325

Here is the list of all SQL Statements being called when this plugin is activated and I refresh/open a page:

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_use_tls'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_append_suffix_to_new_users'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_auto_update_description'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_show_user_status'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_enable_password_change'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_no_random_password'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_authorize_by_group'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_fallback_to_local_password'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_enable_lost_password_recovery'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_max_login_attempts'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_block_time'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_user_notification'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_admin_notification'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_admin_email'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_usermeta_empty_overwrite'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_syncback'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_syncback_use_global_user'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_syncback_global_pwd'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_bulkimport_new_authcode'
LIMIT 1

SELECT option_value
FROM wp_options
WHERE option_name = 'AD_Integration_disable_users'
LIMIT 1

https://www.ads-software.com/plugins/active-directory-integration/

Hi,

Some our our users are finding that it takes multiple attempts to sign in. I’ve tested it myself and the correct password is definitely being used each time but it takes 3-4 attempts to successfully login.

I’m using port 389 with TLS disabled. I’ve also increased the LDAP network timeout from 5 seconds to 15, this hasn’t made any difference though.

Is there anything that you can suggest please?

https://www.ads-software.com/plugins/active-directory-integration/

Doesn’t this plugin need a username/password to connect to AD before doing any user lookups? If yes, where does the plugin store the connection credentials? I searched everywhere but couldn’t find anything.

I use the latest version of the plugin

Thank you

https://www.ads-software.com/plugins/active-directory-integration/

If I go in the Active directory browser, it works.

I connect to the active directory but receive an error message :

AD Integration Logon Test
openLDAP installed
[INFO] method authenticate() called
[INFO] ——————————————
PHP version: 5.4.45
WP version: 4.5.3
ADI version: 1.1.8
OS Info : Windows NT mypc 6.1 build 7601 (Windows 7 Business Edition Service Pack 1) i586
Web Server : cgi-fcgi
adLDAP ver.: 3.3.2 EXTENDED (201302271401)
——————————————
[INFO] LDAP paging: enabled
[NOTICE] username: testuser
[NOTICE] password: **not shown**
[INFO] Options for adLDAP connection:
– account_suffix:
– base_dn: OU=xxx,OU=xx,OU=Business Units,DC=xxx,DC=xxx,DC=xxx,DC=xxx
– domain_controllers: 111.111.111.111;111.111.111.112;111.111.111.113;111.111.111.114;
– ad_port: 636
– use_tls: 0
– network timeout: 5
[INFO] Checking domain controller ports:
[INFO] – 111.111.111.111 – OK
[INFO] – 111.111.111.112 – OK
[INFO] – 111.111.111.113 – OK
[INFO] – 111.111.111.114 – OK
[NOTICE] adLDAP object created.
[INFO] max_login_attempts: 0
[NOTICE] trying account suffix “”
[ERROR] Authentication failed
[WARN] storing failed login for user “testuser”

Logon failed

https://www.ads-software.com/plugins/active-directory-integration/

Hello,
great product. I noticed a small problem. The plugin injects it’s style sheet into every admin page and is disabling my admin page styles. Is there a work around for this?

https://www.ads-software.com/plugins/active-directory-integration/

Hi there,

Still waiting the ADI 2.0 release, hope it can come out ASAP:)

I have a question about the ADI 2.0 compatibility, because seems it is a totally new system, so does it support upgrading from ADI 1.0 and keep all old data? or I need re-install the whole ADI system.

Thanks, and if you have ADI 2.0 release date, please let me know.

https://www.ads-software.com/plugins/active-directory-integration/

I am using your wonderful Active Directory Integration plugin to allow a specific group of users to login using their corporate ID and password but they are sent a user activation email with their username and a password that is generated by WordPress when they login for the first time. Is there a way to prevent or block the email from being sent to the AD user’s?

I will have two types of user’s on my site;

1)I want to block these users from getting a registration confirmation/activation emailThe AD users who login with their corporate ID and password. They will all be from the same email domain but having multiple suffixes eg; @germany.company.com, @africa.company.com.

2)users who will need to register, and then be approved by the admin and then will be sent an activation email, and they will be from many different email domains.

Thanks in advance for any help.

Active Directory Integration