root/alternc/trunk/bureau/class/m_dom.php

<?php
/*
 $Id: m_dom.php,v 1.27 2006/02/17 18:34:30 olivier Exp $
 ----------------------------------------------------------------------
 LICENSE

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

 This program 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 General Public License for more details.

 To read the license please visit http://www.gnu.org/copyleft/gpl.html
 ----------------------------------------------------------------------
 Original Author of file: Benjamin Sonntag
 Purpose of file: PHP Class that manage domain names installed on the server
 ----------------------------------------------------------------------
*/

define('SLAVE_FLAG', "/var/run/alternc/refresh_slave");

/**
* Classe de gestion des domaines de l'hébergé.
* 
* Cette classe permet de gérer les domaines / sous-domaines, redirections
* dns et mx des domaines d'un membre hébergé.<br />
* Copyleft {@link http://alternc.net/ AlternC Team}
* 
* @copyright    AlternC-Team 2002-11-01 http://alternc.net/
* 
*/
class m_dom {

  /** $domains : Cache des domaines du membre
   * @access private
   */
  var $domains;

  /** $dns : Liste des dns trouvés par la fonction whois
   * @access private
   */
  var $dns;

  /** Flag : a-t-on trouvé un sous-domaine Webmail pour ce domaine ?
   * @access private
   */
  var $webmail;

  /**
   * Système de verrouillage du cron
   * Ce fichier permet de verrouiller le cron en attendant la validation
   * du domaine par update_domains.sh
   * @access private
   */
  var $fic_lock_cron="/var/run/alternc/cron.lock";

  /**
   * Le cron a-t-il été bloqué ?
   * Il faut appeler les fonctions privées lock et unlock entre les
   * appels aux domaines.
   * @access private
   */
  var $islocked=false;

  var $type_local = "0";
  var $type_url = "1";
  var $type_ip = "2";
  var $type_webmail = "3";

  var $action_insert = "0";
  var $action_update= "1";
  var $action_delete = "2";

  /* ----------------------------------------------------------------- */
  /**
   * Constructeur
   */
  function m_dom() {
  }

  /* ----------------------------------------------------------------- */
  /**
   * Quota name
   */
  function alternc_quota_names() {
    return "dom";
  }

  /* ----------------------------------------------------------------- */
  /**
   * Retourne un tableau contenant les domaines d'un membre.
   *
   * @return array retourne un tableau indexé contenant la liste des
   *  domaines hébergés sur le compte courant. Retourne FALSE si une
   *  erreur s'est produite.
   */
  function enum_domains() {
    global $db,$err,$cuid;
    $err->log("dom","enum_domains");
    $db->query("select * from domaines where compte='$cuid';");
    $this->domains=array();
    if ($db->num_rows()>0) {
      while ($db->next_record()) {
    $this->domains[]=$db->f("domaine");
      }
    }
    return $this->domains;
  }

  /* ----------------------------------------------------------------- */
  /**
   *  Efface un domaine du membre courant, et tous ses sous-domaines
   *
   * Cette fonction efface un domaine et tous ses sous-domaines, ainsi que
   * les autres services attachés à celui-ci. Elle appelle donc les autres
   * classe. Chaque classe peut déclarer une fonction del_dom qui sera
   * appellée lors de la destruction d'un domaine.
   *
   * @param string $dom nom de domaine à effacer
   * @return boolean Retourne FALSE si une erreur s'est produite, TRUE sinon.
   */
  function del_domain($dom) {
    global $db,$err,$classes,$cuid;
    $err->log("dom","del_domain",$dom);
    $dom=strtolower($dom);
    $db->query("SELECT * FROM domaines WHERE domaine='$dom';");
    if ($db->num_rows()==0) {
      $err->raise("dom",1,$dom);
      return false;
    }
    $db->next_record();
    if ($db->f("compte")!=$cuid) {
      $err->raise("dom",2,$dom);
      return false;
    }
    $db->query("INSERT INTO domaines_standby (compte,domaine,mx,gesdns,gesmx,action) SELECT compte,domaine,mx,gesdns,gesmx,2 FROM domaines WHERE domaine='$dom'"); // DELETE
    $db->query("DELETE FROM domaines WHERE domaine='$dom';");
    $db->query("DELETE FROM sub_domaines WHERE domaine='$dom';");

    // DEPENDANCE :
    // Lancement de del_dom sur les classes domain_sensitive :
    // Declenchons les autres classes.
    foreach($classes as $c) {
      if (method_exists($GLOBALS[$c],"alternc_del_domain")) {
    $GLOBALS[$c]->alternc_del_domain($dom);
      }
    }
    foreach($classes as $c) {
      if (method_exists($GLOBALS[$c],"alternc_del_mx_domain")) {
    $GLOBALS[$c]->alternc_del_mx_domain($dom);
      }
    }
    return true;
  }

