modules/country_code/country_code.module

<?php
// $Id: country_code.module,v 1.95 2008/12/10 12:22:01 catch Exp $

/**
 * @file
 * Enables location-appropriate path and content handling based on the user's IP address.
 */

/**
 * Custom language_negotiation option for country-based language negotiation.
 */
define('LANGUAGE_NEGOTIATION_COUNTRY_CODE', 15);

define('COUNTRY_CODE_LANGUAGE_LONG', 'long');

define('COUNTRY_CODE_LANGUAGE_SHORT', 'short');

/**
 * Used when it was not possible to detect user's country, or when user's
 * country is not in the list of supported countries.
 */
define('COUNTRY_CODE_GLOBAL', 'xx');

/**
 * Use the default country.
 */
define('COUNTRY_CODE_DEFAULT', 'default');


/**
 * Implementation of hook_init().
 *
 * Set global $language variable based on user's country.
 */
function country_code_init() {
  // Language negotiations must be set to country based.
  if (variable_get('language_negotiation', LANGUAGE_NEGOTIATION_NONE) != LANGUAGE_NEGOTIATION_COUNTRY_CODE) {
    return;
  }

  // When first installing, this hook is called without a prior call to hook_boot().
  if (!function_exists('country_code')) {
    country_code_boot();
  }

  // Set a country-based language if applicable.
  _country_code_init_language();
}

/**
 * Initialize a country code in the session.
 *
 * A country code can be set via a path prefix in the form cc/ provided the prefix is a
 * valid two-digit country code for an installed and enabled country.
 *
 * The special global code defined in COUNTRY_CODE_GLOBAL can be passed through a
 * query string in the form ?country_code=xx. This form is allowed to avoid a prefix
 * with the global code.
 *
 * Requests originating externally are given special handling, such that incoming
 * visitors can be given a country code based on their location rather than the path
 * prefix on the link they followed.
 *
 * If no country code was set on the basis of the query string or a path prefix,
 * regular handling is called.
 */
function _country_code_init_code() {
  // Cribbed from language_init().
  $args = isset($_GET['q']) ? explode('/', $_GET['q']) : array();
  $prefix = array_shift($args);
  // Accept a country code passed in through the URL, if the country is enabled.
  if ($prefix && array_key_exists($prefix, country_code_countries())) {
    // Rebuild $GET['q'] with the country code removed.
    // If there are no further args, we're at the front page.
    if (empty($args)) {
      $_GET['q'] = variable_get('site_frontpage', 'node');
    }
    else {
      $_GET['q'] = implode('/', $args);
    }
    // If the link is external, only use path if country_code_external is true.
    // If there is no country_code data in the session, this is a first visit
    // and therefore equivalent to external.
    if (!variable_get('country_code_external', 0) || isset($_SESSION['country_code']) || _country_code_request_is_external()) {
      country_code_set($prefix);
      return;
    }
  }
  // Accept a global code passed in the query string.
  if (isset($_GET['country_code']) && $_GET['country_code'] == COUNTRY_CODE_GLOBAL) {
    country_code_set(COUNTRY_CODE_GLOBAL);
    return;
  }
  // Default to fetching a country code by IP or another setting-based approach.
  country_code();
}

/**
 * Handler for country code determination based on IP.
 *
 * Note: This service already returns not identified country codes as 'xx' (global).
 * Other services implementing hook_country_code_handler() will need to ensure they
 * return this code for unidentified countries.
 */
function country_code_get_country_code_hostip($ip_address) {
  return strtolower(file_get_contents('http://api.hostip.info/country.php?ip=' . $ip_address));
}

/**
 * Implementation of hook_country_code_handler().
 */
function country_code_country_code_handler() {
  return array(
    'country_code_hostip' => array(
      // Because this function is called at hook_boot, t() may not exist.
      'title' => function_exists('t') ? t('hostip.info') : 'hostip.info',
      'callback' => 'country_code_get_country_code_hostip',
    ),
  );
}

/**
 * Determine if a request is external.
 */
function _country_code_request_is_external() {
  global $base_url;

  // HTTP_REFERER will not be set by some browsers.
  if (!isset($_SERVER['HTTP_REFERER'])) {
    return FALSE;
  }

  $base = parse_url($base_url);
  $referer = parse_url($_SERVER['HTTP_REFERER']);

  return !($base['host'] == $referer['host'] && (!empty($base['path']) && strpos($referer['path'], $base['path']) === 0));
}

