modules/domain/domain.module

<?php
// $Id: domain.module,v 1.133 2009/11/01 16:30:55 agentken Exp $

/**
 * @defgroup domain Domain Access: A domain-based access control system
 *
 * The core Domain Access module.
 */

/**
 * @file
 * Core module functions for the Domain Access suite.
 * @ingroup domain
 */

/**
 * Defines how to handle access permissions when installing the module.
 * You may alter this variable before installing the module. See README.txt.
 */
define('DOMAIN_INSTALL_RULE', TRUE);

/**
 * Defines whether to show affiliated content on all domains.
 * You may alter this variable before installing the module. See README.txt.
 */
define('DOMAIN_SITE_GRANT', TRUE);

/**
 * Defines whether to assign users to the default domain on install.
 * You may alter this variable before installing the module. See README.txt.
 */
define('DOMAIN_ASSIGN_USERS', TRUE);

/**
 * Sets a default value at which to start paginating Domain lists.
 */
define('DOMAIN_LIST_SIZE', 25);

/**
 * Adds the domain user data to the $user object.
 */
function domain_boot() {
  global $user;
  $user->domain_user = domain_get_user_domains($user);
}

/**
 * Implement hook_init().
 *
 * Inititalizes a global $_domain variable if necessary (usually that's done in
 * domain_bootstrap.inc) and loads information on current domain.
 *
 * Also handles www stripping, checks the validity of user domains and updates
 * $conf['site_name'].
 */
function domain_init() {
  global $_domain, $conf;

  if (!is_array($_domain)) {
    $_domain = array();
  }

  // Error handling in case the module is not installed correctly.
  if (empty($_domain)) {
    $_domain['error'] = '-1';
  }
  // If $_domain['error'] is present, then set a message and stop.
  if (!isset($error) && isset($_domain['error'])) {
    $error = 'Domain access failed to load during phase: '. $_domain['error'] .'. Please check your settings.php file and site configuration.';
    // Do not show on form submissions, when enabling the module.
    if (empty($_POST)) {
      // Show a warning to admin users.
      if (user_access('administer domains')) {
        drupal_set_message($error, 'error');
      }
      watchdog('Domain Access', $error, NULL, WATCHDOG_ERROR);
    }
    return;
  }
  // End of the error handling routine.

  // If coming from a node save, make sure we are on an accessible domain.
  domain_node_save_redirect();

  // Strip the www. off the domain, if required by the module settings.
  $www_replaced = FALSE;
  if (variable_get('domain_www', 0) && strpos($_domain['subdomain'], 'www.') !== FALSE) {
    $_domain['subdomain'] = str_replace('www.', '', $_domain['subdomain']);
    $www_replaced = TRUE;
  }

  // Add information from domain_lookup but keep existing values (domain_id and subdomain)
  $domain = domain_lookup($_domain['domain_id']);
  $_domain = array_merge($domain, $_domain);

  // If we have replaced 'www.' in the url, redirect to the clean domain.
  if ($www_replaced) {
    drupal_goto(domain_get_uri($_domain));
  }

  // For Domain User, we check the validity of accounts, so the 'valid' flag must be TRUE.
  if (empty($_domain['valid'])) {
    domain_invalid_domain_requested();
  }

  // Set the site name to the domain-specific name.
  $conf['site_name'] = $_domain['sitename'];

  // Properly load custom_url_rewrite_outbound().
  // See http://drupal.org/node/529026
  include_once(drupal_get_path('module', 'domain') .'/settings_custom_url.inc');
}

/**
 * Implement hook_menu()
 */
