workbench/system/Wanderer/Tools/ExecuteStartup/main.c

   1 /*
   2     Copyright © 2006-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc: Executes programs in sys:WBStartup
   6     Lang: English
   7 */
   8
   9 /*****************************************************************************
  10
  11     NAME
  12         ExecuteStartup
  13
  14     LOCATION
  15         Wanderer:Tools
  16
  17     FUNCTION
  18         Executes programs in sys:WBStartup.
  19
  20         It checks the following tooltypes of the called programs:
  21                 STARTPRI=n    n can be between +127 and -128. The program
  22                               with the highest priority is started first.
  23
  24                 WAIT=n        Wait n seconds after execution.
  25                               n can be between 0 and 60.
  26
  27                 DONOTWAIT     don't wait till the program is finished.
  28
  29     EXAMPLE
  30
  31     BUGS
  32         All programs are treated like DONOTWAIT is set.
  33
  34     SEE ALSO
  35
  36 ******************************************************************************/
  37
  38 #define DEBUG 0
  39
  40 #include <string.h>
  41 #include <stdlib.h>
  42
  43 #include <aros/debug.h>
  44 #include <proto/exec.h>
  45 #include <proto/dos.h>
  46 #include <proto/icon.h>
  47 #include <proto/workbench.h>
  48 #include <proto/intuition.h>
  49
  50 #include "locale.h"
  51
  52 #define STARTUPDIR "sys:WBStartup/"
  53
  54 struct InfoNode
  55 {
  56     struct Node node;
  57     ULONG waittime;
  58     BOOL donotwait;
  59 };
  60
  61 const TEXT version_string[] = "$VER: ExecuteStartup 0.2 (20.10.2007) © AROS Dev Team";
  62
  63 static TEXT fileNameBuffer[MAXFILENAMELENGTH];
  64 static APTR poolmem;
  65
  66 static BOOL checkIcon(STRPTR name, LONG *pri, ULONG *time, BOOL *notwait);
  67 static BOOL searchInfo(struct List *infoList);
  68 static void executePrograms(struct List *infolist);
  69 static BOOL executeWBStartup(void);
  70
  71 int
  72 main(void)
  73 {
  74
  75     executeWBStartup();
  76
  77     return RETURN_OK;
  78 }
  79
  80 static BOOL
  81 checkIcon(STRPTR name, LONG *pri, ULONG *time, BOOL *notwait)
  82 {
  83     *pri = 0;
  84     *time = 0;
  85     *notwait = FALSE;
  86
  87     struct DiskObject *dobj = GetDiskObject(name);
  88     if (dobj == NULL)
  89     {
  90     struct EasyStruct es = {sizeof(struct EasyStruct), 0,
  91         "Error", "ExecuteStartup\nGetDiskObject failed for:\n%s", "OK"};
  92     EasyRequest(0, &es, 0, name);
  93     return FALSE;
  94     }
  95
  96     if ((dobj->do_Type == WBTOOL) || (dobj->do_Type == WBPROJECT))
  97     {
  98     const STRPTR *toolarray = (const STRPTR *)dobj->do_ToolTypes;
  99     STRPTR s;
 100     if ((s = FindToolType(toolarray, "STARTPRI")))
 101     {
 102         *pri = atol(s);
 103         if (*pri < -128) *pri = -128;
 104         if (*pri > 127) *pri = 127;
 105     }
 106     if ((s = FindToolType(toolarray, "WAIT")))
 107     {
 108         *time = atol(s);
 109         if (*time > 60) *time = 60;
 110     }
 111     if ((s = FindToolType(toolarray, "DONOTWAIT")))
 112     {
 113         *notwait = TRUE;
 114     }
 115     FreeDiskObject(dobj);
 116     return TRUE;
 117     }
 118     return FALSE;
 119 }
 120
 121 static BOOL
 122 searchInfo(struct List *infoList)
 123 {
 124     BOOL retvalue = TRUE;
 125     LONG error;
 126     struct AnchorPath *ap = AllocPooled(poolmem, sizeof(struct AnchorPath));
 127     if (ap)
 128     {
 129     error = MatchFirst(STARTUPDIR "?#?.info", ap);
 130     while (!error)
 131     {
 132         strcpy(fileNameBuffer, ap->ap_Info.fib_FileName);
 133         BYTE * pointPos = strrchr(fileNameBuffer, '.');
 134         *pointPos = '\0';
 135
 136         LONG pri;
 137         ULONG time;
 138         BOOL notwait;
 139         if (checkIcon(fileNameBuffer, &pri, &time, &notwait))
 140         {
 141         struct InfoNode *newnode = AllocPooled(poolmem, sizeof (*newnode));
 142         if (newnode == NULL)
 143         {
 144             struct EasyStruct es = {sizeof(struct EasyStruct), 0,
 145             "Error", "ExecuteStartup\nOut of memory for InfoNode", "OK"};
 146             EasyRequest(0, &es, 0);
 147             retvalue = FALSE;
 148             goto exit;
 149         }
 150         newnode->node.ln_Name = AllocPooled(poolmem, strlen(fileNameBuffer) + 1);
 151         if (newnode->node.ln_Name == NULL)
 152         {
 153             struct EasyStruct es = {sizeof(struct EasyStruct), 0,
 154             "Error", "ExecuteStartup\nOut of memory for ln_Name", "OK"};
 155             EasyRequest(0, &es, 0);
 156             retvalue = FALSE;
 157             goto exit;
 158         }
 159         strcpy(newnode->node.ln_Name, fileNameBuffer);
 160         newnode->node.ln_Pri = pri;
 161         newnode->waittime = time;
 162         newnode->donotwait = notwait;
 163         Enqueue(infoList, (struct Node*)newnode);
 164         }
 165         error = MatchNext(ap);
 166
 167     }
 168     if (error != ERROR_NO_MORE_ENTRIES)
 169     {
 170         struct EasyStruct es = {sizeof(struct EasyStruct), 0,
 171         "Error", "ExecuteStartup\nError %ld occured while scanning directory", "OK"};
 172         EasyRequest(0, &es, 0, error);
 173         retvalue = FALSE;
 174         goto exit;
 175     }
 176     MatchEnd(ap);
 177     }
 178     else
 179     {
 180     struct EasyStruct es = {sizeof(struct EasyStruct), 0,
 181         "Error", "ExecuteStartup\nOut of memory for AnchorPath", "OK"};
 182     EasyRequest(0, &es, 0);
 183     retvalue = FALSE;
 184     }
 185 exit:
 186     return retvalue;
 187 }
 188
 189 static void
 190 executePrograms(struct List *infolist)
 191 {
 192     struct InfoNode *infonode;
 193     ForeachNode(infolist, infonode)
 194     {
 195     D(bug("ExecuteStartup Name %s Pri %d Time %d Notwait %d\n",
 196             infonode->node.ln_Name, infonode->node.ln_Pri,
 197             infonode->waittime, infonode->donotwait));
 198     if (OpenWorkbenchObject(infonode->node.ln_Name, TAG_END))
 199     {
 200         Delay(infonode->waittime * 50);
 201     }
 202     else
 203     {
 204         struct EasyStruct es = {sizeof(struct EasyStruct), 0,
 205         "Warning", "ExecuteStartup\nOpenWorkbenchObject failed for:\n%s", "OK"};
 206         EasyRequest(0, &es, 0, infonode->node.ln_Name);
 207     }
 208     }
 209 }
 210
 211 static BOOL
 212 executeWBStartup(void)
 213 {
 214     struct List infoList;
 215     NEWLIST(&infoList);
 216     BOOL retvalue = FALSE;
 217     BPTR olddir = (BPTR)-1;
 218     BPTR startupdir = 0;
 219
 220     struct FileInfoBlock *fib = AllocDosObjectTags(DOS_FIB, TAG_END);
 221     poolmem = CreatePool(MEMF_ANY | MEMF_CLEAR, sizeof(struct InfoNode) * 10, sizeof(struct InfoNode) * 5);
 222
 223     while (TRUE) /*Cicle loop to avoid the use of goto; It uses now break instruction;*/
 224     {
 225         if (fib == NULL)
 226         {
 227        struct EasyStruct es = {sizeof(struct EasyStruct), 0,
 228            "Error", "ExecuteStartup\nOut of memory for FileInfoBlock", "OK"};
 229        EasyRequest(0, &es, 0);
 230        break;
 231         }
 232
 233         if (poolmem == NULL)
 234         {
 235        struct EasyStruct es = {sizeof(struct EasyStruct), 0,
 236         "Error", "ExecuteStartup\nCouldn't create pool memory", "OK"};
 237        EasyRequest(0, &es, 0);
 238        break;
 239         }
 240
 241         if ( (startupdir = Lock(STARTUPDIR, ACCESS_READ) ) == 0)
 242         {
 243        D(bug("ExecuteStartup: Couldn't lock " STARTUPDIR "\n"));
 244        break;
 245         }
 246
 247         if ( ! Examine(startupdir, fib))
 248         {
 249        struct EasyStruct es = {sizeof(struct EasyStruct), 0,
 250            "Error", "ExecuteStartup\nCouldn't examine " STARTUPDIR, "OK"};
 251        EasyRequest(0, &es, 0);
 252        break;
 253         }
 254
 255     // check if startupdir is a directory
 256         if (fib->fib_DirEntryType >= 0)
 257         {
 258        olddir = CurrentDir(startupdir);
 259        if (searchInfo(&infoList))
 260        {
 261            executePrograms(&infoList);
 262            retvalue = TRUE;
 263        }
 264         }
 265         else
 266         {
 267        D(bug("ExecuteStartup: " STARTUPDIR " isn't a directory\n"));
 268         }
 269
 270         break;
 271     }
 272
 273
 274     // Cleanup
 275     if (startupdir) UnLock(startupdir);
 276     if (olddir != (BPTR)-1) CurrentDir(olddir);
 277     if (fib) FreeDosObject(DOS_FIB, fib);
 278     if (poolmem) DeletePool(poolmem);
 279
 280     return retvalue;
 281 }