/**
 * Set a country-based language if applicable.
 */
function _country_code_init_language() {
  global $language;

  $languages = language_list('enabled');
  $languages = $languages[1];
  $country_languages = country_code_languages();

  // Recognize a language passed through GET.
  // Only accept an incoming language if it's one of the current country's languages.
  if (isset($_GET['language']) && (isset($country_languages[$_GET['language']]) || isset($languages[$_GET['language']]))) {
    $_SESSION['country_code_language'] = $_GET['language'];
  }
  // If we are viewing a node, priorize the node's language.
  // We do this partly because, when we switch countries when viewing a node
  // that has translations, we link to a node in a language to be set.
  // See country_code_get_context_language().
  elseif ($node = menu_get_object()) {
    $node_language = $node && $node->tnid ? $node->language : NULL;
    $_SESSION['country_code_language'] = country_code_language(NULL, $node_language);
  }
  // If there is a langauge already in the session, look for it.
  elseif (isset($_SESSION['country_code_language'])) {
    $set = FALSE;
    $language_short = (strlen($_SESSION['country_code_language']) > 2) ? substr($_SESSION['country_code_language'], 0, 2) : $_SESSION['country_code_language'];
    // If it's global, return a two-digit language
    if ($language_short == COUNTRY_CODE_GLOBAL && isset($country_languages[$language_short])) {
      $_SESSION['country_code_language'] = $language_short;
      $set = TRUE;
    }
    // If we have a country, priorize a language that has the same base
    // language as the current session language.
    else {
      foreach (array_keys($country_languages) as $langcode) {
        if (substr($langcode, 0, 2) == $language_short) {
          $_SESSION['country_code_language'] = $langcode;
          $set = TRUE;
          break;
        }
      }
    }
    // If no language was set, use the default.
    if (!$set) {
      $_SESSION['country_code_language'] = country_code_language();
    }
  }
  // If no language was set, use the default.
  else {
    $_SESSION['country_code_language'] = country_code_language();
  }

  $language = $languages[$_SESSION['country_code_language']];
  // Reset the path with the correct language. This is needed e.g. to ensure that
  // language-specific aliases work.
  $_GET['q'] = drupal_get_normal_path(trim($_GET['q'], '/'), $language->language);
}

/**
 * Implementation of hook_boot().
 *
 * Include url rewriting functions.
 */
function country_code_boot() {
  // drupal_get_path() is not declared yet.
  // TODO: handle conflicts with other modules declaring url rewrite functions.
  if (!(function_exists('custom_url_rewrite_inbound') || function_exists('custom_url_rewrite_outbound'))) {
    $path = dirname(__FILE__) . '/country_code.inc';
    require_once($path);
  }
  _country_code_init_code();
}

/**
 * Implementation of hook_menu().
 */
function country_code_menu() {
  $items = array();

  // Country administration.
  $items['admin/settings/country-code'] = array(
    'title' => 'Country code',
    'description' => "Configure how site should act based on current user's country.",
    'page callback' => 'drupal_get_form',
    'page arguments' => array('country_code_admin_overview'),
    'access arguments' => array('administer site configuration'),
    'file' => 'country_code.admin.inc',
  );
  $items['admin/settings/country-code/overview'] = array(
    'title' => 'List',
    'weight' => 0,
    'type' => MENU_DEFAULT_LOCAL_TASK,
  );
  $items['admin/settings/country-code/add'] = array(
    'title' => 'Add country',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('country_code_admin_country_form'),
    'access arguments' => array('administer site configuration'),
    'weight' => 5,
    'type' => MENU_LOCAL_TASK,
    'file' => 'country_code.admin.inc',
  );
  $items['admin/settings/country-code/configure'] = array(
    'title' => 'Configure',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('country_code_admin_settings'),
    'access arguments' => array('administer site configuration'),
    'weight' => 10,
    'type' => MENU_LOCAL_TASK,
    'file' => 'country_code.admin.inc',
  );

  // Country editing, country language management.
  $items['admin/settings/country-code-country/%country_code_country'] = array(
    'title' => 'Edit country',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('country_code_admin_country_form', 3),
    'access arguments' => array('administer site configuration'),
    'file' => 'country_code.admin.inc',
  );
  $items['admin/settings/country-code-country/%country_code_country/properties'] = array(
    'title' => 'Edit',
    'weight' => 0,
    'type' => MENU_DEFAULT_LOCAL_TASK,
  );
  $items['admin/settings/country-code-country/%country_code_country/languages'] = array(
    'title' => 'Languages',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('country_code_admin_country_languages', 3),
    'access arguments' => array('administer site configuration'),
    'weight' => 10,
    'type' => MENU_LOCAL_TASK,
    'file' => 'country_code.admin.inc',
  );
  $items['admin/settings/country-code-country/%country_code_country/languages/list'] = array(
    'title' => 'List',
    'weight' => 0,
    'type' => MENU_DEFAULT_LOCAL_TASK,
  );
  $items['admin/settings/country-code-country/%country_code_country/languages/add'] = array(
    'title' => 'Add language',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('country_code_admin_language_form', 3),
    'access arguments' => array('administer site configuration'),
    'weight' => 10,
    'type' => MENU_LOCAL_TASK,
    'file' => 'country_code.admin.inc',
  );

  // Delete country.
  $items['admin/settings/country-code/delete/%country_code_country'] = array(
    'title' => 'Confirm',
    'page callback' => 'drupal_get_form',
    'page arguments' => array('country_code_admin_country_delete', 4),
    'access arguments' => array('administer site configuration'),
    'type' => MENU_CALLBACK,
    'file' => 'country_code.admin.inc',
  );

  return $items;
}