  /* ----------------------------------------------------------------- */
  /**
   *  Installe un domaine sur le compte courant.
   *
   * <p>Si le domaine existe déjà ou est interdit, ou est celui du serveur,
   * l'installation est refusée. Si l'hébergement DNS est demandé, la fonction
   * checkhostallow vérifiera que le domaine peut être installé conformément
   * aux demandes des super-admin.
   * Si le dns n'est pas demandé, le domaine peut être installé s'il est en
   * seconde main d'un tld (exemple : test.eu.org ou test.com, mais pas
   * toto.test.org ou test.test.asso.fr)</p>
   * <p>Chaque classe peut définir une fonction add_dom($dom) qui sera
   * appellée lors de l'installation d'un nouveau domaine.</p>
   *
   * @param string $dom nom fqdn du domaine à installer
   * @param integer $dns 1 ou 0 pour héberger le DNS du domaine ou pas.
   * @param integer $noerase 1 ou 0 pour rendre le domaine inamovible ou non
   * @param integer $force 1 ou 0, si 1, n'effectue pas les tests de DNS.
   *  force ne devrait être utilisé que par le super-admin.
   $ @return boolean Retourne FALSE si une erreur s'est produite, TRUE sinon.
  */
  function add_domain($domain,$dns,$noerase=0,$force=0) {
    global $db,$err,$quota,$classes,$L_MX,$L_FQDN,$tld,$cuid;
    $err->log("dom","add_domain",$domain);
    $mx="1";
    // Locked ?
    if (!$this->islocked) {
      $err->raise("dom",3);
      return false;
    }
    // Verifie que le domaine est rfc-compliant
    $domain=strtolower($domain);
    $t=checkfqdn($domain);
    if ($t) {
      $err->raise("dom",3+$t);
      return false;
    }
    // Interdit les domaines clés (table forbidden_domains) sauf en cas FORCE
    $db->query("select domain from forbidden_domains where domain='$domain'");
    if ($db->num_rows() && !$force) {
      $err->raise("dom",22);
      return false;
    }
    if ($domain==$L_FQDN || $domain=="www.$L_FQDN") {
      $err->raise("dom",18);
      return false;
    }
    $db->query("SELECT compte FROM domaines WHERE domaine='$domain';");
    if ($db->num_rows()) {
      $err->raise("dom",8);
      return false;
    }
    $db->query("SELECT compte FROM `sub_domaines` WHERE sub != \"\" AND concat( sub, \".\", domaine )='$domain' OR domaine='$domain';");
    if ($db->num_rows()) {
      $err->raise("dom",8);
      return false;
    }
    $db->query("select compte from domaines_standby where domaine='$domain';");
    if ($db->num_rows()!=0) {
      $err->raise("dom",9);
      return false;
    }
    $this->dns=$this->whois($domain);
    if (!$force) {
      $v=checkhostallow($domain,$this->dns);
      if ($v==-1) {
    $err->raise("dom",7);     // TLD interdit
    return false;
      }
      if ($dns && $v==-2) {
    $err->raise("dom",12);     // Domaine non trouvé dans le whois
    return false;
      }
      if ($dns && $v==-3) {
    $err->raise("dom",23);     // Domaine non trouvé dans le whois
    return false;
      }

      if ($dns) $dns="1"; else $dns="0";

      // mode 5 : force DNS to NO.
      if ($tld[$v]==5) $dns=0;
      // It must be a real domain (no subdomain)
      if (!$dns) {
    $v=checkhostallow_nodns($domain);
    if ($v) {
      $err->raise("dom",22);
      return false;
    }
      }
    }
    // Check the quota :
    if (!$quota->cancreate("dom")) {
      $err->raise("dom",10);
      return false;
    }
    if ($noerase) $noerase="1"; else $noerase="0";
    $db->query("insert into domaines (compte,domaine,mx,gesdns,gesmx,noerase) values ('$cuid','$domain','$L_MX','$dns','$mx','$noerase');");
    $db->query("insert into domaines_standby (compte,domaine,mx,gesdns,gesmx,action) values ('$cuid','$domain','$L_MX','$dns','$mx',0);"); // INSERT
    // Creation des 3 sous-domaines par défaut : Vide, www et mail
    $this->set_sub_domain($domain, '',     $this->type_url,     'add', 'http://www.'.$domain);
    $this->set_sub_domain($domain, 'www',  $this->type_local,   'add', '/');
    $this->set_sub_domain($domain, 'mail', $this->type_webmail, 'add', '');
    // DEPENDANCE :
    // Lancement de add_dom sur les classes domain_sensitive :
     // Declenchons les autres classes.    
    foreach($classes as $c) {
      if (method_exists($GLOBALS[$c],"alternc_add_domain")) {
    $GLOBALS[$c]->alternc_add_domain($domain);
      }
    }
    foreach($classes as $c) {
      if (method_exists($GLOBALS[$c],"alternc_add_mx_domain")) {
    $GLOBALS[$c]->alternc_add_mx_domain($domain);
      }
    }
   return true;
  }

