PageRenderTime 60ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 1ms

/htdocs/core/class/utils.class.php

http://github.com/Dolibarr/dolibarr
PHP | 1162 lines | 829 code | 151 blank | 182 comment | 261 complexity | 8a3610f1c65ed81c13f8fa486b76c16f 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) 2016	Laurent Destailleur <eldy@users.sourceforge.net>
    3. 

  3.  * Copyright (C) 2021	Regis Houssin		<regis.houssin@inodbox.com>
    4. 

  4.  *
    5. 

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

  6.  * it under the terms of the GNU General Public License as published by
    7. 

  7.  * the Free Software Foundation; either version 3 of the License, or
    8. 

  8.  * any later version.
    9. 

  9.  *
    10. 

  10.  * This program is distributed in the hope that it will be useful,
    11. 

  11.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
    12. 

  12.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    13. 

  13.  * GNU General Public License for more details.
    14. 

  14.  *
    15. 

  15.  * You should have received a copy of the GNU General Public License
    16. 

  16.  * along with this program. If not, see <https://www.gnu.org/licenses/>.
    17. 

  17.  */
    18. 

  18. 

  19. /**
    20. 

  20.  *   	\file       htdocs/core/class/utils.class.php
    21. 

  21.  *      \ingroup    core
    22. 

  22.  *		\brief      File for Utils class
    23. 

  23.  */
    24. 

  24. 

  25. 

  26. /**
    27. 

  27.  *		Class to manage utility methods
    28. 

  28.  */
    29. 

  29. class Utils
    30. 

  30. {
    31. 

  31. 	/**
    32. 

  32. 	 * @var DoliDB Database handler.
    33. 

  33. 	 */
    34. 

  34. 	public $db;
    35. 

  35. 

  36. 	public $output; // Used by Cron method to return message
    37. 

  37. 	public $result; // Used by Cron method to return data
    38. 

  38. 

  39. 	/**
    40. 

  40. 	 *	Constructor
    41. 

  41. 	 *
    42. 

  42. 	 *  @param	DoliDB	$db		Database handler
    43. 

  43. 	 */
    44. 

  44. 	public function __construct($db)
    45. 

  45. 	{
    46. 

  46. 		$this->db = $db;
    47. 

  47. 	}
    48. 

  48. 

  49. 

  50. 	/**
    51. 

  51. 	 *  Purge files into directory of data files.
    52. 

  52. 	 *  CAN BE A CRON TASK
    53. 

  53. 	 *
    54. 

  54. 	 *  @param	string      $choices	   Choice of purge mode ('tempfiles', 'tempfilesold' to purge temp older than $nbsecondsold seconds, 'logfiles', or mix of this). Note 'allfiles' is possible too but very dangerous.
    55. 

  55. 	 *  @param  int         $nbsecondsold  Nb of seconds old to accept deletion of a directory if $choice is 'tempfilesold'
    56. 

  56. 	 *  @return	int						   0 if OK, < 0 if KO (this function is used also by cron so only 0 is OK)
    57. 

  57. 	 */
    58. 

  58. 	public function purgeFiles($choices = 'tempfilesold+logfiles', $nbsecondsold = 86400)
    59. 

  59. 	{
    60. 

  60. 		global $conf, $langs, $dolibarr_main_data_root;
    61. 

  61. 

  62. 		$langs->load("admin");
    63. 

  63. 

  64. 		require_once DOL_DOCUMENT_ROOT.'/core/lib/files.lib.php';
    65. 

  65. 

  66. 		if (empty($choices)) {
    67. 

  67. 			$choices = 'tempfilesold+logfiles';
    68. 

  68. 		}
    69. 

  69. 

  70. 		dol_syslog("Utils::purgeFiles choice=".$choices, LOG_DEBUG);
    71. 

  71. 

  72. 		$count = 0;
    73. 

  73. 		$countdeleted = 0;
    74. 

  74. 		$counterror = 0;
    75. 

  75. 		$filelog = '';
    76. 

  76. 

  77. 		$choicesarray = preg_split('/[\+,]/', $choices);
    78. 

  78. 		foreach ($choicesarray as $choice) {
    79. 

  79. 			$filesarray = array();
    80. 

  80. 

  81. 			if ($choice == 'tempfiles' || $choice == 'tempfilesold') {
    82. 

  82. 				// Delete temporary files
    83. 

  83. 				if ($dolibarr_main_data_root) {
    84. 

  84. 					$filesarray = dol_dir_list($dolibarr_main_data_root, "directories", 1, '^temp$', '', 'name', SORT_ASC, 2, 0, '', 1); // Do not follow symlinks
    85. 

  85. 

  86. 					if ($choice == 'tempfilesold') {
    87. 

  87. 						$now = dol_now();
    88. 

  88. 						foreach ($filesarray as $key => $val) {
    89. 

  89. 							if ($val['date'] > ($now - ($nbsecondsold))) {
    90. 

  90. 								unset($filesarray[$key]); // Discard temp dir not older than $nbsecondsold
    91. 

  91. 							}
    92. 

  92. 						}
    93. 

  93. 					}
    94. 

  94. 				}
    95. 

  95. 			}
    96. 

  96. 

  97. 			if ($choice == 'allfiles') {
    98. 

  98. 				// Delete all files (except install.lock, do not follow symbolic links)
    99. 

  99. 				if ($dolibarr_main_data_root) {
    100. 

  100. 					$filesarray = dol_dir_list($dolibarr_main_data_root, "all", 0, '', 'install\.lock$', 'name', SORT_ASC, 0, 0, '', 1);
    101. 

  101. 				}
    102. 

  102. 			}
    103. 

  103. 

  104. 			if ($choice == 'logfile' || $choice == 'logfiles') {
    105. 

  105. 				// Define files log
    106. 

  106. 				if ($dolibarr_main_data_root) {
    107. 

  107. 					$filesarray = dol_dir_list($dolibarr_main_data_root, "files", 0, '.*\.log[\.0-9]*(\.gz)?$', 'install\.lock$', 'name', SORT_ASC, 0, 0, '', 1);
    108. 

  108. 				}
    109. 

  109. 

  110. 				if (!empty($conf->syslog->enabled)) {
    111. 

  111. 					$filelog = $conf->global->SYSLOG_FILE;
    112. 

  112. 					$filelog = preg_replace('/DOL_DATA_ROOT/i', DOL_DATA_ROOT, $filelog);
    113. 

  113. 

  114. 					$alreadyincluded = false;
    115. 

  115. 					foreach ($filesarray as $tmpcursor) {
    116. 

  116. 						if ($tmpcursor['fullname'] == $filelog) {
    117. 

  117. 							$alreadyincluded = true;
    118. 

  118. 						}
    119. 

  119. 					}
    120. 

  120. 					if (!$alreadyincluded) {
    121. 

  121. 						$filesarray[] = array('fullname'=>$filelog, 'type'=>'file');
    122. 

  122. 					}
    123. 

  123. 				}
    124. 

  124. 			}
    125. 

  125. 

  126. 			if (is_array($filesarray) && count($filesarray)) {
    127. 

  127. 				foreach ($filesarray as $key => $value) {
    128. 

  128. 					//print "x ".$filesarray[$key]['fullname']."-".$filesarray[$key]['type']."<br>\n";
    129. 

  129. 					if ($filesarray[$key]['type'] == 'dir') {
    130. 

  130. 						$startcount = 0;
    131. 

  131. 						$tmpcountdeleted = 0;
    132. 

  132. 

  133. 						$result = dol_delete_dir_recursive($filesarray[$key]['fullname'], $startcount, 1, 0, $tmpcountdeleted);
    134. 

  134. 

  135. 						if (!in_array($filesarray[$key]['fullname'], array($conf->api->dir_temp, $conf->user->dir_temp))) {		// The 2 directories $conf->api->dir_temp and $conf->user->dir_temp are recreated at end, so we do not count them
    136. 

  136. 							$count += $result;
    137. 

  137. 							$countdeleted += $tmpcountdeleted;
    138. 

  138. 						}
    139. 

  139. 					} elseif ($filesarray[$key]['type'] == 'file') {
    140. 

  140. 						// If (file that is not logfile) or (if mode is logfile)
    141. 

  141. 						if ($filesarray[$key]['fullname'] != $filelog || $choice == 'logfile' || $choice == 'logfiles') {
    142. 

  142. 							$result = dol_delete_file($filesarray[$key]['fullname'], 1, 1);
    143. 

  143. 							if ($result) {
    144. 

  144. 								$count++;
    145. 

  145. 								$countdeleted++;
    146. 

  146. 							} else {
    147. 

  147. 								$counterror++;
    148. 

  148. 							}
    149. 

  149. 						}
    150. 

  150. 					}
    151. 

  151. 				}
    152. 

  152. 

  153. 				// Update cachenbofdoc
    154. 

  154. 				if (!empty($conf->ecm->enabled) && $choice == 'allfiles') {
    155. 

  155. 					require_once DOL_DOCUMENT_ROOT.'/ecm/class/ecmdirectory.class.php';
    156. 

  156. 					$ecmdirstatic = new EcmDirectory($this->db);
    157. 

  157. 					$result = $ecmdirstatic->refreshcachenboffile(1);
    158. 

  158. 				}
    159. 

  159. 			}
    160. 

  160. 		}
    161. 

  161. 

  162. 		if ($count > 0) {
    163. 

  163. 			$this->output = $langs->trans("PurgeNDirectoriesDeleted", $countdeleted);
    164. 

  164. 			if ($count > $countdeleted) {
    165. 

  165. 				$this->output .= '<br>'.$langs->trans("PurgeNDirectoriesFailed", ($count - $countdeleted));
    166. 

  166. 			}
    167. 

  167. 		} else {
    168. 

  168. 			$this->output = $langs->trans("PurgeNothingToDelete").(in_array('tempfilesold', $choicesarray) ? ' (older than 24h for temp files)' : '');
    169. 

  169. 		}
    170. 

  170. 

  171. 		// Recreate temp dir that are not automatically recreated by core code for performance purpose, we need them
    172. 

  172. 		if (!empty($conf->api->enabled)) {
    173. 

  173. 			dol_mkdir($conf->api->dir_temp);
    174. 

  174. 		}
    175. 

  175. 		dol_mkdir($conf->user->dir_temp);
    176. 

  176. 

  177. 		//return $count;
    178. 

  178. 		return 0; // This function can be called by cron so must return 0 if OK
    179. 

  179. 	}
    180. 

  180. 

  181. 

  182. 	/**
    183. 

  183. 	 *  Make a backup of database
    184. 

  184. 	 *  CAN BE A CRON TASK
    185. 

  185. 	 *
    186. 

  186. 	 *  @param	string		$compression	   'gz' or 'bz' or 'none'
    187. 

  187. 	 *  @param  string      $type              'mysql', 'postgresql', ...
    188. 

  188. 	 *  @param  int         $usedefault        1=Use default backup profile (Set this to 1 when used as cron)
    189. 

  189. 	 *  @param  string      $file              'auto' or filename to build
    190. 

  190. 	 *  @param  int         $keeplastnfiles    Keep only last n files (not used yet)
    191. 

  191. 	 *  @param	int		    $execmethod		   0=Use default method (that is 1 by default), 1=Use the PHP 'exec', 2=Use the 'popen' method
    192. 

  192. 	 *  @return	int						       0 if OK, < 0 if KO (this function is used also by cron so only 0 is OK)
    193. 

  193. 	 */
    194. 

  194. 	public function dumpDatabase($compression = 'none', $type = 'auto', $usedefault = 1, $file = 'auto', $keeplastnfiles = 0, $execmethod = 0)
    195. 

  195. 	{
    196. 

  196. 		global $db, $conf, $langs, $dolibarr_main_data_root;
    197. 

  197. 		global $dolibarr_main_db_name, $dolibarr_main_db_host, $dolibarr_main_db_user, $dolibarr_main_db_port, $dolibarr_main_db_pass;
    198. 

  198. 		global $dolibarr_main_db_character_set;
    199. 

  199. 

  200. 		$langs->load("admin");
    201. 

  201. 

  202. 		dol_syslog("Utils::dumpDatabase type=".$type." compression=".$compression." file=".$file, LOG_DEBUG);
    203. 

  203. 		require_once DOL_DOCUMENT_ROOT.'/core/lib/files.lib.php';
    204. 

  204. 

  205. 		// Check compression parameter
    206. 

  206. 		if (!in_array($compression, array('none', 'gz', 'bz', 'zip', 'zstd'))) {
    207. 

  207. 			$langs->load("errors");
    208. 

  208. 			$this->error = $langs->transnoentitiesnoconv("ErrorBadValueForParameter", $compression, "Compression");
    209. 

  209. 			return -1;
    210. 

  210. 		}
    211. 

  211. 

  212. 		// Check type parameter
    213. 

  213. 		if ($type == 'auto') {
    214. 

  214. 			$type = $this->db->type;
    215. 

  215. 		}
    216. 

  216. 		if (!in_array($type, array('postgresql', 'pgsql', 'mysql', 'mysqli', 'mysqlnobin'))) {
    217. 

  217. 			$langs->load("errors");
    218. 

  218. 			$this->error = $langs->transnoentitiesnoconv("ErrorBadValueForParameter", $type, "Basetype");
    219. 

  219. 			return -1;
    220. 

  220. 		}
    221. 

  221. 

  222. 		// Check file parameter
    223. 

  223. 		if ($file == 'auto') {
    224. 

  224. 			$prefix = 'dump';
    225. 

  225. 			$ext = 'sql';
    226. 

  226. 			if (in_array($type, array('mysql', 'mysqli'))) {
    227. 

  227. 				$prefix = 'mysqldump';
    228. 

  228. 				$ext = 'sql';
    229. 

  229. 			}
    230. 

  230. 			//if ($label == 'PostgreSQL') { $prefix='pg_dump'; $ext='dump'; }
    231. 

  231. 			if (in_array($type, array('pgsql'))) {
    232. 

  232. 				$prefix = 'pg_dump';
    233. 

  233. 				$ext = 'sql';
    234. 

  234. 			}
    235. 

  235. 			$file = $prefix.'_'.$dolibarr_main_db_name.'_'.dol_sanitizeFileName(DOL_VERSION).'_'.strftime("%Y%m%d%H%M").'.'.$ext;
    236. 

  236. 		}
    237. 

  237. 

  238. 		$outputdir = $conf->admin->dir_output.'/backup';
    239. 

  239. 		$result = dol_mkdir($outputdir);
    240. 

  240. 		$errormsg = '';
    241. 

  241. 

  242. 		// MYSQL
    243. 

  243. 		if ($type == 'mysql' || $type == 'mysqli') {
    244. 

  244. 			$cmddump = $conf->global->SYSTEMTOOLS_MYSQLDUMP;
    245. 

  245. 

  246. 

  247. 			$outputfile = $outputdir.'/'.$file;
    248. 

  248. 			// for compression format, we add extension
    249. 

  249. 			$compression = $compression ? $compression : 'none';
    250. 

  250. 			if ($compression == 'gz') {
    251. 

  251. 				$outputfile .= '.gz';
    252. 

  252. 			} elseif ($compression == 'bz') {
    253. 

  253. 				$outputfile .= '.bz2';
    254. 

  254. 			} elseif ($compression == 'zstd') {
    255. 

  255. 				$outputfile .= '.zst';
    256. 

  256. 			}
    257. 

  257. 			$outputerror = $outputfile.'.err';
    258. 

  258. 			dol_mkdir($conf->admin->dir_output.'/backup');
    259. 

  259. 

  260. 			// Parameteres execution
    261. 

  261. 			$command = $cmddump;
    262. 

  262. 			$command = preg_replace('/(\$|%)/', '', $command); // We removed chars that can be used to inject vars that contains space inside path of command without seeing there is a space to bypass the escapeshellarg.
    263. 

  263. 			if (preg_match("/\s/", $command)) {
    264. 

  264. 				$command = escapeshellarg($command); // If there is spaces, we add quotes on command to be sure $command is only a program and not a program+parameters
    265. 

  265. 			}
    266. 

  266. 

  267. 			//$param=escapeshellarg($dolibarr_main_db_name)." -h ".escapeshellarg($dolibarr_main_db_host)." -u ".escapeshellarg($dolibarr_main_db_user)." -p".escapeshellarg($dolibarr_main_db_pass);
    268. 

  268. 			$param = $dolibarr_main_db_name." -h ".$dolibarr_main_db_host;
    269. 

  269. 			$param .= " -u ".$dolibarr_main_db_user;
    270. 

  270. 			if (!empty($dolibarr_main_db_port)) {
    271. 

  271. 				$param .= " -P ".$dolibarr_main_db_port;
    272. 

  272. 			}
    273. 

  273. 			if (!GETPOST("use_transaction", "alpha")) {
    274. 

  274. 				$param .= " -l --single-transaction";
    275. 

  275. 			}
    276. 

  276. 			if (GETPOST("disable_fk", "alpha") || $usedefault) {
    277. 

  277. 				$param .= " -K";
    278. 

  278. 			}
    279. 

  279. 			if (GETPOST("sql_compat", "alpha") && GETPOST("sql_compat", "alpha") != 'NONE') {
    280. 

  280. 				$param .= " --compatible=".escapeshellarg(GETPOST("sql_compat", "alpha"));
    281. 

  281. 			}
    282. 

  282. 			if (GETPOST("drop_database", "alpha")) {
    283. 

  283. 				$param .= " --add-drop-database";
    284. 

  284. 			}
    285. 

  285. 			if (GETPOST("use_mysql_quick_param", "alpha")) {
    286. 

  286. 				$param .= " --quick";
    287. 

  287. 			}
    288. 

  288. 			if (GETPOST("sql_structure", "alpha") || $usedefault) {
    289. 

  289. 				if (GETPOST("drop", "alpha") || $usedefault) {
    290. 

  290. 					$param .= " --add-drop-table=TRUE";
    291. 

  291. 				} else {
    292. 

  292. 					$param .= " --add-drop-table=FALSE";
    293. 

  293. 				}
    294. 

  294. 			} else {
    295. 

  295. 				$param .= " -t";
    296. 

  296. 			}
    297. 

  297. 			if (GETPOST("disable-add-locks", "alpha")) {
    298. 

  298. 				$param .= " --add-locks=FALSE";
    299. 

  299. 			}
    300. 

  300. 			if (GETPOST("sql_data", "alpha") || $usedefault) {
    301. 

  301. 				$param .= " --tables";
    302. 

  302. 				if (GETPOST("showcolumns", "alpha") || $usedefault) {
    303. 

  303. 					$param .= " -c";
    304. 

  304. 				}
    305. 

  305. 				if (GETPOST("extended_ins", "alpha") || $usedefault) {
    306. 

  306. 					$param .= " -e";
    307. 

  307. 				} else {
    308. 

  308. 					$param .= " --skip-extended-insert";
    309. 

  309. 				}
    310. 

  310. 				if (GETPOST("delayed", "alpha")) {
    311. 

  311. 					$param .= " --delayed-insert";
    312. 

  312. 				}
    313. 

  313. 				if (GETPOST("sql_ignore", "alpha")) {
    314. 

  314. 					$param .= " --insert-ignore";
    315. 

  315. 				}
    316. 

  316. 				if (GETPOST("hexforbinary", "alpha") || $usedefault) {
    317. 

  317. 					$param .= " --hex-blob";
    318. 

  318. 				}
    319. 

  319. 			} else {
    320. 

  320. 				$param .= " -d"; // No row information (no data)
    321. 

  321. 			}
    322. 

  322. 			if ($dolibarr_main_db_character_set == 'utf8mb4') {
    323. 

  323. 				// We save output into utf8mb4 charset
    324. 

  324. 				$param .= " --default-character-set=utf8mb4 --no-tablespaces";
    325. 

  325. 			} else {
    326. 

  326. 				$param .= " --default-character-set=utf8 --no-tablespaces"; // We always save output into utf8 charset
    327. 

  327. 			}
    328. 

  328. 			$paramcrypted = $param;
    329. 

  329. 			$paramclear = $param;
    330. 

  330. 			if (!empty($dolibarr_main_db_pass)) {
    331. 

  331. 				$paramcrypted .= ' -p"'.preg_replace('/./i', '*', $dolibarr_main_db_pass).'"';
    332. 

  332. 				$paramclear .= ' -p"'.str_replace(array('"', '`', '$'), array('\"', '\`', '\$'), $dolibarr_main_db_pass).'"';
    333. 

  333. 			}
    334. 

  334. 

  335. 			$handle = '';
    336. 

  336. 

  337. 			// Start call method to execute dump
    338. 

  338. 			$fullcommandcrypted = $command." ".$paramcrypted." 2>&1";
    339. 

  339. 			$fullcommandclear = $command." ".$paramclear." 2>&1";
    340. 

  340. 			if ($compression == 'none') {
    341. 

  341. 				$handle = fopen($outputfile, 'w');
    342. 

  342. 			} elseif ($compression == 'gz') {
    343. 

  343. 				$handle = gzopen($outputfile, 'w');
    344. 

  344. 			} elseif ($compression == 'bz') {
    345. 

  345. 				$handle = bzopen($outputfile, 'w');
    346. 

  346. 			} elseif ($compression == 'zstd') {
    347. 

  347. 				$handle = fopen($outputfile, 'w');
    348. 

  348. 			}
    349. 

  349. 

  350. 			$ok = 0;
    351. 

  351. 			if ($handle) {
    352. 

  352. 				if (!empty($conf->global->MAIN_EXEC_USE_POPEN)) {
    353. 

  353. 					$execmethod = $conf->global->MAIN_EXEC_USE_POPEN;
    354. 

  354. 				}
    355. 

  355. 				if (empty($execmethod)) {
    356. 

  356. 					$execmethod = 1;
    357. 

  357. 				}
    358. 

  358. 

  359. 				dol_syslog("Utils::dumpDatabase execmethod=".$execmethod." command:".$fullcommandcrypted, LOG_INFO);
    360. 

  360. 

  361. 				// TODO Replace with executeCLI function
    362. 

  362. 				if ($execmethod == 1) {
    363. 

  363. 					$output_arr = array();
    364. 

  364. 					$retval = null;
    365. 

  365. 					exec($fullcommandclear, $output_arr, $retval);
    366. 

  366. 

  367. 					if ($retval != 0) {
    368. 

  368. 						$langs->load("errors");
    369. 

  369. 						dol_syslog("Datadump retval after exec=".$retval, LOG_ERR);
    370. 

  370. 						$errormsg = 'Error '.$retval;
    371. 

  371. 						$ok = 0;
    372. 

  372. 					} else {
    373. 

  373. 						$i = 0;
    374. 

  374. 						if (!empty($output_arr)) {
    375. 

  375. 							foreach ($output_arr as $key => $read) {
    376. 

  376. 								$i++; // output line number
    377. 

  377. 								if ($i == 1 && preg_match('/Warning.*Using a password/i', $read)) {
    378. 

  378. 									continue;
    379. 

  379. 								}
    380. 

  380. 								fwrite($handle, $read.($execmethod == 2 ? '' : "\n"));
    381. 

  381. 								if (preg_match('/'.preg_quote('-- Dump completed').'/i', $read)) {
    382. 

  382. 									$ok = 1;
    383. 

  383. 								} elseif (preg_match('/'.preg_quote('SET SQL_NOTES=@OLD_SQL_NOTES').'/i', $read)) {
    384. 

  384. 									$ok = 1;
    385. 

  385. 								}
    386. 

  386. 							}
    387. 

  387. 						}
    388. 

  388. 					}
    389. 

  389. 				}
    390. 

  390. 				if ($execmethod == 2) {	// With this method, there is no way to get the return code, only output
    391. 

  391. 					$handlein = popen($fullcommandclear, 'r');
    392. 

  392. 					$i = 0;
    393. 

  393. 					while (!feof($handlein)) {
    394. 

  394. 						$i++; // output line number
    395. 

  395. 						$read = fgets($handlein);
    396. 

  396. 						// Exclude warning line we don't want
    397. 

  397. 						if ($i == 1 && preg_match('/Warning.*Using a password/i', $read)) {
    398. 

  398. 							continue;
    399. 

  399. 						}
    400. 

  400. 						fwrite($handle, $read);
    401. 

  401. 						if (preg_match('/'.preg_quote('-- Dump completed').'/i', $read)) {
    402. 

  402. 							$ok = 1;
    403. 

  403. 						} elseif (preg_match('/'.preg_quote('SET SQL_NOTES=@OLD_SQL_NOTES').'/i', $read)) {
    404. 

  404. 							$ok = 1;
    405. 

  405. 						}
    406. 

  406. 					}
    407. 

  407. 					pclose($handlein);
    408. 

  408. 				}
    409. 

  409. 

  410. 

  411. 				if ($compression == 'none') {
    412. 

  412. 					fclose($handle);
    413. 

  413. 				} elseif ($compression == 'gz') {
    414. 

  414. 					gzclose($handle);
    415. 

  415. 				} elseif ($compression == 'bz') {
    416. 

  416. 					bzclose($handle);
    417. 

  417. 				} elseif ($compression == 'zstd') {
    418. 

  418. 					fclose($handle);
    419. 

  419. 				}
    420. 

  420. 

  421. 				if (!empty($conf->global->MAIN_UMASK)) {
    422. 

  422. 					@chmod($outputfile, octdec($conf->global->MAIN_UMASK));
    423. 

  423. 				}
    424. 

  424. 			} else {
    425. 

  425. 				$langs->load("errors");
    426. 

  426. 				dol_syslog("Failed to open file ".$outputfile, LOG_ERR);
    427. 

  427. 				$errormsg = $langs->trans("ErrorFailedToWriteInDir");
    428. 

  428. 			}
    429. 

  429. 

  430. 			// Get errorstring
    431. 

  431. 			if ($compression == 'none') {
    432. 

  432. 				$handle = fopen($outputfile, 'r');
    433. 

  433. 			} elseif ($compression == 'gz') {
    434. 

  434. 				$handle = gzopen($outputfile, 'r');
    435. 

  435. 			} elseif ($compression == 'bz') {
    436. 

  436. 				$handle = bzopen($outputfile, 'r');
    437. 

  437. 			} elseif ($compression == 'zstd') {
    438. 

  438. 				$handle = fopen($outputfile, 'r');
    439. 

  439. 			}
    440. 

  440. 			if ($handle) {
    441. 

  441. 				// Get 2048 first chars of error message.
    442. 

  442. 				$errormsg = fgets($handle, 2048);
    443. 

  443. 				//$ok=0;$errormsg='';  To force error
    444. 

  444. 

  445. 				// Close file
    446. 

  446. 				if ($compression == 'none') {
    447. 

  447. 					fclose($handle);
    448. 

  448. 				} elseif ($compression == 'gz') {
    449. 

  449. 					gzclose($handle);
    450. 

  450. 				} elseif ($compression == 'bz') {
    451. 

  451. 					bzclose($handle);
    452. 

  452. 				} elseif ($compression == 'zstd') {
    453. 

  453. 					fclose($handle);
    454. 

  454. 				}
    455. 

  455. 				if ($ok && preg_match('/^-- (MySql|MariaDB)/i', $errormsg)) {	// No error
    456. 

  456. 					$errormsg = '';
    457. 

  457. 				} else {
    458. 

  458. 					// Renommer fichier sortie en fichier erreur
    459. 

  459. 					//print "$outputfile -> $outputerror";
    460. 

  460. 					@dol_delete_file($outputerror, 1, 0, 0, null, false, 0);
    461. 

  461. 					@rename($outputfile, $outputerror);
    462. 

  462. 					// Si safe_mode on et command hors du parametre exec, on a un fichier out vide donc errormsg vide
    463. 

  463. 					if (!$errormsg) {
    464. 

  464. 						$langs->load("errors");
    465. 

  465. 						$errormsg = $langs->trans("ErrorFailedToRunExternalCommand");
    466. 

  466. 					}
    467. 

  467. 				}
    468. 

  468. 			}
    469. 

  469. 			// Fin execution commande
    470. 

  470. 

  471. 			$this->output = $errormsg;
    472. 

  472. 			$this->error = $errormsg;
    473. 

  473. 			$this->result = array("commandbackuplastdone" => $command." ".$paramcrypted, "commandbackuptorun" => "");
    474. 

  474. 			//if (empty($this->output)) $this->output=$this->result['commandbackuplastdone'];
    475. 

  475. 		}
    476. 

  476. 

  477. 		// MYSQL NO BIN
    478. 

  478. 		if ($type == 'mysqlnobin') {
    479. 

  479. 			$outputfile = $outputdir.'/'.$file;
    480. 

  480. 			$outputfiletemp = $outputfile.'-TMP.sql';
    481. 

  481. 			// for compression format, we add extension
    482. 

  482. 			$compression = $compression ? $compression : 'none';
    483. 

  483. 			if ($compression == 'gz') {
    484. 

  484. 				$outputfile .= '.gz';
    485. 

  485. 			}
    486. 

  486. 			if ($compression == 'bz') {
    487. 

  487. 				$outputfile .= '.bz2';
    488. 

  488. 			}
    489. 

  489. 			$outputerror = $outputfile.'.err';
    490. 

  490. 			dol_mkdir($conf->admin->dir_output.'/backup');
    491. 

  491. 

  492. 			if ($compression == 'gz' or $compression == 'bz') {
    493. 

  493. 				$this->backupTables($outputfiletemp);
    494. 

  494. 				dol_compress_file($outputfiletemp, $outputfile, $compression);
    495. 

  495. 				unlink($outputfiletemp);
    496. 

  496. 			} else {
    497. 

  497. 				$this->backupTables($outputfile);
    498. 

  498. 			}
    499. 

  499. 

  500. 			$this->output = "";
    501. 

  501. 			$this->result = array("commandbackuplastdone" => "", "commandbackuptorun" => "");
    502. 

  502. 		}
    503. 

  503. 

  504. 		// POSTGRESQL
    505. 

  505. 		if ($type == 'postgresql' || $type == 'pgsql') {
    506. 

  506. 			$cmddump = $conf->global->SYSTEMTOOLS_POSTGRESQLDUMP;
    507. 

  507. 

  508. 			$outputfile = $outputdir.'/'.$file;
    509. 

  509. 			// for compression format, we add extension
    510. 

  510. 			$compression = $compression ? $compression : 'none';
    511. 

  511. 			if ($compression == 'gz') {
    512. 

  512. 				$outputfile .= '.gz';
    513. 

  513. 			}
    514. 

  514. 			if ($compression == 'bz') {
    515. 

  515. 				$outputfile .= '.bz2';
    516. 

  516. 			}
    517. 

  517. 			$outputerror = $outputfile.'.err';
    518. 

  518. 			dol_mkdir($conf->admin->dir_output.'/backup');
    519. 

  519. 

  520. 			// Parameteres execution
    521. 

  521. 			$command = $cmddump;
    522. 

  522. 			$command = preg_replace('/(\$|%)/', '', $command); // We removed chars that can be used to inject vars that contains space inside path of command without seeing there is a space to bypass the escapeshellarg.
    523. 

  523. 			if (preg_match("/\s/", $command)) {
    524. 

  524. 				$command = escapeshellarg($command); // If there is spaces, we add quotes on command to be sure $command is only a program and not a program+parameters
    525. 

  525. 			}
    526. 

  526. 

  527. 			//$param=escapeshellarg($dolibarr_main_db_name)." -h ".escapeshellarg($dolibarr_main_db_host)." -u ".escapeshellarg($dolibarr_main_db_user)." -p".escapeshellarg($dolibarr_main_db_pass);
    528. 

  528. 			//$param="-F c";
    529. 

  529. 			$param = "-F p";
    530. 

  530. 			$param .= " --no-tablespaces --inserts -h ".$dolibarr_main_db_host;
    531. 

  531. 			$param .= " -U ".$dolibarr_main_db_user;
    532. 

  532. 			if (!empty($dolibarr_main_db_port)) {
    533. 

  533. 				$param .= " -p ".$dolibarr_main_db_port;
    534. 

  534. 			}
    535. 

  535. 			if (GETPOST("sql_compat") && GETPOST("sql_compat") == 'ANSI') {
    536. 

  536. 				$param .= "  --disable-dollar-quoting";
    537. 

  537. 			}
    538. 

  538. 			if (GETPOST("drop_database")) {
    539. 

  539. 				$param .= " -c -C";
    540. 

  540. 			}
    541. 

  541. 			if (GETPOST("sql_structure")) {
    542. 

  542. 				if (GETPOST("drop")) {
    543. 

  543. 					$param .= " --add-drop-table";
    544. 

  544. 				}
    545. 

  545. 				if (!GETPOST("sql_data")) {
    546. 

  546. 					$param .= " -s";
    547. 

  547. 				}
    548. 

  548. 			}
    549. 

  549. 			if (GETPOST("sql_data")) {
    550. 

  550. 				if (!GETPOST("sql_structure")) {
    551. 

  551. 					$param .= " -a";
    552. 

  552. 				}
    553. 

  553. 				if (GETPOST("showcolumns")) {
    554. 

  554. 					$param .= " -c";
    555. 

  555. 				}
    556. 

  556. 			}
    557. 

  557. 			$param .= ' -f "'.$outputfile.'"';
    558. 

  558. 			//if ($compression == 'none')
    559. 

  559. 			if ($compression == 'gz') {
    560. 

  560. 				$param .= ' -Z 9';
    561. 

  561. 			}
    562. 

  562. 			//if ($compression == 'bz')
    563. 

  563. 			$paramcrypted = $param;
    564. 

  564. 			$paramclear = $param;
    565. 

  565. 			/*if (! empty($dolibarr_main_db_pass))
    566. 

  566. 			 {
    567. 

  567. 			 $paramcrypted.=" -W".preg_replace('/./i','*',$dolibarr_main_db_pass);
    568. 

  568. 			 $paramclear.=" -W".$dolibarr_main_db_pass;
    569. 

  569. 			 }*/
    570. 

  570. 			$paramcrypted .= " -w ".$dolibarr_main_db_name;
    571. 

  571. 			$paramclear .= " -w ".$dolibarr_main_db_name;
    572. 

  572. 

  573. 			$this->output = "";
    574. 

  574. 			$this->result = array("commandbackuplastdone" => "", "commandbackuptorun" => $command." ".$paramcrypted);
    575. 

  575. 		}
    576. 

  576. 

  577. 		// Clean old files
    578. 

  578. 		if (!$errormsg && $keeplastnfiles > 0) {
    579. 

  579. 			$tmpfiles = dol_dir_list($conf->admin->dir_output.'/backup', 'files', 0, '', '(\.err|\.old|\.sav)$', 'date', SORT_DESC);
    580. 

  580. 			$i = 0;
    581. 

  581. 			foreach ($tmpfiles as $key => $val) {
    582. 

  582. 				$i++;
    583. 

  583. 				if ($i <= $keeplastnfiles) {
    584. 

  584. 					continue;
    585. 

  585. 				}
    586. 

  586. 				dol_delete_file($val['fullname'], 0, 0, 0, null, false, 0);
    587. 

  587. 			}
    588. 

  588. 		}
    589. 

  589. 

  590. 		return ($errormsg ? -1 : 0);
    591. 

  591. 	}
    592. 

  592. 

  593. 

  594. 

  595. 	/**
    596. 

  596. 	 * Execute a CLI command.
    597. 

  597. 	 *
    598. 

  598. 	 * @param 	string	$command			Command line to execute.
    599. 

  599. 	 * 										Warning: The command line is sanitize so can't contains any redirection char '>'. Use param $redirectionfile if you need it.
    600. 

  600. 	 * @param 	string	$outputfile			A path for an output file (used only when method is 2). For example: $conf->admin->dir_temp.'/out.tmp';
    601. 

  601. 	 * @param	int		$execmethod			0=Use default method (that is 1 by default), 1=Use the PHP 'exec', 2=Use the 'popen' method
    602. 

  602. 	 * @param	string	$redirectionfile	If defined, a redirection of output to this files is added.
    603. 

  603. 	 * @param	int		$noescapecommand	1=Do not escape command. Warning: Using this parameter need you alreay sanitized the command. if not, it will lead to security vulnerability.
    604. 

  604. 	 * 										This parameter is provided for backward compatibility with external modules. Always use 0 in core.
    605. 

  605. 	 * @return	array						array('result'=>...,'output'=>...,'error'=>...). result = 0 means OK.
    606. 

  606. 	 */
    607. 

  607. 	public function executeCLI($command, $outputfile, $execmethod = 0, $redirectionfile = null, $noescapecommand = 0)
    608. 

  608. 	{
    609. 

  609. 		global $conf, $langs;
    610. 

  610. 

  611. 		$result = 0;
    612. 

  612. 		$output = '';
    613. 

  613. 		$error = '';
    614. 

  614. 

  615. 		if (empty($noescapecommand)) {
    616. 

  616. 			$command = escapeshellcmd($command);
    617. 

  617. 		}
    618. 

  618. 		if ($redirectionfile) {
    619. 

  619. 			$command .= " > ".dol_sanitizePathName($redirectionfile);
    620. 

  620. 		}
    621. 

  621. 		$command .= " 2>&1";
    622. 

  622. 

  623. 		if (!empty($conf->global->MAIN_EXEC_USE_POPEN)) {
    624. 

  624. 			$execmethod = $conf->global->MAIN_EXEC_USE_POPEN;
    625. 

  625. 		}
    626. 

  626. 		if (empty($execmethod)) {
    627. 

  627. 			$execmethod = 1;
    628. 

  628. 		}
    629. 

  629. 		//$execmethod=1;
    630. 

  630. 

  631. 		dol_syslog("Utils::executeCLI execmethod=".$execmethod." system:".$command, LOG_DEBUG);
    632. 

  632. 		$output_arr = array();
    633. 

  633. 

  634. 		if ($execmethod == 1) {
    635. 

  635. 			$retval = null;
    636. 

  636. 			exec($command, $output_arr, $retval);
    637. 

  637. 			$result = $retval;
    638. 

  638. 			if ($retval != 0) {
    639. 

  639. 				$langs->load("errors");
    640. 

  640. 				dol_syslog("Utils::executeCLI retval after exec=".$retval, LOG_ERR);
    641. 

  641. 				$error = 'Error '.$retval;
    642. 

  642. 			}
    643. 

  643. 		}
    644. 

  644. 		if ($execmethod == 2) {	// With this method, there is no way to get the return code, only output
    645. 

  645. 			$handle = fopen($outputfile, 'w+b');
    646. 

  646. 			if ($handle) {
    647. 

  647. 				dol_syslog("Utils::executeCLI run command ".$command);
    648. 

  648. 				$handlein = popen($command, 'r');
    649. 

  649. 				while (!feof($handlein)) {
    650. 

  650. 					$read = fgets($handlein);
    651. 

  651. 					fwrite($handle, $read);
    652. 

  652. 					$output_arr[] = $read;
    653. 

  653. 				}
    654. 

  654. 				pclose($handlein);
    655. 

  655. 				fclose($handle);
    656. 

  656. 			}
    657. 

  657. 			if (!empty($conf->global->MAIN_UMASK)) {
    658. 

  658. 				@chmod($outputfile, octdec($conf->global->MAIN_UMASK));
    659. 

  659. 			}
    660. 

  660. 		}
    661. 

  661. 

  662. 		// Update with result
    663. 

  663. 		if (is_array($output_arr) && count($output_arr) > 0) {
    664. 

  664. 			foreach ($output_arr as $val) {
    665. 

  665. 				$output .= $val.($execmethod == 2 ? '' : "\n");
    666. 

  666. 			}
    667. 

  667. 		}
    668. 

  668. 

  669. 		dol_syslog("Utils::executeCLI result=".$result." output=".$output." error=".$error, LOG_DEBUG);
    670. 

  670. 

  671. 		return array('result'=>$result, 'output'=>$output, 'error'=>$error);
    672. 

  672. 	}
    673. 

  673. 

  674. 	/**
    675. 

  675. 	 * Generate documentation of a Module
    676. 

  676. 	 *
    677. 

  677. 	 * @param 	string	$module		Module name
    678. 

  678. 	 * @return	int					<0 if KO, >0 if OK
    679. 

  679. 	 */
    680. 

  680. 	public function generateDoc($module)
    681. 

  681. 	{
    682. 

  682. 		global $conf, $langs, $user, $mysoc;
    683. 

  683. 		global $dirins;
    684. 

  684. 

  685. 		$error = 0;
    686. 

  686. 

  687. 		$modulelowercase = strtolower($module);
    688. 

  688. 		$now = dol_now();
    689. 

  689. 

  690. 		// Dir for module
    691. 

  691. 		$dir = $dirins.'/'.$modulelowercase;
    692. 

  692. 		// Zip file to build
    693. 

  693. 		$FILENAMEDOC = '';
    694. 

  694. 

  695. 		// Load module
    696. 

  696. 		dol_include_once($modulelowercase.'/core/modules/mod'.$module.'.class.php');
    697. 

  697. 		$class = 'mod'.$module;
    698. 

  698. 

  699. 		if (class_exists($class)) {
    700. 

  700. 			try {
    701. 

  701. 				$moduleobj = new $class($this->db);
    702. 

  702. 			} catch (Exception $e) {
    703. 

  703. 				$error++;
    704. 

  704. 				dol_print_error($e->getMessage());
    705. 

  705. 			}
    706. 

  706. 		} else {
    707. 

  707. 			$error++;
    708. 

  708. 			$langs->load("errors");
    709. 

  709. 			dol_print_error($langs->trans("ErrorFailedToLoadModuleDescriptorForXXX", $module));
    710. 

  710. 			exit;
    711. 

  711. 		}
    712. 

  712. 

  713. 		$arrayversion = explode('.', $moduleobj->version, 3);
    714. 

  714. 		if (count($arrayversion)) {
    715. 

  715. 			$FILENAMEASCII = strtolower($module).'.asciidoc';
    716. 

  716. 			$FILENAMEDOC = strtolower($module).'.html';
    717. 

  717. 			$FILENAMEDOCPDF = strtolower($module).'.pdf';
    718. 

  718. 

  719. 			$dirofmodule = dol_buildpath(strtolower($module), 0);
    720. 

  720. 			$dirofmoduledoc = dol_buildpath(strtolower($module), 0).'/doc';
    721. 

  721. 			$dirofmoduletmp = dol_buildpath(strtolower($module), 0).'/doc/temp';
    722. 

  722. 			$outputfiledoc = $dirofmoduledoc.'/'.$FILENAMEDOC;
    723. 

  723. 			if ($dirofmoduledoc) {
    724. 

  724. 				if (!dol_is_dir($dirofmoduledoc)) {
    725. 

  725. 					dol_mkdir($dirofmoduledoc);
    726. 

  726. 				}
    727. 

  727. 				if (!dol_is_dir($dirofmoduletmp)) {
    728. 

  728. 					dol_mkdir($dirofmoduletmp);
    729. 

  729. 				}
    730. 

  730. 				if (!is_writable($dirofmoduletmp)) {
    731. 

  731. 					$this->error = 'Dir '.$dirofmoduletmp.' does not exists or is not writable';
    732. 

  732. 					return -1;
    733. 

  733. 				}
    734. 

  734. 

  735. 				if (empty($conf->global->MODULEBUILDER_ASCIIDOCTOR) && empty($conf->global->MODULEBUILDER_ASCIIDOCTORPDF)) {
    736. 

  736. 					$this->error = 'Setup of module ModuleBuilder not complete';
    737. 

  737. 					return -1;
    738. 

  738. 				}
    739. 

  739. 

  740. 				// Copy some files into temp directory, so instruction include::ChangeLog.md[] will works inside the asciidoc file.
    741. 

  741. 				dol_copy($dirofmodule.'/README.md', $dirofmoduletmp.'/README.md', 0, 1);
    742. 

  742. 				dol_copy($dirofmodule.'/ChangeLog.md', $dirofmoduletmp.'/ChangeLog.md', 0, 1);
    743. 

  743. 

  744. 				// Replace into README.md and ChangeLog.md (in case they are included into documentation with tag __README__ or __CHANGELOG__)
    745. 

  745. 				$arrayreplacement = array();
    746. 

  746. 				$arrayreplacement['/^#\s.*/m'] = ''; // Remove first level of title into .md files
    747. 

  747. 				$arrayreplacement['/^#/m'] = '##'; // Add on # to increase level
    748. 

  748. 

  749. 				dolReplaceInFile($dirofmoduletmp.'/README.md', $arrayreplacement, '', 0, 0, 1);
    750. 

  750. 				dolReplaceInFile($dirofmoduletmp.'/ChangeLog.md', $arrayreplacement, '', 0, 0, 1);
    751. 

  751. 

  752. 

  753. 				$destfile = $dirofmoduletmp.'/'.$FILENAMEASCII;
    754. 

  754. 

  755. 				$fhandle = fopen($destfile, 'w+');
    756. 

  756. 				if ($fhandle) {
    757. 

  757. 					$specs = dol_dir_list(dol_buildpath(strtolower($module).'/doc', 0), 'files', 1, '(\.md|\.asciidoc)$', array('\/temp\/'));
    758. 

  758. 

  759. 					$i = 0;
    760. 

  760. 					foreach ($specs as $spec) {
    761. 

  761. 						if (preg_match('/notindoc/', $spec['relativename'])) {
    762. 

  762. 							continue; // Discard file
    763. 

  763. 						}
    764. 

  764. 						if (preg_match('/example/', $spec['relativename'])) {
    765. 

  765. 							continue; // Discard file
    766. 

  766. 						}
    767. 

  767. 						if (preg_match('/disabled/', $spec['relativename'])) {
    768. 

  768. 							continue; // Discard file
    769. 

  769. 						}
    770. 

  770. 

  771. 						$pathtofile = strtolower($module).'/doc/'.$spec['relativename'];
    772. 

  772. 						$format = 'asciidoc';
    773. 

  773. 						if (preg_match('/\.md$/i', $spec['name'])) {
    774. 

  774. 							$format = 'markdown';
    775. 

  775. 						}
    776. 

  776. 

  777. 						$filecursor = @file_get_contents($spec['fullname']);
    778. 

  778. 						if ($filecursor) {
    779. 

  779. 							fwrite($fhandle, ($i ? "\n<<<\n\n" : "").$filecursor."\n");
    780. 

  780. 						} else {
    781. 

  781. 							$this->error = 'Failed to concat content of file '.$spec['fullname'];
    782. 

  782. 							return -1;
    783. 

  783. 						}
    784. 

  784. 

  785. 						$i++;
    786. 

  786. 					}
    787. 

  787. 

  788. 					fclose($fhandle);
    789. 

  789. 

  790. 					$contentreadme = file_get_contents($dirofmoduletmp.'/README.md');
    791. 

  791. 					$contentchangelog = file_get_contents($dirofmoduletmp.'/ChangeLog.md');
    792. 

  792. 

  793. 					include DOL_DOCUMENT_ROOT.'/core/lib/parsemd.lib.php';
    794. 

  794. 

  795. 					//var_dump($phpfileval['fullname']);
    796. 

  796. 					$arrayreplacement = array(
    797. 

  797. 						'mymodule'=>strtolower($module),
    798. 

  798. 						'MyModule'=>$module,
    799. 

  799. 						'MYMODULE'=>strtoupper($module),
    800. 

  800. 						'My module'=>$module,
    801. 

  801. 						'my module'=>$module,
    802. 

  802. 						'Mon module'=>$module,
    803. 

  803. 						'mon module'=>$module,
    804. 

  804. 						'htdocs/modulebuilder/template'=>strtolower($module),
    805. 

  805. 						'__MYCOMPANY_NAME__'=>$mysoc->name,
    806. 

  806. 						'__KEYWORDS__'=>$module,
    807. 

  807. 						'__USER_FULLNAME__'=>$user->getFullName($langs),
    808. 

  808. 						'__USER_EMAIL__'=>$user->email,
    809. 

  809. 						'__YYYY-MM-DD__'=>dol_print_date($now, 'dayrfc'),
    810. 

  810. 						'---Put here your own copyright and developer email---'=>dol_print_date($now, 'dayrfc').' '.$user->getFullName($langs).($user->email ? ' <'.$user->email.'>' : ''),
    811. 

  811. 						'__DATA_SPECIFICATION__'=>'Not yet available',
    812. 

  812. 						'__README__'=>dolMd2Asciidoc($contentreadme),
    813. 

  813. 						'__CHANGELOG__'=>dolMd2Asciidoc($contentchangelog),
    814. 

  814. 					);
    815. 

  815. 

  816. 					dolReplaceInFile($destfile, $arrayreplacement);
    817. 

  817. 				}
    818. 

  818. 

  819. 				// Launch doc generation
    820. 

  820. 				$currentdir = getcwd();
    821. 

  821. 				chdir($dirofmodule);
    822. 

  822. 

  823. 				require_once DOL_DOCUMENT_ROOT.'/core/class/utils.class.php';
    824. 

  824. 				$utils = new Utils($this->db);
    825. 

  825. 

  826. 				// Build HTML doc
    827. 

  827. 				$command = $conf->global->MODULEBUILDER_ASCIIDOCTOR.' '.$destfile.' -n -o '.$dirofmoduledoc.'/'.$FILENAMEDOC;
    828. 

  828. 				$outfile = $dirofmoduletmp.'/out.tmp';
    829. 

  829. 

  830. 				$resarray = $utils->executeCLI($command, $outfile);
    831. 

  831. 				if ($resarray['result'] != '0') {
    832. 

  832. 					$this->error = $resarray['error'].' '.$resarray['output'];
    833. 

  833. 				}
    834. 

  834. 				$result = ($resarray['result'] == 0) ? 1 : 0;
    835. 

  835. 

  836. 				// Build PDF doc
    837. 

  837. 				$command = $conf->global->MODULEBUILDER_ASCIIDOCTORPDF.' '.$destfile.' -n -o '.$dirofmoduledoc.'/'.$FILENAMEDOCPDF;
    838. 

  838. 				$outfile = $dirofmoduletmp.'/outpdf.tmp';
    839. 

  839. 				$resarray = $utils->executeCLI($command, $outfile);
    840. 

  840. 				if ($resarray['result'] != '0') {
    841. 

  841. 					$this->error = $resarray['error'].' '.$resarray['output'];
    842. 

  842. 				}
    843. 

  843. 				$result = ($resarray['result'] == 0) ? 1 : 0;
    844. 

  844. 

  845. 				chdir($currentdir);
    846. 

  846. 			} else {
    847. 

  847. 				$result = 0;
    848. 

  848. 			}
    849. 

  849. 

  850. 			if ($result > 0) {
    851. 

  851. 				return 1;
    852. 

  852. 			} else {
    853. 

  853. 				$error++;
    854. 

  854. 				$langs->load("errors");
    855. 

  855. 				$this->error = $langs->trans("ErrorFailToGenerateFile", $outputfiledoc);
    856. 

  856. 			}
    857. 

  857. 		} else {
    858. 

  858. 			$error++;
    859. 

  859. 			$langs->load("errors");
    860. 

  860. 			$this->error = $langs->trans("ErrorCheckVersionIsDefined");
    861. 

  861. 		}
    862. 

  862. 

  863. 		return -1;
    864. 

  864. 	}
    865. 

  865. 

  866. 	/**
    867. 

  867. 	 * This saves syslog files and compresses older ones.
    868. 

  868. 	 * Nb of archive to keep is defined into $conf->global->SYSLOG_FILE_SAVES
    869. 

  869. 	 * CAN BE A CRON TASK
    870. 

  870. 	 *
    871. 

  871. 	 * @return	int						0 if OK, < 0 if KO
    872. 

  872. 	 */
    873. 

  873. 	public function compressSyslogs()
    874. 

  874. 	{
    875. 

  875. 		global $conf;
    876. 

  876. 

  877. 		if (empty($conf->loghandlers['mod_syslog_file'])) { // File Syslog disabled
    878. 

  878. 			return 0;
    879. 

  879. 		}
    880. 

  880. 

  881. 		if (!function_exists('gzopen')) {
    882. 

  882. 			$this->error = 'Support for gzopen not available in this PHP';
    883. 

  883. 			return -1;
    884. 

  884. 		}
    885. 

  885. 

  886. 		dol_include_once('/core/lib/files.lib.php');
    887. 

  887. 

  888. 		$nbSaves = empty($conf->global->SYSLOG_FILE_SAVES) ? 10 : intval($conf->global->SYSLOG_FILE_SAVES);
    889. 

  889. 

  890. 		if (empty($conf->global->SYSLOG_FILE)) {
    891. 

  891. 			$mainlogdir = DOL_DATA_ROOT;
    892. 

  892. 			$mainlog = 'dolibarr.log';
    893. 

  893. 		} else {
    894. 

  894. 			$mainlogfull = str_replace('DOL_DATA_ROOT', DOL_DATA_ROOT, $conf->global->SYSLOG_FILE);
    895. 

  895. 			$mainlogdir = dirname($mainlogfull);
    896. 

  896. 			$mainlog = basename($mainlogfull);
    897. 

  897. 		}
    898. 

  898. 

  899. 		$tabfiles = dol_dir_list(DOL_DATA_ROOT, 'files', 0, '^(dolibarr_.+|odt2pdf)\.log$'); // Also handle other log files like dolibarr_install.log
    900. 

  900. 		$tabfiles[] = array('name' => $mainlog, 'path' => $mainlogdir);
    901. 

  901. 

  902. 		foreach ($tabfiles as $file) {
    903. 

  903. 			$logname = $file['name'];
    904. 

  904. 			$logpath = $file['path'];
    905. 

  905. 

  906. 			if (dol_is_file($logpath.'/'.$logname) && dol_filesize($logpath.'/'.$logname) > 0) {	// If log file exists and is not empty
    907. 

  907. 				// Handle already compressed files to rename them and add +1
    908. 

  908. 

  909. 				$filter = '^'.preg_quote($logname, '/').'\.([0-9]+)\.gz$';
    910. 

  910. 

  911. 				$gzfilestmp = dol_dir_list($logpath, 'files', 0, $filter);
    912. 

  912. 				$gzfiles = array();
    913. 

  913. 

  914. 				foreach ($gzfilestmp as $gzfile) {
    915. 

  915. 					$tabmatches = array();
    916. 

  916. 					preg_match('/'.$filter.'/i', $gzfile['name'], $tabmatches);
    917. 

  917. 

  918. 					$numsave = intval($tabmatches[1]);
    919. 

  919. 

  920. 					$gzfiles[$numsave] = $gzfile;
    921. 

  921. 				}
    922. 

  922. 

  923. 				krsort($gzfiles, SORT_NUMERIC);
    924. 

  924. 

  925. 				foreach ($gzfiles as $numsave => $dummy) {
    926. 

  926. 					if (dol_is_file($logpath.'/'.$logname.'.'.($numsave + 1).'.gz')) {
    927. 

  927. 						return -2;
    928. 

  928. 					}
    929. 

  929. 

  930. 					if ($numsave >= $nbSaves) {
    931. 

  931. 						dol_delete_file($logpath.'/'.$logname.'.'.$numsave.'.gz', 0, 0, 0, null, false, 0);
    932. 

  932. 					} else {
    933. 

  933. 						dol_move($logpath.'/'.$logname.'.'.$numsave.'.gz', $logpath.'/'.$logname.'.'.($numsave + 1).'.gz', 0, 1, 0, 0);
    934. 

  934. 					}
    935. 

  935. 				}
    936. 

  936. 

  937. 				// Compress current file and recreate it
    938. 

  938. 

  939. 				if ($nbSaves > 0) {			// If $nbSaves is 1, we keep 1 archive .gz file, If 2, we keep 2 .gz files
    940. 

  940. 					$gzfilehandle = gzopen($logpath.'/'.$logname.'.1.gz', 'wb9');
    941. 

  941. 

  942. 					if (empty($gzfilehandle)) {
    943. 

  943. 						$this->error = 'Failted to open file '.$logpath.'/'.$logname.'.1.gz';
    944. 

  944. 						return -3;
    945. 

  945. 					}
    946. 

  946. 

  947. 					$sourcehandle = fopen($logpath.'/'.$logname, 'r');
    948. 

  948. 

  949. 					if (empty($sourcehandle)) {
    950. 

  950. 						$this->error = 'Failed to open file '.$logpath.'/'.$logname;
    951. 

  951. 						return -4;
    952. 

  952. 					}
    953. 

  953. 

  954. 					while (!feof($sourcehandle)) {
    955. 

  955. 						gzwrite($gzfilehandle, fread($sourcehandle, 512 * 1024)); // Read 512 kB at a time
    956. 

  956. 					}
    957. 

  957. 

  958. 					fclose($sourcehandle);
    959. 

  959. 					gzclose($gzfilehandle);
    960. 

  960. 

  961. 					@chmod($logpath.'/'.$logname.'.1.gz', octdec(empty($conf->global->MAIN_UMASK) ? '0664' : $conf->global->MAIN_UMASK));
    962. 

  962. 				}
    963. 

  963. 

  964. 				dol_delete_file($logpath.'/'.$logname, 0, 0, 0, null, false, 0);
    965. 

  965. 

  966. 				// Create empty file
    967. 

  967. 				$newlog = fopen($logpath.'/'.$logname, 'a+');
    968. 

  968. 				fclose($newlog);
    969. 

  969. 

  970. 				//var_dump($logpath.'/'.$logname." - ".octdec(empty($conf->global->MAIN_UMASK)?'0664':$conf->global->MAIN_UMASK));
    971. 

  971. 				@chmod($logpath.'/'.$logname, octdec(empty($conf->global->MAIN_UMASK) ? '0664' : $conf->global->MAIN_UMASK));
    972. 

  972. 			}
    973. 

  973. 		}
    974. 

  974. 

  975. 		$this->output = 'Archive log files (keeping last SYSLOG_FILE_SAVES='.$nbSaves.' files) done.';
    976. 

  976. 		return 0;
    977. 

  977. 	}
    978. 

  978. 

  979. 	/**	Backup the db OR just a table without mysqldump binary, with PHP only (does not require any exec permission)
    980. 

  980. 	 *	Author: David Walsh (http://davidwalsh.name/backup-mysql-database-php)
    981. 

  981. 	 *	Updated and enhanced by Stephen Larroque (lrq3000) and by the many commentators from the blog
    982. 

  982. 	 *	Note about foreign keys constraints: for Dolibarr, since there are a lot of constraints and when imported the tables will be inserted in the dumped order, not in constraints order, then we ABSOLUTELY need to use SET FOREIGN_KEY_CHECKS=0; when importing the sql dump.
    983. 

  983. 	 *	Note2: db2SQL by Howard Yeend can be an alternative, by using SHOW FIELDS FROM and SHOW KEYS FROM we could generate a more precise dump (eg: by getting the type of the field and then precisely outputting the right formatting - in quotes, numeric or null - instead of trying to guess like we are doing now).
    984. 

  984. 	 *
    985. 

  985. 	 *	@param	string	$outputfile		Output file name
    986. 

  986. 	 *	@param	string	$tables			Table name or '*' for all
    987. 

  987. 	 *	@return	int						<0 if KO, >0 if OK
    988. 

  988. 	 */
    989. 

  989. 	public function backupTables($outputfile, $tables = '*')
    990. 

  990. 	{
    991. 

  991. 		global $db, $langs;
    992. 

  992. 		global $errormsg;
    993. 

  993. 

  994. 		// Set to UTF-8
    995. 

  995. 		if (is_a($db, 'DoliDBMysqli')) {
    996. 

  996. 			/** @var DoliDBMysqli $db */
    997. 

  997. 			$db->db->set_charset('utf8');
    998. 

  998. 		} else {
    999. 

  999. 			/** @var DoliDB $db */
    1000. 

  1000. 			$db->query('SET NAMES utf8');
    1001. 

  1001. 			$db->query('SET CHARACTER SET utf8');
    1002. 

  1002. 		}
    1003. 

  1003. 

  1004. 		//get all of the tables
    1005. 

  1005. 		if ($tables == '*') {
    1006. 

  1006. 			$tables = array();
    1007. 

  1007. 			$result = $db->query('SHOW FULL TABLES WHERE Table_type = \'BASE TABLE\'');
    1008. 

  1008. 			while ($row = $db->fetch_row($result)) {
    1009. 

  1009. 				$tables[] = $row[0];
    1010. 

  1010. 			}
    1011. 

  1011. 		} else {
    1012. 

  1012. 			$tables = is_array($tables) ? $tables : explode(',', $tables);
    1013. 

  1013. 		}
    1014. 

  1014. 

  1015. 		//cycle through
    1016. 

  1016. 		$handle = fopen($outputfile, 'w+');
    1017. 

  1017. 		if (fwrite($handle, '') === false) {
    1018. 

  1018. 			$langs->load("errors");
    1019. 

  1019. 			dol_syslog("Failed to open file ".$outputfile, LOG_ERR);
    1020. 

  1020. 			$errormsg = $langs->trans("ErrorFailedToWriteInDir");
    1021. 

  1021. 			return -1;
    1022. 

  1022. 		}
    1023. 

  1023. 

  1024. 		// Print headers and global mysql config vars
    1025. 

  1025. 		$sqlhead = '';
    1026. 

  1026. 		$sqlhead .= "-- ".$db::LABEL." dump via php with Dolibarr ".DOL_VERSION."
    1027. 

  1027. --
    1028. 

  1028. -- Host: ".$db->db->host_info."    Database: ".$db->database_name."
    1029. 

  1029. -- ------------------------------------------------------
    1030. 

  1030. -- Server version	".$db->db->server_info."
    1031. 

  1031. 

  1032. /*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
    1033. 

  1033. /*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
    1034. 

  1034. /*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
    1035. 

  1035. /*!40101 SET NAMES utf8 */;
    1036. 

  1036. /*!40103 SET @OLD_TIME_ZONE=@@TIME_ZONE */;
    1037. 

  1037. /*!40103 SET TIME_ZONE='+00:00' */;
    1038. 

  1038. /*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
    1039. 

  1039. /*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
    1040. 

  1040. /*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
    1041. 

  1041. /*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
    1042. 

  1042. 

  1043. ";
    1044. 

    1045. 

  1045. 		if (GETPOST("nobin_disable_fk")) {
    1046. 

  1046. 			$sqlhead .= "SET FOREIGN_KEY_CHECKS=0;\n";
    1047. 

  1047. 		}
    1048. 

  1048. 		//$sqlhead .= "SET SQL_MODE=\"NO_AUTO_VALUE_ON_ZERO\";\n";
    1049. 

  1049. 		if (GETPOST("nobin_use_transaction")) {
    1050. 

  1050. 			$sqlhead .= "SET AUTOCOMMIT=0;\nSTART TRANSACTION;\n";
    1051. 

  1051. 		}
    1052. 

  1052. 

  1053. 		fwrite($handle, $sqlhead);
    1054. 

  1054. 

  1055. 		$ignore = '';
    1056. 

  1056. 		if (GETPOST("nobin_sql_ignore")) {
    1057. 

  1057. 			$ignore = 'IGNORE ';
    1058. 

  1058. 		}
    1059. 

  1059. 		$delayed = '';
    1060. 

  1060. 		if (GETPOST("nobin_delayed")) {
    1061. 

  1061. 			$delayed = 'DELAYED ';
    1062. 

  1062. 		}
    1063. 

  1063. 

  1064. 		// Process each table and print their definition + their datas
    1065. 

  1065. 		foreach ($tables as $table) {
    1066. 

  1066. 			// Saving the table structure
    1067. 

  1067. 			fwrite($handle, "\n--\n-- Table structure for table `".$table."`\n--\n");
    1068. 

  1068. 

  1069. 			if (GETPOST("nobin_drop")) {
    1070. 

  1070. 				fwrite($handle, "DROP TABLE IF EXISTS `".$table."`;\n"); // Dropping table if exists prior to re create it
    1071. 

  1071. 			}
    1072. 

  1072. 			fwrite($handle, "/*!40101 SET @saved_cs_client     = @@character_set_client */;\n");
    1073. 

  1073. 			fwrite($handle, "/*!40101 SET character_set_client = utf8 */;\n");
    1074. 

  1074. 			$resqldrop = $db->query('SHOW CREATE TABLE '.$table);
    1075. 

  1075. 			$row2 = $db->fetch_row($resqldrop);
    1076. 

  1076. 			if (empty($row2[1])) {
    1077. 

  1077. 				fwrite($handle, "\n-- WARNING: Show create table ".$table." return empy string when it should not.\n");
    1078. 

  1078. 			} else {
    1079. 

  1079. 				fwrite($handle, $row2[1].";\n");
    1080. 

  1080. 				//fwrite($handle,"/*!40101 SET character_set_client = @saved_cs_client */;\n\n");
    1081. 

  1081. 

  1082. 				// Dumping the data (locking the table and disabling the keys check while doing the process)
    1083. 

  1083. 				fwrite($handle, "\n--\n-- Dumping data for table `".$table."`\n--\n");
    1084. 

  1084. 				if (!GETPOST("nobin_nolocks")) {
    1085. 

  1085. 					fwrite($handle, "LOCK TABLES `".$table."` WRITE;\n"); // Lock the table before inserting data (when the data will be imported back)
    1086. 

  1086. 				}
    1087. 

  1087. 				if (GETPOST("nobin_disable_fk")) {
    1088. 

  1088. 					fwrite($handle, "ALTER TABLE `".$table."` DISABLE KEYS;\n");
    1089. 

  1089. 				} else {
    1090. 

  1090. 					fwrite($handle, "/*!40000 ALTER TABLE `".$table."` DISABLE KEYS */;\n");
    1091. 

  1091. 				}
    1092. 

  1092. 

  1093. 				$sql = "SELECT * FROM ".$table; // Here SELECT * is allowed because we don't have definition of columns to take
    1094. 

  1094. 				$result = $db->query($sql);
    1095. 

  1095. 				while ($row = $db->fetch_row($result)) {
    1096. 

  1096. 					// For each row of data we print a line of INSERT
    1097. 

  1097. 					fwrite($handle, "INSERT ".$delayed.$ignore."INTO ".$table." VALUES (");
    1098. 

  1098. 					$columns = count($row);
    1099. 

  1099. 					for ($j = 0; $j < $columns; $j++) {
    1100. 

  1100. 						// Processing each columns of the row to ensure that we correctly save the value (eg: add quotes for string - in fact we add quotes for everything, it's easier)
    1101. 

  1101. 						if ($row[$j] == null && !is_string($row[$j])) {
    1102. 

  1102. 							// IMPORTANT: if the field is NULL we set it NULL
    1103. 

  1103. 							$row[$j] = 'NULL';
    1104. 

  1104. 						} elseif (is_string($row[$j]) && $row[$j] == '') {
    1105. 

  1105. 							// if it's an empty string, we set it as an empty string
    1106. 

  1106. 							$row[$j] = "''";
    1107. 

  1107. 						} elseif (is_numeric($row[$j]) && !strcmp($row[$j], $row[$j] + 0)) { // test if it's a numeric type and the numeric version ($nb+0) == string version (eg: if we have 01, it's probably not a number but rather a string, else it would not have any leading 0)
    1108. 

  1108. 							// if it's a number, we return it as-is
    1109. 

  1109. 							//	                    $row[$j] = $row[$j];
    1110. 

  1110. 						} else { // else for all other cases we escape the value and put quotes around
    1111. 

  1111. 							$row[$j] = addslashes($row[$j]);
    1112. 

  1112. 							$row[$j] = preg_replace("#\n#", "\\n", $row[$j]);
    1113. 

  1113. 							$row[$j] = "'".$row[$j]."'";
    1114. 

  1114. 						}
    1115. 

  1115. 					}
    1116. 

  1116. 					fwrite($handle, implode(',', $row).");\n");
    1117. 

  1117. 				}
    1118. 

  1118. 				if (GETPOST("nobin_disable_fk")) {
    1119. 

  1119. 					fwrite($handle, "ALTER TABLE `".$table."` ENABLE KEYS;\n"); // Enabling back the keys/index checking
    1120. 

  1120. 				}
    1121. 

  1121. 				if (!GETPOST("nobin_nolocks")) {
    1122. 

  1122. 					fwrite($handle, "UNLOCK TABLES;\n"); // Unlocking the table
    1123. 

  1123. 				}
    1124. 

  1124. 				fwrite($handle, "\n\n\n");
    1125. 

  1125. 			}
    1126. 

  1126. 		}
    1127. 

  1127. 

  1128. 		/* Backup Procedure structure*/
    1129. 

  1129. 		/*
    1130. 

  1130. 		 $result = $db->query('SHOW PROCEDURE STATUS');
    1131. 

  1131. 		 if ($db->num_rows($result) > 0)
    1132. 

  1132. 		 {
    1133. 

  1133. 		 while ($row = $db->fetch_row($result)) { $procedures[] = $row[1]; }
    1134. 

  1134. 		 foreach($procedures as $proc)
    1135. 

  1135. 		 {
    1136. 

  1136. 		 fwrite($handle,"DELIMITER $$\n\n");
    1137. 

  1137. 		 fwrite($handle,"DROP PROCEDURE IF EXISTS '$name'.'$proc'$$\n");
    1138. 

  1138. 		 $resqlcreateproc=$db->query("SHOW CREATE PROCEDURE '$proc'");
    1139. 

  1139. 		 $row2 = $db->fetch_row($resqlcreateproc);
    1140. 

  1140. 		 fwrite($handle,"\n".$row2[2]."$$\n\n");
    1141. 

  1141. 		 fwrite($handle,"DELIMITER ;\n\n");
    1142. 

  1142. 		 }
    1143. 

  1143. 		 }
    1144. 

  1144. 		 */
    1145. 

  1145. 		/* Backup Procedure structure*/
    1146. 

  1146. 

  1147. 		// Write the footer (restore the previous database settings)
    1148. 

  1148. 		$sqlfooter = "\n\n";
    1149. 

  1149. 		if (GETPOST("nobin_use_transaction")) {
    1150. 

  1150. 			$sqlfooter .= "COMMIT;\n";
    1151. 

  1151. 		}
    1152. 

  1152. 		if (GETPOST("nobin_disable_fk")) {
    1153. 

  1153. 			$sqlfooter .= "SET FOREIGN_KEY_CHECKS=1;\n";
    1154. 

  1154. 		}
    1155. 

  1155. 		$sqlfooter .= "\n\n-- Dump completed on ".date('Y-m-d G-i-s');
    1156. 

  1156. 		fwrite($handle, $sqlfooter);
    1157. 

  1157. 

  1158. 		fclose($handle);
    1159. 

  1159. 

  1160. 		return 1;
    1161. 

  1161. 	}
    1162. 

  1162. }
    1163. 

  1163.