/**
 * Implementation of hook_help().
 */
function country_code_help($path, $arg) {
  switch ($path) {
    case 'admin/settings/country-code':
      if (variable_get('language_negotiation', LANGUAGE_NEGOTIATION_NONE) != LANGUAGE_NEGOTIATION_COUNTRY_CODE) {
        return '<p>'. t('To enable language negotiation based on country code, go to <a href="@language-settings">language settings</a>.', array('@language-settings' => url('admin/settings/language/configure'))) .'</p>';
      }
      break;
  }
}

/**
 * Return a user's preferred country, if set, or a default.
 */
function country_code_preferred_country($account, $default = TRUE) {
  $countries = country_code_countries();
  if (!empty($account->country_code) && isset($countries[$account->country_code])) {
    return $account->country_code;
  }
  else {
    return $default ? country_code_default() : FALSE;
  }
}

/**
 * Return the default country, if set.
 */
function country_code_default() {
  return variable_get('site_country_default_country', '');
}

/**
 * Implementation of hook_user().
 */
function country_code_user($op, $edit, &$account, $category = NULL) {
  global $user;

  // If the site is set to enable user country selection and we have more
  // than one country and are either creating a user on the admin
  // interface or editing the user, show the country selector.
  if (variable_get('country_code_user_country', 0) && variable_get('country_code_count', 0) > 0 && ($op == 'register' && user_access('administer users') || $op == 'form' && $category == 'account')) {
    $countries = country_code_countries();

    // If the user is being created and is anonymous, we set the user country by
    // the user's location.
    $user_preferred_country = $account ? country_code_preferred_country($account) : (!$user ? _country_code_ip_code() : country_code_default());

    $names = array(
      COUNTRY_CODE_GLOBAL => t('Global'),
    );
    foreach ($countries as $code => $country) {
      $names[$code] = $country->name;
    }
    $form['country_code'] = array(
      '#type' => 'fieldset',
      '#title' => t('Country settings'),
      // Assign a weight just above the locale module's section.
      '#weight' => 0.9,
    );

    // Get language negotiation settings.
    $mode = variable_get('language_negotiation', LANGUAGE_NEGOTIATION_NONE);
    $form['country_code']['country_code'] = array(
      '#type' => (count($names) <= 5 ? 'radios' : 'select'),
      '#title' => t('Country'),
      '#default_value' => isset($account->country_code) ? $account->country_code : $user_preferred_country,
      '#options' => $names,
      '#description' => ($mode == LANGUAGE_NEGOTIATION_COUNTRY_CODE) ? t("This account's default country for language selection, content filtering and date formats") : t("This account's default country for content filtering and date formats."),
    );

    return $form;
  }
  elseif ($op == 'update') {
    country_code_set($edit['country_code']);
  }
}


/**
 * Implementation of hook_theme().
 */
function country_code_theme() {
  return array(
    'country_code_admin_overview' => array(
      'arguments' => array('form' => array()),
    ),
    'country_code_admin_country_languages' => array(
      'arguments' => array('form' => array()),
    ),
  );
}