function domain_menu() {
  $items = array();
  $admin = user_access('administer domains');
  $items['admin/build/domain'] = array(
    'title' => 'Domains',
    'access arguments' => array('administer domains'),
    'page callback' => 'domain_view',
    'file' => 'domain.admin.inc',
    'description' => 'Settings for the Domain Access module.',
  );
  $items['admin/build/domain/view'] = array(
    'title' => 'Domain list',
    'access arguments' => array('administer domains'),
    'type' => MENU_DEFAULT_LOCAL_TASK,
    'page callback' => 'domain_view',
    'file' => 'domain.admin.inc',
    'weight' => -10
  );
  $items['admin/build/domain/settings'] = array(
    'title' => 'Settings',
    'access arguments' => array('administer domains'),
    'type' => MENU_LOCAL_TASK,
    'page callback' => 'domain_configure',
    'file' => 'domain.admin.inc',
    'weight' => -8
  );
  $items['admin/build/domain/create'] = array(
    'title' => 'Create domain record',
    'access arguments' => array('administer domains'),
    'type' => MENU_LOCAL_TASK,
    'page callback' => 'drupal_get_form',
    'page arguments' => array('domain_form'),
    'file' => 'domain.admin.inc',
    'weight' => -7
    );
  $items['admin/build/domain/advanced'] = array(
    'title' => 'Node settings',
    'access arguments' => array('administer domains'),
    'type' => MENU_LOCAL_TASK,
    'page callback' => 'drupal_get_form',
    'page arguments' => array('domain_advanced_form'),
    'file' => 'domain.admin.inc',
    'weight' => -6
  );
  // Register the batch actions as menu callbacks
  $batch = module_invoke_all('domainbatch');
  if (!empty($batch)) {
    $items['admin/build/domain/batch'] = array(
      'title' => 'Batch updating',
      'access arguments' => array('administer domains'),
      'type' => MENU_LOCAL_TASK,
      'page callback' => 'domain_batch',
      'file' => 'domain.admin.inc',
      'weight' => -5
    );
    // Get the submenu items
    foreach ($batch as $key => $value) {
      $items['admin/build/domain/batch/'. $key] = array(
        'title' => $value['#form']['#title'],
        'access arguments' => array('administer domains'),
        'type' => MENU_CALLBACK,
        'page callback' => 'domain_batch',
        'page arguments' => array($key),
        'file' => 'domain.admin.inc',
        'weight' => $value['#weight']
      );
    }
  }
  $items['admin/build/domain/roles'] = array(
    'title' => 'User defaults',
    'access arguments' => array('administer domains'),
    'type' => MENU_LOCAL_TASK,
    'page callback' => 'drupal_get_form',
    'page arguments' => array('domain_roles_form'),
    'file' => 'domain.admin.inc',
    'weight' => -4
  );
  $items['admin/build/domain/edit/%domain'] = array(
    'title' => 'Edit domain record',
    'access arguments' => array('administer domains'),
    'type' => MENU_CALLBACK,
    'page callback' => 'drupal_get_form',
    'page arguments' => array('domain_form', 4),
    'file' => 'domain.admin.inc',
  );
  $items['admin/build/domain/delete/%domain'] = array(
    'title' => 'Delete domain record',
    'access arguments' => array('administer domains'),
    'type' => MENU_CALLBACK,
    'page callback' => 'drupal_get_form',
    'page arguments' => array('domain_delete_form', 4),
    'file' => 'domain.admin.inc',
  );
  return $items;
}

/**
 * Implement hook_perm()
 */
function domain_perm() {
  $perms = array(
    'access inactive domains',
    'administer domains',
    'assign domain editors',
    'delete domain nodes',
    'edit domain nodes',
    'set domain access',
    'publish to any assigned domain',
    'publish from assigned domain',
    'publish from default domain',
  );
  return $perms;
}

/**
 * Implement hook_theme()
 */
function domain_theme() {
  $themes = array(
    'domain_admin_users_form' => array(
      'arguments' => array('form' => array()),
      'file' => 'domain.admin.inc',
    ),
    'domain_batch_form' => array(
      'arguments' => array('form' => array()),
      'file' => 'domain.admin.inc',
    ),
    'domain_batch_title' => array(
      'arguments' => array('batch' => array()),
      'file' => 'domain.admin.inc',
    ),
    'domain_roles_form' => array(
      'arguments' => array('form' => array()),
      'file' => 'domain.admin.inc',
    ),
  );
  return $themes;
}

/**
 * Implement hook_block()
 *
 * A nifty little domain-switcher block, useful during debugging.
 */
function domain_block($op = 'list', $delta = 0, $edit = array()) {
  global $_domain, $base_url;
  $blocks = array();
  switch ($op) {
    case 'list':
      $blocks[0] = array(
        'info' => t('Domain switcher'),
      );
      $blocks[1] = array(
       'info' => t('Domain access information'),
      );
      return $blocks;
      break;
    case 'view':
      switch ($delta) {
        case 0:
          $block['subject'] = t('Domain switcher');
          $items = array();
          $domains = domain_domains();
          $msg = FALSE;
          foreach ($domains as $domain) {
            if ($domain['valid']) {
              $title = $domain['sitename'];
              $allow = TRUE;
            }
            else {
              $title = $domain['sitename'] .' *';
              $allow = FALSE;
              if (user_access('access inactive domains')) {
                $msg = TRUE;
                $allow = TRUE;
              }
            }
            if ($allow) {
              $items[] = l($title, domain_get_uri($domain));
            }
          }
          $block['content'] = theme('item_list', $items);
          if ($msg) {
            $block['content'] .= t('<em>* Inactive domain.</em>');
          }
          break;
        case 1:
          $block['content'] = '';
          if (arg(0) == 'node' && is_numeric(arg(1))) {
            $block['subject'] = t('Domain access information');
            $this_node = node_load(arg(1));
            $output = '';
            if (!empty($this_node->subdomains)) {
              $output .= theme('item_list', $this_node->subdomains, t('Assigned domains'));
            }
            $this_domain = domain_get_node_match($this_node->nid);
            $output .= theme('item_list', array($this_domain['sitename']), t('Source domain'));
            if (empty($output)) {
              $output = t('This node is not assigned to a domain.');
            }
            $block['content'] = '<p>'. t('%node is published with the following Domain Access rules:', array('%node' => $this_node->title)) .'</p>'. $output;
          }
          return $block;
          break;
      }
      return $block;
      break;
  }
}

