PageRenderTime 53ms CodeModel.GetById 16ms RepoModel.GetById 1ms app.codeStats 0ms

/htdocs/install/etape1.php

http://github.com/Dolibarr/dolibarr
PHP | 904 lines | 677 code | 125 blank | 102 comment | 141 complexity | 990e476e15d5a6077aa1e1a6ab35c1b1 MD5 | raw file
Possible License(s): GPL-2.0, AGPL-3.0, LGPL-2.0, CC-BY-SA-4.0, BSD-3-Clause, MPL-2.0-no-copyleft-exception, LGPL-3.0, GPL-3.0, LGPL-2.1, MIT 
    

  1. <?php
    2. 

  2. /* Copyright (C) 2004-2007 Rodolphe Quiedeville <rodolphe@quiedeville.org>
    3. 

  3.  * Copyright (C) 2004-2011 Laurent Destailleur  <eldy@users.sourceforge.net>
    4. 

  4.  * Copyright (C) 2004      Benoit Mortier       <benoit.mortier@opensides.be>
    5. 

  5.  * Copyright (C) 2004      Sebastien Di Cintio  <sdicintio@ressource-toi.org>
    6. 

  6.  * Copyright (C) 2005-2011 Regis Houssin        <regis@dolibarr.fr>
    7. 

  7.  *
    8. 

  8.  * This program is free software; you can redistribute it and/or modify
    9. 

  9.  * it under the terms of the GNU General Public License as published by
    10. 

  10.  * the Free Software Foundation; either version 2 of the License, or
    11. 

  11.  * (at your option) any later version.
    12. 

  12.  *
    13. 

  13.  * This program is distributed in the hope that it will be useful,
    14. 

  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    15. 

  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    16. 

  16.  * GNU General Public License for more details.
    17. 

  17.  *
    18. 

  18.  * You should have received a copy of the GNU General Public License
    19. 

  19.  * along with this program. If not, see <http://www.gnu.org/licenses/>.
    20. 

  20.  */
    21. 

  21. 

  22. /**
    23. 

  23.  *		\file       htdocs/install/etape1.php
    24. 

  24.  *		\ingroup	install
    25. 

  25.  *		\brief      Build conf file on disk
    26. 

  26.  */
    27. 

  27. 

  28. define('DONOTLOADCONF',1);	// To avoid loading conf by file inc.php
    29. 

  29. 

  30. include("./inc.php");
    31. 

  31. 

  32. $action=GETPOST('action');
    33. 

  33. $setuplang=isset($_POST["selectlang"])?$_POST["selectlang"]:(isset($_GET["selectlang"])?$_GET["selectlang"]:'auto');
    34. 

  34. $langs->setDefaultLang($setuplang);
    35. 

  35. 

  36. $langs->load("admin");
    37. 

  37. $langs->load("install");
    38. 

  38. $langs->load("errors");
    39. 

  39. 

  40. // Recuparation des information de connexion
    41. 

  41. $userroot=isset($_POST["db_user_root"])?$_POST["db_user_root"]:"";
    42. 

  42. $passroot=isset($_POST["db_pass_root"])?$_POST["db_pass_root"]:"";
    43. 

  43. // Repertoire des pages dolibarr
    44. 

  44. $main_dir=isset($_POST["main_dir"])?trim($_POST["main_dir"]):'';
    45. 

  45. 

  46. // Now we load forced value from install.forced.php file.
    47. 

  47. $useforcedwizard=false;
    48. 

  48. $forcedfile="./install.forced.php";
    49. 

  49. if ($conffile == "/etc/dolibarr/conf.php") $forcedfile="/etc/dolibarr/install.forced.php";
    50. 

  50. if (@file_exists($forcedfile)) { $useforcedwizard=true; include_once($forcedfile); }
    51. 

  51. 

  52. dolibarr_install_syslog("--- etape1: Entering etape1.php page");
    53. 

  53. 

  54. $error = 0;
    55. 

  55. 

  56. 

  57. /*
    58. 

  58.  *	View
    59. 

  59.  */
    60. 

  60. 

  61. 

  62. pHeader($langs->trans("ConfigurationFile"),"etape2");
    63. 

  63. 

  64. // Test if we can run a first install process
    65. 

  65. if (! is_writable($conffile))
    66. 

  66. {
    67. 

  67.     print $langs->trans("ConfFileIsNotWritable",$conffiletoshow);
    68. 

  68.     pFooter(1,$setuplang,'jscheckparam');
    69. 

  69.     exit;
    70. 

  70. }
    71. 

  71. 

  72. 

  73. // Check parameters
    74. 

  74. if (empty($_POST["db_type"]))
    75. 

  75. {
    76. 

  76.     print '<div class="error">'.$langs->trans("ErrorFieldRequired",$langs->transnoentities("DatabaseType")).'</div>';
    77. 

  77.     $error++;
    78. 

  78. }
    79. 

  79. if (empty($_POST["db_host"]))
    80. 

  80. {
    81. 

  81.     print '<div class="error">'.$langs->trans("ErrorFieldRequired",$langs->transnoentities("Server")).'</div>';
    82. 

  82.     $error++;
    83. 

  83. }
    84. 

  84. if (empty($_POST["db_name"]))
    85. 

  85. {
    86. 

  86.     print '<div class="error">'.$langs->trans("ErrorFieldRequired",$langs->transnoentities("DatabaseName")).'</div>';
    87. 

  87.     $error++;
    88. 

  88. }
    89. 

  89. if (empty($_POST["db_user"]))
    90. 

  90. {
    91. 

  91.     print '<div class="error">'.$langs->trans("ErrorFieldRequired",$langs->transnoentities("Login")).'</div>';
    92. 

  92.     $error++;
    93. 

  93. }
    94. 

  94. if (! empty($_POST["db_port"]) && ! is_numeric($_POST["db_port"]))
    95. 

  95. {
    96. 

  96.     print '<div class="error">'.$langs->trans("ErrorBadValueForParameter",$_POST["db_port"],$langs->transnoentities("Port")).'</div>';
    97. 

  97.     $error++;
    98. 

  98. }
    99. 

  99. if (! empty($_POST["db_prefix"]) && ! preg_match('/^[a-z0-9]+_$/i', $_POST["db_prefix"]))
    100. 

  100. {
    101. 

  101. 	print '<div class="error">'.$langs->trans("ErrorBadValueForParameter",$_POST["db_prefix"],$langs->transnoentities("DatabasePrefix")).'</div>';
    102. 

  102. 	$error++;
    103. 

  103. }
    104. 

  104. 

  105. 

  106. // Remove last / into dans main_dir
    107. 

  107. if (substr($main_dir, dol_strlen($main_dir) -1) == "/")
    108. 

  108. {
    109. 

  109.     $main_dir = substr($main_dir, 0, dol_strlen($main_dir)-1);
    110. 

  110. }
    111. 

  111. 

  112. // Remove last / into dans main_url
    113. 

  113. if (! empty($_POST["main_url"]) && substr($_POST["main_url"], dol_strlen($_POST["main_url"]) -1) == "/")
    114. 

  114. {
    115. 

  115.     $_POST["main_url"] = substr($_POST["main_url"], 0, dol_strlen($_POST["main_url"])-1);
    116. 

  116. }
    117. 

  117. 

  118. // Directory for generated documents (invoices, orders, ecm, etc...)
    119. 

  119. $main_data_dir=isset($_POST["main_data_dir"])?$_POST["main_data_dir"]:'';
    120. 

  120. if (! $main_data_dir) { $main_data_dir="$main_dir/documents"; }
    121. 

  121. 

  122. 

  123. // Test database connexion
    124. 

  124. if (! $error)
    125. 

  125. {
    126. 

  126.     $result=@include_once($main_dir."/core/db/".$_POST["db_type"].".class.php");
    127. 

  127.     if ($result)
    128. 

  128.     {
    129. 

  129.         // If we ask database or user creation we need to connect as root, so we need root login
    130. 

  130.         if (! empty($_POST["db_create_database"]) && ! $userroot)
    131. 

  131.         {
    132. 

  132.             print '<div class="error">'.$langs->trans("YouAskDatabaseCreationSoDolibarrNeedToConnect",$_POST["db_name"]).'</div>';
    133. 

  133.             print '<br>';
    134. 

  134.             print $langs->trans("BecauseConnectionFailedParametersMayBeWrong").'<br><br>';
    135. 

  135.             print $langs->trans("ErrorGoBackAndCorrectParameters");
    136. 

  136.             $error++;
    137. 

  137.         }
    138. 

  138.         if (! empty($_POST["db_create_user"]) && ! $userroot)
    139. 

  139.         {
    140. 

  140.             print '<div class="error">'.$langs->trans("YouAskLoginCreationSoDolibarrNeedToConnect",$_POST["db_user"]).'</div>';
    141. 

  141.             print '<br>';
    142. 

  142.             print $langs->trans("BecauseConnectionFailedParametersMayBeWrong").'<br><br>';
    143. 

  143.             print $langs->trans("ErrorGoBackAndCorrectParameters");
    144. 

  144.             $error++;
    145. 

  145.         }
    146. 

  146. 

  147.         // If we need root access
    148. 

  148.         if (! $error && (! empty($_POST["db_create_database"]) || ! empty($_POST["db_create_user"])))
    149. 

  149.         {
    150. 

  150.             $databasefortest=$_POST["db_name"];
    151. 

  151.             if (! empty($_POST["db_create_database"]))
    152. 

  152.             {
    153. 

  153.                 if ($_POST["db_type"] == 'mysql' || $_POST["db_type"] == 'mysqli')
    154. 

  154.                 {
    155. 

  155.                     $databasefortest='mysql';
    156. 

  156.                 }
    157. 

  157.                 elseif ($_POST["db_type"] == 'pgsql')
    158. 

  158.                 {
    159. 

  159.                     $databasefortest='postgres';
    160. 

  160.                 }
    161. 

  161.                 else
    162. 

  162.                 {
    163. 

  163.                     $databasefortest='mssql';
    164. 

  164.                 }
    165. 

  165.             }
    166. 

  166.             //print $_POST["db_type"].",".$_POST["db_host"].",$userroot,$passroot,$databasefortest,".$_POST["db_port"];
    167. 

  167. 

  168.             $db=getDoliDBInstance($_POST["db_type"],$_POST["db_host"],$userroot,$passroot,$databasefortest,$_POST["db_port"]);
    169. 

  169. 

  170.             dol_syslog("databasefortest=".$databasefortest." connected=".$db->connected." database_selected=".$db->database_selected, LOG_DEBUG);
    171. 

  171.             //print "databasefortest=".$databasefortest." connected=".$db->connected." database_selected=".$db->database_selected;
    172. 

  172. 

  173.             if (empty($_POST["db_create_database"]) && $db->connected && ! $db->database_selected)
    174. 

  174.             {
    175. 

  175.                 print '<div class="error">'.$langs->trans("ErrorConnectedButDatabaseNotFound",$_POST["db_name"]).'</div>';
    176. 

  176.                 print '<br>';
    177. 

  177.                 if (! $db->connected) print $langs->trans("IfDatabaseNotExistsGoBackAndUncheckCreate").'<br><br>';
    178. 

  178.                 print $langs->trans("ErrorGoBackAndCorrectParameters");
    179. 

  179.                 $error++;
    180. 

  180.             }
    181. 

  181.             elseif ($db->error && ! (! empty($_POST["db_create_database"]) && $db->connected))
    182. 

  182.             {
    183. 

  183.                 print '<div class="error">'.$db->error.'</div>';
    184. 

  184.                 if (! $db->connected) print $langs->trans("BecauseConnectionFailedParametersMayBeWrong").'<br><br>';
    185. 

  185.                 print $langs->trans("ErrorGoBackAndCorrectParameters");
    186. 

  186.                 $error++;
    187. 

  187.             }
    188. 

  188.         }
    189. 

  189.         // If we need simple access
    190. 

  190.         if (! $error && (empty($_POST["db_create_database"]) && empty($_POST["db_create_user"])))
    191. 

  191.         {
    192. 

  192.             $db=getDoliDBInstance($_POST["db_type"],$_POST["db_host"],$_POST["db_user"],$_POST["db_pass"],$_POST["db_name"],$_POST["db_port"]);
    193. 

  193. 

  194.             if ($db->error)
    195. 

  195.             {
    196. 

  196.                 print '<div class="error">'.$db->error.'</div>';
    197. 

  197.                 if (! $db->connected) print $langs->trans("BecauseConnectionFailedParametersMayBeWrong").'<br><br>';
    198. 

  198.                 print $langs->trans("ErrorGoBackAndCorrectParameters");
    199. 

  199.                 $error++;
    200. 

  200.             }
    201. 

  201.         }
    202. 

  202.     }
    203. 

  203.     else
    204. 

  204.     {
    205. 

  205.         print "<br>\nFailed to include_once(\"".$main_dir."/core/db/".$_POST["db_type"].".class.php\")<br>\n";
    206. 

  206.         print '<div class="error">'.$langs->trans("ErrorWrongValueForParameter",$langs->transnoentities("WebPagesDirectory")).'</div>';
    207. 

  207.         print $langs->trans("ErrorGoBackAndCorrectParameters");
    208. 

  208.         $error++;
    209. 

  209.     }
    210. 

  210. }
    211. 

  211. 

  212. else
    213. 

  213. {
    214. 

  214.     if (isset($db)) print $db->lasterror();
    215. 

  215.     if (isset($db) && ! $db->connected) print '<br>'.$langs->trans("BecauseConnectionFailedParametersMayBeWrong").'<br><br>';
    216. 

  216.     print $langs->trans("ErrorGoBackAndCorrectParameters");
    217. 

  217.     $error++;
    218. 

  218. }
    219. 

  219. 

  220. if (! $error && $db->connected)
    221. 

  221. {
    222. 

  222.     if (! empty($_POST["db_create_database"]))
    223. 

  223.     {
    224. 

  224.         $result=$db->select_db($_POST["db_name"]);
    225. 

  225.         if ($result)
    226. 

  226.         {
    227. 

  227.             print '<div class="error">'.$langs->trans("ErrorDatabaseAlreadyExists",$_POST["db_name"]).'</div>';
    228. 

  228.             print $langs->trans("IfDatabaseExistsGoBackAndCheckCreate").'<br><br>';
    229. 

  229.             print $langs->trans("ErrorGoBackAndCorrectParameters");
    230. 

  230.             $error++;
    231. 

  231.         }
    232. 

  232.     }
    233. 

  233. }
    234. 

  234. 

  235. // Define $defaultCharacterSet and $defaultCollationConnection
    236. 

  236. if (! $error && $db->connected)
    237. 

  237. {
    238. 

  238.     if (! empty($_POST["db_create_database"]))	// If we create database, we force default value
    239. 

  239.     {
    240. 

  240.     	$defaultCharacterSet=getStaticMember(get_class($db),'forcecharset');

    241. 

  241.     	$defaultCollationConnection=getStaticMember(get_class($db),'forcecollate');
    242. 

  242.     }
    243. 

  243.     else	// If already created, we take current value
    244. 

  244.     {
    245. 

  245.         $defaultCharacterSet=$db->getDefaultCharacterSetDatabase();
    246. 

  246.         $defaultCollationConnection=$db->getDefaultCollationDatabase();
    247. 

  247.     }
    248. 

  248. 

  249.     print '<input type="hidden" name="dolibarr_main_db_character_set" value="'.$defaultCharacterSet.'">';
    250. 

  250.     print '<input type="hidden" name="dolibarr_main_db_collation" value="'.$defaultCollationConnection.'">';
    251. 

  251.     $_POST['dolibarr_main_db_character_set']=$defaultCharacterSet;
    252. 

  252.     $_POST['dolibarr_main_db_collation']=$defaultCollationConnection;
    253. 

  253. }
    254. 

  254. 

  255. 

  256. // Create config file
    257. 

  257. if (! $error && $db->connected && $action == "set")
    258. 

  258. {
    259. 

  259.     umask(0);
    260. 

  260.     foreach($_POST as $cle=>$valeur)
    261. 

  261.     {
    262. 

  262.         if (! preg_match('/^db_pass/i',$cle)) dolibarr_install_syslog("Choice for ".$cle." = ".$valeur);
    263. 

  263.     }
    264. 

  264. 

  265.     // Show title of step
    266. 

  266.     print '<h3>'.$langs->trans("ConfigurationFile").'</h3>';
    267. 

  267.     print '<table cellspacing="0" width="100%" cellpadding="1" border="0">';
    268. 

  268. 

  269.     // Check parameter main_dir
    270. 

  270.     if (! $error)
    271. 

  271.     {
    272. 

  272.         if (! is_dir($main_dir))
    273. 

  273.         {
    274. 

  274.             dolibarr_install_syslog("etape1: Repertoire '".$main_dir."' inexistant ou non accessible");
    275. 

  275. 

  276.             print "<tr><td>";
    277. 

  277.             print $langs->trans("ErrorDirDoesNotExists",$main_dir).'<br>';
    278. 

  278.             print $langs->trans("ErrorWrongValueForParameter",$langs->trans("WebPagesDirectory")).'<br>';
    279. 

  279.             print $langs->trans("ErrorGoBackAndCorrectParameters").'<br><br>';
    280. 

  280.             print '</td><td>';
    281. 

  281.             print $langs->trans("Error");
    282. 

  282.             print "</td></tr>";
    283. 

  283.             $error++;
    284. 

  284.         }
    285. 

  285.     }
    286. 

  286. 

  287.     if (! $error)
    288. 

  288.     {
    289. 

  289.         dolibarr_install_syslog("etape1: Directory '".$main_dir."' exists");
    290. 

  290.     }
    291. 

  291. 

  292. 

  293.     // Create subdirectory main_data_dir
    294. 

  294.     if (! $error)
    295. 

  295.     {
    296. 

  296.         // Create directory for documents
    297. 

  297.         if (! is_dir($main_data_dir))
    298. 

  298.         {
    299. 

  299.             dol_mkdir($main_data_dir);
    300. 

  300.         }
    301. 

  301. 

  302.         if (! is_dir($main_data_dir))
    303. 

  303.         {
    304. 

  304.             print "<tr><td>".$langs->trans("ErrorDirDoesNotExists",$main_data_dir);
    305. 

  305.             print ' '.$langs->trans("YouMustCreateItAndAllowServerToWrite");
    306. 

  306.             print '</td><td>';
    307. 

  307.             print '<font class="error">'.$langs->trans("Error").'</font>';
    308. 

  308.             print "</td></tr>";
    309. 

  309.             print '<tr><td colspan="2"><br>'.$langs->trans("CorrectProblemAndReloadPage",$_SERVER['PHP_SELF'].'?testget=ok').'</td></tr>';
    310. 

  310.             $error++;
    311. 

  311.         }
    312. 

  312.         else
    313. 

  313.         {
    314. 

  314.             // Create .htaccess file in document directory
    315. 

  315.             $pathhtaccess=$main_data_dir.'/.htaccess';
    316. 

  316.             if (! file_exists($pathhtaccess))
    317. 

  317.             {
    318. 

  318.                 dolibarr_install_syslog("etape1: .htaccess file does not exists, we create it in '".$main_data_dir."'");
    319. 

  319.                 $handlehtaccess=@fopen($pathhtaccess,'w');
    320. 

  320.                 if ($handlehtaccess)
    321. 

  321.                 {
    322. 

  322.                     fwrite($handlehtaccess,'Order allow,deny'."\n");
    323. 

  323.                     fwrite($handlehtaccess,'Deny from all'."\n");
    324. 

  324. 

  325.                     fclose($handlehtaccess);
    326. 

  326.                     dolibarr_install_syslog("etape1: .htaccess file created");
    327. 

  327.                 }
    328. 

  328.             }
    329. 

  329. 

  330.             // Les documents sont en dehors de htdocs car ne doivent pas pouvoir etre telecharges en passant outre l'authentification
    331. 

  331.             $dir[0] = $main_data_dir."/mycompany";
    332. 

  332.             $dir[1] = $main_data_dir."/users";
    333. 

  333.             $dir[2] = $main_data_dir."/custom";
    334. 

  334.             $dir[3] = $main_data_dir."/facture";
    335. 

  335.             $dir[4] = $main_data_dir."/propale";
    336. 

  336.             $dir[5] = $main_data_dir."/ficheinter";
    337. 

  337.             $dir[6] = $main_data_dir."/produit";
    338. 

  338. 

  339.             // Boucle sur chaque repertoire de dir[] pour les creer s'ils nexistent pas
    340. 

  340.             $num=count($dir);
    341. 

  341.             for ($i = 0; $i < $num; $i++)
    342. 

  342.             {
    343. 

  343.                 if (is_dir($dir[$i]))
    344. 

  344.                 {
    345. 

  345.                     dolibarr_install_syslog("etape1: Directory '".$dir[$i]."' exists");
    346. 

  346.                 }
    347. 

  347.                 else
    348. 

  348.                 {
    349. 

  349.                     if (dol_mkdir($dir[$i]) < 0)
    350. 

  350.                     {
    351. 

  351.                         print "<tr><td>";
    352. 

  352.                         print "Failed to create directory: ".$dir[$i];
    353. 

  353.                         print '</td><td>';
    354. 

  354.                         print $langs->trans("Error");
    355. 

  355.                         print "</td></tr>";
    356. 

  356.                         $error++;
    357. 

  357.                     }
    358. 

  358.                     else
    359. 

  359.                     {
    360. 

  360.                         dolibarr_install_syslog("etape1: Directory '".$dir[$i]."' created");
    361. 

  361.                     }
    362. 

  362.                 }
    363. 

  363.             }
    364. 

  364.             if ($error)
    365. 

  365.             {
    366. 

  366.                 print "<tr><td>".$langs->trans("ErrorDirDoesNotExists",$main_data_dir);
    367. 

  367.                 print ' '.$langs->trans("YouMustCreateItAndAllowServerToWrite");
    368. 

  368.                 print '</td><td>';
    369. 

  369.                 print '<font class="error">'.$langs->trans("Error").'</font>';
    370. 

  370.                 print "</td></tr>";
    371. 

  371.                 print '<tr><td colspan="2"><br>'.$langs->trans("CorrectProblemAndReloadPage",$_SERVER['PHP_SELF'].'?testget=ok').'</td></tr>';
    372. 

  372.             }
    373. 

  373.         }
    374. 

  374.     }
    375. 

  375. 

  376.     // Table prefix
    377. 

  377.     $main_db_prefix = ((GETPOST("db_prefix") && GETPOST("db_prefix") != '') ? GETPOST("db_prefix") : 'llx_');
    378. 

  378. 

  379.     // Force https
    380. 

  380.     $main_force_https = ((GETPOST("main_force_https") && (GETPOST("main_force_https") == "on" || GETPOST("main_force_https") == 1)) ? '1' : '0');
    381. 

  381. 

  382.     // Use alternative directory
    383. 

  383.     $main_use_alt_dir = ((GETPOST("main_use_alt_dir") && (GETPOST("main_use_alt_dir") == "on" || GETPOST("main_use_alt_dir") == 1)) ? '' : '//');
    384. 

  384. 

  385.     // Alternative root directory name
    386. 

  386.     $main_alt_dir_name = ((GETPOST("main_alt_dir_name") && GETPOST("main_alt_dir_name") != '') ? GETPOST("main_alt_dir_name") : 'custom');
    387. 

  387. 

  388.     // Write conf file on disk
    389. 

  389.     if (! $error)
    390. 

  390.     {
    391. 

  391.         // Save old conf file on disk
    392. 

  392.         if (file_exists("$conffile"))
    393. 

  393.         {
    394. 

  394.             // We must ignore errors as an existing old file may already exists and not be replacable or
    395. 

  395.             // the installer (like for ubuntu) may not have permission to create another file than conf.php.
    396. 

  396.             // Also no other process must be able to read file or we expose the new file, so content with password.
    397. 

  397.             @dol_copy($conffile, $conffile.'.old', '0400');
    398. 

  398.         }
    399. 

  399. 

  400.         $error+=write_conf_file($conffile);
    401. 

  401.     }
    402. 

  402. 

  403.     // Write main.inc.php and master.inc.php into documents/custom dir
    404. 

  404.     $error+=write_main_file($main_data_dir.'/custom/main.inc.php',$main_dir);
    405. 

  405.     $error+=write_master_file($main_data_dir.'/custom/master.inc.php',$main_dir);
    406. 

  406. 

  407.     // Create database and admin user database
    408. 

  408.     if (! $error)
    409. 

  409.     {
    410. 

  410.         // We reload configuration file
    411. 

  411.         conf($dolibarr_main_document_root);
    412. 

  412. 

  413.         print '<tr><td>';
    414. 

  414.         print $langs->trans("ConfFileReload");
    415. 

  415.         print '</td>';
    416. 

  416.         print '<td>'.$langs->trans("OK").'</td></tr>';
    417. 

  417. 

  418. 

  419.         $userroot=isset($_POST["db_user_root"])?$_POST["db_user_root"]:"";
    420. 

  420.         $passroot=isset($_POST["db_pass_root"])?$_POST["db_pass_root"]:"";
    421. 

  421. 

  422. 

  423.         // Si creation utilisateur admin demandee, on le cree
    424. 

  424.         if (isset($_POST["db_create_user"]) && $_POST["db_create_user"] == "on")
    425. 

  425.         {
    426. 

  426.             dolibarr_install_syslog("etape1: Create database user: ".$dolibarr_main_db_user);
    427. 

  427. 

  428.             //print $conf->db->host." , ".$conf->db->name." , ".$conf->db->user." , ".$conf->db->port;
    429. 

  429.             $databasefortest=$conf->db->name;
    430. 

  430.             if ($conf->db->type == 'mysql' || $conf->db->type == 'mysqli')
    431. 

  431.             {
    432. 

  432.                 $databasefortest='mysql';
    433. 

  433.             }
    434. 

  434.             else if ($conf->db->type == 'pgsql')
    435. 

  435.             {
    436. 

  436.                 $databasefortest='postgres';
    437. 

  437.             }
    438. 

  438.             else if ($conf->db->type == 'mssql')
    439. 

  439.             {
    440. 

  440.                 $databasefortest='mssql';
    441. 

  441.             }
    442. 

  442. 

  443.             // Creation handler de base, verification du support et connexion
    444. 

  444. 

  445.             $db=getDoliDBInstance($conf->db->type,$conf->db->host,$userroot,$passroot,$databasefortest,$conf->db->port);
    446. 

  446. 

  447.             if ($db->error)
    448. 

  448.             {
    449. 

  449.                 print '<div class="error">'.$db->error.'</div>';
    450. 

  450.                 $error++;
    451. 

  451.             }
    452. 

  452. 

  453.             if (! $error)
    454. 

  454.             {
    455. 

  455.                 if ($db->connected)
    456. 

  456.                 {
    457. 

  457.                     $result=$db->DDLCreateUser($dolibarr_main_db_host,$dolibarr_main_db_user,$dolibarr_main_db_pass,$dolibarr_main_db_name);
    458. 

  458. 

  459.                     if ($result > 0)
    460. 

  460.                     {
    461. 

  461. 

  462.                         print '<tr><td>';
    463. 

  463.                         print $langs->trans("UserCreation").' : ';
    464. 

  464.                         print $dolibarr_main_db_user;
    465. 

  465.                         print '</td>';
    466. 

  466.                         print '<td>'.$langs->trans("OK").'</td></tr>';
    467. 

  467.                     }
    468. 

  468.                     else
    469. 

  469.                     {
    470. 

  470.                         if ($db->errno() == 'DB_ERROR_RECORD_ALREADY_EXISTS'
    471. 

  471.                         || $db->errno() == 'DB_ERROR_KEY_NAME_ALREADY_EXISTS'
    472. 

  472.                         || $db->errno() == 'DB_ERROR_USER_ALREADY_EXISTS')
    473. 

  473.                         {
    474. 

  474.                             dolibarr_install_syslog("etape1: User already exists");
    475. 

  475.                             print '<tr><td>';
    476. 

  476.                             print $langs->trans("UserCreation").' : ';
    477. 

  477.                             print $dolibarr_main_db_user;
    478. 

  478.                             print '</td>';
    479. 

  479.                             print '<td>'.$langs->trans("LoginAlreadyExists").'</td></tr>';
    480. 

  480.                         }
    481. 

  481.                         else
    482. 

  482.                         {
    483. 

  483.                             dolibarr_install_syslog("etape1: Failed to create user");
    484. 

  484.                             print '<tr><td>';
    485. 

  485.                             print $langs->trans("UserCreation").' : ';
    486. 

  486.                             print $dolibarr_main_db_user;
    487. 

  487.                             print '</td>';
    488. 

  488.                             print '<td>'.$langs->trans("Error").': '.$db->errno().' '.$db->error()."</td></tr>";
    489. 

  489.                         }
    490. 

  490.                     }
    491. 

  491. 

  492.                     $db->close();
    493. 

  493.                 }
    494. 

  494.                 else
    495. 

  495.                 {
    496. 

  496.                     print '<tr><td>';
    497. 

  497.                     print $langs->trans("UserCreation").' : ';
    498. 

  498.                     print $dolibarr_main_db_user;
    499. 

  499.                     print '</td>';
    500. 

  500.                     print '<td>'.$langs->trans("Error").'</td>';
    501. 

  501.                     print '</tr>';
    502. 

  502. 

  503.                     // Affiche aide diagnostique
    504. 

  504.                     print '<tr><td colspan="2"><br>';
    505. 

  505.                     print $langs->trans("YouAskDatabaseCreationSoDolibarrNeedToConnect",$dolibarr_main_db_user,$dolibarr_main_db_host,$userroot);
    506. 

  506.                     print '<br>';
    507. 

  507.                     print $langs->trans("BecauseConnectionFailedParametersMayBeWrong").'<br><br>';
    508. 

  508.                     print $langs->trans("ErrorGoBackAndCorrectParameters").'<br><br>';
    509. 

  509.                     print '</td></tr>';
    510. 

  510. 

  511.                     $error++;
    512. 

  512.                 }
    513. 

  513.             }
    514. 

  514.         }   // Fin si "creation utilisateur"
    515. 

  515. 

  516. 

  517.         // If database creation is asked, we create it
    518. 

  518.         if (! $error && (isset($_POST["db_create_database"]) && $_POST["db_create_database"] == "on"))
    519. 

  519.         {
    520. 

  520.             dolibarr_install_syslog("etape1: Create database : ".$dolibarr_main_db_name, LOG_DEBUG);
    521. 

  521.             $newdb=getDoliDBInstance($conf->db->type,$conf->db->host,$userroot,$passroot,'',$conf->db->port);
    522. 

  522.             //print 'eee'.$conf->db->type." ".$conf->db->host." ".$userroot." ".$passroot." ".$conf->db->port." ".$newdb->connected." ".$newdb->forcecharset;exit;
    523. 

  523. 

  524.             if ($newdb->connected)
    525. 

  525.             {
    526. 

  526.                 $result=$newdb->DDLCreateDb($dolibarr_main_db_name, $dolibarr_main_db_character_set, $dolibarr_main_db_collation, $dolibarr_main_db_user);
    527. 

  527. 

  528.                 if ($result)
    529. 

  529.                 {
    530. 

  530.                     print '<tr><td>';
    531. 

  531.                     print $langs->trans("DatabaseCreation")." (".$langs->trans("User")." ".$userroot.") : ";
    532. 

  532.                     print $dolibarr_main_db_name;
    533. 

  533.                     print '</td>';
    534. 

  534.                     print "<td>".$langs->trans("OK")."</td></tr>";
    535. 

  535. 

  536.                     $check1=$newdb->getDefaultCharacterSetDatabase();
    537. 

  537.                     $check2=$newdb->getDefaultCollationDatabase();
    538. 

  538.                     dolibarr_install_syslog('etape1: Note that default server was charset='.$check1.' collation='.$check2, LOG_DEBUG);
    539. 

  539. 

  540.                     // If values differs, we save conf file again
    541. 

  541.                     //if ($check1 != $dolibarr_main_db_character_set) dolibarr_install_syslog('etape1: Value for character_set is not the one asked for database creation', LOG_WARNING);
    542. 

  542.                     //if ($check2 != $dolibarr_main_db_collation)     dolibarr_install_syslog('etape1: Value for collation is not the one asked for database creation', LOG_WARNING);
    543. 

  543.                 }
    544. 

  544.                 else
    545. 

  545.                 {
    546. 

  546.                     // Affiche aide diagnostique
    547. 

  547.                     print '<tr><td colspan="2"><br>';
    548. 

  548.                     print $langs->trans("ErrorFailedToCreateDatabase",$dolibarr_main_db_name).'<br>';
    549. 

  549.                     print $newdb->lasterror().'<br>';
    550. 

  550.                     print $langs->trans("IfDatabaseExistsGoBackAndCheckCreate");
    551. 

  551.                     print '<br>';
    552. 

  552.                     print '</td></tr>';
    553. 

  553. 

  554.                     dolibarr_install_syslog('etape1: Failed to create database '.$dolibarr_main_db_name.' '.$newdb->lasterrno().' '.$newdb->lasterror(), LOG_ERR);
    555. 

  555.                     $error++;
    556. 

  556.                 }
    557. 

  557.                 $newdb->close();
    558. 

  558.             }
    559. 

  559.             else {
    560. 

  560.                 print '<tr><td>';
    561. 

  561.                 print $langs->trans("DatabaseCreation")." (".$langs->trans("User")." ".$userroot.") : ";
    562. 

  562.                 print $dolibarr_main_db_name;
    563. 

  563.                 print '</td>';
    564. 

  564.                 print '<td>'.$langs->trans("Error").'</td>';
    565. 

  565.                 print '</tr>';
    566. 

  566. 

  567.                 // Affiche aide diagnostique
    568. 

  568.                 print '<tr><td colspan="2"><br>';
    569. 

  569.                 print $langs->trans("YouAskDatabaseCreationSoDolibarrNeedToConnect",$dolibarr_main_db_user,$dolibarr_main_db_host,$userroot);
    570. 

  570.                 print '<br>';
    571. 

  571.                 print $langs->trans("BecauseConnectionFailedParametersMayBeWrong").'<br><br>';
    572. 

  572.                 print $langs->trans("ErrorGoBackAndCorrectParameters").'<br><br>';
    573. 

  573.                 print '</td></tr>';
    574. 

  574. 

  575.                 $error++;
    576. 

  576.             }
    577. 

  577.         }   // Fin si "creation database"
    578. 

  578. 

  579. 

  580.         // We test access with dolibarr database user (not admin)
    581. 

  581.         if (! $error)
    582. 

  582.         {
    583. 

  583.             dolibarr_install_syslog("etape1: connexion de type=".$conf->db->type." sur host=".$conf->db->host." port=".$conf->db->port." user=".$conf->db->user." name=".$conf->db->name, LOG_DEBUG);
    584. 

  584.             //print "connexion de type=".$conf->db->type." sur host=".$conf->db->host." port=".$conf->db->port." user=".$conf->db->user." name=".$conf->db->name;
    585. 

  585. 

  586.             $db=getDoliDBInstance($conf->db->type,$conf->db->host,$conf->db->user,$conf->db->pass,$conf->db->name,$conf->db->port);
    587. 

  587. 

  588.             if ($db->connected == 1)
    589. 

  589.             {
    590. 

  590.                 // si acces serveur ok et acces base ok, tout est ok, on ne va pas plus loin, on a meme pas utilise le compte root.
    591. 

  591.                 if ($db->database_selected == 1)
    592. 

  592.                 {
    593. 

  593.                     dolibarr_install_syslog("etape1: connexion to server by user ".$conf->db->user." is ok", LOG_DEBUG);
    594. 

  594.                     print "<tr><td>";
    595. 

  595.                     print $langs->trans("ServerConnection")." (".$langs->trans("User")." ".$conf->db->user.") : ";
    596. 

  596.                     print $dolibarr_main_db_host;
    597. 

  597.                     print "</td><td>";
    598. 

  598.                     print $langs->trans("OK");
    599. 

  599.                     print "</td></tr>";
    600. 

  600. 

  601.                     dolibarr_install_syslog("etape1: connexion to database : ".$conf->db->name.", by user : ".$conf->db->user." is ok", LOG_DEBUG);
    602. 

  602.                     print "<tr><td>";
    603. 

  603.                     print $langs->trans("DatabaseConnection")." (".$langs->trans("User")." ".$conf->db->user.") : ";
    604. 

  604.                     print $dolibarr_main_db_name;
    605. 

  605.                     print "</td><td>";
    606. 

  606.                     print $langs->trans("OK");
    607. 

  607.                     print "</td></tr>";
    608. 

  608. 

  609.                     $error = 0;
    610. 

  610.                 }
    611. 

  611.                 else
    612. 

  612.                 {
    613. 

  613.                     dolibarr_install_syslog("etape1: connexion to server by user ".$conf->db->user." is ok", LOG_DEBUG);
    614. 

  614.                     print "<tr><td>";
    615. 

  615.                     print $langs->trans("ServerConnection")." (".$langs->trans("User")." ".$conf->db->user.") : ";
    616. 

  616.                     print $dolibarr_main_db_host;
    617. 

  617.                     print "</td><td>";
    618. 

  618.                     print $langs->trans("OK");
    619. 

  619.                     print "</td></tr>";
    620. 

  620. 

  621.                     dolibarr_install_syslog("etape1: connexion to database ".$conf->db->name.", by user : ".$conf->db->user." has failed", LOG_ERR);
    622. 

  622.                     print "<tr><td>";
    623. 

  623.                     print $langs->trans("DatabaseConnection")." (".$langs->trans("User")." ".$conf->db->user.") : ";
    624. 

  624.                     print $dolibarr_main_db_name;
    625. 

  625.                     print '</td><td>';
    626. 

  626.                     print $langs->trans("Error");
    627. 

  627.                     print "</td></tr>";
    628. 

  628. 

  629.                     // Affiche aide diagnostique
    630. 

  630.                     print '<tr><td colspan="2"><br>';
    631. 

  631.                     print $langs->trans('CheckThatDatabasenameIsCorrect',$dolibarr_main_db_name).'<br>';
    632. 

  632.                     print $langs->trans('IfAlreadyExistsCheckOption').'<br>';
    633. 

  633.                     print $langs->trans("ErrorGoBackAndCorrectParameters").'<br><br>';
    634. 

  634.                     print '</td></tr>';
    635. 

  635. 

  636.                     $error++;
    637. 

  637.                 }
    638. 

  638.             }
    639. 

  639.             else
    640. 

  640.             {
    641. 

  641.                 dolibarr_install_syslog("etape1: la connexion au serveur par le user ".$conf->db->user." est rate");
    642. 

  642.                 print "<tr><td>";
    643. 

  643.                 print $langs->trans("ServerConnection")." (".$langs->trans("User")." ".$conf->db->user.") : ";
    644. 

  644.                 print $dolibarr_main_db_host;
    645. 

  645.                 print '</td><td>';
    646. 

  646.                 print '<font class="error">'.$db->error.'</div>';
    647. 

  647.                 print "</td></tr>";
    648. 

  648. 

  649.                 // Affiche aide diagnostique
    650. 

  650.                 print '<tr><td colspan="2"><br>';
    651. 

  651.                 print $langs->trans("ErrorConnection",$conf->db->host,$conf->db->name,$conf->db->user);
    652. 

  652.                 print $langs->trans('IfLoginDoesNotExistsCheckCreateUser').'<br>';
    653. 

  653.                 print $langs->trans("ErrorGoBackAndCorrectParameters").'<br><br>';
    654. 

  654.                 print '</td></tr>';
    655. 

  655. 

  656.                 $error++;
    657. 

  657.             }
    658. 

  658.         }
    659. 

  659.     }
    660. 

  660. 

  661.     print '</table>';
    662. 

  662. }
    663. 

  663. 

  664. ?>
    665. 

  665. 

  666. <script type="text/javascript">
    667. 

  667. function jsinfo()
    668. 

  668. {
    669. 

  669. 	ok=true;
    670. 

  670. 

  671. 	//alert('<?php echo dol_escape_js($langs->transnoentities("NextStepMightLastALongTime")); ?>');
    672. 

  672. 

  673. 	document.getElementById('nextbutton').style.visibility="hidden";
    674. 

  674. 	document.getElementById('pleasewait').style.visibility="visible";
    675. 

  675. 

  676. 	return ok;
    677. 

  677. }
    678. 

  678. </script>
    679. 

  679. 

  680. <?php
    681. 

  681. 

  682. dolibarr_install_syslog("--- install/etape1.php end", LOG_INFO);
    683. 

  683. 

  684. pFooter($error,$setuplang,'jsinfo');
    685. 

  685. 

  686. 

  687. /**
    688. 

  688.  *  Create main file. No particular permissions are set by installer.
    689. 

  689.  *
    690. 

  690.  *  @param  string		$mainfile       Full path name of main file to generate/update
    691. 

  691.  *  @param	string		$main_dir		Full path name to main.inc.php file
    692. 

  692.  *  @return	void
    693. 

  693.  */
    694. 

  694. function write_main_file($mainfile,$main_dir)
    695. 

  695. {
    696. 

  696.     $fp = @fopen("$mainfile", "w");
    697. 

  697.     if($fp)
    698. 

  698.     {
    699. 

  699.         clearstatcache();
    700. 

  700.         fputs($fp, '<?php'."\n");
    701. 

  701.         fputs($fp, "# Wrapper to include main into htdocs\n");
    702. 

  702.         fputs($fp, "include_once('".$main_dir."/main.inc.php');\n");
    703. 

  703.         fputs($fp, '?>');
    704. 

  704.         fclose($fp);
    705. 

  705.     }
    706. 

  706. }
    707. 

  707. 

  708. 

  709. /**
    710. 

  710.  *  Create master file. No particular permissions are set by installer.
    711. 

  711.  *
    712. 

  712.  *  @param  string		$masterfile     Full path name of master file to generate/update
    713. 

  713.  *  @param	string		$main_dir		Full path name to master.inc.php file
    714. 

  714.  *  @return	void
    715. 

  715.  */
    716. 

  716. function write_master_file($masterfile,$main_dir)
    717. 

  717. {
    718. 

  718.     $fp = @fopen("$masterfile", "w");
    719. 

  719.     if($fp)
    720. 

  720.     {
    721. 

  721.         clearstatcache();
    722. 

  722.         fputs($fp, '<?php'."\n");
    723. 

  723.         fputs($fp, "# Wrapper to include master into htdocs\n");
    724. 

  724.         fputs($fp, "include_once('".$main_dir."/master.inc.php');\n");
    725. 

  725.         fputs($fp, '?>');
    726. 

  726.         fclose($fp);
    727. 

  727.     }
    728. 

  728. }
    729. 

  729. 

  730. 

  731. /**
    732. 

  732.  *  Save configuration file. No particular permissions are set by installer.
    733. 

  733.  *
    734. 

  734.  *  @param  string		$conffile        Path to conf file to generate/update
    735. 

  735.  *  @return	void
    736. 

  736.  */
    737. 

  737. function write_conf_file($conffile)
    738. 

  738. {
    739. 

  739.     global $conf,$langs;
    740. 

  740.     global $_POST,$main_dir,$main_data_dir,$main_force_https,$main_use_alt_dir,$main_alt_dir_name,$main_db_prefix;
    741. 

  741.     global $dolibarr_main_url_root,$dolibarr_main_document_root,$dolibarr_main_data_root,$dolibarr_main_db_host;
    742. 

  742.     global $dolibarr_main_db_port,$dolibarr_main_db_name,$dolibarr_main_db_user,$dolibarr_main_db_pass;
    743. 

  743.     global $dolibarr_main_db_type,$dolibarr_main_db_character_set,$dolibarr_main_db_collation,$dolibarr_main_authentication;
    744. 

  744.     global $conffile,$conffiletoshow,$conffiletoshowshort;
    745. 

  745.     global $force_dolibarr_lib_ADODB_PATH, $force_dolibarr_lib_NUSOAP_PATH;
    746. 

  746.     global $force_dolibarr_lib_TCPDF_PATH, $force_dolibarr_lib_FPDI_PATH;
    747. 

  747.     global $force_dolibarr_lib_PHPEXCEL_PATH, $force_dolibarr_lib_GEOIP_PATH;
    748. 

  748.     global $force_dolibarr_lib_ODTPHP_PATH, $force_dolibarr_lib_ODTPHP_PATHTOPCLZIP;
    749. 

  749.     global $force_dolibarr_js_CKEDITOR, $force_dolibarr_js_JQUERY, $force_dolibarr_js_JQUERY_UI, $force_dolibarr_js_JQUERY_FLOT;
    750. 

  750.     global $force_dolibarr_font_DOL_DEFAULT_TTF, $force_dolibarr_font_DOL_DEFAULT_TTF_BOLD;
    751. 

  751. 

  752.     $error=0;
    753. 

  753. 

  754.     $key = md5(uniqid(mt_rand(),TRUE)); // Genere un hash d'un nombre aleatoire
    755. 

  755. 

  756.     $fp = fopen("$conffile", "w");
    757. 

  757.     if($fp)
    758. 

  758.     {
    759. 

  759.         clearstatcache();
    760. 

  760. 

  761.         fputs($fp,'<?php'."\n");
    762. 

  762.         fputs($fp,'//'."\n");
    763. 

  763.         fputs($fp,'// File generated by Dolibarr installer '.DOL_VERSION.' on '.dol_print_date(dol_now(),'')."\n");
    764. 

  764.         fputs($fp,'//'."\n");
    765. 

  765.         fputs($fp,'// Take a look at conf.php.example file for an example of '.$conffiletoshowshort.' file'."\n");
    766. 

  766.         fputs($fp,'// and explanations for all possibles parameters.'."\n");
    767. 

  767.         fputs($fp,'//'."\n");
    768. 

  768. 

  769.         fputs($fp, '$dolibarr_main_url_root=\''.str_replace("'","\'",($_POST["main_url"])).'\';');
    770. 

  770.         fputs($fp,"\n");
    771. 

  771. 

  772.         fputs($fp, '$dolibarr_main_document_root=\''.str_replace("'","\'",($main_dir)).'\';');
    773. 

  773.         fputs($fp,"\n");
    774. 

  774. 

  775.         fputs($fp, $main_use_alt_dir.'$dolibarr_main_url_root_alt=\''.str_replace("'","\'",($_POST["main_url"]."/".$main_alt_dir_name)).'\';');
    776. 

  776.         fputs($fp,"\n");
    777. 

  777. 

  778.         fputs($fp, $main_use_alt_dir.'$dolibarr_main_document_root_alt=\''.str_replace("'","\'",($main_dir."/".$main_alt_dir_name)).'\';');
    779. 

  779. 		fputs($fp,"\n");
    780. 

  780. 

  781. 		fputs($fp, '$dolibarr_main_data_root=\''.str_replace("'","\'",($main_data_dir)).'\';');
    782. 

  782. 		fputs($fp,"\n");
    783. 

  783. 

  784. 		fputs($fp, '$dolibarr_main_db_host=\''.str_replace("'","\'",($_POST["db_host"])).'\';');
    785. 

  785. 		fputs($fp,"\n");
    786. 

  786. 

  787. 		fputs($fp, '$dolibarr_main_db_port=\''.str_replace("'","\'",($_POST["db_port"])).'\';');
    788. 

  788. 		fputs($fp,"\n");
    789. 

  789. 

  790. 		fputs($fp, '$dolibarr_main_db_name=\''.str_replace("'","\'",($_POST["db_name"])).'\';');
    791. 

  791. 		fputs($fp,"\n");
    792. 

  792. 

  793. 		fputs($fp, '$dolibarr_main_db_prefix=\''.str_replace("'","\'",($main_db_prefix)).'\';');
    794. 

  794. 		fputs($fp,"\n");
    795. 

  795. 

  796. 		fputs($fp, '$dolibarr_main_db_user=\''.str_replace("'","\'",($_POST["db_user"])).'\';');
    797. 

  797. 		fputs($fp,"\n");
    798. 

  798. 		fputs($fp, '$dolibarr_main_db_pass=\''.str_replace("'","\'",($_POST["db_pass"])).'\';');
    799. 

  799. 		fputs($fp,"\n");
    800. 

  800. 

  801. 		fputs($fp, '$dolibarr_main_db_type=\''.str_replace("'","\'",($_POST["db_type"])).'\';');
    802. 

  802. 		fputs($fp,"\n");
    803. 

  803. 

  804. 		fputs($fp, '$dolibarr_main_db_character_set=\''.str_replace("'","\'",($_POST["dolibarr_main_db_character_set"])).'\';');
    805. 

  805. 		fputs($fp,"\n");
    806. 

  806. 

  807. 		fputs($fp, '$dolibarr_main_db_collation=\''.str_replace("'","\'",($_POST["dolibarr_main_db_collation"])).'\';');
    808. 

  808. 		fputs($fp,"\n");
    809. 

  809. 

  810. 		/* Authentication */
    811. 

  811. 		fputs($fp, '$dolibarr_main_authentication=\'dolibarr\';');
    812. 

  812. 		fputs($fp,"\n\n");
    813. 

  813. 

  814. 		fputs($fp, '// Specific settings');
    815. 

  815.         fputs($fp,"\n");
    816. 

  816. 

  817.         fputs($fp, '$dolibarr_main_prod=\'0\';');
    818. 

  818.         fputs($fp,"\n");
    819. 

  819. 

  820.         fputs($fp, '$dolibarr_nocsrfcheck=\'0\';');
    821. 

  821.         fputs($fp,"\n");
    822. 

  822. 

  823.         fputs($fp, '$dolibarr_main_force_https=\''.$main_force_https.'\';');
    824. 

  824. 		fputs($fp,"\n");
    825. 

  825. 

  826. 		fputs($fp, '$dolibarr_main_cookie_cryptkey=\''.$key.'\';');
    827. 

  827. 		fputs($fp,"\n");
    828. 

  828. 

  829. 		fputs($fp, '$dolibarr_mailing_limit_sendbyweb=\'0\';');
    830. 

  830.         fputs($fp,"\n");
    831. 

  831. 

  832.         // Write params to overwrites default lib path
    833. 

  833.         fputs($fp,"\n");
    834. 

  834.         if (empty($force_dolibarr_lib_ADODB_PATH)) { fputs($fp, '//'); $force_dolibarr_lib_ADODB_PATH=''; }
    835. 

  835.         fputs($fp, '$dolibarr_lib_ADODB_PATH=\''.$force_dolibarr_lib_ADODB_PATH.'\';');
    836. 

  836.         fputs($fp,"\n");
    837. 

  837.         if (empty($force_dolibarr_lib_GEOIP_PATH)) { fputs($fp, '//'); $force_dolibarr_lib_GEOIP_PATH=''; }
    838. 

  838.         fputs($fp, '$dolibarr_lib_GEOIP_PATH=\''.$force_dolibarr_lib_GEOIP_PATH.'\';');
    839. 

  839.         fputs($fp,"\n");
    840. 

  840.         if (empty($force_dolibarr_lib_NUSOAP_PATH)) { fputs($fp, '//'); $force_dolibarr_lib_NUSOAP_PATH=''; }
    841. 

  841.         fputs($fp, '$dolibarr_lib_NUSOAP_PATH=\''.$force_dolibarr_lib_NUSOAP_PATH.'\';');
    842. 

  842.         fputs($fp,"\n");
    843. 

  843.         if (empty($force_dolibarr_lib_FPDI_PATH)) { fputs($fp, '//'); $force_dolibarr_lib_FPDI_PATH=''; }
    844. 

  844.         fputs($fp, '$dolibarr_lib_FPDI_PATH=\''.$force_dolibarr_lib_FPDI_PATH.'\';');
    845. 

  845.         fputs($fp,"\n");
    846. 

  846.         if (empty($force_dolibarr_lib_PHPEXCEL_PATH)) { fputs($fp, '//'); $force_dolibarr_lib_PHPEXCEL_PATH=''; }
    847. 

  847.         fputs($fp, '$dolibarr_lib_PHPEXCEL_PATH=\''.$force_dolibarr_lib_PHPEXCEL_PATH.'\';');
    848. 

  848.         fputs($fp,"\n");
    849. 

  849.         if (empty($force_dolibarr_lib_ODTPHP_PATH)) { fputs($fp, '//'); $force_dolibarr_lib_ODTPHP_PATH=''; }
    850. 

  850.         fputs($fp, '$dolibarr_lib_ODTPHP_PATH=\''.$force_dolibarr_lib_ODTPHP_PATH.'\';');
    851. 

  851.         fputs($fp,"\n");
    852. 

  852.         if (empty($force_dolibarr_lib_ODTPHP_PATHTOPCLZIP)) { fputs($fp, '//'); $force_dolibarr_lib_ODTPHP_PATHTOPCLZIP=''; }
    853. 

  853.         fputs($fp, '$dolibarr_lib_ODTPHP_PATHTOPCLZIP=\''.$force_dolibarr_lib_ODTPHP_PATHTOPCLZIP.'\';');
    854. 

  854.         fputs($fp,"\n");
    855. 

  855.         if (empty($force_dolibarr_lib_TCPDF_PATH)) { fputs($fp, '//'); $force_dolibarr_lib_TCPDF_PATH=''; }
    856. 

  856.         fputs($fp, '$dolibarr_lib_TCPDF_PATH=\''.$force_dolibarr_lib_TCPDF_PATH.'\';');
    857. 

  857.         fputs($fp,"\n");
    858. 

  858.         if (empty($force_dolibarr_js_CKEDITOR)) { fputs($fp, '//'); $force_dolibarr_js_CKEDITOR=''; }
    859. 

  859.         fputs($fp, '$dolibarr_js_CKEDITOR=\''.$force_dolibarr_js_CKEDITOR.'\';');
    860. 

  860.         fputs($fp,"\n");
    861. 

  861.         if (empty($force_dolibarr_js_JQUERY)) { fputs($fp, '//'); $force_dolibarr_js_JQUERY=''; }
    862. 

  862.         fputs($fp, '$dolibarr_js_JQUERY=\''.$force_dolibarr_js_JQUERY.'\';');
    863. 

  863.         fputs($fp,"\n");
    864. 

  864.         if (empty($force_dolibarr_js_JQUERY_UI)) { fputs($fp, '//'); $force_dolibarr_js_JQUERY_UI=''; }
    865. 

  865.         fputs($fp, '$dolibarr_js_JQUERY_UI=\''.$force_dolibarr_js_JQUERY_UI.'\';');
    866. 

  866.         fputs($fp,"\n");
    867. 

  867.         if (empty($force_dolibarr_js_JQUERY_FLOT)) { fputs($fp, '//'); $force_dolibarr_js_JQUERY_FLOT=''; }
    868. 

  868.         fputs($fp, '$dolibarr_js_JQUERY_FLOT=\''.$force_dolibarr_js_JQUERY_FLOT.'\';');
    869. 

  869.         fputs($fp,"\n");
    870. 

  870. 

  871.         // Write params to overwrites default font path
    872. 

  872.         fputs($fp,"\n");
    873. 

  873.         if (empty($force_dolibarr_font_DOL_DEFAULT_TTF)) { fputs($fp, '//'); $force_dolibarr_font_DOL_DEFAULT_TTF=''; }
    874. 

  874.    		fputs($fp, '$dolibarr_font_DOL_DEFAULT_TTF=\''.$force_dolibarr_font_DOL_DEFAULT_TTF.'\';');
    875. 

  875.         fputs($fp,"\n");
    876. 

  876.         if (empty($force_dolibarr_font_DOL_DEFAULT_TTF_BOLD)) { fputs($fp, '//'); $force_dolibarr_font_DOL_DEFAULT_TTF_BOLD=''; }
    877. 

  877.         fputs($fp, '$dolibarr_font_DOL_DEFAULT_TTF_BOLD=\''.$force_dolibarr_font_DOL_DEFAULT_TTF_BOLD.'\';');
    878. 

  878.         fputs($fp,"\n");
    879. 

  879. 

  880. 		fputs($fp, '?>');
    881. 

  881. 		fclose($fp);
    882. 

  882. 

  883. 		if (file_exists("$conffile"))
    884. 

  884. 		{
    885. 

  885. 			include("$conffile");	// On force rechargement. Ne pas mettre include_once !
    886. 

  886. 			conf($dolibarr_main_document_root);
    887. 

  887. 

  888. 			print "<tr><td>";
    889. 

  889. 			print $langs->trans("SaveConfigurationFile");
    890. 

  890. 			print ' <strong>'.$conffile.'</strong>';
    891. 

  891. 			print "</td><td>";
    892. 

  892. 			print $langs->trans("OK");
    893. 

  893. 			print "</td></tr>";
    894. 

  894. 		}
    895. 

  895. 		else
    896. 

  896. 		{
    897. 

  897. 			$error++;
    898. 

  898. 		}
    899. 

  899. 	}
    900. 

  900. 

  901. 	return $error;
    902. 

  902. }
    903. 

  903. 

  904. ?>
    905. 

  905.