workbench/c/WaitX.c

   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 }