source: bureau/class/m_dom.php @ 468

Revision 468, 29.8 KB checked in by anarcat, 9 years ago (diff)

[project @ alternc: changeset 2004-11-25 17:20:55 by anonymous]
mettre le flag pour slave_dns dans /var/run/alternc closes: #278

Original author: anonymous
Date: 2004-11-25 17:20:55

Line 
1<?php
2/*
3 $Id: m_dom.php,v 1.20 2004/11/25 17:20:55 anonymous Exp $
4 ----------------------------------------------------------------------
5 LICENSE
6
7 This program is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public License (GPL)
9 as published by the Free Software Foundation; either version 2
10 of the License, or (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 To read the license please visit http://www.gnu.org/copyleft/gpl.html
18 ----------------------------------------------------------------------
19 Original Author of file: Benjamin Sonntag
20 Purpose of file: PHP Class that manage domain names installed on the server
21 ----------------------------------------------------------------------
22*/
23
24define('SLAVE_FLAG', "/var/run/alternc/refresh_slave");
25
26/**
27* Classe de gestion des domaines de l'hébergé.
28*
29* Cette classe permet de gérer les domaines / sous-domaines, redirections
30* dns et mx des domaines d'un membre hébergé.<br />
31* Copyleft {@link http://alternc.net/ AlternC Team}
32*
33* @copyright    AlternC-Team 2002-11-01 http://alternc.net/
34*
35*/
36class m_dom {
37
38  /** $domains : Cache des domaines du membre
39   * @access private
40   */
41  var $domains;
42
43  /** $dns : Liste des dns trouvés par la fonction whois
44   * @access private
45   */
46  var $dns;
47
48  /** Flag : a-t-on trouvé un sous-domaine Webmail pour ce domaine ?
49   * @access private
50   */
51  var $webmail;
52
53  /**
54   * Système de verrouillage du cron
55   * Ce fichier permet de verrouiller le cron en attendant la validation
56   * du domaine par do_domaines.sh
57   * @access private
58   */
59  var $fic_lock_cron="/var/run/alternc/cron.lock";
60
61  /**
62   * Le cron a-t-il été bloqué ?
63   * Il faut appeler les fonctions privées lock et unlock entre les
64   * appels aux domaines.
65   * @access private
66   */
67  var $islocked=false;
68
69  var $type_local = "0";
70  var $type_url = "1";
71  var $type_ip = "2";
72  var $type_webmail = "3";
73
74  var $action_insert = "0";
75  var $action_update= "1";
76  var $action_delete = "2";
77
78  /* ----------------------------------------------------------------- */
79  /**
80   * Constructeur
81   */
82  function m_dom() {
83  }
84
85  /* ----------------------------------------------------------------- */
86  /**
87   * Quota name
88   */
89  function alternc_quota_names() {
90    return "dom";
91  }
92
93  /* ----------------------------------------------------------------- */
94  /**
95   * Retourne un tableau contenant les domaines d'un membre.
96   *
97   * @return array retourne un tableau indexé contenant la liste des
98   *  domaines hébergés sur le compte courant. Retourne FALSE si une
99   *  erreur s'est produite.
100   */
101  function enum_domains() {
102    global $db,$err,$cuid;
103    $err->log("dom","enum_domains");
104    $db->query("select * from domaines where compte='$cuid';");
105    $this->domains=array();
106    if ($db->num_rows()>0) {
107      while ($db->next_record()) {
108        $this->domains[]=$db->f("domaine");
109      }
110    }
111    return $this->domains;
112  }
113
114  /* ----------------------------------------------------------------- */
115  /**
116   *  Efface un domaine du membre courant, et tous ses sous-domaines
117   *
118   * Cette fonction efface un domaine et tous ses sous-domaines, ainsi que
119   * les autres services attachés à celui-ci. Elle appelle donc les autres
120   * classe. Chaque classe peut déclarer une fonction del_dom qui sera
121   * appellée lors de la destruction d'un domaine.
122   *
123   * @param string $dom nom de domaine à effacer
124   * @return boolean Retourne FALSE si une erreur s'est produite, TRUE sinon.
125   */
126  function del_domain($dom) {
127    global $db,$err,$classes,$cuid;
128    $err->log("dom","del_domain",$dom);
129    $dom=strtolower($dom);
130    $db->query("SELECT * FROM domaines WHERE domaine='$dom';");
131    if ($db->num_rows()==0) {
132      $err->raise("dom",1,$dom);
133      return false;
134    }
135    $db->next_record();
136    if ($db->f("compte")!=$cuid) {
137      $err->raise("dom",2,$dom);
138      return false;
139    }
140    $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
141    $db->query("DELETE FROM domaines WHERE domaine='$dom';");
142    $db->query("DELETE FROM sub_domaines WHERE domaine='$dom';");
143
144    // DEPENDANCE :
145    // Lancement de del_dom sur les classes domain_sensitive :
146    // Declenchons les autres classes.
147    for($i=0;$i<count($classes);$i++) {
148      if (method_exists($GLOBALS[$classes[$i]],"alternc_del_domain")) {
149        $GLOBALS[$classes[$i]]->alternc_del_domain($dom);
150      }
151    }
152    for($i=0;$i<count($classes);$i++) {
153      if (method_exists($GLOBALS[$classes[$i]],"alternc_del_mx_domain")) {
154        $GLOBALS[$classes[$i]]->alternc_del_mx_domain($dom);
155      }
156    }
157    return true;
158  }
159
160  /* ----------------------------------------------------------------- */
161  /**
162   *  Installe un domaine sur le compte courant.
163   *
164   * <p>Si le domaine existe déjà ou est interdit, ou est celui du serveur,
165   * l'installation est refusée. Si l'hébergement DNS est demandé, la fonction
166   * checkhostallow vérifiera que le domaine peut être installé conformément
167   * aux demandes des super-admin.
168   * Si le dns n'est pas demandé, le domaine peut être installé s'il est en
169   * seconde main d'un tld (exemple : test.eu.org ou test.com, mais pas
170   * toto.test.org ou test.test.asso.fr)</p>
171   * <p>Chaque classe peut définir une fonction add_dom($dom) qui sera
172   * appellée lors de l'installation d'un nouveau domaine.</p>
173   *
174   * @param string $dom nom fqdn du domaine à installer
175   * @param integer $dns 1 ou 0 pour héberger le DNS du domaine ou pas.
176   * @param integer $noerase 1 ou 0 pour rendre le domaine inamovible ou non
177   * @param integer $force 1 ou 0, si 1, n'effectue pas les tests de DNS.
178   *  force ne devrait être utilisé que par le super-admin.
179   $ @return boolean Retourne FALSE si une erreur s'est produite, TRUE sinon.
180  */
181  function add_domain($domain,$dns,$noerase=0,$force=0) {
182    global $db,$err,$quota,$classes,$L_MX,$L_FQDN,$tld,$cuid;
183    $err->log("dom","add_domain",$domain);
184    $mx="1";
185    // Locked ?
186    if (!$this->islocked) {
187      $err->raise("dom",3);
188      return false;
189    }
190    // Verifie que le domaine est rfc-compliant
191    $domain=strtolower($domain);
192    $t=checkfqdn($domain);
193    if ($t) {
194      $err->raise("dom",3+$t);
195      return false;
196    }
197    // Interdit les domaines clés (table forbidden_domains) sauf en cas FORCE
198    $db->query("select domain from forbidden_domains where domain='$domain'");
199    if ($db->num_rows() && !$force) {
200      $err->raise("dom",22);
201      return false;
202    }
203    if ($domain==$L_FQDN || $domain=="www.$L_FQDN") {
204      $err->raise("dom",18);
205      return false;
206    }
207    $db->query("SELECT compte FROM domaines WHERE domaine='$domain';");
208    if ($db->num_rows()) {
209      $err->raise("dom",8);
210      return false;
211    }
212    $db->query("select compte from domaines_standby where domaine='$domain';");
213    if ($db->num_rows()!=0) {
214      $err->raise("dom",9);
215      return false;
216    }
217    $this->dns=$this->whois($domain);
218    if (!$force) {
219      $v=checkhostallow($domain,$this->dns);
220      if ($v==-1) {
221        $err->raise("dom",7);   // TLD interdit
222        return false;
223      }
224      if ($dns && $v==-2) {
225        $err->raise("dom",12);  // Domaine non trouvé dans le whois
226        return false;
227      }
228      if ($dns && $v==-3) {
229        $err->raise("dom",23);  // Domaine non trouvé dans le whois
230        return false;
231      }
232
233      if ($dns) $dns="1"; else $dns="0";
234
235      // mode 5 : force DNS to NO.
236      if ($tld[$v]==5) $dns=0;
237      // It must be a real domain (no subdomain)
238      if (!$dns) {
239        $v=checkhostallow_nodns($domain);
240        if ($v) {
241          $err->raise("dom",22);
242          return false;
243        }
244      }
245    }
246    // Check the quota :
247    if (!$quota->cancreate("dom")) {
248      $err->raise("dom",10);
249      return false;
250    }
251    if ($noerase) $noerase="1"; else $noerase="0";
252    $db->query("insert into domaines (compte,domaine,mx,gesdns,gesmx,noerase) values ('$cuid','$domain','$L_MX','$dns','$mx','$noerase');");
253    $db->query("insert into domaines_standby (compte,domaine,mx,gesdns,gesmx,action) values ('$cuid','$domain','$L_MX','$dns','$mx',0);"); // INSERT
254    // Creation des 3 sous-domaines par défaut : Vide, www et mail
255    $db->query("insert into sub_domaines (compte,domaine,sub,valeur,type) values ('$cuid','$domain','','/',0);");
256    $db->query("insert into sub_domaines (compte,domaine,sub,valeur,type) values ('$cuid','$domain','www','/',0);");
257    $db->query("insert into sub_domaines (compte,domaine,sub,valeur,type) values ('$cuid','$domain','mail','',3);");
258    // DEPENDANCE :
259    // Lancement de add_dom sur les classes domain_sensitive :
260     // Declenchons les autres classes.   
261    for($i=0;$i<count($classes);$i++) {
262      if (method_exists($GLOBALS[$classes[$i]],"alternc_add_domain")) {
263        $GLOBALS[$classes[$i]]->alternc_add_domain($domain);
264      }
265    }
266    for($i=0;$i<count($classes);$i++) {
267      if (method_exists($GLOBALS[$classes[$i]],"alternc_add_mx_domain")) {
268        $GLOBALS[$classes[$i]]->alternc_add_mx_domain($domain);
269      }
270    }
271   return true;
272  }
273
274  /* ----------------------------------------------------------------- */
275  /**
276   * Retourne les entrées DNS du domaine $domain issues du WHOIS.
277   *
278   * Cette fonction effectue un appel WHOIS($domain) sur Internet,
279   * et extrait du whois les serveurs DNS du domaine demandé. En fonction
280   * du TLD, on sait (ou pas) faire le whois correspondant.
281   * Actuellement, les tld suivants sont supportés :
282   * .com .net .org .be .info .ca .cx .fr .biz .name
283   *
284   * @param string $domain Domaine fqdn dont on souhaite les serveurs DNS
285   * @return array Retourne un tableau indexé avec les NOMS fqdn des dns
286   *   du domaine demandé. Retourne FALSE si une erreur s'est produite.
287   *
288   */
289  function whois($domain) {
290    global $db,$err;
291    $err->log("dom","whois",$domain);
292    // pour ajouter un nouveau TLD, utiliser le code ci-dessous.
293    //  echo "whois : $domain<br />";
294    ereg(".*\.([^\.]*)",$domain,$out);
295    $ext=$out[1];
296    // pour ajouter un nouveau TLD, utiliser le code ci-dessous.
297    //  echo "ext: $ext<br />";
298    $egal="";
299    switch($ext) {
300    case "com":
301    case "net":
302      $serveur="rs.internic.net";
303      $egal="=";
304      break;
305    case "org":
306      $serveur="whois.pir.org";
307      break;
308    case "be":
309      $serveur="whois.dns.be";
310      break;
311    case "info":
312      $serveur="whois.afilias.net";
313      break;
314    case "ca":
315      $serveur="whois.cira.ca";
316      break;
317    case "cx":
318      $serveur="whois.nic.cx";
319      break;
320    case "it":
321      $serveur="whois.nic.it";
322      break;
323    case "fr":
324      $serveur="whois.nic.fr";
325      break;
326    case "biz":
327      $serveur="whois.nic.biz";
328      break;
329    case "name":
330      $serveur="whois.nic.name";
331      break;
332    default:
333      $err->raise("dom",7);
334      return false;
335      break;
336    }
337    // pour ajouter un nouveau TLD, utiliser le code ci-dessous.
338    //  echo "serveur : $serveur <br />";
339    if (($fp=fsockopen($serveur, 43))>0) {
340      fputs($fp, "$egal$domain\r\n");
341      $found = false;
342      $state=0;
343      while (!feof($fp)) {
344        $ligne = fgets($fp,128);
345        // pour ajouter un nouveau TLD, utiliser le code ci-dessous.
346        //      echo "| $ligne<br />";
347        switch($ext) {
348        case "org":
349        case "com":
350        case "net":
351        case "info":
352        case "biz":
353        case "name":
354          if (ereg("Name Server:", $ligne)) {
355            $found = true;
356            $tmp=strtolower(ereg_replace(chr(10), "",ereg_replace(chr(13),"",ereg_replace(" ","", ereg_replace("Name Server:","", $ligne)))));
357            if ($tmp)
358              $server[]=$tmp;
359          }
360          break;
361        case "cx":
362          $ligne = ereg_replace(chr(10), "",ereg_replace(chr(13),"",ereg_replace(" ","", $ligne)));
363          if ($ligne=="" && $state==1)
364            $state=2;
365          if ($state==1)
366            $server[]=strtolower($ligne);
367          if ($ligne=="Nameservers:" && $state==0) {
368            $state=1;
369            $found = true;
370          }
371          break;
372        case "ca":
373          $ligne=ereg_replace(chr(10), "",ereg_replace(chr(13),"",ereg_replace(" ","", $ligne)));
374          if ($ligne=="Status:EXIST")
375            $found=true;
376          if (ereg("NS.-Hostname:", $ligne)) {
377            $tmp=strtolower(ereg_replace("NS.-Hostname:","", $ligne));
378            if ($tmp)
379              $server[]=$tmp;
380          }
381          break;
382        case "be":
383          $ligne=ereg_replace(chr(10), "",ereg_replace(chr(13),"",ereg_replace(" ","", $ligne)));
384          if ($ligne=="NameServers:") {
385            $state=1;
386            $found=true;
387          }
388          if ($state==1 && substr($ligne,0,5)=="Name:") {
389            $tmp=trim(strtolower(ereg_replace("Name:","", $ligne)));
390            if ($tmp)
391              $server[]=$tmp;
392          }
393          break;
394        case "it":
395          if (ereg("nserver:", $ligne)) {
396            $found=true;
397            $tmp=strtolower(preg_replace("/nserver:\s*[^ ]*\s*([^\s]*)$/","\\1", $ligne));
398            if ($tmp)
399              $server[]=$tmp;
400          }
401          break;
402        case "fr":
403          if (ereg("nserver:", $ligne)) {
404            $found=true;
405            $tmp=strtolower(preg_replace("/nserver:\s*([^\s]*)\s*.*$/","\\1", $ligne));
406            if ($tmp)
407              $server[]=$tmp;
408          }
409          break;
410        } // switch
411      } // while
412      fclose($fp);
413    } else {
414      $err->raise("dom",11);
415      return false;
416    }
417
418    if ($found) {
419      return $server;
420    } else {
421      $err->raise("dom",12);
422      return false;
423    }
424  } // whois
425
426  /* ----------------------------------------------------------------- */
427  /**
428   *  retourne TOUTES les infos d'un domaine
429   *
430   * <b>Note</b> : si le domaine est en attente (présent dans
431   *  domaines_standby), une erreur est retournée
432   *
433   * @param string $dom Domaine dont on souhaite les informations
434   * @return array Retourne toutes les infos du domaine sous la forme d'un
435   * tableau associatif comme suit :<br /><pre>
436   *  $r["name"] =  Nom fqdn
437   *  $r["dns"]  =  Gestion du dns ou pas ?
438   *  $r["mx"]   =  Valeur du champs MX si "dns"=true
439   *  $r["mail"] =  Heberge-t-on le mail ou pas ? (si "dns"=false)
440   *  $r["nsub"] =  Nombre de sous-domaines
441   *  $r["sub"]  =  tableau associatif des sous-domaines
442   *  $r["sub"][0-(nsub-1)]["name"] = nom du sous-domaine (NON-complet)
443   *  $r["sub"][0-(nsub-1)]["dest"] = Destination (url, ip, local ...)
444   *  $r["sub"][0-(nsub-1)]["type"] = Type (0-n) de la redirection.
445   *  </pre>
446   *  Retourne FALSE si une erreur s'est produite.
447   *
448   */
449  function get_domain_all($dom) {
450    global $db,$err,$cuid;
451    $err->log("dom","get_domain_all",$dom);
452    // Locked ?
453    if (!$this->islocked) {
454      $err->raise("dom",3);
455      return false;
456    }
457    $t=checkfqdn($dom);
458    if ($t) {
459      $err->raise("dom",3+$t);
460      return false;
461    }
462    $r["name"]=$dom;
463    $db->query("select * from domaines_standby where compte='$cuid' and domaine='$dom'");
464    if ($db->num_rows()>0) {
465      $err->raise("dom",13);
466      return false;
467    }
468    $db->query("select * from domaines where compte='$cuid' and domaine='$dom'");
469    if ($db->num_rows()==0) {
470      $err->raise("dom",1,$dom);
471      return false;
472    }
473    $db->next_record();
474    $r["dns"]=$db->Record["gesdns"];
475    $r["mail"]=$db->Record["gesmx"];
476    $r["mx"]=$db->Record["mx"];
477    $r[noerase]=$db->Record[noerase];
478    $db->free();
479    $db->query("select count(*) as cnt from sub_domaines where compte='$cuid' and domaine='$dom'");
480    $db->next_record();
481    $r["nsub"]=$db->Record["cnt"];
482    $db->free();
483    $db->query("select * from sub_domaines where compte='$cuid' and domaine='$dom'");
484    // Pas de webmail, on le cochera si on le trouve.
485    $this->webmail=0;
486    for($i=0;$i<$r["nsub"];$i++) {
487      $db->next_record();
488      $r["sub"][$i]=array();
489      $r["sub"][$i]["name"]=$db->Record["sub"];
490      $r["sub"][$i]["dest"]=$db->Record["valeur"];
491      $r["sub"][$i]["type"]=$db->Record["type"];
492      if ($db->Record["type"]==3) { // Webmail
493        $this->webmail=1;
494        $r["sub"][$i]["dest"]=_("Webmail access");
495      }
496    }
497    $db->free();
498    return $r;
499  } // get_domain_all
500
501  /* ----------------------------------------------------------------- */
502  /**
503   * Retourne TOUTES les infos d'un sous domaine du compte courant.
504   *
505   * @param string $dom Domaine fqdn concerné
506   * @param string $sub Sous-domaine dont on souhaite les informations
507   * @return arrray Retourne un tableau associatif contenant les
508   *  informations du sous-domaine demandé.<pre>
509   *  $r["name"]= nom du sous-domaine (NON-complet)
510   *  $r["dest"]= Destination (url, ip, local ...)
511   *  </pre>
512   *  $r["type"]= Type (0-n) de la redirection.
513   *  Retourne FALSE si une erreur s'est produite.
514   */
515  function get_sub_domain_all($dom,$sub) {
516    global $db,$err,$cuid;
517    $err->log("dom","get_sub_domain_all",$dom."/".$sub);
518    // Locked ?
519    if (!$this->islocked) {
520      $err->raise("dom",3);
521      return false;
522    }
523    $t=checkfqdn($dom);
524    if ($t) {
525      $err->raise("dom",3+$t);
526      return false;
527    }
528    $db->query("select * from sub_domaines where compte='$cuid' and domaine='$dom' and sub='$sub'");
529    if ($db->num_rows()==0) {
530      $err->raise("dom",14);
531      return false;
532    }
533    $db->next_record();
534    $r=array();
535    $r["name"]=$db->Record["sub"];
536    $r["dest"]=$db->Record["valeur"];
537    $r["type"]=$db->Record["type"];
538    $db->free();
539    return $r;
540  } // get_sub_domain_all
541
542  /* ----------------------------------------------------------------- */
543  /**
544   * Modifier les information du sous-domaine demandé.
545   *
546   * <b>Note</b> : si le sous-domaine $sub.$dom n'existe pas, il est créé.<br />
547   * <b>Note : TODO</b> : vérification de concordance de $dest<br />
548   *
549   * @param string $dom Domaine dont on souhaite modifier/ajouter un sous domaine
550   * @param string $subk Sous domaine à modifier / créer
551   * @param integer $type Type de sous-domaine (local, ip, url ...)
552   * @param string $action Action : vaut "add" ou "edit" selon que l'on
553   *  Crée (add) ou Modifie (edit) le sous-domaine
554   * @param string $dest Destination du sous-domaine, dépend de la valeur
555   *  de $type (url, ip, dossier...)
556   * @return boolean Retourne FALSE si une erreur s'est produite, TRUE sinon.
557   */
558  function set_sub_domain($dom,$sub,$type,$action,$dest) {
559    global $db,$err,$cuid;
560    $err->log("dom","set_sub_domain",$dom."/".$sub);
561    // Locked ?
562    if (!$this->islocked) {
563      $err->raise("dom",3);
564      return false;
565    }
566    $dest=trim($dest);
567    $dom=strtolower($dom);
568    $sub=strtolower($sub);
569    if ($type==2) { // IP
570      if (!checkip($dest)) {
571        $err->raise("dom",19);
572        return false;
573      }
574    }
575    if ($type==1) { // URL
576      if (!checkurl($dest)) {
577        $err->raise("dom",20);
578        return false;
579      }
580    }
581    if ($type==0) { // LOCAL
582      if (substr($dest,0,1)!="/") {
583        $dest="/".$dest;
584      }
585      if (!checkuserpath($dest)) {
586        $err->raise("dom",21);
587        return false;
588      }
589    }
590    // On a épuré $dir des problèmes eventuels ... On est en DESSOUS du dossier de l'utilisateur.
591    $t=checkfqdn($dom);
592    if ($t) {
593      $err->raise("dom",3+$t);
594      return false;
595    }
596    if (!$r=$this->get_sub_domain_all($dom,$sub)) {
597      // Le sous-domaine n'existe pas, on le crée seulement si $action vaut add
598      if ($action=="add") {
599        $db->query("insert into sub_domaines (compte,domaine,sub,valeur,type) values ('$cuid','$dom','$sub','$dest',$type);");
600        $db->query("delete from sub_domaines_standby where domaine='$dom' and sub='$sub';");
601        $db->query("insert into sub_domaines_standby (compte,domaine,sub,valeur,type,action) values ('$cuid','$dom','$sub','$dest','$type',0);"); // INSERT
602      } else {
603        $err->raise("dom",14);
604        return false;
605      }
606    } else {
607      if ($action=="edit") {
608        // On vérifie que des modifications ont bien eu lieu :)
609        if ($r["type"]==$type && $r["dest"]==$dest) {
610          $err->raise("dom",15);
611          return false;
612        }
613        // OK, des modifs ont été faites, on valide :
614        $db->query("update sub_domaines set type='$type', valeur='$dest' where domaine='$dom' and sub='$sub'");
615        $db->query("delete from sub_domaines_standby where domaine='$dom' and sub='$sub'");
616        $db->query("insert into sub_domaines_standby (compte,domaine,sub,valeur,type,action) values ('$cuid','$dom','$sub','$dest','$type',1);"); // UPDATE
617      } else {
618        $err->raise("dom",16);
619        return false;
620      }
621    }
622    return true;
623  } // set_sub_domain
624
625  /* ----------------------------------------------------------------- */
626  /**
627   *  Supprime le sous-domaine demandé
628   *
629   * @param string $dom Domaine dont on souhaite supprimer un sous-domaine
630   * @param string $sub Sous-domaine que l'on souhaite supprimer
631   * @return boolean Retourne FALSE si une erreur s'est produite, TRUE sinon.
632   *
633   */
634  function del_sub_domain($dom,$sub) {
635    global $db,$err,$cuid;
636    $err->log("dom","del_sub_domain",$dom."/".$sub);
637    // Locked ?
638    if (!$this->islocked) {
639      $err->raise("dom",3);
640      return false;
641    }
642    $t=checkfqdn($dom);
643    if ($t) {
644      $err->raise("dom",3+$t);
645      return false;
646    }
647    if (!$r=$this->get_sub_domain_all($dom,$sub)) {
648      // Le sous-domaine n'existe pas, erreur
649      $err->raise("dom",14);
650      return false;
651    } else {
652      // OK, on valide :
653      $db->query("delete from sub_domaines where domaine='$dom' and sub='$sub'");
654      $db->query("delete from sub_domaines_standby where domaine='$dom' and sub='$sub'");
655      $db->query("insert into sub_domaines_standby (compte,domaine,sub,valeur,type,action) values ('$cuid','$dom','$sub','".$r["dest"]."','".$r["type"]."',2);"); // DELETE
656    }
657    return true;
658  } // del_sub_domain
659
660  /* ----------------------------------------------------------------- */
661  /**
662   * Modifie les information du domaine précisé.
663   *
664   * @param string $dom Domaine du compte courant que l'on souhaite modifier
665   * @param integer $dns Vaut 1 ou 0 pour héberger ou pas le DNS du domaine
666   * @param integer $mx Nom fqdn du serveur mx, si le mx local est précisé,
667   *  on héberge alors les mails du domaine.
668   * @return boolean appelle $mail->add_dom ou $ma->del_dom si besoin, en
669   *  fonction du champs MX. Retourne FALSE si une erreur s'est produite,
670   *  TRUE sinon.
671   *
672   */
673  function edit_domain($dom,$dns,$mx) {
674    global $db,$err,$L_MX,$classes,$cuid;
675    $err->log("dom","edit_domain",$dom);
676    // Locked ?
677    if (!$this->islocked) {
678      $err->raise("dom",3);
679      return false;
680    }
681    $t=checkfqdn($dom);
682    if ($t) {
683      $err->raise("dom",3+$t);
684      return false;
685    }
686    if (!$r=$this->get_domain_all($dom)) {
687      // Le domaine n'existe pas, Failure
688      $err->raise("dom",4,$dom);
689      return false;
690    }
691    if ($dns!="1") $dns="0";
692    // On vérifie que des modifications ont bien eu lieu :)
693    if ($r["dns"]==$dns && $r["mx"]==$mx) {
694      $err->raise("dom",15);
695      return false;
696    }
697    // MX ?
698    if ($mx==$L_MX)
699      $gesmx="1";
700    else
701      $gesmx="0";
702    // OK, des modifs ont été faites, on valide :
703    // DEPENDANCE :
704    if ($gesmx && !$r["mail"]) { // on a associé le MX : on cree donc l'entree dans LDAP
705      // Lancement de add_dom sur les classes domain_sensitive :
706     for($i=0;$i<count($classes);$i++) {
707      if (method_exists($GLOBALS[$classes[$i]],"alternc_add_mx_domain")) {
708        $GLOBALS[$classes[$i]]->alternc_add_mx_domain($dom);
709      }
710        }
711    }
712
713        if (!$gesmx && $r["mail"]) { // on a dissocié le MX : on détruit donc l'entree dans LDAP
714      // Lancement de del_dom sur les classes domain_sensitive :
715     for($i=0;$i<count($classes);$i++) {
716      if (method_exists($GLOBALS[$classes[$i]],"alternc_del_mx_domain")) {
717        $GLOBALS[$classes[$i]]->alternc_del_mx_domain($dom);
718      }
719        }
720    }
721
722    $db->query("update domaines set gesdns='$dns', mx='$mx', gesmx='$gesmx' where domaine='$dom'");
723    $db->query("insert into domaines_standby (compte,domaine,mx,gesdns,gesmx,action) values ('$cuid','$dom','$mx','$dns','$gesmx',1);"); 
724    // UPDATE
725    return true;
726  } // edit_domain
727
728
729
730  /****************************/
731  /*  Slave dns ip managment  */
732  /****************************/
733  /* ----------------------------------------------------------------- */
734  /**
735   * Return the list of ip addresses and classes that are allowed access to domain list
736   * through AXFR Transfers from the bind server.
737   */
738  function enum_slave_ip() {
739        global $db,$err;
740        $db->query("SELECT * FROM slaveip;");
741        if (!$db->next_record()) {
742          return false;
743        }
744        do {
745          $res[]=$db->Record;
746        } while ($db->next_record());
747        return $res;
748  }
749
750  /* ----------------------------------------------------------------- */
751  /**
752   * Add an ip address (or a ip class) to the list of allowed slave ip access list.
753   */
754  function add_slave_ip($ip,$class="32") {
755        global $db,$err;
756        if (!checkip($ip)) {
757                $err->raise("dom",19);
758                return false;
759        }
760        $class=intval($class);
761        if ($class<8 || $class>32) $class=32;
762        $db->query("SELECT * FROM slaveip WHERE ip='$ip' AND class='$class';");
763        if ($db->next_record()) {
764          $err->raise("err",22);
765          return false;
766        }
767        $db->query("INSERT INTO slaveip (ip,class) VALUES ('$ip','$class');");
768        $f=fopen(SLAVE_FLAG,"w");
769        fputs($f,"yopla");
770        fclose($f);     
771        return true;
772  }
773
774  /* ----------------------------------------------------------------- */
775  /**
776   * Remove an ip address (or a ip class) from the list of allowed slave ip access list.
777   */
778  function del_slave_ip($ip) {
779        global $db,$err;
780        if (!checkip($ip)) {
781                $err->raise("dom",19);
782                return false;
783        }
784        $db->query("DELETE FROM slaveip WHERE ip='$ip'");
785        $f=fopen(SLAVE_FLAG,"w");
786        fputs($f,"yopla");
787        fclose($f);     
788        return true;
789  }
790
791
792
793  /* ----------------------------------------------------------------- */
794  /**
795   * Check for a slave account
796   */
797  function check_slave_account($login,$pass) {
798        global $db,$err;
799        $db->query("SELECT * FROM slaveaccount WHERE login='$login' AND pass='$pass';");
800        if ($db->next_record()) { 
801                return true;
802        }
803        return false;
804  }
805
806  /* ----------------------------------------------------------------- */
807  /**
808   * Out (echo) the complete hosted domain list :
809   */
810  function echo_domain_list() {
811        global $db,$err;
812        $db->query("SELECT domaine FROM domaines WHERE gesdns=1 ORDER BY domaine");
813        while ($db->next_record()) {
814                echo $db->f("domaine")."\n";
815        }
816        return true;
817  }
818
819  /* ----------------------------------------------------------------- */
820  /**
821   * Return the list of allowed slave accounts
822   */
823  function enum_slave_account() {
824        global $db,$err;
825        $db->query("SELECT * FROM slaveaccount;");
826        $res=array();
827        while ($db->next_record()) {
828                $res[]=$db->Record;
829        }
830        if (!count($res)) return false;
831        return $res;
832  }
833
834  /* ----------------------------------------------------------------- */
835  /**
836   * Add a slave account that will be allowed to access the domain list
837   */
838  function add_slave_account($login,$pass) {
839        global $db,$err;
840        $db->query("SELECT * FROM slaveaccount WHERE login='$login'");
841        if ($db->next_record()) {
842          $err->raise("err",23);
843          return false;
844        }
845        $db->query("INSERT INTO slaveaccount (login,pass) VALUES ('$login','$pass')");
846        return true;
847  }
848
849  /* ----------------------------------------------------------------- */
850  /**
851   * Remove a slave account
852   */
853  function del_slave_account($login) {
854        global $db,$err;
855        $db->query("DELETE FROM slaveaccount WHERE login='$login'");
856        return true;
857  }
858
859  /*************/
860  /*  Private  */
861  /*************/
862
863
864  /* ----------------------------------------------------------------- */
865  /**
866   * Lock tente de verrouiller le fichier lock du cron. Si tout va bien (toujours?)
867   * retourne True, sinon retourne False
868   * NOTE : le systeme de lock est asymétrique, si on a un fichier CRONLOCK, on
869   * attends (que le cron ait fini son execution).
870   * @access private
871   */
872  function lock() {
873    global $db,$err;
874    $err->log("dom","lock");
875    if ($this->islocked) {
876      $err->raise("dom",17);
877    }
878    while (file_exists($this->fic_lock_cron)) {
879      sleep(2);
880    }
881    $this->islocked=true;
882    return true;
883  }
884
885  /* ----------------------------------------------------------------- */
886  /**
887   * unlock déverrouille le fichier lock du cron. Si tout va bien (toujours?)
888   * retourne True, sinon retourne False
889   * NOTE : actuellement, vu le système de lock asymetrique, on ne fait rien ;)
890   * @access private
891   */
892  function unlock() {
893    global $db,$err;
894    $err->log("dom","unlock");
895    if (!$this->islocked) {
896      $err->raise("dom",3);
897    }
898    $this->islocked=false;
899    return true;
900  }
901
902  /* ----------------------------------------------------------------- */
903  /**
904   * Efface un compte (tous ses domaines)
905   */
906  function alternc_del_member() {
907    global $err;
908    $err->log("dom","alternc_del_member");
909    $li=$this->enum_domains();
910    foreach($li as $dom) {
911      $this->del_domain($dom);
912    }
913    return true;
914  }
915
916  /* ----------------------------------------------------------------- */
917  /**
918   * Returns the used quota for the $name service for the current user.
919   * @param $name string name of the quota
920   * @return integer the number of service used or false if an error occured
921   * @access private
922   */
923  function alternc_get_quota($name) {
924    global $db,$err,$cuid;
925    if ($name=="dom") {
926      $err->log("dom","get_quota");
927      $db->query("SELECT COUNT(*) AS cnt FROM domaines WHERE compte='$cuid'");
928      $db->next_record();
929      return $db->f("cnt");
930    } else return false;
931  }
932
933  /* ----------------------------------------------------------------- */
934  /**
935   * Exporte toutes les informations domaine du compte.
936   * @access private
937   * EXPERIMENTAL 'sid' function ;)
938   */
939  function alternc_export() {
940    global $db,$err;
941    $err->log("dom","export");
942    $this->enum_domains();
943    $str="<dom>\n";
944    foreach ($this->domains as $d) {
945      $str.="  <domain>\n    <name>$d</name>\n";
946      $s=$this->get_domain_all($d);
947      $str.="    <hasdns>$s[dns]</hasdns>\n";
948      $str.="    <hasmx>$s[mx]</hasmx>\n";
949      $str.="    <mx>$s[mail]</mx>\n";
950      if (is_array($s[sub])) {
951        foreach ($s[sub] as $sub) {
952          $str.="    <subdomain>";
953          $str.="<name>".$sub[name]."</name>";
954          $str.="<dest>".$sub[dest]."</dest>";
955          $str.="<type>".$sub[type]."</type>";
956          $str.="</subdomain>\n";
957        }
958      }
959      $str.="  </domain>\n";
960    }
961    $str.="</dom>\n";
962    return $str;
963  }
964
965
966} /* Class m_domains */
967
968?>
Note: See TracBrowser for help on using the repository browser.