/**
 * Implementation of hook_form_alter().
 *
 * Unset or adjust the language selection element on user edit forms.
 */
function country_code_form_alter(&$form, $form_state, $form_id) {
  if (in_array($form_id, array('user_profile_form', 'user_register')) && isset($form['locale'])) {
    // If user language selection is disabled, unset the locale element.
    if (!variable_get('country_code_user_language', 1)) {
      unset($form['locale']);
    }
    // Otherwise, limit the available languages to those of the user's selected
    // country.
    elseif (isset($form['country_code']) && $form['country_code']['country_code']['#default_value']) {
      $countries = country_code_countries();
      $country = $form['country_code']['country_code']['#default_value'];
      if (isset($countries[$country])) {
        $languages = country_code_languages($country);
        $options = array_intersect_key($form['locale']['language']['#options'], $languages);
        // Use the short names for these languages.
        foreach ($options as $key => $value) {
          $options[$key] = $languages[$key]->name . ' (' . $languages[$key]->native . ')';
        }
      }
    }
    // If not using country, restrict to two-digit languages, since only these
    // can be linked with countries.
    else {
      $options = array_intersect_key($form['locale']['language']['#options'], country_code_languages_short());
    }
    if (isset($options)) {
      // If at least two options remain, limit the options to them.
      if (count($options) > 1) {
        $form['locale']['language']['#options'] = $options;
      }
      // Otherwise, unset the element.
      else {
        unset($form['locale']);
      }
    }
  }
}

/**
 * Implementation of hook_form_form_id_alter().
 *
 * Add a custom language negotiation option to the locale_languages_configure form.
 */
function country_code_form_locale_languages_configure_form_alter(&$form, $form_state) {
  $form['language_negotiation']['#options'][LANGUAGE_NEGOTIATION_COUNTRY_CODE] = t('Based on <a href="@countries">country settings</a>.', array('@countries' => url('admin/settings/country-code')));
}

/**
 * Implementation of hook_form_form_id_alter().
 *
 * Add a custom language negotiation option to the locale_languages_configure form.
 */
function country_code_form_system_modules_alter(&$form, $form_state) {
  $form['#submit'][] = 'country_code_system_modules_submit';
}

/**
 * Form submit handler for system_modules altered form.
 */
function country_code_system_modules_submit($form, &$form_state) {
  if ($form_state['values']['status']['country_code'] == 0 && in_array('country_code', $form['status']['#default_value'])) {
    _country_code_reset();
  }
}

/**
 * Reset cached country code information.
 */
function _country_code_reset() {
  // Set the country code to global.
  // TODO: should we be calling country_code(TRUE) instead?
  // country_code(TRUE);
  country_code_set(COUNTRY_CODE_GLOBAL);
  // Refresh static variables.
  if (!(function_exists('custom_url_rewrite_inbound') || function_exists('custom_url_rewrite_outbound'))) {
    $path = dirname(__FILE__) . '/country_code.inc';
    require_once($path);
  }
  $path = '';
  $options = array();
  custom_url_rewrite_outbound($path, $options, '', TRUE);
}

/**
 * Implementation of hook_block().
 *
 * Display a country switcher. Country links may be provided by other modules.
 */
function country_code_block($op = 'list', $delta = 0) {
  if ($op == 'list') {
    $block[0]['info'] = t('Country switcher');
    // Not worth caching.
    $block[0]['cache'] = BLOCK_NO_CACHE;
    return $block;
  }

  // Only show if we have at least two countries and country dependent
  // web addresses, so we can actually link to other language versions.
  elseif ($op == 'view') {
    if (variable_get('country_code_count', 0) > 1 ) {
      $links = array();
      $countries = country_code_countries();
      $global = country_code_global();
      array_unshift($countries, $global);

      $node = menu_get_object();
      $translations = $node && $node->tnid ? module_invoke('translation', 'node_get_translations', $node->tnid) : array();
      foreach ($countries as $country) {
        if (!empty($translations)) {
          if ($best_language = country_code_get_context_language(array_keys($translations), $country->country)) {
            $path = 'node/' . $translations[$best_language]->nid;
          }
        }
        $links[$country->country] = array(
          // Add a prefix only if this is not the current country.
          // This way the 'active' class will be set correctly.
          'href'       => ($country->country == country_code() ? '' : $country->country . '/') . (isset($path) ? $path : $_GET['q']),
          'title'      => $country->name,
          'attributes' => array('class' => 'country-code-link'),
        );
      }
      // Pass the global code in the query string.
      $links[COUNTRY_CODE_GLOBAL]['query'] = 'country_code=' . COUNTRY_CODE_GLOBAL;
      // Allow modules to alter country links.
      drupal_alter('country_code_link', $links, $_GET['q']);

      $block['subject'] = t('Countries');
      $block['content'] = theme('links', $links, array());
      return $block;
    }
  }
}

