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             print_header($strdatabaseupgrades, $strdatabaseupgrades, $strdatabaseupgrades, "",
 336                     upgrade_get_javascript(), false, "&nbsp;", "&nbsp;");
 337
 338             upgrade_log_start();
 339             print_heading('backup');
 340             $db->debug=true;
 341
 342         /// Both old .sql files and new install.xml are supported
 343         /// but we priorize install.xml (XMLDB) if present
 344             $status = false;
 345             if (file_exists($CFG->dirroot . '/backup/db/install.xml')) {
 346                 $status = install_from_xmldb_file($CFG->dirroot . '/backup/db/install.xml'); //New method
 347             } else if (file_exists($CFG->dirroot . '/backup/db/' . $CFG->dbtype . '.sql')) {
 348                 $status = modify_database($CFG->dirroot . '/backup/db/' . $CFG->dbtype . '.sql'); //Old method
 349             }
 350
 351             $db->debug = false;
 352             if ($status) {
 353                 if (set_config("backup_version", $backup_version) and set_config("backup_release", $backup_release)) {
 354                     //initialize default backup settings now
 355                     $adminroot = admin_get_root();
 356                     apply_default_settings($adminroot->locate('backups'));
 357                     notify(get_string("databasesuccess"), "green");
 358                     notify(get_string("databaseupgradebackups", "", $backup_version), "green");
 359                     print_continue($continueto);
 360                     print_footer('none');
 361                     exit;
 362                 } else {
 363                     error("Upgrade of backup system failed! (Could not update version in config table)");
 364                 }
 365             } else {
 366                 error("Backup tables could NOT be set up successfully!");
 367             }
 368         }
 369
 370     /// Upgrading code starts here
 371         $oldupgrade = false;
 372         $newupgrade = false;
 373         if (is_readable($CFG->dirroot . '/backup/db/' . $CFG->dbtype . '.php')) {
 374             include_once($CFG->dirroot . '/backup/db/' . $CFG->dbtype . '.php');  // defines old upgrading function
 375             $oldupgrade = true;
 376         }
 377         if (is_readable($CFG->dirroot . '/backup/db/upgrade.php')) {
 378             include_once($CFG->dirroot . '/backup/db/upgrade.php');  // defines new upgrading function
 379             $newupgrade = true;
 380         }
 381
 382         if ($backup_version > $CFG->backup_version) {       // Upgrade tables
 383             $strdatabaseupgrades = get_string("databaseupgrades");
 384             print_header($strdatabaseupgrades, $strdatabaseupgrades, $strdatabaseupgrades, '', upgrade_get_javascript());
 385
 386             upgrade_log_start();
 387             print_heading('backup');
 388
 389         /// Run de old and new upgrade functions for the module
 390             $oldupgrade_function = 'backup_upgrade';
 391             $newupgrade_function = 'xmldb_backup_upgrade';
 392
 393         /// First, the old function if exists
 394             $oldupgrade_status = true;
 395             if ($oldupgrade && function_exists($oldupgrade_function)) {
 396                 $db->debug = true;
 397                 $oldupgrade_status = $oldupgrade_function($CFG->backup_version);
 398             } else if ($oldupgrade) {
 399                 notify ('Upgrade function ' . $oldupgrade_function . ' was not available in ' .
 400                         '/backup/db/' . $CFG->dbtype . '.php');
 401             }
 402
 403         /// Then, the new function if exists and the old one was ok
 404             $newupgrade_status = true;
 405             if ($newupgrade && function_exists($newupgrade_function) && $oldupgrade_status) {
 406                 $db->debug = true;
 407                 $newupgrade_status = $newupgrade_function($CFG->backup_version);
 408             } else if ($newupgrade) {
 409                 notify ('Upgrade function ' . $newupgrade_function . ' was not available in ' .
 410                         '/backup/db/upgrade.php');
 411             }
 412
 413             $db->debug=false;
 414         /// Now analyze upgrade results
 415             if ($oldupgrade_status && $newupgrade_status) {    // No upgrading failed
 416                 if (set_config("backup_version", $backup_version) and set_config("backup_release", $backup_release)) {
 417                     notify(get_string("databasesuccess"), "green");
 418                     notify(get_string("databaseupgradebackups", "", $backup_version), "green");
 419                     print_continue($continueto);
 420                     print_footer('none');
 421                     exit;
 422                 } else {
 423                     error("Upgrade of backup system failed! (Could not update version in config table)");
 424                 }
 425             } else {
 426                 error("Upgrade failed!  See backup/version.php");
 427             }
 428
 429         } else if ($backup_version < $CFG->backup_version) {
 430             upgrade_log_start();
 431             notify("WARNING!!!  The code you are using is OLDER than the version that made these databases!");
 432         }
 433         upgrade_log_finish();
 434     }
 435
 436
 437     //This function is used to insert records in the backup_ids table
 438     //If the info field is greater than max_db_storage, then its info
 439     //is saved to filesystem
 440     function backup_putid ($backup_unique_code, $table, $old_id, $new_id, $info="") {
 441
 442         global $CFG;
 443
 444         $max_db_storage = 128;  //Max bytes to save to db, else save to file
 445
 446         $status = true;
 447
 448         //First delete to avoid PK duplicates
 449         $status = backup_delid($backup_unique_code, $table, $old_id);
 450
 451         //Now, serialize info
 452         $info_ser = serialize($info);
 453
 454         //Now, if the size of $info_ser > $max_db_storage, save it to filesystem and
 455         //insert a "infile" in the info field
 456
 457         if (strlen($info_ser) > $max_db_storage) {
 458             //Calculate filename (in current_backup_dir, $backup_unique_code_$table_$old_id.info)
 459             $filename = $CFG->dataroot."/temp/backup/".$backup_unique_code."/".$backup_unique_code."_".$table."_".$old_id.".info";
 460             //Save data to file
 461             $status = backup_data2file($filename,$info_ser);
 462             //Set info_to save
 463             $info_to_save = "infile";
 464         } else {
 465             //Saving to db, addslashes
 466             $info_to_save = addslashes($info_ser);
 467         }
 468
 469         //Now, insert the record
 470         if ($status) {
 471             //Build the record
 472             $rec = new object();
 473             $rec->backup_code = $backup_unique_code;
 474             $rec->table_name = $table;
 475             $rec->old_id = $old_id;
 476             $rec->new_id = ($new_id === null? 0 : $new_id);
 477             $rec->info = $info_to_save;
 478
 479             if (!insert_record('backup_ids', $rec, false)) {
 480                 $status = false;
 481             }
 482         }
 483         return $status;
 484     }
 485
 486     //This function is used to delete recods from the backup_ids table
 487     //If the info field is "infile" then the file is deleted too
 488     function backup_delid ($backup_unique_code, $table, $old_id) {
 489
 490         global $CFG;
 491
 492         $status = true;
 493
 494         $status = execute_sql("DELETE FROM {$CFG->prefix}backup_ids
 495                                WHERE backup_code = $backup_unique_code AND
 496                                      table_name = '$table' AND
 497                                      old_id = '$old_id'",false);
 498         return $status;
 499     }
 500
 501     //This function is used to get a record from the backup_ids table
 502     //If the info field is "infile" then its info
 503     //is read from filesystem
 504     function backup_getid ($backup_unique_code, $table, $old_id) {
 505
 506         global $CFG;
 507
 508         $status = true;
 509         $status2 = true;
 510
 511         $status = get_record ("backup_ids","backup_code",$backup_unique_code,
 512                                            "table_name",$table,
 513                                            "old_id", $old_id);
 514
 515         //If info field = "infile", get file contents
 516         if (!empty($status->info) && $status->info == "infile") {
 517             $filename = $CFG->dataroot."/temp/backup/".$backup_unique_code."/".$backup_unique_code."_".$table."_".$old_id.".info";
 518             //Read data from file
 519             $status2 = backup_file2data($filename,$info);
 520             if ($status2) {
 521                 //unserialize data
 522                 $status->info = unserialize($info);
 523             } else {
 524                 $status = false;
 525             }
 526         } else {
 527             //Only if status (record exists)
 528             if ($status) {
 529                 ////First strip slashes
 530                 $temp = stripslashes($status->info);
 531                 //Now unserialize
 532                 $status->info = unserialize($temp);
 533             }
 534         }
 535
 536         return $status;
 537     }
 538
 539     //This function is used to add slashes (and decode from UTF-8 if needed)
 540     //It's used intensivelly when restoring modules and saving them in db
 541     function backup_todb ($data) {
 542         // MDL-10770
 543         if ($data === '$@NULL@$') {
 544             return null;
 545         } else {
 546             return restore_decode_absolute_links(addslashes($data));
 547         }
 548     }
 549
 550     //This function is used to check that every necessary function to
 551     //backup/restore exists in the current php installation. Thanks to
 552     //gregb@crowncollege.edu by the idea.
 553     function backup_required_functions($justcheck=false) {
 554
 555         if(!function_exists('utf8_encode')) {
 556             if (empty($justcheck)) {
 557                 error('You need to add XML support to your PHP installation');
 558             } else {
 559                 return false;
 560             }
 561         }
 562
 563         return true;
 564     }
 565
 566     //This function send n white characters to the browser and flush the
 567     //output buffer. Used to avoid browser timeouts and to show the progress.
 568     function backup_flush($n=0,$time=false) {
 569         if (defined('RESTORE_SILENTLY_NOFLUSH')) {
 570             return;
 571         }
 572         if ($time) {
 573             $ti = strftime("%X",time());
 574         } else {
 575             $ti = "";
 576         }
 577         echo str_repeat(" ", $n) . $ti . "\n";
 578         flush();
 579     }
 580
 581     //This function creates the filename and write data to it
 582     //returning status as result
 583     function backup_data2file ($file,&$data) {
 584
 585         $status = true;
 586         $status2 = true;
 587
 588         $f = fopen($file,"w");
 589         $status = fwrite($f,$data);
 590         $status2 = fclose($f);
 591
 592         return ($status && $status2);
 593     }
 594
 595     //This function read the filename and read data from it
 596     function backup_file2data ($file,&$data) {
 597
 598         $status = true;
 599         $status2 = true;
 600
 601         $f = fopen($file,"r");
 602         $data = fread ($f,filesize($file));
 603         $status2 = fclose($f);
 604
 605         return ($status && $status2);
 606     }
 607
 608     /** this function will restore an entire backup.zip into the specified course
 609      * using standard moodle backup/restore functions, but silently.
 610      * @param string $pathtofile the absolute path to the backup file.
 611      * @param int $destinationcourse the course id to restore to.
 612      * @param boolean $emptyfirst whether to delete all coursedata first.
 613      * @param boolean $userdata whether to include any userdata that may be in the backup file.
 614      * @param array $preferences optional, 0 will be used.  Can contain:
 615      *   metacourse
 616      *   logs
 617      *   course_files
 618      *   messages
 619      */
 620     function import_backup_file_silently($pathtofile,$destinationcourse,$emptyfirst=false,$userdata=false, $preferences=array()) {
 621         global $CFG,$SESSION,$USER; // is there such a thing on cron? I guess so..
 622         global $restore; // ick
 623         if (empty($USER)) {
 624             $USER = get_admin();
 625             $USER->admin = 1; // not sure why, but this doesn't get set
 626         }
 627
 628         define('RESTORE_SILENTLY',true); // don't output all the stuff to us.
 629
 630         $debuginfo = 'import_backup_file_silently: ';
 631         $cleanupafter = false;
 632         $errorstr = ''; // passed by reference to restore_precheck to get errors from.
 633
 634         if (!$course = get_record('course','id',$destinationcourse)) {
 635             mtrace($debuginfo.'Course with id $destinationcourse was not a valid course!');
 636             return false;
 637         }
 638
 639         // first check we have a valid file.
 640         if (!file_exists($pathtofile) || !is_readable($pathtofile)) {
 641             mtrace($debuginfo.'File '.$pathtofile.' either didn\'t exist or wasn\'t readable');
 642             return false;
 643         }
 644
 645         // now make sure it's a zip file
 646         require_once($CFG->dirroot.'/lib/filelib.php');
 647         $filename = substr($pathtofile,strrpos($pathtofile,'/')+1);
 648         $mimetype = mimeinfo("type", $filename);
 649         if ($mimetype != 'application/zip') {
 650             mtrace($debuginfo.'File '.$pathtofile.' was of wrong mimetype ('.$mimetype.')' );
 651             return false;
 652         }
 653
 654         // restore_precheck wants this within dataroot, so lets put it there if it's not already..
 655         if (strstr($pathtofile,$CFG->dataroot) === false) {
 656             // first try and actually move it..
 657             if (!check_dir_exists($CFG->dataroot.'/temp/backup/',true)) {
 658                 mtrace($debuginfo.'File '.$pathtofile.' outside of dataroot and couldn\'t move it! ');
 659                 return false;
 660             }
 661             if (!copy($pathtofile,$CFG->dataroot.'/temp/backup/'.$filename)) {
 662                 mtrace($debuginfo.'File '.$pathtofile.' outside of dataroot and couldn\'t move it! ');
 663                 return false;
 664             } else {
 665                 $pathtofile = 'temp/backup/'.$filename;
 666                 $cleanupafter = true;
 667             }
 668         } else {
 669             // it is within dataroot, so take it off the path for restore_precheck.
 670             $pathtofile = substr($pathtofile,strlen($CFG->dataroot.'/'));
 671         }
 672
 673         if (!backup_required_functions()) {
 674             mtrace($debuginfo.'Required function check failed (see backup_required_functions)');
 675             return false;
 676         }
 677
 678         @ini_set("max_execution_time","3000");
 679         raise_memory_limit("192M");
 680
 681         if (!$backup_unique_code = restore_precheck($destinationcourse,$pathtofile,$errorstr,true)) {
 682             mtrace($debuginfo.'Failed restore_precheck (error was '.$errorstr.')');
 683             return false;
 684         }
 685
 686         $SESSION->restore = new StdClass;
 687
 688         // add on some extra stuff we need...
 689         $SESSION->restore->metacourse   = $restore->metacourse = (isset($preferences['restore_metacourse']) ? $preferences['restore_metacourse'] : 0);
 690         $SESSION->restore->restoreto    = $restore->restoreto = 1;
 691         $SESSION->restore->users        = $restore->users = $userdata;
 692         $SESSION->restore->logs         = $restore->logs = (isset($preferences['restore_logs']) ? $preferences['restore_logs'] : 0);
 693         $SESSION->restore->user_files   = $restore->user_files = $userdata;
 694         $SESSION->restore->messages     = $restore->messages = (isset($preferences['restore_messages']) ? $preferences['restore_messages'] : 0);
 695         $SESSION->restore->course_id    = $restore->course_id = $destinationcourse;
 696         $SESSION->restore->restoreto    = 1;
 697         $SESSION->restore->course_id    = $destinationcourse;
 698         $SESSION->restore->deleting     = $emptyfirst;
 699         $SESSION->restore->restore_course_files = $restore->course_files = (isset($preferences['restore_course_files']) ? $preferences['restore_course_files'] : 0);
 700         $SESSION->restore->backup_version = $SESSION->info->backup_backup_version;
 701         $SESSION->restore->course_startdateoffset = $course->startdate - $SESSION->course_header->course_startdate;
 702
 703         restore_setup_for_check($SESSION->restore,$backup_unique_code);
 704
 705         // maybe we need users (defaults to 2 in restore_setup_for_check)
 706         if (!empty($userdata)) {
 707             $SESSION->restore->users = 1;
 708         }
 709
 710         // we also need modules...
 711         if ($allmods = get_records("modules")) {
 712             foreach ($allmods as $mod) {
 713                 $modname = $mod->name;
 714                 //Now check that we have that module info in the backup file
 715                 if (isset($SESSION->info->mods[$modname]) && $SESSION->info->mods[$modname]->backup == "true") {
 716                     $SESSION->restore->mods[$modname]->restore = true;
 717                     $SESSION->restore->mods[$modname]->userinfo = $userdata;
 718                 }
 719                 else {
 720                     // avoid warnings
 721                     $SESSION->restore->mods[$modname]->restore = false;
 722                     $SESSION->restore->mods[$modname]->userinfo = false;
 723                 }
 724             }
 725         }
 726         $restore = clone($SESSION->restore);
 727         if (!restore_execute($SESSION->restore,$SESSION->info,$SESSION->course_header,$errorstr)) {
 728             mtrace($debuginfo.'Failed restore_execute (error was '.$errorstr.')');
 729             return false;
 730         }
 731         return true;
 732     }
 733
 734     /**
 735     * Function to backup an entire course silently and create a zipfile.
 736     *
 737     * @param int $courseid the id of the course
 738     * @param array $prefs see {@link backup_generate_preferences_artificially}
 739     */
 740     function backup_course_silently($courseid, $prefs, &$errorstring) {
 741         global $CFG, $preferences; // global preferences here because something else wants it :(
 742         define('BACKUP_SILENTLY', 1);
 743         if (!$course = get_record('course', 'id', $courseid)) {
 744             debugging("Couldn't find course with id $courseid in backup_course_silently");
 745             return false;
 746         }
 747         $preferences = backup_generate_preferences_artificially($course, $prefs);
 748         if (backup_execute($preferences, $errorstring)) {
 749             return $CFG->dataroot . '/' . $course->id . '/backupdata/' . $preferences->backup_name;
 750         }
 751         else {
 752             return false;
 753         }
 754     }
 755
 756     /**
 757     * Function to generate the $preferences variable that
 758     * backup uses.  This will back up all modules and instances in a course.
 759     *
 760     * @param object $course course object
 761     * @param array $prefs can contain:
 762             backup_metacourse
 763             backup_users
 764             backup_logs
 765             backup_user_files
 766             backup_course_files
 767             backup_site_files
 768             backup_messages
 769     * and if not provided, they will not be included.
 770     */
 771
 772     function backup_generate_preferences_artificially($course, $prefs) {
 773         global $CFG;
 774         $preferences = new StdClass;
 775         $preferences->backup_unique_code = time();
 776         $preferences->backup_name = backup_get_zipfile_name($course, $preferences->backup_unique_code);
 777         $count = 0;
 778
 779         if ($allmods = get_records("modules") ) {
 780             foreach ($allmods as $mod) {
 781                 $modname = $mod->name;
 782                 $modfile = "$CFG->dirroot/mod/$modname/backuplib.php";
 783                 $modbackup = $modname."_backup_mods";
 784                 $modbackupone = $modname."_backup_one_mod";
 785                 $modcheckbackup = $modname."_check_backup_mods";
 786                 if (!file_exists($modfile)) {
 787                     continue;
 788                 }
 789                 include_once($modfile);
 790                 if (!function_exists($modbackup) || !function_exists($modcheckbackup)) {
 791                     continue;
 792                 }
 793                 $var = "exists_".$modname;
 794                 $preferences->$var = true;
 795                 $count++;
 796                 // check that there are instances and we can back them up individually
 797                 if (!count_records('course_modules','course',$course->id,'module',$mod->id) || !function_exists($modbackupone)) {
 798                     continue;
 799                 }
 800                 $var = 'exists_one_'.$modname;
 801                 $preferences->$var = true;
 802                 $varname = $modname.'_instances';
 803                 $preferences->$varname = get_all_instances_in_course($modname,$course);
 804                 foreach ($preferences->$varname as $instance) {
 805                     $preferences->mods[$modname]->instances[$instance->id]->name = $instance->name;
 806                     $var = 'backup_'.$modname.'_instance_'.$instance->id;
 807                     $preferences->$var = true;
 808                     $preferences->mods[$modname]->instances[$instance->id]->backup = true;
 809                     $var = 'backup_user_info_'.$modname.'_instance_'.$instance->id;
 810                     $preferences->$var = true;
 811                     $preferences->mods[$modname]->instances[$instance->id]->userinfo = true;
 812                     $var = 'backup_'.$modname.'_instances';
 813                     $preferences->$var = 1; // we need this later to determine what to display in modcheckbackup.
 814                 }
 815
 816                 //Check data
 817                 //Check module info
 818                 $preferences->mods[$modname]->name = $modname;
 819
 820                 $var = "backup_".$modname;
 821                 $preferences->$var = true;
 822                 $preferences->mods[$modname]->backup = true;
 823
 824                 //Check include user info
 825                 $var = "backup_user_info_".$modname;
 826                 $preferences->$var = true;
 827                 $preferences->mods[$modname]->userinfo = true;
 828
 829             }
 830         }
 831
 832         //Check other parameters
 833         $preferences->backup_metacourse = (isset($prefs['backup_metacourse']) ? $prefs['backup_metacourse'] : 0);
 834         $preferences->backup_users = (isset($prefs['backup_users']) ? $prefs['backup_users'] : 0);
 835         $preferences->backup_logs = (isset($prefs['backup_logs']) ? $prefs['backup_logs'] : 0);
 836         $preferences->backup_user_files = (isset($prefs['backup_user_files']) ? $prefs['backup_user_files'] : 0);
 837         $preferences->backup_course_files = (isset($prefs['backup_course_files']) ? $prefs['backup_course_files'] : 0);
 838         $preferences->backup_site_files = (isset($prefs['backup_site_files']) ? $prefs['backup_site_files'] : 0);
 839         $preferences->backup_messages = (isset($prefs['backup_messages']) ? $prefs['backup_messages'] : 0);
 840         $preferences->backup_course = $course->id;
 841         backup_add_static_preferences($preferences);
 842         return $preferences;
 843     }
 844
 845
 846 ?>