/**
 * Implement hook_user()
 *
 * Attached domain_id records to all registering users.  These
 * are used to determine which 'domain_editor' group that users
 * with the 'edit domain nodes' and 'delete domain nodes' permissions are in.
 */
function domain_user($op, &$edit, &$account, $category = NULL) {
  switch ($op) {
    case 'load':
      $domains = domain_get_user_domains($account);
      $account->domain_user = $domains;
      break;
    case 'form':
    case 'register':
      if (is_null($category) || $category == 'account') {
        global $_domain;
        $result = db_query("SELECT domain_id, subdomain, sitename, scheme FROM {domain}");
        $options = array();
        // Get the domains for this user, but ignore roles unless told to use them.
        $add_roles = variable_get('domain_add_roles', 0);
        // In the register case, we take the 'new user' settings.
        if ($op == 'register') {
          $add_roles = TRUE;
        }
        $account->domain_user = domain_get_user_domains($account, $add_roles, TRUE);
        // By default, the requesting domain is assigned.
        if (empty($account->domain_user)) {
          ($_domain['domain_id'] == 0) ? $default  = array(-1) : $default = array($_domain['domain_id'] => $_domain['domain_id']);
        }
        else {
          $default = $account->domain_user;
        }
        $options[-1] = variable_get('domain_sitename', variable_get('site_name', 'Drupal'));
        while ($data = db_fetch_array($result)) {
          $options[$data['domain_id']] = check_plain($data['sitename']);
        }
        // Replace the zero record to -1.
        unset($options[0]);
        $format = domain_select_format();
        if (user_access('assign domain editors')) {
          $form['domain_user'] = array(
            '#type' => 'fieldset',
            '#title' => t('Domain access'),
            '#collapsible' => TRUE,
            '#collapsed' => FALSE,
            '#weight' => 1
          );
          $form['domain_user']['domain_user'] = array(
            '#type' => empty($format) ? 'checkboxes' : 'select',
            '#options' => $options,
            '#title' => t('Domain access settings'),
            '#description' => t('Select the affiliates that this user belongs to.  Used to grant editing permissions for users with the "edit domain nodes" permission.'),
            '#default_value' => $default
          );
          if ($format) {
            $form['domain_user']['domain_user']['#multiple'] = TRUE;
            $form['domain_user']['domain_user']['#size'] = count($options) > 10 ? 10 : count($options);
          }
        }
        else {
          $form['domain_user'] = array(
            '#type' => 'value',
            '#value' => $default
          );
        }
        return $form;
      }
      break;
    case 'validate':
      return array('domain_user' => $edit['domain_user']);
      break;
    case 'insert':
    case 'update':
      // If our field element is missing, do nothing.
      if (!isset($edit['domain_user'])) {
        return;
      }
      // Clear and reset the {domain_editor} table.
      db_query("DELETE FROM {domain_editor} WHERE uid = %d", $account->uid);
      if (empty($edit['domain_user'])) {
        return;
      }
      foreach ($edit['domain_user'] as $domain_id => $status) {
        if ($status != 0) {
          // Convert the -1 checkboxes to a zero.
          if ($domain_id == -1) {
            $domain_id = 0;
          }
          db_query("INSERT INTO {domain_editor} (uid, domain_id) VALUES (%d, %d)", $account->uid, $domain_id);
        }
      }
      // Clear the $edit field.
      $edit['domain_user'] = NULL;
      break;
    case 'view':
      if (user_access('assign domain editors')) {
        $account->content['domain'] = array(
          '#type' => 'user_profile_category',
          '#weight' => 10,
          '#title' => t('Domain status'),
        );
        if (empty($account->domain_user)) {
          $output = t('This user is not assigned to a domain.');
        }
        else {
          $output = '<ul>';
          foreach ($account->domain_user as $id) {
            if (abs($id) > 0) {
              if ($id > 0) {
                $domain = domain_lookup($id);
                $output .= '<li>'. $domain['sitename'] .'</li>';
              }
              else {
                $output .= '<li>'. variable_get('domain_sitename', variable_get('site_name', 'Drupal')) .'</li>';
              }
            }
          }
          $output .= '</ul>';
        }
        $account->content['domain']['domain_settings'] = array(
          '#type' => 'user_profile_item',
          '#title' => t('Domain settings'),
          '#value' => $output,
        );
        break;
    }
  }
}

/**
 * Implement hook_user_operations().
 */