/**
 * Return an object representing the global version of a site.
 */
function country_code_global() {
  $global = new stdClass();
  $global->country = COUNTRY_CODE_GLOBAL;
  $global->name = t('Global');
  return $global;
}

/**
 * Implementation of hook_link_alter().
 *
 * Remove links not supported by current country.
 */
function country_code_link_alter(&$links, &$node) {
  $languages = country_code_languages();
  foreach ($links as $module => $link) {
    if (strpos($module, 'node_translation') === 0) {
      if (!variable_get('country_code_node_links', 1)) {
        unset($links[$module]);
      }
      else {
        $langcode = substr($module, 17);
        if (!isset($languages[$langcode])) {
          unset($links[$module]);
        }
        else {
          $links[$module]['title'] = $languages[$langcode]->native;
        }
      }
    }
  }
}

/**
 * Implementation of hook_translation_link_alter().
 *
 * Strip out languages not supported by current country.
 */
function country_code_translation_link_alter(&$links) {
  global $language;

  if (variable_get('language_negotiation', LANGUAGE_NEGOTIATION_NONE) == LANGUAGE_NEGOTIATION_COUNTRY_CODE) {
    $country_code = country_code();
    $country_languages = country_code_languages($country_code);
    $links = array_intersect_key($links, $country_languages);
    foreach ($links as $key => $link) {
      // If the link's language is not the current one, prepend a prefix
      // and pass a language key. The prepended prefix ensures the links
      // don't get the 'active' class.
      if ($link['language']->language != $language->language) {
        // Only add the prefix if the base language is different.
        if (substr($link['language']->language, 0, 2) != substr($language->language, 0, 2)) {
          $links[$key]['href'] = drupal_is_front_page() ? $country_code : $country_code . '/' . $links[$key]['href'];
        }
        $links[$key]['query'] = array('language' => $key);
      }
      // Show short language names.
      $links[$key]['title'] = $country_languages[$key]->native;
    }
  }
}

/**
 * Implementation of hook_views_api().
 */
function country_code_views_api() {
  return array(
    'api' => 2,
  );
}

/**
 * Get a list of countries from database.
 *
 * @param $enabled
 *   Whether to return only enabled countries.
 * @param $reset
 *   Whether to reset the countries array.
 * @return
 *   An array of countries.
 */
function country_code_countries($enabled = TRUE, $reset = FALSE) {
  static $countries, $enabled_countries;

  if (!isset($countries) || $reset) {
    $countries = array();
    $enabled_countries = array();
    $result = db_query('SELECT country, enabled FROM {country_code_country}');
    while ($country = db_fetch_object($result)) {
      $country->name = country_code_country_name($country->country);
      $countries[$country->country] = $country;
      if ($country->enabled) {
        $enabled_countries[$country->country] = $country;
      }
    }
  }

  return $enabled ? $enabled_countries : $countries;
}

/**
 * Return a language for the given country. Or try to discover the language
 * based on user preferences and country settings.
 *
 * @param $country
 *   Country code.
 * @param $languages
 *   An array of languages that the returned language should be one of.
 * @return
 *   Language code.
 */
function country_code_language($country = NULL, $reference_language = NULL) {
  global $user;

  if (!isset($country)) {
    $country = country_code();
  }

  $languages = country_code_languages($country);

  // If there is a reference language and it is valid, return it.
  if (!empty($reference_language) && isset($languages[$reference_language])) {
    return $reference_language;
  }

  // Return user's preferred language or the first key.
  if (variable_get('country_code_user_language', 1) && isset($user->language) && isset($languages[$user->language])) {
    return $user->language;
  }
  // Otherwise, return a supported language based on the user's browser data.
  elseif (variable_get('country_code_browser_language', 1) && $language = language_from_browser()) {
    if (isset($languages[$language->language])) {
      return $language->language;
    }
    // Match a two-digit browser language.
    if (strlen($language->language) == 2) {
      foreach (array_keys($languages) as $langcode) {
        if (substr($langcode, 0, 2) == $language->language) {
          return $langcode;
        }
      }
    }
  }

  // Default to the first (lowest weight) language.
  return key($languages);
}