  /* ----------------------------------------------------------------- */
  /**
   * Retourne les entrées DNS du domaine $domain issues du WHOIS.
   *
   * Cette fonction effectue un appel WHOIS($domain) sur Internet,
   * et extrait du whois les serveurs DNS du domaine demandé. En fonction
   * du TLD, on sait (ou pas) faire le whois correspondant.
   * Actuellement, les tld suivants sont supportés :
   * .com .net .org .be .info .ca .cx .fr .biz .name
   *
   * @param string $domain Domaine fqdn dont on souhaite les serveurs DNS
   * @return array Retourne un tableau indexé avec les NOMS fqdn des dns
   *   du domaine demandé. Retourne FALSE si une erreur s'est produite.
   *
   */
  function whois($domain) {
    global $db,$err;
    $err->log("dom","whois",$domain);
    // pour ajouter un nouveau TLD, utiliser le code ci-dessous.
    //    echo "whois : $domain<br />";
    ereg(".*\.([^\.]*)",$domain,$out);
    $ext=$out[1];
    // pour ajouter un nouveau TLD, utiliser le code ci-dessous.
    //    echo "ext: $ext<br />";
    $egal="";
    switch($ext) {
    case "com":
    case "net":
      $serveur="rs.internic.net";
      $egal="=";
      break;
    case "org":
      $serveur="whois.pir.org";
      break;
    case "be":
      $serveur="whois.dns.be";
      break;
    case "eu":
      $serveur="195.234.53.193";
      break;
    case "info":
      $serveur="whois.afilias.net";
      break;
    case "ca":
      $serveur="whois.cira.ca";
      break;
    case "cx":
      $serveur="whois.nic.cx";
      break;
    case "it":
      $serveur="whois.nic.it";
      break;
    case "fr":
      $serveur="whois.nic.fr";
      break;
    case "biz":
      $serveur="whois.nic.biz";
      break;
    case "name":
      $serveur="whois.nic.name";
      $egal="domain = ";
      break;
    case "ws":
      $serveur="whois.samoanic.ws";
      break;
    default:
      $err->raise("dom",7);
      return false;
      break;
    }
    // pour ajouter un nouveau TLD, utiliser le code ci-dessous.
    //    echo "serveur : $serveur <br />";
    if (($fp=fsockopen($serveur, 43))>0) {
      fputs($fp, "$egal$domain\r\n");
      $found = false;
      $state=0;
      while (!feof($fp)) {
    $ligne = fgets($fp,128);
    // pour ajouter un nouveau TLD, utiliser le code ci-dessous.
    //    echo "| $ligne<br />";
    switch($ext) {
    case "org":
    case "com":
    case "net":
    case "info":
    case "biz":
    case "name":
      if (ereg("Name Server:", $ligne)) {
        $found = true;
        $tmp=strtolower(ereg_replace(chr(10), "",ereg_replace(chr(13),"",ereg_replace(" ","", ereg_replace("Name Server:","", $ligne)))));
        if ($tmp)
          $server[]=$tmp;
      }
      break;
    case "cx":
      $ligne = ereg_replace(chr(10), "",ereg_replace(chr(13),"",ereg_replace(" ","", $ligne)));
      if ($ligne=="" && $state==1)
        $state=2;
      if ($state==1)
        $server[]=strtolower($ligne);
      if ($ligne=="Nameservers:" && $state==0) {
        $state=1;
        $found = true;
      }
      break;
        case "eu":
    case "be":
          $ligne=preg_replace("/^ *([^ ]*) \(.*\)$/","\\1",trim($ligne));
          if($found)
             $tmp = trim($ligne);
          if ($tmp)
             $server[]=$tmp;
          if ($ligne=="Nameservers:") {
            $state=1;
            $found=true;
          }
          break;
        case "it":
          if (ereg("nserver:", $ligne)) {
            $found=true;
            $tmp=strtolower(preg_replace("/nserver:\s*[^ ]*\s*([^\s]*)$/","\\1", $ligne));
            if ($tmp)
              $server[]=$tmp;
          }
          break;
    case "fr":
          if (ereg("nserver:", $ligne)) {
            $found=true;
            $tmp=strtolower(preg_replace("/nserver:\s*([^\s]*)\s*.*$/","\\1", $ligne));
            if ($tmp)
              $server[]=$tmp;
          }
          break;
    case "ca":
    case "ws";
      if (ereg('^[[:space:]]*Name servers:[[:space:]]*$', $ligne)) {
            // found the server
          $state = 1;
      } elseif ($state) {
          if (ereg('^[^%]', $ligne) && $ligne = ereg_replace('[[:space:]]', "", $ligne)) {
          // first non-whitespace line is considered to be the nameservers themselves
          $found = true;
          $server[] = $ligne;
        }
      }
      break;
    } // switch
      } // while
      fclose($fp);
    } else {
      $err->raise("dom",11);
      return false;
    }

    if ($found) {
      return $server;
    } else {
      $err->raise("dom",12);
      return false;
    }
  } // whois