function domain_user_operations() {
  if (!user_access('assign domain editors')) {
    return;
  }
  return array(
    'domain' => array(
      'label' => t('Assign users to domains'),
      'callback' => 'domain_user_operation_assign',
    ),
  );
}

/**
 * Implement hook_form_alter().
 */
function domain_form_user_admin_account_alter(&$form, $form_state) {
  if (!user_access('assign domain editors')) {
    return;
  }
  $options = array();
  $format = domain_select_format();
  foreach (domain_domains() as $data) {
    // Cannot pass zero in checkboxes.
    ($data['domain_id'] == 0) ? $key = -1 : $key = $data['domain_id'];
    // The domain must be valid.
    if ($data['valid'] || user_access('access inactive domains')) {
      // Filter checkbox output but not select list.
      $options[$key] = empty($format) ? check_plain($data['sitename']) : $data['sitename'];
    }
  }
  $form['domain'] = array(
    '#type' => 'fieldset',
    '#title' => t('Affiliate editor options'),
    '#collapsible' => TRUE,
    '#collapsed' => TRUE,
    '#prefix' => '<div class="description">'. t('If you select <em>Assign users to domains</em> above, you should confirm the <em>Affiliate editor options</em> settings below.') .'</div>',
    '#weight' => -1,
  );
  $form['domain']['domains'] = array(
    '#type' => empty($format) ? 'checkboxes' : 'select',
    '#title' => t('Assign to'),
    '#options' => $options,
    '#required' => FALSE,
    '#description' => t('Select which affiliates these users should belong to. <em>Note: this will erase any current assignment for the selsected users.</em>'),
    '#default_value' => array(($_domain['domain_id'] == 0) ? -1 : $_domain['domain_id']), // Can't use 0 as a checkbox value.
  );
  if ($format) {
    $form['domain']['domains']['#multiple'] = TRUE;
    $form['domain']['domains']['#size'] = count($options) > 10 ? 10 : count($options);
  }
  // Add our domain elements.
  foreach (array_keys($form['name']) as $uid) {
    $form['user_domains'][$uid][0] = array('#value' => theme('item_list', _domain_user_list($uid)));
  }
  $form['#theme'] = 'domain_admin_users_form';
  $form['#submit'][] = 'domain_update_users';
}

/**
 * Helper function to get the names of all domains for a user.
 *
 * @param $uid
 *   The user id.
 * @return
 * An array of domain names.
 */
function _domain_user_list($uid) {
  $temp_account = new stdClass;
  $temp_account->uid = $uid;
  $list = domain_get_user_domains($temp_account, FALSE);
  $domains = array();
  foreach ($list as $domain_id) {
    if ($domain_id == -1) {
      $domain_id = 0;
    }
    $domains[] = check_plain(db_result(db_query("SELECT sitename FROM {domain} WHERE domain_id = %d ORDER BY domain_id ASC", $domain_id)));
  }
  return $domains;
}

/**
 * Callback for domain_content_node_operations().
 *
 * This callback is required, but we actually do our action inside
 * of domain_update_users().
 */
function domain_user_operation_assign($accounts) {
}

/**
 * FormsAPI to handle the batch update of users.
 */
function domain_update_users($form, &$form_state) {
  $values = $form_state['values'];
  if ($values['operation'] != 'domain') {
    return;
  }
  foreach ($values['accounts'] as $uid) {
    db_query("DELETE FROM {domain_editor} WHERE uid = %d", $uid);
    foreach (array_filter($values['domains']) as $domain_id) {
      // Cannot use 0 as a checkbox.
      if ($domain_id == -1) {
        $domain_id = 0;
      }
      db_query("INSERT INTO {domain_editor} (uid, domain_id) VALUES (%d, %d)", $uid, $domain_id);
    }
  }
}

 /**
 * Implement hook_cron()
 *
 * This function invokes hook_domaincron() and allows
 * Domain Access modules to run functions for all active affiliates.
 */
function domain_cron() {
  global $_domain;
  // Check to see if this function is needed at all.
  $modules = module_implements('domaincron');
  if (!empty($modules)) {
    // Store the current $_domain global.
    $_temp = $_domain;
    // Get the domain list.
    $domains = domain_domains();
    // Run the hook for each active domain.
    foreach ($domains as $domain) {
      domain_set_domain($domain['domain_id'], TRUE);
      foreach ($modules as $module) {
        module_invoke($module, 'domaincron', $domain);
      }
    }
    // Set the $_domain global back.
    $_domain = $_temp;
  }
}

/**
 * Menu loader function.
 *
 * The passed parameter will be checked against the {domain} table for
 * valid records.
 *
 * @param $domain_id
 *   The id request for a specific domain.
 * @return
 *   $domain array on success or FALSE on failure.
 */