/**
 * Fetch an individual country.
 *
 * Because we use '%country_code_country' as a wildcard in our hook_menu()
 * handler, this function will also be called automatically when we go to edit
 * or delete a country.
 *
 * @param $country
 *   A country code.
 * @return
 *   A single record in array format, or FALSE if none matched the incoming
 *   country code.
 */
function country_code_country_load($country) {
  $sql = "SELECT * FROM {country_code_country} WHERE country = '%s'";
  $result = db_query($sql, $country);
  if ($record = db_fetch_array($result)) {
    $record['name'] = country_code_country_name($record['country']);
    return $record;
  }
  else {
    return FALSE;
  }
}

/**
 * Insert a new country, or update an existing one.
 *
 * @param $record
 *   A country record to be saved. If country already exists in database, the
 *   record will be updated. Otherwise, a new record will be inserted into the
 *   database.
 * @return
 *   The flag SAVED_NEW or SAVED_UPDATE based on the operation performed.
 */
function country_code_country_save($record) {
  $existing = country_code_country_load($record['country']);
  if ($existing) {
    // If it is the default country, enforce it as enabled.
    $record['enabled'] = (variable_get('site_country_default_country', '') == $record['country']) ? TRUE : $record['enabled'];
    // Update enabled country count if we are changing the enabled status of a country.
    if (isset($record['enabled']) && $existing['enabled'] != $record['enabled']) {
      $current_count = variable_get('country_code_count', 0);
      variable_set('country_code_count', $record['enabled'] ? $current_count + 1 : $current_count - 1);
    }
    return drupal_write_record('country_code_country', $record, 'country');
  }
  else {
    // If this is the first country, set it as the default and enable it.
    if (count(country_code_countries(FALSE)) == 0) {
      $record['enabled'] = 1;
      variable_set('site_country_default_country', $record['country']);
    }
    // Increment enabled country count if we are adding an enabled country.
    if ($record['enabled']) {
      variable_set('country_code_count', variable_get('country_code_count', 0) + 1);
    }
    return drupal_write_record('country_code_country', $record);
  }
}

/**
 * Deletes a country, given its country code.
 *
 * @param $country
 *   The country code of the country to be deleted.
 * @return
 *   1 for success, 0 for failure if an attempt was made to remove the last
 *   country which was also the default.
 */
function country_code_country_delete($country) {
  // Don't allow users to delete the default country, if it is the last country
  // remaining (enabled or disabled).
  if (count(country_code_countries(FALSE)) == 1) {
    return 0;
  }
  if ($country['enabled']) {
    variable_set('country_code_count', variable_get('country_code_count', 0) > 1 ? variable_get('country_code_count', 0) - 1 : 0);
  }
  db_query("DELETE FROM {country_code_country} WHERE country = '%s'", $country['country']);
  $countries = country_code_countries(TRUE, TRUE);  // Reset country list.
  // If the deleted country was the default, try to set a new default.
  if (variable_get('site_country_default_country', '') == $country['country']) {
    // Only true if there is at least one enabled country configured.
    if (count($countries) > 0) {
      $new = array_shift($countries);
      variable_set('site_country_default_country', $new->country);
    }
    // Try to set a new default from the disabled countries.
    else {
      // Check first if there any disabled countries we can use.
      $countries = country_code_countries(FALSE);
      // If yes, enable it and make it the default.
      if (count($countries) > 0) {
        $new = array_shift($countries);
        $new->enabled = 1;
        drupal_write_record('country_code_country', $new, 'country');
        variable_set('site_country_default_country', $new->country);
      }
      // If this was the last, delete the variable.
      else {
        variable_del('site_country_default_country');
      }
    }
  }
  return 1;
}

/**
 * Given a country code, return the country name.
 *
 * @return
 *   String, country name.
 */
function country_code_country_name($code) {
  $countries = site_country_country_list();
  return isset($countries[$code]) ? $countries[$code] : NULL;
}

/**
 * Given a country code, return all languages for that country.
 *
 * @return
 *   Array of language objects.
 */
