?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed indentation.
[AROS.git] / workbench / c / WaitX.c
blob4740dad519416f704fa391aafca225d8aa8565d1
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_ENTRY(int, Start,
115 AROS_UFHA(char *, argstr, A0),
116 AROS_UFHA(ULONG, argsize, D0),
117 struct ExecBase *, sBase)
118 {
119 AROS_USERFUNC_INIT
120 return MainEntry(sBase);
121 AROS_USERFUNC_EXIT
122 }
123
124
125 LONG MainEntry(struct ExecBase *SysBase)
126 {
127 struct DosLibrary *DOSBase = NULL;
128 struct UtilityBase *UtilityBase = NULL;
129 struct Library *TimerBase;
130
131 BYTE TimerDevice = -1;
132 struct ClockData *clock = NULL;
133 struct Interval *interval = NULL;
134 struct MsgPort *TimerPort = NULL;
135 struct timerequest *TimerReq = NULL;
136 ULONG i, loop, step, unit, seconds = 0, signal = 0, timesig = 0, usersig = SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E;
137
138 BPTR StdErr = BNULL, StdIn;
139 char ProgName[256];
140 struct RDArgs *rdargs = NULL;
141 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";
142
143 enum
144 {
145 TEM_DATE,
146 TEM_TIME,
147 TEM_YEARS,
148 TEM_MONTHS,
149 TEM_DAYS,
150 TEM_HOURS,
151 TEM_MINS,
152 TEM_SECS,
153 TEM_LOOP,
154 TEM_ALWAYS,
155 TEM_VERBOSE,
156 TEM_HELP,
157 TEM_CMDLINE,
158 TEM_NUMARGS
159 };
160
161 IPTR ArgArray[TEM_NUMARGS], ret;
162 STRPTR cmdline;
163 STRPTR tmpptr;
164
165 ret = 20; /* Fatal error if something fails here */
166 if (!(DOSBase = (struct DosLibrary *)OpenLibrary("dos.library", 36)))
167 goto exit;
168 if (!(UtilityBase = (struct UtilityBase *)OpenLibrary("utility.library", 36)))
169 goto exit;
170 if (!(StdErr = Open("CONSOLE:", MODE_NEWFILE)))
171 goto exit;
172 ret = 0; /* Clear return */
173
174 GetProgramName(ProgName, sizeof(ProgName));
175 for (i=0; i<TEM_NUMARGS; ArgArray[i++]=0)
176 ;
177 rdargs = ReadArgs(Template, ArgArray, NULL);
178
179 if (ArgArray[TEM_HELP] || !rdargs)
180 {
181 FPrintf(StdErr, "%s\n\n", &Version[6]);
182 FPrintf(StdErr, "Usage: %s [DATE=<DD/MM/YYYY>] [TIME=<HH:MM:SS>] <commandline>\n", ProgName);
183 FPrintf(StdErr, "Usage: %s [HOURS=<hours>] [MINS=<mins>] [SECS=<secs>] <commandline>\n", ProgName);
184 goto exit;
185 }
186
187 loop = step = 1;
188 if (ArgArray[TEM_LOOP])
189 loop = *((ULONG *)ArgArray[TEM_LOOP]);
190
191 if (ArgArray[TEM_ALWAYS] || loop == 0)
192 {
193 loop = 1;
194 step = 0;
195 }
196
197 if (ArgArray[TEM_CMDLINE])
198 cmdline = (STRPTR)ArgArray[TEM_CMDLINE];
199 else
200 cmdline = ""; /* Prevented from Execute()ing later */
201
202 if (ArgArray[TEM_DATE] || ArgArray[TEM_TIME] || ArgArray[TEM_YEARS] || ArgArray[TEM_MONTHS])
203 {
204 unit = UNIT_WAITUNTIL;
205 if (!(clock = AllocMem(sizeof(struct ClockData), MEMF_PUBLIC | MEMF_CLEAR)))
206 {
207 FPrintf(StdErr, "Unable to allocate needed memory!\n");
208 ret = 10;
209 goto exit;
210 }
211 if (!(interval = AllocMem(sizeof(struct Interval), MEMF_PUBLIC | MEMF_CLEAR)))
212 {
213 FPrintf(StdErr, "Unable to allocate needed memory!\n");
214 ret = 10;
215 goto exit;
216 }
217
218 if (ArgArray[TEM_YEARS])
219 interval->years = *((ULONG *)ArgArray[TEM_YEARS]);
220 if (ArgArray[TEM_MONTHS])
221 interval->months = *((ULONG *)ArgArray[TEM_MONTHS]);
222 if (ArgArray[TEM_DAYS])
223 interval->seconds += *((ULONG *)ArgArray[TEM_DAYS]) * 86400;
224 if (ArgArray[TEM_HOURS])
225 interval->seconds += *((ULONG *)ArgArray[TEM_HOURS]) * 3600;
226 if (ArgArray[TEM_MINS])
227 interval->seconds += *((ULONG *)ArgArray[TEM_MINS]) * 60;
228 if (ArgArray[TEM_SECS])
229 interval->seconds += *((ULONG *)ArgArray[TEM_SECS]);
230
231 if (interval->years || interval->months || interval->seconds)
232 interval->set = 1;
233 }
234 else
235 {
236 unit = UNIT_VBLANK;
237 seconds = 0;
238
239 if (ArgArray[TEM_DAYS])
240 seconds += *((ULONG *)ArgArray[TEM_DAYS]) * 86400;
241 if (ArgArray[TEM_HOURS])
242 seconds += *((ULONG *)ArgArray[TEM_HOURS]) * 3600;
243 if (ArgArray[TEM_MINS])
244 seconds += *((ULONG *)ArgArray[TEM_MINS]) * 60;
245 if (ArgArray[TEM_SECS])
246 seconds += *((ULONG *)ArgArray[TEM_SECS]);
247 }
248
249 if (seconds > 0 || clock)
250 {
251 if (!(TimerPort = CreateMsgPort()))
252 {
253 FPrintf(StdErr, "Couldn't create Timer-MsgPort!\n");
254 ret = 10;
255 goto exit;
256 }
257 if (!(TimerReq = (struct timerequest *)CreateIORequest(TimerPort, sizeof(struct timerequest))))
258 {
259 FPrintf(StdErr, "Couldn't create Timer-IORequest!\n");
260 ret = 10;
261 goto exit;
262 }
263 if ((TimerDevice = OpenDevice(TIMERNAME, unit, (struct IORequest *)TimerReq, 0)))
264 {
265 FPrintf(StdErr, "Couldn't open %s!\n", TIMERNAME);
266 ret = 10;
267 goto exit;
268 }
269
270 TimerBase = (struct Library *)TimerReq->tr_node.io_Device;
271 timesig = 1L << TimerPort->mp_SigBit;
272
273 if (clock)
274 {
275 GetSysTime(&TimerReq->tr_time); /* Get current System Time */
276 Amiga2Date(TimerReq->tr_time.tv_secs, clock); /* Fill in current date/time as default */
277
278 if (ArgArray[TEM_DATE])
279 {
280 tmpptr = (STRPTR)ArgArray[TEM_DATE];
281 clock->mday = strtoi(tmpptr);
282 if ((tmpptr = strstr(tmpptr, "/")))
283 {
284 clock->month = strtoi(++tmpptr);
285 if ((tmpptr = strstr(tmpptr, "/")))
286 {
287 clock->year = strtoi(++tmpptr);
288 }
289 if (!interval->set)
290 {
291 interval->years = 1;
292 interval->set = 1;
293 }
294 }
295 else if (!interval->set)
296 {
297 interval->months = 1;
298 interval->set = 1;
299 }
300
301 if (clock->year < 100) /* Be nice to digit-challenged ppl. ;) */
302 {
303 if (clock->year < 78)
304 clock->year += 2000; /* If less than 78, assume 20xx */
305 else
306 clock->year += 1900;
307 }
308 }
309 else if (!interval->set)
310 {
311 interval->seconds = 86400;
312 interval->set = 1;
313 }
314
315 if (ArgArray[TEM_TIME])
316 {
317 tmpptr = (STRPTR)ArgArray[TEM_TIME];
318 clock->hour = strtoi(tmpptr);
319 clock->min = clock->sec = 0; /* Clear default time */
320 if ((tmpptr = strstr(tmpptr, ":")))
321 {
322 clock->min = strtoi(++tmpptr);
323 if ((tmpptr = strstr(tmpptr, ":")))
324 clock->sec = strtoi(++tmpptr);
325 }
326 }
327
328 if (!(seconds = CheckDate(clock)))
329 {
330 FPrintf(StdErr, "Invalid date/time!\n");
331 ret = 5;
332 goto exit;
333 }
334 if (seconds <= TimerReq->tr_time.tv_secs)
335 {
336 ULONG count = loop;
337
338 for (i=0; i<count; i+=step)
339 {
340 clock->year += interval->years;
341 clock->month += interval->months;
342
343 if (clock->month > 12) /* We need some annual magic */
344 {
345 clock->month %= 12;
346 clock->year += clock->month / 12;
347 }
348
349 if (!(seconds = CheckDate(clock)))
350 {
351 clock->mday -= 1; /* If date doesn't exist, try previous day */
352 if (!(seconds = CheckDate(clock)))
353 {
354 clock->mday -= 1;
355 if (!(seconds = CheckDate(clock)))
356 {
357 clock->mday -= 1;
358 if (!(seconds = CheckDate(clock)))
359 {
360 FPrintf(StdErr, "Invalid date/time!\n");
361 ret = 5;
362 goto exit;
363 } /* Give up */
364 clock->mday += 1;
365 }
366 clock->mday += 1;
367 }
368 clock->mday += 1; /* Restore day for future reference */
369 }
370
371 if (interval->seconds)
372 {
373 seconds += interval->seconds;
374 Amiga2Date(seconds, clock);
375 }
376
377 if (loop > 0 && step > 0)
378 loop--;
379 if (seconds > TimerReq->tr_time.tv_secs)
380 break;
381 }
382
383 if (seconds <= TimerReq->tr_time.tv_secs || loop == 0)
384 {
385 FPrintf(StdErr, "Date/time has already passed!\n");
386 ret = 5;
387 goto exit;
388 }
389 else if (ArgArray[TEM_VERBOSE])
390 {
391 FPrintf(StdErr, "Note: Schedule has been moved to %02lu/%02lu/%lu %02lu:%02lu:%02lu because the assigned date/time has already passed",
392 (ULONG)clock->mday, (ULONG)clock->month, (ULONG)clock->year, (ULONG)clock->hour, (ULONG)clock->min, (ULONG)clock->sec);
393
394 if (step == 0)
395 FPrintf(StdErr, ".\n");
396 else
397 FPrintf(StdErr, " (%lu loop(s) left).\n", loop);
398 }
399 }
400 }
401 }
402
403 if (IsInteractive((StdIn = Input())))
404 StdIn = BNULL; /* Don't use StdIn if it isn't redirected */
405
406 for (i=0; i<loop; i+=step)
407 {
408 if (seconds > 0)
409 {
410 TimerReq->tr_time.tv_secs = seconds;
411 TimerReq->tr_time.tv_micro = 0;
412 TimerReq->tr_node.io_Command = TR_ADDREQUEST;
413
414 SendIO((struct IORequest *)TimerReq);
415 signal = Wait(timesig | usersig);
416
417 if (signal & usersig)
418 {
419 AbortIO((struct IORequest *)TimerReq);
420 WaitIO((struct IORequest *)TimerReq);
421 SetSignal(0L, timesig | usersig); /* Clear signalbits since WaitIO most likely preserves them */
422
423 if (signal & SIGBREAKF_CTRL_C)
424 break;
425 }
426 }
427
428 if (cmdline[0] == '\0')
429 break; /* There's no point in going on */
430 if (!(signal & SIGBREAKF_CTRL_D))
431 {
432 if (!Execute(cmdline, StdIn, Output()))
433 {
434 FPrintf(StdErr, "Unable to execute \"%s\".\n", cmdline);
435 ret = 5;
436 goto exit;
437 }
438 }
439 if (seconds == 0)
440 break; /* Don't go into tight unbreakable loop */
441
442 if (clock)
443 {
444 clock->year += interval->years;
445 clock->month += interval->months;
446
447 if (clock->month > 12) /* We need some annual magic */
448 {
449 clock->month %= 12;
450 clock->year += clock->month / 12;
451 }
452
453 if (!(seconds = CheckDate(clock)))
454 {
455 clock->mday -= 1; /* If date doesn't exist, try previous day */
456 if (!(seconds = CheckDate(clock)))
457 {
458 clock->mday -= 1;
459 if (!(seconds = CheckDate(clock)))
460 {
461 clock->mday -= 1;
462 if (!(seconds = CheckDate(clock)))
463 {
464 FPrintf(StdErr, "Invalid date/time!\n");
465 ret = 5;
466 goto exit;
467 } /* Give up */
468 clock->mday += 1;
469 }
470 clock->mday += 1;
471 }
472 clock->mday += 1; /* Restore day for future reference */
473 }
474
475 if (interval->seconds)
476 {
477 seconds += interval->seconds;
478 Amiga2Date(seconds, clock);
479 }
480 }
481
482 if (ArgArray[TEM_VERBOSE] && (i+1<loop || step == 0))
483 {
484 FPrintf(StdErr, "Next scheduled execution ");
485
486 if (clock)
487 FPrintf(StdErr, "at %02lu/%02lu/%lu %02lu:%02lu:%02lu", (ULONG)clock->mday, (ULONG)clock->month, (ULONG)clock->year,
488 (ULONG)clock->hour, (ULONG)clock->min, (ULONG)clock->sec);
489 else
490 FPrintf(StdErr, "in %lu hours, %lu minutes and %lu seconds", seconds / 3600, (seconds % 3600) / 60, seconds % 60);
491
492 if (step == 0)
493 FPrintf(StdErr, ".\n");
494 else
495 FPrintf(StdErr, " (%lu loop(s) left).\n", loop-i-1);
496 }
497 }
498
499 exit:
500 if (clock)
501 FreeMem(clock, sizeof(struct ClockData));
502 if (interval)
503 FreeMem(interval, sizeof(struct Interval));
504
505 if (!TimerDevice)
506 CloseDevice((struct IORequest *)TimerReq);
507 if (TimerReq)
508 DeleteIORequest((struct IORequest *)TimerReq);
509 if (TimerPort)
510 DeleteMsgPort(TimerPort);
511
512 if (rdargs)
513 FreeArgs(rdargs);
514
515 Close(StdErr);
516 if (DOSBase)
517 CloseLibrary((struct Library *)DOSBase);
518
519 return ret;
520 }
521
522
523 /* A simple atoi()-alike function because it does what we need, and no more. */
524 int strtoi(STRPTR string)
525 {
526 int i, num;
527
528 for (i=0,num=0; string[i]>='0' && string[i]<='9'; ++i)
529 num = 10 * num + (string[i] - '0');
530
531 return num;
532 }
Mirror of AROS' svn.