function domain_load($domain_id = NULL) {
  $domain = domain_lookup($domain_id);
  if ($domain == -1) {
    return FALSE;
  }
  else {
    return $domain;
  }
}

/**
 * Runs a lookup against the {domain} table.  One of the two values must be present
 *
 * This function also calls hook_domainload(), which lets module developers overwrite
 * or add to the $domain array.
 *
 * @param $domain_id
 *  The domain_id taken from {domain}. Optional.
 * @param $subdomain
 *  The string representation of a {domain} entry. Optional.
 * @param $reset
 *  A boolean flag to clear the static variable if necessary.
 * @return
 *  An array containing the requested row from the {domain} table, plus the
 *  elements added by hook_domainload().  Returns -1 on failure.
 */
function domain_lookup($domain_id = NULL, $subdomain = NULL, $reset = FALSE) {
  static $domains;
  // If both are NULL, no lookup can be run.
  if (is_null($domain_id) && is_null($subdomain)) {
    return -1;
  }
  // Create a unique key so we can static cache all requests.
  $key = $domain_id . $subdomain;
  // Run the lookup, if needed.
  if (!isset($domains[$key]) || $reset) {
    if ($subdomain) {
      $domain = db_fetch_array(db_query("SELECT domain_id, subdomain, sitename, scheme, valid FROM {domain} WHERE subdomain = '%s'", $subdomain));
    }
    else if ($domain_id == 0) {
      $domain = domain_default();
    }
    else {
      $domain = db_fetch_array(db_query("SELECT domain_id, subdomain, sitename, scheme, valid FROM {domain} WHERE domain_id = %d", $domain_id));
    }
    // Did we get a valid result?
    if (isset($domain['domain_id'])) {
      // Let Domain Access module extensions act to override the defaults.
      $domains[$key] = domain_api($domain, $reset);
    }
    else {
      $domains[$key] = -1;
    }
  }
  return $domains[$key];
}

/**
 * Assigns the default settings to domain 0, the root domain.
 *
 * This value is used throughout the modules. Even though this
 * record is in the {domain} table, we use the value stored as
 * a variable. Doing so prevents the module from firing when
 * it has not been configured.
 *
 * @param $reset
 * A boolean flag indicating whether to reset the static array or not.
 */
function domain_default($reset = FALSE) {
  static $default;
  if (empty($default) || $reset) {
    $default['domain_id'] = 0;
    $default['sitename'] = variable_get('domain_sitename', variable_get('site_name', 'Drupal'));
    $default['subdomain'] = variable_get('domain_root', '');
    $default['scheme'] = variable_get('domain_scheme', 'http');
    // Set the valid flag.
    $default['valid'] = TRUE;
    // Let submodules overwrite the defaults, if they wish.
    $default = domain_api($default);
  }
  return $default;
}

/**
 * Set the primary domain properly, if necessary.
 */
function domain_set_primary_domain() {
  $root = strtolower(rtrim($_SERVER['SERVER_NAME']));
  $site = variable_get('site_name', 'Drupal');
  $scheme = 'http';
  if (!empty($_SERVER['HTTPS'])) {
    $scheme = 'https';
  }
  db_query("UPDATE {domain} SET subdomain = '%s', sitename = '%s', scheme = '%s', valid = 1 WHERE domain_id = 0", $root, $site, $scheme);
  if (!db_affected_rows()) {
    db_query("INSERT INTO {domain} (subdomain, sitename, scheme, valid) VALUES ('%s', '%s', '%s', %d)", $root, $site, $scheme, 1);
    // MySQL won't let us insert row 0 into an autoincrement table.
    // Similar to the {users} table, this leaves us with no row 1.
    db_query("UPDATE {domain} SET domain_id = domain_id - 1");
  }
  // Set the default domain variables.
  variable_set('domain_root', $root);
  variable_set('domain_scheme', $scheme);
  variable_set('domain_sitename', $site);

  // Allow other modules to respond to changes.
  module_invoke_all('domainupdate', 'update', domain_default(TRUE));
}

/**
 * Return all active domains (including the default) as an array.
 *
 * @param $reset
 * A boolean flag indicating whether to reset the static array or not.
 * @return
 * An array of all active domains, with the domain_id as the key.
 */
function domain_domains($reset = FALSE) {
  static $domains;
  if (empty($domains) || $reset) {
    $domains = array();
    // Query the db for active domain records.
    $result = db_query("SELECT domain_id FROM {domain}");
    while ($data = db_fetch_array($result)) {
      $domain = domain_lookup($data['domain_id'], NULL, TRUE);
      $domains[$domain['domain_id']] = $domain;
    }
  }
  $sort = variable_get('domain_sort', 'id');
  uasort($domains, '_domain_'. $sort  .'_sort');
  return $domains;
}

/**
 * Helper sort function
 */
