workbench/libs/desktop/worker.c

   1 /*
   2    Copyright © 1995-2003, The AROS Development Team. All rights reserved.
   3    $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #define DEBUG 1
   9 #include <aros/debug.h>
  10
  11 #include <exec/types.h>
  12 #include <exec/memory.h>
  13
  14 #include <proto/exec.h>
  15 #include <proto/dos.h>
  16 #include <proto/icon.h>
  17 #include <proto/intuition.h>
  18
  19 #include "worker.h"
  20
  21 #include "desktop_intern.h"
  22
  23 #include "desktop_intern_protos.h"
  24
  25 #include <stdarg.h>
  26 #include <string.h>
  27
  28 /*
  29    FUTURE WORK: 1.  The worker should work inbetween messages from a
  30    requester. This will give faster results. 2.  The WorkerMessage structure
  31    is a bit bloated, perhaps have a seperate message for starts?
  32  */
  33
  34 void scan(struct ScannerWorkerContext *swc)
  35 {
  36     struct ExAllData *ead;
  37     struct SingleResult *sr = NULL;
  38     int             i = 0;
  39     UBYTE          *fullPath;
  40     BPTR            fileLock;
  41     struct FileInfoBlock *fib;
  42     ULONG           commentSize;
  43
  44     swc->swc_More = ExAll
  45     (
  46         swc->swc_DirLock, (struct ExAllData *) swc->swc_Buffer,
  47         SCAN_BUFFER, ED_OWNER, swc->swc_EAC
  48     );
  49
  50     if (swc->swc_EAC->eac_Entries)
  51     {
  52         ead = swc->swc_Buffer;
  53         sr = (struct SingleResult *) AllocVec
  54         (
  55             swc->swc_EAC->eac_Entries * sizeof(struct SingleResult), MEMF_ANY
  56         );
  57         for (i = 0; i < swc->swc_EAC->eac_Entries; i++)
  58         {
  59             ULONG length = strlen(swc->swc_DirName) + 1 /* strlen("/") */
  60                          + strlen(ead->ed_Name) + 1 /* '\0' */;
  61
  62             sr[i].sr_Name = ead->ed_Name;
  63
  64             fullPath = AllocVec(length, MEMF_ANY);
  65
  66             strlcpy(fullPath, swc->swc_DirName, length);
  67             if (swc->swc_DirName[strlen(swc->swc_DirName) - 1] != ':')
  68             {
  69                 strlcat(fullPath, "/", length);
  70             }
  71             strlcat(fullPath, ead->ed_Name, length);
  72
  73             sr[i].sr_DiskObject = GetDiskObjectNew(fullPath);
  74
  75             fileLock = Lock(fullPath, ACCESS_READ);
  76             if (fileLock)
  77             {
  78                 fib = AllocDosObject(DOS_FIB, NULL);
  79                 if (fib)
  80                 {
  81                     if (Examine(fileLock, fib))
  82                     {
  83                         commentSize = strlen(fib->fib_Comment) + 1;
  84                         sr[i].sr_Comment = AllocVec(commentSize, MEMF_ANY);
  85                         CopyMem(fib->fib_Comment, sr[i].sr_Comment,
  86                                 commentSize);
  87                         sr[i].sr_Script = fib->fib_Protection & FIBF_SCRIPT;
  88                         sr[i].sr_Pure = fib->fib_Protection & FIBF_PURE;
  89                         sr[i].sr_Archive = fib->fib_Protection & FIBF_ARCHIVE;
  90                         sr[i].sr_Read = fib->fib_Protection & FIBF_READ;
  91                         sr[i].sr_Write = fib->fib_Protection & FIBF_WRITE;
  92                         sr[i].sr_Execute = fib->fib_Protection & FIBF_EXECUTE;
  93                         sr[i].sr_Delete = fib->fib_Protection & FIBF_DELETE;
  94                         sr[i].sr_Type = fib->fib_DirEntryType;
  95                         sr[i].sr_Size = fib->fib_Size;
  96                         sr[i].sr_LastModified = fib->fib_Date;
  97                     }
  98                     FreeDosObject(DOS_FIB, fib);
  99                 }
 100                 UnLock(fileLock);
 101             }
 102
 103             ead = ead->ed_Next;
 104
 105             FreeVec(fullPath);
 106         }
 107     }
 108
 109     ((struct WorkerScanRequest *) swc->swc_CurrentRequest)->wsr_Results =
 110         swc->swc_EAC->eac_Entries;
 111     ((struct WorkerScanRequest *) swc->swc_CurrentRequest)->wsr_ResultsArray =
 112         sr;
 113     ((struct WorkerScanRequest *) swc->swc_CurrentRequest)->wsr_More =
 114         swc->swc_More;
 115 }
 116
 117 void startScan(struct ScannerWorkerContext *swc)
 118 {
 119     UBYTE          *dirName;
 120     UWORD           bufferSize = 100;
 121     BOOL            success;
 122
 123 // a pointer to this buffer is given to the iconobserver class and
 124 // will be freed when the class is destroyed
 125     swc->swc_Buffer = (STRPTR) AllocVec(SCAN_BUFFER, MEMF_ANY);
 126     swc->swc_DirLock =
 127         ((struct WorkerScanRequest *) swc->swc_CurrentRequest)->wsr_DirLock;
 128     swc->swc_EAC =
 129         (struct ExAllControl *) AllocDosObject(DOS_EXALLCONTROL, NULL);
 130     swc->swc_EAC->eac_LastKey = 0;
 131
 132     dirName = (UBYTE *) AllocVec(bufferSize, MEMF_ANY);
 133     success = NameFromLock(swc->swc_DirLock, dirName, bufferSize);
 134     if (!success)
 135     {
 136         while (IoErr() == ERROR_LINE_TOO_LONG)
 137         {
 138             FreeVec(bufferSize);
 139             bufferSize += 50;
 140             dirName = (UBYTE *) AllocVec(bufferSize, MEMF_ANY);
 141             success = NameFromLock(swc->swc_DirLock, dirName, bufferSize);
 142             if (success)
 143                 break;
 144         }
 145     }
 146
 147     swc->swc_DirName = dirName;
 148
 149     scan(swc);
 150 }
 151
 152 void resumeScan(struct ScannerWorkerContext *swc)
 153 {
 154     swc->swc_Buffer = (STRPTR) AllocVec(SCAN_BUFFER, MEMF_ANY);
 155     scan(swc);
 156 }
 157
 158 void stopScan(struct ScannerWorkerContext *swc)
 159 {
 160     ExAllEnd(swc->swc_DirLock, (struct ExAllData *) swc->swc_Buffer,
 161              SCAN_BUFFER, ED_OWNER, swc->swc_EAC);
 162 }
 163
 164 void destroyScanWorker(struct ScannerWorkerContext *swc)
 165 {
 166     UnLock(swc->swc_DirLock);
 167     FreeDosObject(DOS_EXALLCONTROL, swc->swc_EAC);
 168     FreeVec(swc->swc_DirName);
 169     FreeVec(swc);
 170 }
 171
 172 ULONG workerEntry(void)
 173 {
 174     BOOL            running = TRUE;
 175     struct MsgPort *port;
 176     struct WorkerMessage *msg;
 177     struct ScannerWorkerContext *swc = NULL;
 178
 179     port = &((struct Process *) FindTask(NULL))->pr_MsgPort;
 180
 181     while (running)
 182     {
 183         WaitPort(port);
 184
 185         while ((msg = (struct WorkerMessage *) (GetMsg(port))))
 186         {
 187             switch (msg->w_Command)
 188             {
 189                 case WM_START:
 190                     {
 191                         swc =
 192                             (struct ScannerWorkerContext *)
 193                             AllocVec(sizeof(struct ScannerWorkerContext),
 194                                      MEMF_ANY);
 195                         swc->swc_Context.workerAction = msg->w_Command;
 196                         swc->swc_Context.start = (APTR) startScan;
 197                         swc->swc_Context.resume = (APTR) resumeScan;
 198                         swc->swc_Context.stop = (APTR) stopScan;
 199                         swc->swc_EAC = NULL;
 200                         swc->swc_DirLock = NULL;
 201                         swc->swc_More = FALSE;
 202                         swc->swc_Buffer = NULL;
 203                         swc->swc_CurrentRequest =
 204                             (struct WorkerMessage *) msg;
 205                         swc->swc_Context.start(swc);
 206                         if (!swc->swc_More)
 207                         {
 208                             ((struct WorkerScanRequest *) swc->
 209                              swc_CurrentRequest)->wsr_More = FALSE;
 210                             running = FALSE;
 211                             destroyScanWorker(swc);
 212                         }
 213                         break;
 214                     }
 215                 case WM_RESUME:
 216                     swc->swc_CurrentRequest = msg;
 217                     swc->swc_Context.resume(swc);
 218                     if (!swc->swc_More)
 219                     {
 220                         ((struct WorkerScanRequest *) swc->
 221                          swc_CurrentRequest)->wsr_More = FALSE;
 222                         running = FALSE;
 223                         destroyScanWorker(swc);
 224                     }
 225                     break;
 226
 227                 case WM_STOP:
 228                     if (msg)
 229                         swc->swc_Context.stop(swc);
 230                     destroyScanWorker(swc);
 231                     running = FALSE;
 232                     break;
 233
 234                 default:
 235                     break;
 236             }
 237
 238             ReplyMsg((struct Message *) msg);
 239         }
 240     }
 241
 242     return 0;
 243 }
 244
 245 struct WorkerMessage *createWorkerScanMessage(ULONG workerCommand,
 246                                               ULONG workerAction,
 247                                               ULONG messageID,
 248                                               struct MsgPort *replyPort,
 249                                               BPTR dirLock)
 250 {
 251     struct WorkerMessage *wm = NULL;
 252     struct WorkerScanRequest *sr;
 253
 254     sr = AllocVec(sizeof(struct WorkerScanRequest), MEMF_ANY);
 255     sr->wsr_WMessage.w_Message.mn_Node.ln_Type = NT_MESSAGE;
 256     sr->wsr_WMessage.w_Message.mn_ReplyPort = replyPort;
 257     sr->wsr_WMessage.w_Message.mn_Length = sizeof(struct WorkerScanRequest);
 258     sr->wsr_WMessage.w_Command = workerCommand;
 259
 260     sr->wsr_WMessage.w_Action = workerAction;
 261     sr->wsr_WMessage.w_ID = messageID;
 262     sr->wsr_DirLock = dirLock;
 263     wm = (struct WorkerMessage *) sr;
 264
 265     return wm;
 266 }
 267
 268 struct MsgPort *startScannerWorker(ULONG id, BPTR dirLock,
 269                                    struct MsgPort *replyPort)
 270 {
 271     struct Process *process;
 272     struct ScannerWorkerMessage *msg;
 273
 274     process = CreateNewProcTags
 275     (
 276         NP_Entry,     (IPTR) workerEntry,
 277         NP_Name,      (IPTR) "Worker_Scanner",
 278         NP_StackSize,        8192,
 279         TAG_DONE
 280     );
 281
 282     if (process == NULL) return NULL;
 283
 284     msg = createWorkerScanMessage
 285     (
 286         WM_START, WA_SCANNER, id, replyPort, dirLock
 287     );
 288
 289     PutMsg(&process->pr_MsgPort, (struct Message *) msg);
 290
 291
 292     return &process->pr_MsgPort;
 293 }