  /* ----------------------------------------------------------------- */
  /**
   *  vérifie la presence d'un champs mx valide sur un serveur DNS
   *
  */
  
  function checkmx($domaine,$mx) {
    //initialise variables
    $mxhosts = array();
    
    //récupére les champs mx
    if (!getmxrr($domaine,$mxhosts)) {
      //aucune hôte mx spécifié
      return 1;
    }
    else {
      //vérifie qu'un des hôtes est bien sur alternc
      $bolmx = 0;
      //décompose les différents champ MX coté alternc
      $arrlocalmx = split(",",$mx);
      //parcours les différents champ MX retournés
      foreach($mxhosts as $mxhost) {
        foreach($arrlocalmx as $localmx) {
          if ($mxhost==$localmx) {
            $bolmx = 1;
          }
        }
      }
      //définition de l'erreur selon reponse du parcours de mxhosts
      if ($bolmx == 0) {
        //aucun des champs MX ne correspond au serveur
        return 2;          
      }
      else {
        //un champ mx correct a été trouvé
        return 0;
      }
    }
  } //checkmx


  /* ----------------------------------------------------------------- */
  /**
   *  retourne TOUTES les infos d'un domaine
   *
   * <b>Note</b> : si le domaine est en attente (présent dans
   *  domaines_standby), une erreur est retournée
   *
   * @param string $dom Domaine dont on souhaite les informations
   * @return array Retourne toutes les infos du domaine sous la forme d'un
   * tableau associatif comme suit :<br /><pre>
   *  $r["name"] =  Nom fqdn
   *  $r["dns"]  =  Gestion du dns ou pas ?
   *  $r["mx"]   =  Valeur du champs MX si "dns"=true
   *  $r["mail"] =  Heberge-t-on le mail ou pas ? (si "dns"=false)
   *  $r["nsub"] =  Nombre de sous-domaines
   *  $r["sub"]  =  tableau associatif des sous-domaines
   *  $r["sub"][0-(nsub-1)]["name"] = nom du sous-domaine (NON-complet)
   *  $r["sub"][0-(nsub-1)]["dest"] = Destination (url, ip, local ...)
   *  $r["sub"][0-(nsub-1)]["type"] = Type (0-n) de la redirection.
   *  </pre>
   *  Retourne FALSE si une erreur s'est produite.
   *
   */
  function get_domain_all($dom) {
    global $db,$err,$cuid;
    $err->log("dom","get_domain_all",$dom);
    // Locked ?
    if (!$this->islocked) {
      $err->raise("dom",3);
      return false;
    }
    $t=checkfqdn($dom);
    if ($t) {
      $err->raise("dom",3+$t);
      return false;
    }
    $r["name"]=$dom;
    $db->query("select * from domaines_standby where compte='$cuid' and domaine='$dom'");
    if ($db->num_rows()>0) {
      $err->raise("dom",13);
      return false;
    }
    $db->query("select * from domaines where compte='$cuid' and domaine='$dom'");
    if ($db->num_rows()==0) {
      $err->raise("dom",1,$dom);
      return false;
    }
    $db->next_record();
    $r["dns"]=$db->Record["gesdns"];
    $r["mail"]=$db->Record["gesmx"];
    $r["mx"]=$db->Record["mx"];
    $r[noerase]=$db->Record[noerase];
    $db->free();
    $db->query("select count(*) as cnt from sub_domaines where compte='$cuid' and domaine='$dom'");
    $db->next_record();
    $r["nsub"]=$db->Record["cnt"];
    $db->free();
    $db->query("select * from sub_domaines where compte='$cuid' and domaine='$dom'");
    // Pas de webmail, on le cochera si on le trouve.
    $this->webmail=0;
    for($i=0;$i<$r["nsub"];$i++) {
      $db->next_record();
      $r["sub"][$i]=array();
      $r["sub"][$i]["name"]=$db->Record["sub"];
      $r["sub"