function _domain_id_sort($a, $b) {
  return ($a['domain_id'] < $b['domain_id']) ? -1 : 1;
}

/**
 * Helper sort function
 */
function _domain_name_sort($a, $b) {
  return strcmp($a['sitename'], $b['sitename']);
}

/**
 * Helper sort function
 */
function _domain_url_sort($a, $b) {
  return strcmp($a['subdomain'], $b['subdomain']);
}

/**
 * Helper sort function
 */
function _domain_rid_sort($a, $b) {
  return ($a['domain_id'] > $b['domain_id']) ? -1 : 1;
}

/**
 * Helper sort function
 */
function _domain_rname_sort($a, $b) {
  return strcmp($b['sitename'], $a['sitename']);
}

/**
 * Helper sort function
 */
function _domain_rurl_sort($a, $b) {
  return strcmp($a['subdomain'], $b['subdomain']);
}

/**
 * Determine the default format for domain list forms.
 */
function domain_select_format() {
  $domains = domain_domains();
  $format = 0;
  if (count($domains) > variable_get('domain_list_size', DOMAIN_LIST_SIZE)) {
    $format = 1;
  }
  return variable_get('domain_select_format', $format);
}

/**
 * Validates a domain string.
 * @param string $subdomain
 *   The string to check for domain validity
 * @return array
 *   List of error messages or empty array.
 */
function domain_validate($subdomain) {
  $error_list = array();
  // Validate the domains format generically for now.
  $error = domain_valid_domain($subdomain);
  if (!empty($error)) {
    $error_list[] = $error;
  }
  // Make sure domain is unique
  if (!domain_unique_domain($subdomain)) {
    $error_list[] = t('The domain value must be unique.');
  }
  return $error_list;
}

/**
 * Validate the domain against all correctable errors.
 *
 * Note that we decided not to check for valid TLDs here.
 *
 * @param $subdomain
 *   Domain string to check.
 * @return string
 *   Empty if valid, error message on invalid.
 */
function domain_valid_domain($subdomain) {
  $error_list = array();
  // Check for one colon only.
  if (substr_count($subdomain, ':') > 1) {
    $error_list[] = t('Only one colon (:) is allowed.');
  }
  // If a colon, make sure it is only followed by numbers.
  else if (substr_count($subdomain, ':') == 1) {
    $parts = explode(':', $subdomain);
    $port = (int) $parts[1];
    if (empty($port) || $port != (float) $parts[1]) {
      $error_list[] = t('The port protocol must be an integer.');
    }
  }
  // The domain cannot begin or end with a period.
  if (substr($subdomain, 0, 1) == '.') {
    $error_list[] = t('The domain must not begin with a dot (.)');
  }
  // The domain cannot begin or end with a period.
  if (substr($subdomain, -1) == '.') {
    $error_list[] = t('The domain must not end with a dot (.)');
  }
  // Check for valid characters
  $pattern = '/^[a-z0-9\.\+\-\*\?:]*$/i';
  if (!preg_match($pattern, $subdomain)) {
    $error_list[] = t('Only alphanumeric characters, dashes, and a colon are allowed.');
  }
  if (!empty($error_list)) {
    return t('The domain string is invalid:') . theme('item_list', $error_list);
  }
}

/**
 * Validate the domain against existing domains.
 *
 * @param $subdomain
 *   Domain string to check
 * @return bool
 *   TRUE if unique; FALSE if duplicate.
 */
function domain_unique_domain($subdomain) {
  $count = db_result(db_query("SELECT COUNT(domain_id) FROM {domain} WHERE subdomain = '%s'", $subdomain));
  return !(bool) $count;
}

/**
 * Get the domains a user is assigned to.
 *
 * @param $account
 * The user account object.
 * @param $add_roles
 * A boolean flag indicating whether to add the default role settings to the user's domains.
 * @param $reset
 * A boolean flag indicating whether to reset the static array or not.
 * @return
 * An array of domains to which the user is assigned, in the format array($domain_id => $domain_id).
 * Note that the default domain is -1 here, due to checkbox behavior.
 */
function domain_get_user_domains($account, $add_roles = TRUE, $reset = FALSE) {
  static $domains = array();
  if (empty($account)) {
    // This may happen when creating a new user.
    return array();
  }
  $uid = (int) $account->uid;
  if (!isset($domains[$uid]) || $reset) {
    $domains[$uid] = array();
    $result = db_query("SELECT domain_id FROM {domain_editor} WHERE uid = %d", $uid);
    while ($data = db_fetch_object($result)) {
      if ($data->domain_id == 0) {
        $domains[$uid]['-1'] = -1;
      }
      else {
        $domains[$uid][$data->domain_id] = $data->domain_id;
      }
    }
    if ($add_roles) {
      if (empty($account->roles)) {
        $account->roles = array(0 => 'new user');
      }
      // Add the role-based additions.
      $defaults = variable_get('domain_roles', array());
      foreach ($account->roles as $rid => $role) {
        $filter = array();
        if (isset($defaults[$rid])) {
          $filter = array_filter($defaults[$rid]);
        }
        if (!empty($filter)) {
          foreach ($filter as $domain_id => $status) {
            if ($status) {
              $domains[$uid][$domain_id] = $domain_id;
            }
          }
        }
      }
    }
  }
  return $domains[$uid];
}

