?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
disable debug.
[AROS.git] / workbench / c / WaitX.c
blob59da127e488c5540ad68a0e8769d414c15fa65af
1 /*
2 Copyright © 2010, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Execute a command after a given time
6 Lang: English
7 */
8
9 /******************************************************************************
10
11 NAME
12
13 WaitX
14
15 SYNOPSIS
16
17 D=DATE/K,T=TIME/K,YR=YEARS/K/N,MN=MONTHS/K/N,DY=DAYS/K/N,H=HOURS/K/N,
18 M=MINS/K/N,S=SECS/K/N,L=LOOP/K/N,A=ALWAYS/S,V=VERBOSE/S,HELP/S,CMDLINE/F
19
20 LOCATION
21
22 C:
23
24 FUNCTION
25
26 WaitX will wait for a given amount of time and then it
27 will execute the given command.
28
29 INPUTS
30
31 D=DATE -- Waits until DATE has been reached
32 T=TIME -- Waits until TIME has been reached
33 YR=YEARS -- How many years to wait
34 MN=MONTHS -- How many months to wait
35 DY=DAYS -- How many days to wait
36 H=HOURS -- How many hours to wait
37 M=MINS -- How many minutes to wait
38 S=SECS -- How many seconds to wait
39 L=LOOP -- How many times to execute CMDLINE
40 A=ALWAYS -- Execute CMDLINE every set interval/time/date
41 V=VERBOSE -- Print extra info on what waitx is doing
42
43 EXAMPLE
44
45 $ waitx TIME=12:34:12 echo "this is an example"
46 waitx waits until 12:34:12 is reached and will execute echo
47
48 $ waitx H=5 M=36 echo "this is an example"
49 waitx will wait 5 hours and 36 minutes and execute echo
50
51 $ waitx HOURS=2 MINS=12 SECS=59
52 waitx will wait 2 hours, 12 minutes and 59 seconds and then
53 returns to the prompt
54
55 $ waitx DY=1 L=5 echo "this is an example"
56 waitx will wait 1 day and execute echo,
57 then repeat this a total of 5 times
58
59 $ waitx M=15 ALWAYS echo "this is an example"
60 waitx will execute echo every 15 minutes
61
62 $ waitx D=12/9 T=16 L=0 echo "this is an example"
63 waitx will wait until September 12th 16:00 and execute echo,
64 and repeat forever
65
66 $ waitx echo "this is an example"
67 waitx will execute echo immediatly
68
69 RESULT
70
71 NOTES
72
73 Based on Public Domain WaitX:
74 http://aminet.net/package/util/cli/waitx
75 Programming: Sigbjørn Skjæret <cisc@c2i.net>
76 Idea & Docs: Nicholas Stallard <snowy@netphile.de>
77
78 EXAMPLE
79
80 BUGS
81
82 Will not return to prompt while waiting. This is intended.
83
84 SEE ALSO
85
86 INTERNALS
87
88 ******************************************************************************/
89
90 #define __USE_SYSBASE
91 #include <string.h>
92 #include <proto/dos.h>
93 #include <proto/exec.h>
94 #include <exec/memory.h>
95 #include <proto/timer.h>
96 #include <proto/utility.h>
97 #include <utility/date.h>
98
99
100 struct Interval
101 {
102 ULONG set;
103 ULONG years;
104 ULONG months;
105 ULONG seconds;
106 };
107
108 const char Version[] = "$VER: WaitX 2.1 (16.04.2008)";
109
110 int strtoi(STRPTR string);
111
112 LONG MainEntry(struct ExecBase *SysBase);
113
114 __startup static AROS_PROCH(Start, argstr, argsize, sBase)
115 {
116 AROS_PROCFUNC_INIT
117 return MainEntry(sBase);
118 AROS_PROCFUNC_EXIT
119 }
120
121
122 LONG MainEntry(struct ExecBase *SysBase)
123 {
124 struct DosLibrary *DOSBase = NULL;
125 struct UtilityBase *UtilityBase = NULL;
126 struct Library *TimerBase;
127
128 BYTE TimerDevice = -1;
129 struct ClockData *clock = NULL;
130 struct Interval *interval = NULL;
131 struct MsgPort *TimerPort = NULL;
132 struct timerequest *TimerReq = NULL;
133 ULONG i, loop, step, unit, seconds = 0, signal = 0, timesig = 0, usersig = SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E;
134
135 BPTR StdErr = BNULL, StdIn;
136 char ProgName[256];
137 struct RDArgs *rdargs = NULL;
138 STRPTR Template = "D=DATE/K,T=TIME/K,YR=YEARS/K/N,MN=MONTHS/K/N,DY=DAYS/K/N,H=HOURS/K/N,M=MINS/K/N,S=SECS/K/N,L=LOOP/K/N,A=ALWAYS/S,V=VERBOSE/S,HELP/S,CMDLINE/F";
139
140 enum
141 {
142 TEM_DATE,
143 TEM_TIME,
144 TEM_YEARS,
145 TEM_MONTHS,
146 TEM_DAYS,
147 TEM_HOURS,
148 TEM_MINS,
149 TEM_SECS,
150 TEM_LOOP,
151 TEM_ALWAYS,
152 TEM_VERBOSE,
153 TEM_HELP,
154 TEM_CMDLINE,
155 TEM_NUMARGS
156 };
157
158 IPTR ArgArray[TEM_NUMARGS], ret;
159 STRPTR cmdline;
160 STRPTR tmpptr;
161
162 ret = 20; /* Fatal error if something fails here */
163 if (!(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 36)))
164 goto exit;
165 if (!(UtilityBase = (struct UtilityBase *)OpenLibrary("utility.library", 36)))
166 goto exit;
167 if (!(StdErr = Open("CONSOLE:", MODE_NEWFILE)))
168 goto exit;
169 ret = 0; /* Clear return */
170
171 GetProgramName(ProgName, sizeof(ProgName));
172 for (i=0; i<TEM_NUMARGS; ArgArray[i++]=0)
173 ;
174 rdargs = ReadArgs(Template, ArgArray, NULL);
175
176 if (ArgArray[TEM_HELP] || !rdargs)
177 {
178 FPrintf(StdErr, "%s\n\n", &Version[6]);
179 FPrintf(StdErr, "Usage: %s [DATE=<DD/MM/YYYY>] [TIME=<HH:MM:SS>] <commandline>\n", ProgName);
180 FPrintf(StdErr, "Usage: %s [HOURS=<hours>] [MINS=<mins>] [SECS=<secs>] <commandline>\n", ProgName);
181 goto exit;
182 }
183
184 loop = step = 1;
185 if (ArgArray[TEM_LOOP])
186 loop = *((ULONG *)ArgArray[TEM_LOOP]);
187
188 if (ArgArray[TEM_ALWAYS] || loop == 0)
189 {
190 loop = 1;
191 step = 0;
192 }
193
194 if (ArgArray[TEM_CMDLINE])
195 cmdline = (STRPTR)ArgArray[TEM_CMDLINE];
196 else
197 cmdline = ""; /* Prevented from Execute()ing later */
198
199 if (ArgArray[TEM_DATE] || ArgArray[TEM_TIME] || ArgArray[TEM_YEARS] || ArgArray[TEM_MONTHS])
200 {
201 unit = UNIT_WAITUNTIL;
202 if (!(clock = AllocMem(sizeof(struct ClockData), MEMF_PUBLIC | MEMF_CLEAR)))
203 {
204 FPrintf(StdErr, "Unable to allocate needed memory!\n");
205 ret = 10;
206 goto exit;
207 }
208 if (!(interval = AllocMem(sizeof(struct Interval), MEMF_PUBLIC | MEMF_CLEAR)))
209 {
210 FPrintf(StdErr, "Unable to allocate needed memory!\n");
211 ret = 10;
212 goto exit;
213 }
214
215 if (ArgArray[TEM_YEARS])
216 interval->years = *((ULONG *)ArgArray[TEM_YEARS]);
217 if (ArgArray[TEM_MONTHS])
218 interval->months = *((ULONG *)ArgArray[TEM_MONTHS]);
219 if (ArgArray[TEM_DAYS])
220 interval->seconds += *((ULONG *)ArgArray[TEM_DAYS]) * 86400;
221 if (ArgArray[TEM_HOURS])
222 interval->seconds += *((ULONG *)ArgArray[TEM_HOURS]) * 3600;
223 if (ArgArray[TEM_MINS])
224 interval->seconds += *((ULONG *)ArgArray[TEM_MINS]) * 60;
225 if (ArgArray[TEM_SECS])
226 interval->seconds += *((ULONG *)ArgArray[TEM_SECS]);
227
228 if (interval->years || interval->months || interval->seconds)
229 interval->set = 1;
230 }
231 else
232 {
233 unit = UNIT_VBLANK;
234 seconds = 0;
235
236 if (ArgArray[TEM_DAYS])
237 seconds += *((ULONG *)ArgArray[TEM_DAYS]) * 86400;
238 if (ArgArray[TEM_HOURS])
239 seconds += *((ULONG *)ArgArray[TEM_HOURS]) * 3600;
240 if (ArgArray[TEM_MINS])
241 seconds += *((ULONG *)ArgArray[TEM_MINS]) * 60;
242 if (ArgArray[TEM_SECS])
243 seconds += *((ULONG *)ArgArray[TEM_SECS]);
244 }
245
246 if (seconds > 0 || clock)
247 {
248 if (!(TimerPort = CreateMsgPort()))
249 {
250 FPrintf(StdErr, "Couldn't create Timer-MsgPort!\n");
251 ret = 10;
252 goto exit;
253 }
254 if (!(TimerReq = (struct timerequest *)CreateIORequest(TimerPort, sizeof(struct timerequest))))
255 {
256 FPrintf(StdErr, "Couldn't create Timer-IORequest!\n");
257 ret = 10;
258 goto exit;
259 }
260 if ((TimerDevice = OpenDevice(TIMERNAME, unit, (struct IORequest *)TimerReq, 0)))
261 {
262 FPrintf(StdErr, "Couldn't open %s!\n", TIMERNAME);
263 ret = 10;
264 goto exit;
265 }
266
267 TimerBase = (struct Library *)TimerReq->tr_node.io_Device;
268 timesig = 1L << TimerPort->mp_SigBit;
269
270 if (clock)
271 {
272 GetSysTime(&TimerReq->tr_time); /* Get current System Time */
273 Amiga2Date(TimerReq->tr_time.tv_secs, clock); /* Fill in current date/time as default */
274
275 if (ArgArray[TEM_DATE])
276 {
277 tmpptr = (STRPTR)ArgArray[TEM_DATE];
278 clock->mday = strtoi(tmpptr);
279 if ((tmpptr = strstr(tmpptr, "/")))
280 {
281 clock->month = strtoi(++tmpptr);
282 if ((tmpptr = strstr(tmpptr, "/")))
283 {
284 clock->year = strtoi(++tmpptr);
285 }
286 if (!interval->set)
287 {
288 interval->years = 1;
289 interval->set = 1;
290 }
291 }
292 else if (!interval->set)
293 {
294 interval->months = 1;
295 interval->set = 1;
296 }
297
298 if (clock->year < 100) /* Be nice to digit-challenged ppl. ;) */
299 {
300 if (clock->year < 78)
301 clock->year += 2000; /* If less than 78, assume 20xx */
302 else
303 clock->year += 1900;
304 }
305 }
306 else if (!interval->set)
307 {
308 interval->seconds = 86400;
309 interval->set = 1;
310 }
311
312 if (ArgArray[TEM_TIME])
313 {
314 tmpptr = (STRPTR)ArgArray[TEM_TIME];
315 clock->hour = strtoi(tmpptr);
316 clock->min = clock->sec = 0; /* Clear default time */
317 if ((tmpptr = strstr(tmpptr, ":")))
318 {
319 clock->min = strtoi(++tmpptr);
320 if ((tmpptr = strstr(tmpptr, ":")))
321 clock->sec = strtoi(++tmpptr);
322 }
323 }
324
325 if (!(seconds = CheckDate(clock)))
326 {
327 FPrintf(StdErr, "Invalid date/time!\n");
328 ret = 5;
329 goto exit;
330 }
331 if (seconds <= TimerReq->tr_time.tv_secs)
332 {
333 ULONG count = loop;
334
335 for (i=0; i<count; i+=step)
336 {
337 clock->year += interval->years;
338 clock->month += interval->months;
339
340 if (clock->month > 12) /* We need some annual magic */
341 {
342 clock->month %= 12;
343 clock->year += clock->month / 12;
344 }
345
346 if (!(seconds = CheckDate(clock)))
347 {
348 clock->mday -= 1; /* If date doesn't exist, try previous day */
349 if (!(seconds = CheckDate(clock)))
350 {
351 clock->mday -= 1;
352 if (!(seconds = CheckDate(clock)))
353 {
354 clock->mday -= 1;
355 if (!(seconds = CheckDate(clock)))
356 {
357 FPrintf(StdErr, "Invalid date/time!\n");
358 ret = 5;
359 goto exit;
360 } /* Give up */
361 clock->mday += 1;
362 }
363 clock->mday += 1;
364 }
365 clock->mday += 1; /* Restore day for future reference */
366 }
367
368 if (interval->seconds)
369 {
370 seconds += interval->seconds;
371 Amiga2Date(seconds, clock);
372 }
373
374 if (loop > 0 && step > 0)
375 loop--;
376 if (seconds > TimerReq->tr_time.tv_secs)
377 break;
378 }
379
380 if (seconds <= TimerReq->tr_time.tv_secs || loop == 0)
381 {
382 FPrintf(StdErr, "Date/time has already passed!\n");
383 ret = 5;
384 goto exit;
385 }
386 else if (ArgArray[TEM_VERBOSE])
387 {
388 FPrintf(StdErr, "Note: Schedule has been moved to %02lu/%02lu/%lu %02lu:%02lu:%02lu because the assigned date/time has already passed",
389 (ULONG)clock->mday, (ULONG)clock->month, (ULONG)clock->year, (ULONG)clock->hour, (ULONG)clock->min, (ULONG)clock->sec);
390
391 if (step == 0)
392 FPrintf(StdErr, ".\n");
393 else
394 FPrintf(StdErr, " (%lu loop(s) left).\n", loop);
395 }
396 }
397 }
398 }
399
400 if (IsInteractive((StdIn = Input())))
401 StdIn = BNULL; /* Don't use StdIn if it isn't redirected */
402
403 for (i=0; i<loop; i+=step)
404 {
405 if (seconds > 0)
406 {
407 TimerReq->tr_time.tv_secs = seconds;
408 TimerReq->tr_time.tv_micro = 0;
409 TimerReq->tr_node.io_Command = TR_ADDREQUEST;
410
411 SendIO((struct IORequest *)TimerReq);
412 signal = Wait(timesig | usersig);
413
414 if (signal & usersig)
415 {
416 AbortIO((struct IORequest *)TimerReq);
417 WaitIO((struct IORequest *)TimerReq);
418 SetSignal(0L, timesig | usersig); /* Clear signalbits since WaitIO most likely preserves them */
419
420 if (signal & SIGBREAKF_CTRL_C)
421 break;
422 }
423 }
424
425 if (cmdline[0] == '\0')
426 break; /* There's no point in going on */
427 if (!(signal & SIGBREAKF_CTRL_D))
428 {
429 if (!Execute(cmdline, StdIn, Output()))
430 {
431 FPrintf(StdErr, "Unable to execute \"%s\".\n", cmdline);
432 ret = 5;
433 goto exit;
434 }
435 }
436 if (seconds == 0)
437 break; /* Don't go into tight unbreakable loop */
438
439 if (clock)
440 {
441 clock->year += interval->years;
442 clock->month += interval->months;
443
444 if (clock->month > 12) /* We need some annual magic */
445 {
446 clock->month %= 12;
447 clock->year += clock->month / 12;
448 }
449
450 if (!(seconds = CheckDate(clock)))
451 {
452 clock->mday -= 1; /* If date doesn't exist, try previous day */
453 if (!(seconds = CheckDate(clock)))
454 {
455 clock->mday -= 1;
456 if (!(seconds = CheckDate(clock)))
457 {
458 clock->mday -= 1;
459 if (!(seconds = CheckDate(clock)))
460 {
461 FPrintf(StdErr, "Invalid date/time!\n");
462 ret = 5;
463 goto exit;
464 } /* Give up */
465 clock->mday += 1;
466 }
467 clock->mday += 1;
468 }
469 clock->mday += 1; /* Restore day for future reference */
470 }
471
472 if (interval->seconds)
473 {
474 seconds += interval->seconds;
475 Amiga2Date(seconds, clock);
476 }
477 }
478
479 if (ArgArray[TEM_VERBOSE] && (i+1<loop || step == 0))
480 {
481 FPrintf(StdErr, "Next scheduled execution ");
482
483 if (clock)
484 FPrintf(StdErr, "at %02lu/%02lu/%lu %02lu:%02lu:%02lu", (ULONG)clock->mday, (ULONG)clock->month, (ULONG)clock->year,
485 (ULONG)clock->hour, (ULONG)clock->min, (ULONG)clock->sec);
486 else
487 FPrintf(StdErr, "in %lu hours, %lu minutes and %lu seconds", seconds / 3600, (seconds % 3600) / 60, seconds % 60);
488
489 if (step == 0)
490 FPrintf(StdErr, ".\n");
491 else
492 FPrintf(StdErr, " (%lu loop(s) left).\n", loop-i-1);
493 }
494 }
495
496 exit:
497 if (clock)
498 FreeMem(clock, sizeof(struct ClockData));
499 if (interval)
500 FreeMem(interval, sizeof(struct Interval));
501
502 if (!TimerDevice)
503 CloseDevice((struct IORequest *)TimerReq);
504 if (TimerReq)
505 DeleteIORequest((struct IORequest *)TimerReq);
506 if (TimerPort)
507 DeleteMsgPort(TimerPort);
508
509 if (rdargs)
510 FreeArgs(rdargs);
511
512 Close(StdErr);
513 if (DOSBase)
514 CloseLibrary((struct Library *)DOSBase);
515
516 return ret;
517 }
518
519
520 /* A simple atoi()-alike function because it does what we need, and no more. */
521 int strtoi(STRPTR string)
522 {
523 int i, num;
524
525 for (i=0,num=0; string[i]>='0' && string[i]<='9'; ++i)
526 num = 10 * num + (string[i] - '0');
527
528 return num;
529 }
Mirror of AROS' svn.