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