/**
 * Helper function for passing hook_domainload() by reference.
 *
 * @param $domain
 * The domain array defined by domain_lookup().
 * @param $reset
 *  A boolean flag to clear the static variable if necessary.
 * @return
 * The $domain array, modified by reference by hook_domainload() implementations.
 */
function domain_api($domain, $reset = FALSE) {
  static $_modules;
  if (!isset($_modules) || $reset) {
    $_modules = module_implements('domainload');
  }
  if (!empty($_modules)) {
    foreach ($_modules as $module) {
      // Cannot use module_invoke_all() since these are passed by reference.
      $function = $module .'_domainload';
      $function($domain);
    }
  }
  return $domain;
}

/**
 * Set the active domain to something other than the HTTP request.
 *
 * This function is used in cases where you wish to similuate the loading
 * of a domain while on another domain.
 *
 * @param $domain_id
 *   The domain id of the domain to load.
 * @param $bootstrap
 *   Boolean flag that indicates whether to run domain bootstrap load.
 * @return
 *   No return value. The global $_domain value is altered, and domain-specific
 *   data functions are loaded.
 */
function domain_set_domain($domain_id, $bootstrap = FALSE) {
  global $_domain;
  $_domain = domain_load($domain_id);
  // Now re-run the bootstrap.
  if ($bootstrap) {
    _domain_bootstrap_invoke_all('full', $_domain);
  }
}

/**
 * Return the currently active domain.
 *
 * This value is stored in a global, but having a function
 * will let us replace that with a static function in D7.
 *
 * @return
 *   An array of data defining the currently active domain.
 */
function domain_get_domain() {
  return $GLOBALS['_domain'];
}

/**
 * Check to see if a redirect to the primary domain is needed.
 *
 * If TRUE, issue a redirect and print a message.
 *
 * @param $msg
 *   The message to print. Optional. If passed, this string must be translated and safe.
 */
function domain_check_primary($msg = 'default') {
  global $_domain;
  $default = domain_default();
  if ($_domain['domain_id'] != $default['domain_id']) {
    if ($msg == 'default') {
      drupal_set_message(t('You have been redirected: This page must be accessed from the primary domain.'));
    }
    else if (!empty($msg)) {
      drupal_set_message($msg);
    }
    domain_goto($default);
  }
}

/**
 * Implement hook_domainload()
 *
 * Adds the home page 'path' and 'site_grant' boolean.
 */
function domain_domainload(&$domain) {
  // Get the path to the home page for this domain.
  $domain['path'] = domain_get_path($domain);
  // Grant access to all affiliates.
  $domain['site_grant'] = DOMAIN_SITE_GRANT;
}

/**
 * Determine an absolute path for a domain
 *
 * @param $domain
 *  The currently active $domain array, provided by domain_lookup().
 * @return
 * The base url of the requested domain.
 */
function domain_get_path($domain) {
  global $base_url;
  if (empty($base_url)) {
    return check_url($domain['scheme'] .'://'. $domain['subdomain']);
  }
  $_url = parse_url($base_url);
  // PHP 5 does not return an empty path element.
  if (!isset($_url['path'])) {
    $_url['path'] = '/';
  }
  // We need a trailing slash at the end of the path
  if (substr($_url['path'], -1) != '/') {
    $_url['path'] .= '/';
  }
  $path = check_url($domain['scheme'] .'://'. $domain['subdomain'] . $_url['path']);
  return $path;
}

/**
 * Determine an absolute path to the current page
 *
 * @param $domain
 *  The currently active $domain array, provided by domain_lookup().
 * @return
 * The absolute url to the current page on the requested domain.
 */
function domain_get_uri($domain) {
  $request_uri = request_uri();

  $modules = _domain_path_modules();
  if (!empty($modules) && !drupal_is_front_page()) {
    // If needed, let modules modify the path alias.
    $alias = domain_path($domain['domain_id'], $_GET['q']);
    // Run the result through url() for proper language and path handling.
    $request_uri = url($alias);
  }

  $path = check_url($domain['scheme'] .'://'. $domain['subdomain'] . $request_uri);
  return $path;
}

/**
 * Determine if we must switch the active domain.
 *
 * This function will execute a drupal_goto() to pop users to the correct
 * domain.
 *
 * @param $domain
 *  The currently active $domain array, provided by domain_lookup().
 */
