1: <?php
  2: 
  3: /* * *************************************************************************
  4: 
  5:   pseudo-cron v1.2.1.con // modified version for CONTENIDO
  6:   (c) 2003 Kai Blankenhorn
  7:   www.bitfolge.de/en
  8:   kaib@bitfolge.de
  9: 
 10:   This program is free software; you can redistribute it and/or
 11:   modify it under the terms of the GNU General Public License
 12:   as published by the Free Software Foundation; either version 2
 13:   of the License, or (at your option) any later version.
 14: 
 15:   This program is distributed in the hope that it will be useful,
 16:   but WITHOUT ANY WARRANTY; without even the implied warranty of
 17:   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 18:   GNU General Public License for more details.
 19: 
 20:   You should have received a copy of the GNU General Public License
 21:   along with this program; if not, write to the Free Software
 22:   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 23: 
 24:  * ***************************************************************************
 25: 
 26: 
 27:   Usually regular tasks like backup up the site's database are run using cron
 28:   jobs. With cron jobs, you can exactly plan when a certain command is to be
 29:   executed. But most homepage owners can't create cron jobs on their web
 30:   server - providers demand some extra money for that.
 31:   The only thing that's certain to happen quite regularly on a web page are
 32:   page requests. This is where pseudo-cron comes into play: With every page
 33:   request it checks if any cron jobs should have been run since the previous
 34:   request. If there are, they are run and logged.
 35: 
 36:   Pseudo-cron uses a syntax very much like the Unix cron's one. For an
 37:   overview of the syntax used, see a page of the UNIXGEEKS. The syntax
 38:   pseudo-cron uses is different from the one described on that page in
 39:   the following points:
 40: 
 41:   -  there is no user column
 42:   -  the executed command has to be an include()able file (which may contain further PHP code)
 43: 
 44: 
 45:   All job definitions are made in a text file on the server with a
 46:   user-definable name. A valid command line in this file is, for example:
 47: 
 48:  *   2   1,15   *   *   samplejob.inc.php
 49: 
 50:   This runs samplejob.inc.php at 2am on the 1st and 15th of each month.
 51: 
 52: 
 53:   Features:
 54:   -  runs any PHP script
 55:   -  periodical or time-controlled script execution
 56:   -  logs all executed jobs
 57:   -  can be run from an IMG tag in an HTML page
 58:   -  follow Unix cron syntax for crontabs
 59: 
 60: 
 61:   Usage:
 62:   -  Modify the variables in the config section below to match your server.
 63:   -  Write a PHP script that does the job you want to be run regularly. Be
 64:   sure that any paths in it are relative to the script that will run
 65:   pseudo-cron in the end.
 66:   -  Set up your crontab file with your script
 67:   -  Wait for the next scheduled run :)
 68: 
 69: 
 70:   Note:
 71:   You can log messages to pseudo-cron's log file by calling
 72:   logMessage("log a message", $PC_writeDir, $PC_useLog, $PC_debug);
 73: 
 74: 
 75:   Changelog:
 76: 
 77:   v1.2.1.con   11-28-03
 78:   changed: removed all global variables
 79:   changed: renamed intern variables
 80:   changed: intern function calls
 81:   changed: extended debug information
 82:   modified by horwath@opensa.org
 83: 
 84:   v1.2.1   02-03-03
 85:   fixed:    jobs may be run too often under certain conditions
 86:   added:    global debug switch
 87:   changed: typo in imagecron.php which prevented it from working
 88: 
 89: 
 90:   v1.2   01-31-03
 91:   added:   more documentation
 92:   changed: log file should now be easier to use
 93:   changed: log file name
 94: 
 95: 
 96:   v1.1   01-29-03
 97:   changed: renamed pseudo-cron.php to pseudo-cron.inc.php
 98:   fixed:   comments at the end of a line don't work
 99:   fixed:   empty lines in crontab file create nonsense jobs
100:   changed: log file grows big very quickly
101:   changed: included config file in main file to avoid directory confusion
102:   added:   day of week abbreviations may now be used (three letters, english)
103: 
104: 
105:   v1.0   01-17-03
106:   inital release
107: 
108:  * ************************************************************************* */
109: 
110: defined('CON_FRAMEWORK') || die('Illegal call: Missing framework initialization - request aborted.');
111: 
112: 
113: /* * ************************************* */
114: /*      config section               */
115: /* * ************************************* */
116: 
117: // || PLEASE NOTE:
118: // || all paths used here and in cron scripts
119: // || must be absolute or relative to the script which includes pseudo-cron.inc.php!
120: // the file that contains the job descriptions
121: // for a description of the format, see http://www.unixgeeks.org/security/newbie/unix/cron-1.html
122: // and http://www.bitfolge.de/pseudocron
123: $PC_cronTab = $cfg['path']['contenido_cronlog'] . 'crontab.txt';
124: $PC_localCronTab = $cfg['path']['contenido_cronlog'] . 'crontab.local.txt';
125: 
126: // the directory where the script can store information on completed jobs and its log file
127: // include trailing slash
128: $PC_writeDir = $cfg['path']['contenido_cronlog'];
129: 
130: // the directory where the script can store information on completed jobs and its log file
131: // include trailing slash
132: $PC_jobDir = cRegistry::getBackendPath() . $cfg['path']['cronjobs'];
133: 
134: // store directory information
135: $PC_reqDir = getcwd();
136: 
137: // control logging, 1=use log file, 0=don't use log file
138: $PC_useLog = 1;
139: 
140: // turn on / off debugging output
141: // DO NOT use this on live servers!
142: $PC_debug = false;
143: 
144: /* * ************************************* */
145: /*      don't change anything here      */
146: /* * ************************************* */
147: 
148: define("PC_MINUTE", 1);
149: define("PC_HOUR", 2);
150: define("PC_DOM", 3);
151: define("PC_MONTH", 4);
152: define("PC_DOW", 5);
153: define("PC_CMD", 7);
154: define("PC_CRONLINE", 8);
155: 
156: if ($PC_debug) {
157:     echo "<pre>Configuration:";
158:     echo "\nPC_cronTab = " . $PC_cronTab;
159:     echo "\nPC_writeDir = " . $PC_writeDir;
160:     echo "\nPC_jobDir = " . $PC_jobDir;
161:     echo "\nPC_reqDir = " . $PC_reqDir;
162:     echo "\nPC_useLog = " . $PC_useLog;
163:     echo "\n";
164: }
165: 
166: global $bJobRunned;
167: 
168: $bJobRunned = false;
169: 
170: chdir($PC_jobDir);
171: $PC_jobs = parseCronFile($PC_cronTab, $PC_debug);
172: 
173: for ($i = 0; $i < count($PC_jobs); $i++) {
174:     $bJobRunned = true;
175:     runJob($PC_jobs[$i], $PC_jobDir, $PC_writeDir, $PC_useLog, $PC_debug);
176: }
177: 
178: $PC_jobs = parseCronFile($PC_localCronTab, $PC_debug);
179: for ($i = 0; $i < count($PC_jobs); $i++) {
180:     $bJobRunned = true;
181:     runJob($PC_jobs[$i], $PC_jobDir, $PC_writeDir, $PC_useLog, $PC_debug);
182: }
183: chdir($PC_reqDir);
184: 
185: if ($PC_debug) {
186:     echo "\n</pre>";
187: }
188: 
189: function logMessage($msg, $PC_writeDir, $PC_useLog, $PC_debug) {
190:     if ($PC_useLog == 1) {
191:         $logfile = $PC_writeDir . "pseudo-cron.log";
192: 
193:         if (is_writable($logfile)) {
194:             $file = fopen($logfile, "ab");
195:             if ($msg[strlen($msg) - 1] != "\n") {
196:                 $msg.="\r\n";
197:             }
198:             if ($PC_debug) {
199:                 echo $msg;
200:             }
201:             fputs($file, date("r", time()) . "  " . $msg);
202:             fclose($file);
203:         }
204:     }
205: }
206: 
207: function lTrimZeros($number) {
208:     while ($number[0] == '0') {
209:         $number = substr($number, 1);
210:     }
211:     return $number;
212: }
213: 
214: function parseElement($element, &$targetArray, $numberOfElements) {
215:     $subelements = explode(",", $element);
216:     for ($i = 0; $i < $numberOfElements; $i++) {
217:         $targetArray[$i] = $subelements[0] == "*";
218:     }
219: 
220:     for ($i = 0; $i < count($subelements); $i++) {
221:         if (preg_match("~^(\\*|([0-9]{1,2})(-([0-9]{1,2}))?)(/([0-9]{1,2}))?$~", $subelements[$i], $matches)) {
222:             if ($matches[1] == "*") {
223:                 $matches[2] = 0;      // from
224:                 $matches[4] = $numberOfElements;      //to
225:             } elseif (!array_key_exists(4, $matches) || $matches[4] == "") {
226:                 $matches[4] = $matches[2];
227:             }
228:             if (array_key_exists(5, $matches)) {
229:                 if ($matches[5][0] != "/") {
230:                     $matches[6] = 1;      // step
231:                 }
232:             } else {
233:                 $matches[6] = 1;      // step
234:             }
235:             for ($j = lTrimZeros($matches[2]); $j <= lTrimZeros($matches[4]); $j+=lTrimZeros($matches[6])) {
236:                 $targetArray[$j] = TRUE;
237:             }
238:         }
239:     }
240: }
241: 
242: function decDate(&$dateArr, $amount, $unit, $PC_debug) {
243:     if ($PC_debug) {
244:         echo sprintf("Decreasing from %02d.%02d. %02d:%02d by %d %6s ", $dateArr['mday'], $dateArr['mon'], $dateArr['hours'], $dateArr['minutes'], $amount, $unit);
245:     }
246:     if ($unit == "mday") {
247:         $dateArr["hours"] = 23;
248:         $dateArr["minutes"] = 59;
249:         $dateArr["seconds"] = 59;
250:         $dateArr["mday"] -= $amount;
251:         $dateArr["wday"] -= $amount % 7;
252:         if ($dateArr["wday"] < 0) {
253:             $dateArr["wday"]+=7;
254:         }
255:         if ($dateArr["mday"] < 1) {
256:             $dateArr["mon"]--;
257:             switch ($dateArr["mon"]) {
258:                 case 0:
259:                     $dateArr["mon"] = 12;
260:                     $dateArr["year"]--;
261:                 // fall through
262:                 case 1:
263:                 case 3:
264:                 case 5:
265:                 case 7:
266:                 case 8:
267:                 case 10:
268:                 case 12:
269:                     $dateArr["mday"] = 31;
270:                     break;
271:                 case 4:
272:                 case 6:
273:                 case 9:
274:                 case 11:
275:                     $dateArr["mday"] = 30;
276:                     break;
277:                 case 2:
278:                     $dateArr["mday"] = 28;
279:                     break;
280:             }
281:         }
282:     } elseif ($unit == "hour") {
283:         if ($dateArr["hours"] == 0) {
284:             decDate($dateArr, 1, "mday", $PC_debug);
285:         } else {
286:             $dateArr["minutes"] = 59;
287:             $dateArr["seconds"] = 59;
288:             $dateArr["hours"]--;
289:         }
290:     } elseif ($unit == "minute") {
291:         if ($dateArr["minutes"] == 0) {
292:             decDate($dateArr, 1, "hour", $PC_debug);
293:         } else {
294:             $dateArr["seconds"] = 59;
295:             $dateArr["minutes"]--;
296:         }
297:     }
298:     if ($PC_debug) {
299:         echo sprintf("to %02d.%02d. %02d:%02d\n", $dateArr[mday], $dateArr[mon], $dateArr[hours], $dateArr[minutes]);
300:     }
301: }
302: 
303: function getLastScheduledRunTime($job, $PC_debug) {
304:     $dateArr = getdate();
305:     $minutesBack = 0;
306:     while (
307:         $minutesBack < 525600 AND
308:         (!$job[PC_MINUTE][$dateArr["minutes"]] OR
309:         !$job[PC_HOUR][$dateArr["hours"]] OR
310:         (!$job[PC_DOM][$dateArr["mday"]] OR !$job[PC_DOW][$dateArr["wday"]]) OR
311:         !$job[PC_MONTH][$dateArr["mon"]])
312:     ) {
313:         if (!$job[PC_DOM][$dateArr["mday"]] OR !$job[PC_DOW][$dateArr["wday"]]) {
314:             decDate($dateArr, 1, "mday", $PC_debug);
315:             $minutesBack+=1440;
316:             continue;
317:         }
318:         if (!$job[PC_HOUR][$dateArr["hours"]]) {
319:             decDate($dateArr, 1, "hour", $PC_debug);
320:             $minutesBack+=60;
321:             continue;
322:         }
323:         if (!$job[PC_MINUTE][$dateArr["minutes"]]) {
324:             decDate($dateArr, 1, "minute", $PC_debug);
325:             $minutesBack++;
326:             continue;
327:         }
328:     }
329: 
330:     if ($PC_debug) {
331:         print_r($dateArr);
332:     }
333: 
334:     return mktime($dateArr["hours"], $dateArr["minutes"], 0, $dateArr["mon"], $dateArr["mday"], $dateArr["year"]);
335: }
336: 
337: function getJobFileName($jobname, $PC_writeDir) {
338:     $jobfile = $PC_writeDir . urlencode($jobname) . ".job";
339:     return $jobfile;
340: }
341: 
342: function getLastActialRunTime($jobname, $PC_writeDir) {
343:     $jobfile = getJobFileName($jobname, $PC_writeDir);
344:     if (cFileHandler::exists($jobfile)) {
345:         $file = fopen($jobfile, "rb");
346:         $lastRun = fgets($file, 100);
347:         fclose($file);
348:         if (is_numeric($lastRun)) {
349:             return $lastRun;
350:         }
351:     }
352:     return 0;
353: }
354: 
355: function markLastRun($jobname, $lastRun, $PC_writeDir) {
356:     $jobfile = getJobFileName($jobname, $PC_writeDir);
357: 
358:     if ($file = @fopen($jobfile, "w")) {
359:         fputs($file, $lastRun);
360:         fclose($file);
361:     } else {
362:         //echo "Could not write into file $jobfile - permission denied.";
363:     }
364: }
365: 
366: function runJob($job, $PC_jobDir, $PC_writeDir, $PC_useLog, $PC_debug = false) {
367:     global $cfg, $sess;
368:     $extjob = Array();
369:     $jobfile = getJobFileName($job[PC_CMD], $PC_writeDir);
370:     parseElement($job[PC_MINUTE], $extjob[PC_MINUTE], 60);
371:     parseElement($job[PC_HOUR], $extjob[PC_HOUR], 24);
372:     parseElement($job[PC_DOM], $extjob[PC_DOM], 31);
373:     parseElement($job[PC_MONTH], $extjob[PC_MONTH], 12);
374:     parseElement($job[PC_DOW], $extjob[PC_DOW], 7);
375: 
376:     $lastActual = getLastActialRunTime($job[PC_CMD], $PC_writeDir);
377:     $lastScheduled = getLastScheduledRunTime($extjob, $PC_debug);
378: 
379:     if ($lastScheduled > $lastActual) {
380:         logMessage("Running    " . $job[PC_CRONLINE], $PC_writeDir, $PC_useLog, $PC_debug);
381:         logMessage("  Last run:       " . date("r", $lastActual), $PC_writeDir, $PC_useLog, $PC_debug);
382:         logMessage("  Last scheduled: " . date("r", $lastScheduled), $PC_writeDir, $PC_useLog, $PC_debug);
383:         markLastRun($job[PC_CMD], $lastScheduled, $PC_writeDir);
384: 
385:         if ($PC_debug) {
386:             echo getcwd();
387:             include($PC_jobDir . $job[PC_CMD]);      // display errors only when debugging
388:         } else {
389:             if (is_object($sess)) {
390:                 $sess->freeze();
391:             }
392:             @include($PC_jobDir . $job[PC_CMD]);      // any error messages are supressed
393:             if (is_object($sess)) {
394:                 $sess->thaw();
395:             }
396:         }
397:         logMessage("Completed   " . $job[PC_CRONLINE], $PC_writeDir, $PC_useLog, $PC_debug);
398:         return true;
399:     } else {
400:         if ($PC_debug) {
401:             logMessage("Skipping    " . $job[PC_CRONLINE], $PC_writeDir, $PC_useLog, $PC_debug);
402:             logMessage("  Last run:       " . date("r", $lastActual), $PC_writeDir, $PC_useLog, $PC_debug);
403:             logMessage("  Last scheduled: " . date("r", $lastScheduled), $PC_writeDir, $PC_useLog, $PC_debug);
404:             logMessage("Completed   " . $job[PC_CRONLINE], $PC_writeDir, $PC_useLog, $PC_debug);
405:         }
406:         return false;
407:     }
408: }
409: 
410: function parseCronFile($PC_cronTabFile, $PC_debug) {
411:     $file = @file($PC_cronTabFile);
412:     $job = Array();
413:     $jobs = Array();
414:     for ($i = 0; $i < count($file); $i++) {
415:         if ($file[$i][0] != '#') {
416: //         old regex, without dow abbreviations:
417: //         if (preg_match("~^([-0-9,/*]+)\\s+([-0-9,/*]+)\\s+([-0-9,/*]+)\\s+([-0-9,/*]+)\\s+([-0-7,/*]+|Sun|Mon|Tue|Wen|Thu|Fri|Sat)\\s+([^#]*)(#.*)?$~i",$file[$i],$job)) {
418:             if (preg_match("~^([-0-9,/*]+)\\s+([-0-9,/*]+)\\s+([-0-9,/*]+)\\s+([-0-9,/*]+)\\s+([-0-7,/*]+|(-|/|Sun|Mon|Tue|Wed|Thu|Fri|Sat)+)\\s+([^#]*)(#.*)?$~i", $file[$i], $job)) {
419:                 $jobNumber = count($jobs);
420:                 $jobs[$jobNumber] = $job;
421:                 if ($jobs[$jobNumber][PC_DOW][0] != '*' AND !is_numeric($jobs[$jobNumber][PC_DOW])) {
422:                     $jobs[$jobNumber][PC_DOW] = str_replace(
423:                             Array("Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"), Array(0, 1, 2, 3, 4, 5, 6), $jobs[$jobNumber][PC_DOW]);
424:                 }
425:                 $jobs[$jobNumber][PC_CMD] = trim($job[PC_CMD]);
426:                 $jobs[$jobNumber][PC_CRONLINE] = $file[$i];
427:             }
428:         }
429:     }
430:     if ($PC_debug) {
431:         var_dump($jobs);
432:     }
433:     return $jobs;
434: }
435: 
436: ?>