function country_code_languages($country = NULL, $enabled = TRUE, $index = COUNTRY_CODE_LANGUAGE_LONG) {
  static $languages = array();

  if (is_null($country)) {
    $country = country_code();
  }

  if (!isset($languages[$country])) {
    $languages[$country] = array();
    // If requesting for global, return all two-digit languages.
    if ($country == COUNTRY_CODE_GLOBAL) {
      if ($enabled) {
        $result = db_query("SELECT language, name, native, weight FROM {languages} WHERE CHAR_LENGTH(language) = 2 AND enabled = 1 ORDER BY weight, name");
      }
      else {
        $result = db_query("SELECT language, name, native, weight FROM {languages} WHERE CHAR_LENGTH(language) = 2 ORDER BY weight, name");
      }
    }
    // Otherwise, return a country's languages.
    else {
      if ($enabled) {
        $result = db_query("SELECT c.language, g.language as language_short, g.name, g.native, c.weight FROM {languages} c INNER JOIN {languages} g ON SUBSTRING(c.language, 1, 2) = g.language WHERE SUBSTRING(c.language, 4) = '%s' AND c.enabled = 1 ORDER BY c.weight, c.name", $country);
      }
      else {
        $result = db_query("SELECT c.language, g.language as language_short, g.name, g.native, c.weight FROM {languages} c INNER JOIN {languages} g ON SUBSTRING(c.language, 1, 2) = g.language WHERE SUBSTRING(c.language, 4) = '%s' ORDER BY c.weight, c.name", $country);
      }
    }
    while ($language = db_fetch_object($result)) {
      $key = ($index == COUNTRY_CODE_LANGUAGE_LONG) ? $language->language : $language->language_short;
      $languages[$country][$key] = $language;
    }
  }

  return $languages[$country];
}

/**
 * Fetch a language code for a language and country, or for the current language and
 * current country, if such a language is installed.
 *
 * @return
 *   A language code form en-ca where en is the language and ca
 *   is the country.
 */
function country_code_get_country_language($language_code = NULL, $country_code = NULL, $enabled = TRUE) {
  global $language;

  if (!isset($language_code)) {
    // We can assume current language is always enabled.
    return $language->language;
  }

  if (!isset($country_code)) {
    $country_code = country_code();
  }

  $country_language = $language_code . '-' . $country_code;

  if ($enabled) {
    $enabled_languages = locale_language_list();
    return isset($enabled_languages[$country_language]) ? $country_language : FALSE;
  }
  else {
    return $country_language;
  }
}

/**
 * Return the currently enabled two-digit languages.
 *
 * @return
 *   An array of languages with codes as keys and names as values.
 */
function country_code_languages_short() {
  $languages = locale_language_list('name', TRUE);
  foreach ($languages as $id => $name) {
    if (strlen($id) != 2) {
      unset($languages[$id]);
    }
  }
  return $languages;
}

/**
 * Return the currently enabled five-digit languages for currently enabled countries.
 *
 * @return
 *   An array of languages with codes as keys and names as values.
 */
function country_code_languages_long() {
  $languages = locale_language_list('name', TRUE);
  $country_languages = country_code_languages(COUNTRY_CODE_GLOBAL);
  foreach ($languages as $id => $name) {
    if (strlen($id) != 5) {
      unset($languages[$id]);
    }
  }
  return $languages;
}

/**
 * Determine if a language exists.
 */
function country_code_language_exists($langcode) {
  return db_result(db_query("SELECT COUNT(*) FROM {languages} WHERE language = '%s'", $langcode)) != 0;
}

/**
 * Return the appropriate translation for a nid.
 *
 *  @param $nid
 *    A node ID.
 *  @param $tnid
 *    Optional: a translation ID (tnid) corresponding to the node ID.
 * @return
 *   The best match node ID.
 */
function country_code_get_country_node_id($nid, $tnid = NULL) {
  global $language;

  if ($tnid == NULL) {
    $tnid = db_result(db_query('SELECT tnid FROM {node} WHERE nid = %d', $nid));
  }

  if ($tnid) {
    $translations = translation_node_get_translations($tnid);

    // Priorize country-specific language.
    $languages = array($language->language);

    if (strlen($language->language) > 2) {
      // Also search for 'generic', non country specific language.
      $languages[] = substr($language->language, 0, 2);
    }

    // Return the first found translation.
    foreach ($languages as $langcode) {
      if (isset($translations[$langcode])) {
        return $translations[$langcode]->nid;
      }
    }
    // TODO: return FALSE here?
    // return FALSE;
  }

  return $nid;
}