function domain_goto($domain) {
  global $_domain;
  // We must be on the proper domain, see http://drupal.org/node/186153.
  if ($domain != -1 && $_domain['domain_id'] != $domain['domain_id']) {
    $path = domain_get_uri($domain);
    drupal_goto($path);
  }
}

/**
 * Implement hook_nodeapi().
 *
 * This function is used to provide debugging information and to prep values from
 * the {domain_access} table when editing nodes.  Since not all users can see the
 * domain access editing checkboxes, we pass some node_access values as hidden elements.
 */
function domain_nodeapi(&$node, $op, $a3 = NULL, $a4 = NULL) {
  switch ($op) {
    case 'prepare':
    case 'load':
      // Cannot load if the node has not been created yet.
      if (!isset($node->nid)) {
        return;
      }
      // Append the domain grants to the node for editing.
      $domains = domain_get_node_domains($node->nid);
      $node->domains = $domains['domain_id'];
      $node->domain_site = $domains['domain_site'];
      $node->subdomains = array();
      if ($node->domain_site) {
        $node->subdomains[] = t('All affiliates');
      }
      foreach ($node->domains as $gid) {
        if ($gid > 0) {
          $domain = domain_lookup($gid);
          $node->subdomains[] = $domain['sitename'];
        }
        else {
          $node->subdomains[] = variable_get('domain_sitename', variable_get('site_name', 'Drupal'));
        }
      }
      break;
    case 'view':
      // Search module casts both $a3 and $a4 as FALSE, not NULL.
      // We check that to hide this data from search and other nodeapi
      // calls that are neither a teaser nor a page view.
      if ($a3 !== FALSE || $a4 !== FALSE) {
        $output = '';
        $debug = variable_get('domain_debug', 0);
        if ($debug && user_access('set domain access')) {
          if (!empty($node->subdomains)) {
            $output = theme('item_list', $node->subdomains, t('Assigned domains'));
            $node->content['subdomains'] = array('#value' => $output, '#weight' => 20);
          }
          if (!empty($node->editors)) {
            $output = theme('item_list', $node->editors, t('Editors'));
            $node->content['editors'] = array('#value' => $output, '#weight' => 21);
          }
          if (empty($output)) {
            $node->content['domain'] = array('#value' => t('This node is not assigned to a domain.'), '#weight' => 22);
          }
        }
      }
      break;
    case 'delete':
      // Remove records from the {domain_access} table.
      db_query("DELETE FROM {domain_access} WHERE nid = %d", $node->nid);
      break;
    case 'insert':
    case 'update':
      $_SESSION['domain_nid'] = $node->nid;
      break;
  }
}

/**
 * Get the best matching domain for a node link.
 *
 * @param $nid
 *   The node id.
 * @return
 *   The domain array for the best matching domain for links to this node.
 */
function domain_get_node_match($nid) {
  static $domain = array();
  if (isset($domain[$nid])) {
    return $domain[$nid];
  }
  // Load the domain data for this node -- but only take the first match.
  $id = db_result(db_query_range("SELECT gid FROM {domain_access} WHERE nid = %d AND realm = '%s' ORDER BY gid", $nid, 'domain_id', 0, 1));
  $source = domain_lookup($id);
  drupal_alter('domain_source', $source, $nid);
  $domain[$nid] = $source;
  return $source;
}

/**
 * Allow the lookup of path rewrites.
 *
 * Note that unlinke domain_get_node_match(), this function assumes
 * that all links will be written to the current domain.
 *
 * @param $path
 *   The link path.
 * @return
 *   The domain array for the best matching domain for links to this node.
 */
function domain_get_path_match($path) {
  global $_domain;
  $source = $_domain;
  drupal_alter('domain_source_path', $source, $path);
  return $source;
}

/**
 * Get the domains for a node.
 *
 * @param $nid
 *   The node id.
 * @return
 *   An array, consisting of two parts. 'domain_id' is an array of active domain ids. 'domain_site'
 *   is a TRUE/FALSE boolean indicating affiliate status.
 */
function domain_get_node_domains($nid) {
  static $lookup = array();
  if (isset($lookup[$nid])) {
    return $lookup[$nid];
  }
  $domains = array('domain_id' => array(), 'domain_site' => FALSE);
  $result = db_query("SELECT gid, realm FROM {domain_access} WHERE nid = %d AND (realm = '%s' OR realm = '%s')", $nid, 'domain_id', 'domain_site');
  while ($data = db_fetch_object($result)) {
    // Transform the 0 to -1, since {domain_access} is unsigned.
    ($data->gid == 0) ? $gid = -1 : $gid = $data->gid;
    if ($data->realm == 'domain_id') {
      $domains['domain_id'][$gid] = $gid;
    }
    else if ($data->realm == 'domain_site') {
      $domains['domain_site'] = TRUE;
    }
  }
  $lookup[$nid