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