backup/lib.php

   1 <?php //$Id$
   2     //This file contains all the general function needed (file manipulation...)
   3     //not directly part of the backup/restore utility
   4
   5     require_once($CFG->dirroot.'/lib/uploadlib.php');
   6
   7     //Sets a name/value pair in backup_config table
   8     function backup_set_config($name, $value) {
   9         if (get_field("backup_config", "name", "name", $name)) {
  10             return set_field("backup_config", "value", addslashes($value), "name", $name);
  11         } else {
  12             $config = new object();
  13             $config->name = $name;
  14             $config->value = addslashes($value);
  15             return insert_record("backup_config", $config);
  16         }
  17     }
  18
  19     //Gets all the information from backup_config table
  20     function backup_get_config() {
  21         $backup_config = null;
  22         if ($configs = get_records("backup_config")) {
  23             foreach ($configs as $config) {
  24                 $backup_config[$config->name] = $config->value;
  25             }
  26         }
  27         return (object)$backup_config;
  28     }
  29
  30     //Delete old data in backup tables (if exists)
  31     //Four hours seem to be appropiate now that backup is stable
  32     function backup_delete_old_data() {
  33
  34         global $CFG;
  35
  36         //Change this if you want !!
  37         $hours = 4;
  38         //End change this
  39         $seconds = $hours * 60 * 60;
  40         $delete_from = time()-$seconds;
  41         //Now delete from tables
  42         $status = execute_sql("DELETE FROM {$CFG->prefix}backup_ids
  43                                WHERE backup_code < '$delete_from'",false);
  44         if ($status) {
  45             $status = execute_sql("DELETE FROM {$CFG->prefix}backup_files
  46                                    WHERE backup_code < '$delete_from'",false);
  47         }
  48         //Now, delete old directory (if exists)
  49         if ($status) {
  50             $status = backup_delete_old_dirs($delete_from);
  51         }
  52         return($status);
  53     }
  54
  55     //Function to delete dirs/files into temp/backup directory
  56     //older than $delete_from
  57     function backup_delete_old_dirs($delete_from) {
  58
  59         global $CFG;
  60
  61         $status = true;
  62         //Get files and directories in the temp backup dir witout descend
  63         $list = get_directory_list($CFG->dataroot."/temp/backup", "", false, true, true);
  64         foreach ($list as $file) {
  65             $file_path = $CFG->dataroot."/temp/backup/".$file;
  66             $moddate = filemtime($file_path);
  67             if ($status && $moddate < $delete_from) {
  68                 //If directory, recurse
  69                 if (is_dir($file_path)) {
  70                     $status = delete_dir_contents($file_path);
  71                     //There is nothing, delete the directory itself
  72                     if ($status) {
  73                         $status = rmdir($file_path);
  74                     }
  75                 //If file
  76                 } else {
  77                     unlink("$file_path");
  78                 }
  79             }
  80         }
  81
  82         return $status;
  83     }
  84
  85     //Function to check and create the needed dir to
  86     //save all the backup
  87     function check_and_create_backup_dir($backup_unique_code) {
  88
  89         global $CFG;
  90
  91         $status = check_dir_exists($CFG->dataroot."/temp",true);
  92         if ($status) {
  93             $status = check_dir_exists($CFG->dataroot."/temp/backup",true);
  94         }
  95         if ($status) {
  96             $status = check_dir_exists($CFG->dataroot."/temp/backup/".$backup_unique_code,true);
  97         }
  98
  99         return $status;
 100     }
 101
 102     //Function to delete all the directory contents recursively
 103     //it supports a excluded dit too
 104     //Copied from the web !!
 105     function delete_dir_contents ($dir,$excludeddir="") {
 106
 107         if (!is_dir($dir)) {
 108             // if we've been given a directory that doesn't exist yet, return true.
 109             // this happens when we're trying to clear out a course that has only just
 110             // been created.
 111             return true;
 112         }
 113         $slash = "/";
 114
 115         // Create arrays to store files and directories
 116         $dir_files      = array();
 117         $dir_subdirs    = array();
 118
 119         // Make sure we can delete it
 120         chmod($dir, 0777);
 121
 122         if ((($handle = opendir($dir))) == FALSE) {
 123             // The directory could not be opened
 124             return false;
 125         }
 126
 127         // Loop through all directory entries, and construct two temporary arrays containing files and sub directories
 128         while($entry = readdir($handle)) {
 129             if (is_dir($dir. $slash .$entry) && $entry != ".." && $entry != "." && $entry != $excludeddir) {
 130                 $dir_subdirs[] = $dir. $slash .$entry;
 131             }
 132             else if ($entry != ".." && $entry != "." && $entry != $excludeddir) {
 133                 $dir_files[] = $dir. $slash .$entry;
 134             }
 135         }
 136
 137         // Delete all files in the curent directory return false and halt if a file cannot be removed
 138         for($i=0; $i<count($dir_files); $i++) {
 139             chmod($dir_files[$i], 0777);
 140             if (((unlink($dir_files[$i]))) == FALSE) {
 141                 return false;
 142             }
 143         }
 144
 145         // Empty sub directories and then remove the directory
 146         for($i=0; $i<count($dir_subdirs); $i++) {
 147             chmod($dir_subdirs[$i], 0777);
 148             if (delete_dir_contents($dir_subdirs[$i]) == FALSE) {
 149                 return false;
 150             }
 151             else {
 152                 if (rmdir($dir_subdirs[$i]) == FALSE) {
 153                 return false;
 154                 }
 155             }
 156         }
 157
 158         // Close directory
 159         closedir($handle);
 160
 161         // Success, every thing is gone return true
 162         return true;
 163     }
 164
 165     //Function to clear (empty) the contents of the backup_dir
 166     function clear_backup_dir($backup_unique_code) {
 167
 168         global $CFG;
 169
 170         $rootdir = $CFG->dataroot."/temp/backup/".$backup_unique_code;
 171
 172         //Delete recursively
 173         $status = delete_dir_contents($rootdir);
 174
 175         return $status;
 176     }
 177
 178     //Returns the module type of a course_module's id in a course
 179     function get_module_type ($courseid,$moduleid) {
 180
 181         global $CFG;
 182
 183         $results = get_records_sql ("SELECT cm.id, m.name
 184                                     FROM {$CFG->prefix}course_modules cm,
 185                                          {$CFG->prefix}modules m
 186                                     WHERE cm.course = '$courseid' AND
 187                                           cm.id = '$moduleid' AND
 188                                           m.id = cm.module");
 189
 190         if ($results) {
 191             $name = $results[$moduleid]->name;
 192         } else {
 193             $name = false;
 194         }
 195         return $name;
 196     }
 197
 198     //This function return the names of all directories under a give directory
 199     //Not recursive
 200     function list_directories ($rootdir) {
 201
 202         $results = null;
 203
 204         $dir = opendir($rootdir);
 205         while ($file=readdir($dir)) {
 206             if ($file=="." || $file=="..") {
 207                 continue;
 208             }
 209             if (is_dir($rootdir."/".$file)) {
 210                 $results[$file] = $file;
 211             }
 212         }
 213         closedir($dir);
 214         return $results;
 215     }
 216
 217     //This function return the names of all directories and files under a give directory
 218     //Not recursive
 219     function list_directories_and_files ($rootdir) {
 220
 221         $results = "";
 222
 223         $dir = opendir($rootdir);
 224         while ($file=readdir($dir)) {
 225             if ($file=="." || $file=="..") {
 226                 continue;
 227             }
 228             $results[$file] = $file;
 229         }
 230         closedir($dir);
 231         return $results;
 232     }
 233
 234     //This function clean data from backup tables and
 235     //delete all temp files used
 236     function clean_temp_data ($preferences) {
 237
 238         global $CFG;
 239
 240         $status = true;
 241
 242         //true->do it, false->don't do it. To debug if necessary.
 243         if (true) {
 244             //Now delete from tables
 245             $status = execute_sql("DELETE FROM {$CFG->prefix}backup_ids
 246                                    WHERE backup_code = '$preferences->backup_unique_code'",false);
 247             if ($status) {
 248                 $status = execute_sql("DELETE FROM {$CFG->prefix}backup_files
 249                                        WHERE backup_code = '$preferences->backup_unique_code'",false);
 250             }
 251             //Now, delete temp directory (if exists)
 252             $file_path = $CFG->dataroot."/temp/backup/".$preferences->backup_unique_code;
 253             if (is_dir($file_path)) {
 254                 $status = delete_dir_contents($file_path);
 255                 //There is nothing, delete the directory itself
 256                 if ($status) {
 257                     $status = rmdir($file_path);
 258                 }
 259             }
 260         }
 261         return $status;
 262     }
 263
 264     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 265     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 266     //This functions are used to copy any file or directory ($from_file)
 267     //to a new file or directory ($to_file). It works recursively and
 268     //mantains file perms.
 269     //I've copied it from: http://www.php.net/manual/en/function.copy.php
 270     //Little modifications done
 271
 272     function backup_copy_file ($from_file,$to_file,$log_clam=false) {
 273
 274         global $CFG;
 275
 276         if (is_file($from_file)) {
 277             //echo "<br />Copying ".$from_file." to ".$to_file;              //Debug
 278             //$perms=fileperms($from_file);
 279             //return copy($from_file,$to_file) && chmod($to_file,$perms);
 280             umask(0000);
 281             if (copy($from_file,$to_file)) {
 282                 chmod($to_file,$CFG->directorypermissions);
 283                 if (!empty($log_clam)) {
 284                     clam_log_upload($to_file,null,true);
 285                 }
 286                 return true;
 287             }
 288             return false;
 289         }
 290         else if (is_dir($from_file)) {
 291             return backup_copy_dir($from_file,$to_file);
 292         }
 293         else{
 294             //echo "<br />Error: not file or dir ".$from_file;               //Debug
 295             return false;
 296         }
 297     }
 298
 299     function backup_copy_dir($from_file,$to_file) {
 300
 301         global $CFG;
 302
 303         $status = true; // Initialize this, next code will change its value if needed
 304
 305         if (!is_dir($to_file)) {
 306             //echo "<br />Creating ".$to_file;                                //Debug
 307             umask(0000);
 308             $status = mkdir($to_file,$CFG->directorypermissions);
 309         }
 310         $dir = opendir($from_file);
 311         while ($file=readdir($dir)) {
 312             if ($file=="." || $file=="..") {
 313                 continue;
 314             }
 315             $status = backup_copy_file ("$from_file/$file","$to_file/$file");
 316         }
 317         closedir($dir);
 318         return $status;
 319     }
 320     ///Ends copy file/dirs functions
 321     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 322     // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 323
 324
 325     function upgrade_backup_db($continueto) {
 326     /// This function upgrades the backup tables, if necessary
 327     /// It's called from admin/index.php, also backup.php and restore.php
 328
 329         global $CFG, $db;
 330
 331         require_once ("$CFG->dirroot/backup/version.php");  // Get code versions
 332
 333         if (empty($CFG->backup_version)) {                  // Backup has never been installed.
 334             $strdatabaseupgrades = get_string("databaseupgrades");
 335             $navlinks = array();
 336             $navlinks[] = array('name' => $strdatabaseupgrades, 'link' => null, 'type' => 'misc');
 337             $navigation = build_navigation($navlinks);
 338
 339             print_header($strdatabaseupgrades, $strdatabaseupgrades, $navigation, "",
 340                     upgrade_get_javascript(), false, "&nbsp;", "&nbsp;");
 341
 342             upgrade_log_start();
 343             print_heading('backup');
 344             $db->debug=true;
 345
 346         /// Both old .sql files and new install.xml are supported
 347         /// but we priorize install.xml (XMLDB) if present
 348             $status = false;
 349             if (file_exists($CFG->dirroot . '/backup/db/install.xml')) {
 350                 $status = install_from_xmldb_file($CFG->dirroot . '/backup/db/install.xml'); //New method
 351             } else if (file_exists($CFG->dirroot . '/backup/db/' . $CFG->dbtype . '.sql')) {
 352                 $status = modify_database($CFG->dirroot . '/backup/db/' . $CFG->dbtype . '.sql'); //Old method
 353             }
 354
 355             $db->debug = false;
 356             if ($status) {
 357                 if (set_config("backup_version", $backup_version) and set_config("backup_release", $backup_release)) {
 358                     //initialize default backup settings now
 359                     $adminroot = admin_get_root();
 360                     apply_default_settings($adminroot->locate('backups'));
 361                     notify(get_string("databasesuccess"), "green");
 362                     notify(get_string("databaseupgradebackups", "", $backup_version), "green");
 363                     print_continue($continueto);
 364                     print_footer('none');
 365                     exit;
 366                 } else {
 367                     error("Upgrade of backup system failed! (Could not update version in config table)");
 368                 }
 369             } else {
 370                 error("Backup tables could NOT be set up successfully!");
 371             }
 372         }
 373
 374     /// Upgrading code starts here
 375         $oldupgrade = false;
 376         $newupgrade = false;
 377         if (is_readable($CFG->dirroot . '/backup/db/' . $CFG->dbtype . '.php')) {
 378             include_once($CFG->dirroot . '/backup/db/' . $CFG->dbtype . '.php');  // defines old upgrading function
 379             $oldupgrade = true;
 380         }
 381         if (is_readable($CFG->dirroot . '/backup/db/upgrade.php')) {
 382             include_once($CFG->dirroot . '/backup/db/upgrade.php');  // defines new upgrading function
 383             $newupgrade = true;
 384         }
 385
 386         if ($backup_version > $CFG->backup_version) {       // Upgrade tables
 387             $strdatabaseupgrades = get_string("databaseupgrades");
 388             $navigation = array(array('name' => $strdatabaseupgrades, 'link' => null, 'type' => 'misc'));
 389             print_header($strdatabaseupgrades, $strdatabaseupgrades, build_navigation($navigation), '', upgrade_get_javascript());
 390
 391             upgrade_log_start();
 392             print_heading('backup');
 393
 394         /// Run de old and new upgrade functions for the module
 395             $oldupgrade_function = 'backup_upgrade';
 396             $newupgrade_function = 'xmldb_backup_upgrade';
 397
 398         /// First, the old function if exists
 399             $oldupgrade_status = true;
 400             if ($oldupgrade && function_exists($oldupgrade_function)) {
 401                 $db->debug = true;
 402                 $oldupgrade_status = $oldupgrade_function($CFG->backup_version);
 403             } else if ($oldupgrade) {
 404                 notify ('Upgrade function ' . $oldupgrade_function . ' was not available in ' .
 405                         '/backup/db/' . $CFG->dbtype . '.php');
 406             }
 407
 408         /// Then, the new function if exists and the old one was ok
 409             $newupgrade_status = true;
 410             if ($newupgrade && function_exists($newupgrade_function) && $oldupgrade_status) {
 411                 $db->debug = true;
 412                 $newupgrade_status = $newupgrade_function($CFG->backup_version);
 413             } else if ($newupgrade) {
 414                 notify ('Upgrade function ' . $newupgrade_function . ' was not available in ' .
 415                         '/backup/db/upgrade.php');
 416             }
 417
 418             $db->debug=false;
 419         /// Now analyze upgrade results
 420             if ($oldupgrade_status && $newupgrade_status) {    // No upgrading failed
 421                 if (set_config("backup_version", $backup_version) and set_config("backup_release", $backup_release)) {
 422                     notify(get_string("databasesuccess"), "green");
 423                     notify(get_string("databaseupgradebackups", "", $backup_version), "green");
 424                     print_continue($continueto);
 425                     print_footer('none');
 426                     exit;
 427                 } else {
 428                     error("Upgrade of backup system failed! (Could not update version in config table)");
 429                 }
 430             } else {
 431                 error("Upgrade failed!  See backup/version.php");
 432             }
 433
 434         } else if ($backup_version < $CFG->backup_version) {
 435             upgrade_log_start();
 436             notify("WARNING!!!  The code you are using is OLDER than the version that made these databases!");
 437         }
 438         upgrade_log_finish();
 439     }
 440
 441
 442     //This function is used to insert records in the backup_ids table
 443     //If the info field is greater than max_db_storage, then its info
 444     //is saved to filesystem
 445     function backup_putid ($backup_unique_code, $table, $old_id, $new_id, $info="") {
 446
 447         global $CFG;
 448
 449         $max_db_storage = 128;  //Max bytes to save to db, else save to file
 450
 451         $status = true;
 452
 453         //First delete to avoid PK duplicates
 454         $status = backup_delid($backup_unique_code, $table, $old_id);
 455
 456         //Now, serialize info
 457         $info_ser = serialize($info);
 458
 459         //Now, if the size of $info_ser > $max_db_storage, save it to filesystem and
 460         //insert a "infile" in the info field
 461
 462         if (strlen($info_ser) > $max_db_storage) {
 463             //Calculate filename (in current_backup_dir, $backup_unique_code_$table_$old_id.info)
 464             $filename = $CFG->dataroot."/temp/backup/".$backup_unique_code."/".$backup_unique_code."_".$table."_".$old_id.".info";
 465             //Save data to file
 466             $status = backup_data2file($filename,$info_ser);
 467             //Set info_to save
 468             $info_to_save = "infile";
 469         } else {
 470             //Saving to db, addslashes
 471             $info_to_save = addslashes($info_ser);
 472         }
 473
 474         //Now, insert the record
 475         if ($status) {
 476             //Build the record
 477             $rec = new object();
 478             $rec->backup_code = $backup_unique_code;
 479             $rec->table_name = $table;
 480             $rec->old_id = $old_id;
 481             $rec->new_id = ($new_id === null? 0 : $new_id);
 482             $rec->info = $info_to_save;
 483
 484             if (!insert_record('backup_ids', $rec, false)) {
 485                 $status = false;
 486             }
 487         }
 488         return $status;
 489     }
 490
 491     //This function is used to delete recods from the backup_ids table
 492     //If the info field is "infile" then the file is deleted too
 493     function backup_delid ($backup_unique_code, $table, $old_id) {
 494
 495         global $CFG;
 496
 497         $status = true;
 498
 499         $status = execute_sql("DELETE FROM {$CFG->prefix}backup_ids
 500                                WHERE backup_code = $backup_unique_code AND
 501                                      table_name = '$table' AND
 502                                      old_id = '$old_id'",false);
 503         return $status;
 504     }
 505
 506     //This function is used to get a record from the backup_ids table
 507     //If the info field is "infile" then its info
 508     //is read from filesystem
 509     function backup_getid ($backup_unique_code, $table, $old_id) {
 510
 511         global $CFG;
 512
 513         $status = true;
 514         $status2 = true;
 515
 516         $status = get_record ("backup_ids","backup_code",$backup_unique_code,
 517                                            "table_name",$table,
 518                                            "old_id", $old_id);
 519
 520         //If info field = "infile", get file contents
 521         if (!empty($status->info) && $status->info == "infile") {
 522             $filename = $CFG->dataroot."/temp/backup/".$backup_unique_code."/".$backup_unique_code."_".$table."_".$old_id.".info";
 523             //Read data from file
 524             $status2 = backup_file2data($filename,$info);
 525             if ($status2) {
 526                 //unserialize data
 527                 $status->info = unserialize($info);
 528             } else {
 529                 $status = false;
 530             }
 531         } else {
 532             //Only if status (record exists)
 533             if ($status) {
 534                 ////First strip slashes
 535                 $temp = stripslashes($status->info);
 536                 //Now unserialize
 537                 $status->info = unserialize($temp);
 538             }
 539         }
 540
 541         return $status;
 542     }
 543
 544     //This function is used to add slashes (and decode from UTF-8 if needed)
 545     //It's used intensivelly when restoring modules and saving them in db
 546     function backup_todb ($data) {
 547         // MDL-10770
 548         if ($data === '$@NULL@$') {
 549             return null;
 550         } else {
 551             return restore_decode_absolute_links(addslashes($data));
 552         }
 553     }
 554
 555     //This function is used to check that every necessary function to
 556     //backup/restore exists in the current php installation. Thanks to
 557     //gregb@crowncollege.edu by the idea.
 558     function backup_required_functions($justcheck=false) {
 559
 560         if(!function_exists('utf8_encode')) {
 561             if (empty($justcheck)) {
 562                 error('You need to add XML support to your PHP installation');
 563             } else {
 564                 return false;
 565             }
 566         }
 567
 568         return true;
 569     }
 570
 571     //This function send n white characters to the browser and flush the
 572     //output buffer. Used to avoid browser timeouts and to show the progress.
 573     function backup_flush($n=0,$time=false) {
 574         if (defined('RESTORE_SILENTLY_NOFLUSH')) {
 575             return;
 576         }
 577         if ($time) {
 578             $ti = strftime("%X",time());
 579         } else {
 580             $ti = "";
 581         }
 582         echo str_repeat(" ", $n) . $ti . "\n";
 583         flush();
 584     }
 585
 586     //This function creates the filename and write data to it
 587     //returning status as result
 588     function backup_data2file ($file,&$data) {
 589
 590         $status = true;
 591         $status2 = true;
 592
 593         $f = fopen($file,"w");
 594         $status = fwrite($f,$data);
 595         $status2 = fclose($f);
 596
 597         return ($status && $status2);
 598     }
 599
 600     //This function read the filename and read data from it
 601     function backup_file2data ($file,&$data) {
 602
 603         $status = true;
 604         $status2 = true;
 605
 606         $f = fopen($file,"r");
 607         $data = fread ($f,filesize($file));
 608         $status2 = fclose($f);
 609
 610         return ($status && $status2);
 611     }
 612
 613     /** this function will restore an entire backup.zip into the specified course
 614      * using standard moodle backup/restore functions, but silently.
 615      * @param string $pathtofile the absolute path to the backup file.
 616      * @param int $destinationcourse the course id to restore to.
 617      * @param boolean $emptyfirst whether to delete all coursedata first.
 618      * @param boolean $userdata whether to include any userdata that may be in the backup file.
 619      * @param array $preferences optional, 0 will be used.  Can contain:
 620      *   metacourse
 621      *   logs
 622      *   course_files
 623      *   messages
 624      */
 625     function import_backup_file_silently($pathtofile,$destinationcourse,$emptyfirst=false,$userdata=false, $preferences=array()) {
 626         global $CFG,$SESSION,$USER; // is there such a thing on cron? I guess so..
 627         global $restore; // ick
 628         if (empty($USER)) {
 629             $USER = get_admin();
 630             $USER->admin = 1; // not sure why, but this doesn't get set
 631         }
 632
 633         define('RESTORE_SILENTLY',true); // don't output all the stuff to us.
 634
 635         $debuginfo = 'import_backup_file_silently: ';
 636         $cleanupafter = false;
 637         $errorstr = ''; // passed by reference to restore_precheck to get errors from.
 638
 639         if (!$course = get_record('course','id',$destinationcourse)) {
 640             mtrace($debuginfo.'Course with id $destinationcourse was not a valid course!');
 641             return false;
 642         }
 643
 644         // first check we have a valid file.
 645         if (!file_exists($pathtofile) || !is_readable($pathtofile)) {
 646             mtrace($debuginfo.'File '.$pathtofile.' either didn\'t exist or wasn\'t readable');
 647             return false;
 648         }
 649
 650         // now make sure it's a zip file
 651         require_once($CFG->dirroot.'/lib/filelib.php');
 652         $filename = substr($pathtofile,strrpos($pathtofile,'/')+1);
 653         $mimetype = mimeinfo("type", $filename);
 654         if ($mimetype != 'application/zip') {
 655             mtrace($debuginfo.'File '.$pathtofile.' was of wrong mimetype ('.$mimetype.')' );
 656             return false;
 657         }
 658
 659         // restore_precheck wants this within dataroot, so lets put it there if it's not already..
 660         if (strstr($pathtofile,$CFG->dataroot) === false) {
 661             // first try and actually move it..
 662             if (!check_dir_exists($CFG->dataroot.'/temp/backup/',true)) {
 663                 mtrace($debuginfo.'File '.$pathtofile.' outside of dataroot and couldn\'t move it! ');
 664                 return false;
 665             }
 666             if (!copy($pathtofile,$CFG->dataroot.'/temp/backup/'.$filename)) {
 667                 mtrace($debuginfo.'File '.$pathtofile.' outside of dataroot and couldn\'t move it! ');
 668                 return false;
 669             } else {
 670                 $pathtofile = 'temp/backup/'.$filename;
 671                 $cleanupafter = true;
 672             }
 673         } else {
 674             // it is within dataroot, so take it off the path for restore_precheck.
 675             $pathtofile = substr($pathtofile,strlen($CFG->dataroot.'/'));
 676         }
 677
 678         if (!backup_required_functions()) {
 679             mtrace($debuginfo.'Required function check failed (see backup_required_functions)');
 680             return false;
 681         }
 682
 683         @ini_set("max_execution_time","3000");
 684         raise_memory_limit("192M");
 685
 686         if (!$backup_unique_code = restore_precheck($destinationcourse,$pathtofile,$errorstr,true)) {
 687             mtrace($debuginfo.'Failed restore_precheck (error was '.$errorstr.')');
 688             return false;
 689         }
 690
 691         $SESSION->restore = new StdClass;
 692
 693         // add on some extra stuff we need...
 694         $SESSION->restore->metacourse   = $restore->metacourse = (isset($preferences['restore_metacourse']) ? $preferences['restore_metacourse'] : 0);
 695         $SESSION->restore->restoreto    = $restore->restoreto = 1;
 696         $SESSION->restore->users        = $restore->users = $userdata;
 697         $SESSION->restore->logs         = $restore->logs = (isset($preferences['restore_logs']) ? $preferences['restore_logs'] : 0);
 698         $SESSION->restore->user_files   = $restore->user_files = $userdata;
 699         $SESSION->restore->messages     = $restore->messages = (isset($preferences['restore_messages']) ? $preferences['restore_messages'] : 0);
 700         $SESSION->restore->course_id    = $restore->course_id = $destinationcourse;
 701         $SESSION->restore->restoreto    = 1;
 702         $SESSION->restore->course_id    = $destinationcourse;
 703         $SESSION->restore->deleting     = $emptyfirst;
 704         $SESSION->restore->restore_course_files = $restore->course_files = (isset($preferences['restore_course_files']) ? $preferences['restore_course_files'] : 0);
 705         $SESSION->restore->backup_version = $SESSION->info->backup_backup_version;
 706         $SESSION->restore->course_startdateoffset = $course->startdate - $SESSION->course_header->course_startdate;
 707
 708         restore_setup_for_check($SESSION->restore,$backup_unique_code);
 709
 710         // maybe we need users (defaults to 2 in restore_setup_for_check)
 711         if (!empty($userdata)) {
 712             $SESSION->restore->users = 1;
 713         }
 714
 715         // we also need modules...
 716         if ($allmods = get_records("modules")) {
 717             foreach ($allmods as $mod) {
 718                 $modname = $mod->name;
 719                 //Now check that we have that module info in the backup file
 720                 if (isset($SESSION->info->mods[$modname]) && $SESSION->info->mods[$modname]->backup == "true") {
 721                     $SESSION->restore->mods[$modname]->restore = true;
 722                     $SESSION->restore->mods[$modname]->userinfo = $userdata;
 723                 }
 724                 else {
 725                     // avoid warnings
 726                     $SESSION->restore->mods[$modname]->restore = false;
 727                     $SESSION->restore->mods[$modname]->userinfo = false;
 728                 }
 729             }
 730         }
 731         $restore = clone($SESSION->restore);
 732         if (!restore_execute($SESSION->restore,$SESSION->info,$SESSION->course_header,$errorstr)) {
 733             mtrace($debuginfo.'Failed restore_execute (error was '.$errorstr.')');
 734             return false;
 735         }
 736         return true;
 737     }
 738
 739     /**
 740     * Function to backup an entire course silently and create a zipfile.
 741     *
 742     * @param int $courseid the id of the course
 743     * @param array $prefs see {@link backup_generate_preferences_artificially}
 744     */
 745     function backup_course_silently($courseid, $prefs, &$errorstring) {
 746         global $CFG, $preferences; // global preferences here because something else wants it :(
 747         define('BACKUP_SILENTLY', 1);
 748         if (!$course = get_record('course', 'id', $courseid)) {
 749             debugging("Couldn't find course with id $courseid in backup_course_silently");
 750             return false;
 751         }
 752         $preferences = backup_generate_preferences_artificially($course, $prefs);
 753         if (backup_execute($preferences, $errorstring)) {
 754             return $CFG->dataroot . '/' . $course->id . '/backupdata/' . $preferences->backup_name;
 755         }
 756         else {
 757             return false;
 758         }
 759     }
 760
 761     /**
 762     * Function to generate the $preferences variable that
 763     * backup uses.  This will back up all modules and instances in a course.
 764     *
 765     * @param object $course course object
 766     * @param array $prefs can contain:
 767             backup_metacourse
 768             backup_users
 769             backup_logs
 770             backup_user_files
 771             backup_course_files
 772             backup_site_files
 773             backup_messages
 774     * and if not provided, they will not be included.
 775     */
 776
 777     function backup_generate_preferences_artificially($course, $prefs) {
 778         global $CFG;
 779         $preferences = new StdClass;
 780         $preferences->backup_unique_code = time();
 781         $preferences->backup_name = backup_get_zipfile_name($course, $preferences->backup_unique_code);
 782         $count = 0;
 783
 784         if ($allmods = get_records("modules") ) {
 785             foreach ($allmods as $mod) {
 786                 $modname = $mod->name;
 787                 $modfile = "$CFG->dirroot/mod/$modname/backuplib.php";
 788                 $modbackup = $modname."_backup_mods";
 789                 $modbackupone = $modname."_backup_one_mod";
 790                 $modcheckbackup = $modname."_check_backup_mods";
 791                 if (!file_exists($modfile)) {
 792                     continue;
 793                 }
 794                 include_once($modfile);
 795                 if (!function_exists($modbackup) || !function_exists($modcheckbackup)) {
 796                     continue;
 797                 }
 798                 $var = "exists_".$modname;
 799                 $preferences->$var = true;
 800                 $count++;
 801                 // check that there are instances and we can back them up individually
 802                 if (!count_records('course_modules','course',$course->id,'module',$mod->id) || !function_exists($modbackupone)) {
 803                     continue;
 804                 }
 805                 $var = 'exists_one_'.$modname;
 806                 $preferences->$var = true;
 807                 $varname = $modname.'_instances';
 808                 $preferences->$varname = get_all_instances_in_course($modname, $course, NULL, true);
 809                 foreach ($preferences->$varname as $instance) {
 810                     $preferences->mods[$modname]->instances[$instance->id]->name = $instance->name;
 811                     $var = 'backup_'.$modname.'_instance_'.$instance->id;
 812                     $preferences->$var = true;
 813                     $preferences->mods[$modname]->instances[$instance->id]->backup = true;
 814                     $var = 'backup_user_info_'.$modname.'_instance_'.$instance->id;
 815                     $preferences->$var = true;
 816                     $preferences->mods[$modname]->instances[$instance->id]->userinfo = true;
 817                     $var = 'backup_'.$modname.'_instances';
 818                     $preferences->$var = 1; // we need this later to determine what to display in modcheckbackup.
 819                 }
 820
 821                 //Check data
 822                 //Check module info
 823                 $preferences->mods[$modname]->name = $modname;
 824
 825                 $var = "backup_".$modname;
 826                 $preferences->$var = true;
 827                 $preferences->mods[$modname]->backup = true;
 828
 829                 //Check include user info
 830                 $var = "backup_user_info_".$modname;
 831                 $preferences->$var = true;
 832                 $preferences->mods[$modname]->userinfo = true;
 833
 834             }
 835         }
 836
 837         //Check other parameters
 838         $preferences->backup_metacourse = (isset($prefs['backup_metacourse']) ? $prefs['backup_metacourse'] : 0);
 839         $preferences->backup_users = (isset($prefs['backup_users']) ? $prefs['backup_users'] : 0);
 840         $preferences->backup_logs = (isset($prefs['backup_logs']) ? $prefs['backup_logs'] : 0);
 841         $preferences->backup_user_files = (isset($prefs['backup_user_files']) ? $prefs['backup_user_files'] : 0);
 842         $preferences->backup_course_files = (isset($prefs['backup_course_files']) ? $prefs['backup_course_files'] : 0);
 843         $preferences->backup_site_files = (isset($prefs['backup_site_files']) ? $prefs['backup_site_files'] : 0);
 844         $preferences->backup_messages = (isset($prefs['backup_messages']) ? $prefs['backup_messages'] : 0);
 845         $preferences->backup_course = $course->id;
 846         backup_add_static_preferences($preferences);
 847         return $preferences;
 848     }
 849
 850
 851 ?>