/**
 * Return the appropriate translation for a node.
 *
 *  @param $node
 *    A fully loaded node object.
 * @return
 *   The best match node.
 */
function country_code_get_country_node($node) {
  return node_load(country_code_get_country_node_id($node->nid, $node->tnid));
}

/**
 * Given a set of languages, return the best language for the current context.
 *
 * @param $languages
 *   Array, list of language codes.
 * @param $country
 *   String, country code.
 * @param enabled
 *   Whether to search only on enabled languages.
 *
 * @return unknown
 */
function country_code_get_context_language($languages, $country = NULL, $enabled = TRUE) {
  global $language;

  if (!isset($country)) {
    $country = country_code();
  }

  $language_short = (strlen($language->language) > 2) ? substr($language->language, 0, 2) : $language->language;

  // If it's global, return two-digits language
  if ($country == COUNTRY_CODE_GLOBAL && in_array($language_short, $languages)) {
    return $language_short;
  }

  // First see if there is a country specific language matching current
  // two digits language code.
  if ($country_language = country_code_get_country_language($language_short, $country, $enabled)) {
    if (in_array($country_language, $languages)) {
      return $country_language;
    }
  }

  // Search for a language on all languages set for the given country.
  $country_languages = country_code_languages($country, $enabled);
  foreach ($country_languages as $langcode => $country_language) {
    if (in_array($langcode, $languages)) {
      return $langcode;
    }
    elseif (in_array($country_language->language_short, $languages)) {
      return $country_language->language_short;
    }
  }

  return FALSE;
}

/**
 * Return the ip_address.  This is only used for testing.  You can override the
 * ip address by setting this in your settings.php (the IP is for cbc.ca, in
 * Canada):
 *   $conf = array(
 *     'country_code_ip_address' => '159.33.3.85',
 *   );
 */
function _country_code_ip_address() {
  return variable_get('country_code_ip_address', ip_address());
}

/**
 * Return the country code of the user, based on the user's IP address.
 *
 * @TODO: support IP to country (ip2cc) or other similar modules?
 */
function country_code($reset = FALSE) {
  global $user;

  if ($reset || empty($_SESSION['country_code'])) {
    // Accept a user country preference.
    if (variable_get('country_code_user_country', 0) && $country = country_code_preferred_country($user, FALSE)) {
      $country_code = $country;
    }
    // Otherwise, try IP detection.
    else {
      $country_code = _country_code_ip_code();
    }
    // If we have countries but the detected country is not supported, use a fallback.
    if (variable_get('country_code_count', 0) && !array_key_exists($country_code, country_code_countries())) {
      // Get the country code fallback.  If it's not set to global, then get the 'country_code_default' variable setting.
      $country_code = variable_get('country_code_fallback', COUNTRY_CODE_GLOBAL) != COUNTRY_CODE_GLOBAL && country_code_default() ? country_code_default() : COUNTRY_CODE_GLOBAL;
    }
    country_code_set($country_code);
  }
  return $_SESSION['country_code'];
}

/**
 * Return a country code based on the visitor's IP address.
 */
function _country_code_ip_code() {
  static $country_code;
  if (!isset($country_code)) {
    $handlers = module_invoke_all('country_code_handler');
    $handler = $handlers[variable_get('country_code_handler', 'country_code_hostip')];
    $country_code = call_user_func($handler['callback'], _country_code_ip_address());
  }
  return $country_code;
}

/**
 * Set session country code.
 */
function country_code_set($country_code) {
  $_SESSION['country_code'] = $country_code;
}

/**
 * Return a path prefix consisting of a country code and a forward slash or an empty string
 * in the case of a country of xx (unknown).
 */
function _country_code_prefix() {
  $country_code = country_code();
  return country_code() == COUNTRY_CODE_GLOBAL ? '' : $country_code . '/';
}

/**
 * Implementation of hook_form_alter().
 */
function country_code_form_system_site_information_settings_alter(&$form, $form_state) {
  $form['#submit'][] = 'country_code_system_site_information_settings_submit';
}

/**
 * Form submit handler for system_site_information_settings altered form.
 */
function country_code_system_site_information_settings_submit($form, &$form_state) {
  $country = $form_state['values']['site_country_default_country'];
  if (!empty($country)) {
    $record = array();
    $record['country'] = $country;
    $record['enabled'] = 1;
    country_code_country_save($record);
  }
}