loader/task.c

   1 /*
   2  *        Tasks functions
   3  */
   4 static char Copyright[] = "Copyright  Martin Ayotte, 1994";
   5
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <sys/types.h>
  11 #include <unistd.h>
  12 #include "windows.h"
  13 #include "wine.h"
  14 #include "task.h"
  15 #include "stddebug.h"
  16 /* #define DEBUG_TASK */
  17 /* #undef DEBUG_TASK */
  18 #include "debug.h"
  19
  20
  21 static LPWINETASKENTRY lpTaskList = NULL;
  22 static int nTaskCount = 0;
  23
  24 /**********************************************************************
  25  *                              GetCurrentTask  [KERNEL.36]
  26  */
  27 HTASK GetCurrentTask()
  28 {
  29         LPWINETASKENTRY lpTask = lpTaskList;
  30         int pid = getpid();
  31         dprintf_task(stddeb,"GetCurrentTask() // unix_pid=%08X !\n", pid);
  32         if (lpTask == NULL) return 0;
  33         while (TRUE) {
  34                 if (lpTask->unix_pid == pid) break;
  35                 if (lpTask->lpNextTask == NULL) return 0;
  36                 lpTask = lpTask->lpNextTask;
  37                 }
  38         dprintf_task(stddeb,"GetCurrentTask() returned hTask=%04X !\n", lpTask->te.hTask);
  39         return lpTask->te.hTask;
  40 }
  41
  42
  43 /**********************************************************************
  44  *                              GetNumTasks     [KERNEL.152]
  45  */
  46 WORD GetNumTasks()
  47 {
  48         dprintf_task(stddeb,"GetNumTasks() returned %d !\n", nTaskCount);
  49         return nTaskCount;
  50 }
  51
  52
  53 /**********************************************************************
  54  *                              GetWindowTask   [USER.224]
  55  */
  56 HTASK GetWindowTask(HWND hWnd)
  57 {
  58         HWND    *wptr;
  59         int             count;
  60         LPWINETASKENTRY lpTask = lpTaskList;
  61         dprintf_task(stddeb,"GetWindowTask(%04X) !\n", hWnd);
  62         while (lpTask != NULL) {
  63                 wptr = lpTask->lpWndList;
  64                 if (wptr != NULL) {
  65                         count = 0;
  66                         while (++count < MAXWIN_PER_TASK) {
  67                                 dprintf_task(stddeb,"GetWindowTask // searching %04X %04X !\n",
  68                                                                                 lpTask->te.hTask, *(wptr));
  69                                 if (*(wptr) == hWnd) {
  70                                         dprintf_task(stddeb,"GetWindowTask(%04X) found hTask=%04X !\n",
  71                                                                                                 hWnd, lpTask->te.hTask);
  72                                         return lpTask->te.hTask;
  73                                         }
  74                                 wptr++;
  75                                 }
  76                         }
  77                 lpTask = lpTask->lpNextTask;
  78                 }
  79         return 0;
  80 }
  81
  82
  83 /**********************************************************************
  84  *                              EnumTaskWindows [USER.225]
  85  */
  86 BOOL EnumTaskWindows(HANDLE hTask, FARPROC lpEnumFunc, LONG lParam)
  87 {
  88         HWND    *wptr, hWnd;
  89         BOOL    bRet;
  90         int             count = 0;
  91         LPWINETASKENTRY lpTask = lpTaskList;
  92         dprintf_task(stddeb,"EnumTaskWindows(%04X, %08X, %08X) !\n", hTask, lpEnumFunc, lParam);
  93         while (TRUE) {
  94                 if (lpTask->te.hTask == hTask) break;
  95                 if (lpTask == NULL) {
  96                         dprintf_task(stddeb,"EnumTaskWindows // hTask=%04X not found !\n", hTask);
  97                         return FALSE;
  98                         }
  99                 lpTask = lpTask->lpNextTask;
 100                 }
 101         dprintf_task(stddeb,"EnumTaskWindows // found hTask=%04X !\n", hTask);
 102         wptr = lpTask->lpWndList;
 103         if (wptr == NULL) return FALSE;
 104         if (lpEnumFunc == NULL) return FALSE;
 105         while ((hWnd = *(wptr++)) != 0) {
 106                 if (++count >= MAXWIN_PER_TASK) return FALSE;
 107                 dprintf_task(stddeb,"EnumTaskWindows // hWnd=%04X count=%d !\n", hWnd, count);
 108 #ifdef WINELIB
 109                 bRet = (*lpEnumFunc)(hWnd, lParam);
 110 #else
 111                 bRet = CallBack16(lpEnumFunc, 2, 0, (int)hWnd, 2, (int)lParam);
 112 #endif
 113                 if (bRet == 0) break;
 114                 }
 115         return TRUE;
 116 }
 117
 118
 119 /**********************************************************************
 120  *                              CreateNewTask           [internal]
 121  */
 122 HANDLE CreateNewTask(HINSTANCE hInst, HTASK hTaskParent)
 123 {
 124         HANDLE hTask;
 125         LPWINETASKENTRY lpTask = lpTaskList;
 126         LPWINETASKENTRY lpNewTask;
 127         MODULEENTRY module;
 128
 129         module.dwSize = sizeof(module);
 130         ModuleFindHandle(&module, hInst);
 131
 132         if (lpTask != NULL) {
 133                 while (TRUE) {
 134                         if (lpTask->lpNextTask == NULL) break;
 135                         lpTask = lpTask->lpNextTask;
 136                         }
 137                 }
 138         hTask = GlobalAlloc(GMEM_MOVEABLE, sizeof(WINETASKENTRY));
 139         lpNewTask = (LPWINETASKENTRY) GlobalLock(hTask);
 140         dprintf_task(stddeb,"CreateNewTask entry allocated %08X\n", lpNewTask);
 141         if (lpNewTask == NULL) return 0;
 142         if (lpTaskList == NULL) {
 143                 lpTaskList = lpNewTask;
 144                 lpNewTask->lpPrevTask = NULL;
 145                 }
 146         else {
 147                 lpTask->lpNextTask = lpNewTask;
 148                 lpTask->te.hNext = lpNewTask->te.hTask;
 149                 lpNewTask->lpPrevTask = lpTask;
 150                 }
 151         lpNewTask->lpNextTask = NULL;
 152         lpNewTask->hIcon = 0;
 153         lpNewTask->te.dwSize = sizeof(TASKENTRY);
 154         lpNewTask->te.hModule = 0;
 155         lpNewTask->te.hInst = hInst;
 156         lpNewTask->te.hTask = hTask;
 157         lpNewTask->te.hTaskParent = hTaskParent;
 158         lpNewTask->te.wSS = 0;
 159         lpNewTask->te.wSP = 0;
 160         lpNewTask->te.wStackTop = 0;
 161         lpNewTask->te.wStackMinimum = 0;
 162         lpNewTask->te.wStackBottom = 0;
 163         lpNewTask->te.wcEvents = 0;
 164         lpNewTask->te.hQueue = 0;
 165         strcpy(lpNewTask->te.szModule, module.szModule);
 166         lpNewTask->te.wPSPOffset = 0;
 167         lpNewTask->unix_pid = getpid();
 168         lpNewTask->lpWndList = (HWND *) malloc(MAXWIN_PER_TASK * sizeof(HWND));
 169         if (lpNewTask->lpWndList != NULL)
 170                 memset((LPSTR)lpNewTask->lpWndList, 0, MAXWIN_PER_TASK * sizeof(HWND));
 171         dprintf_task(stddeb,"CreateNewTask // unix_pid=%08X return hTask=%04X\n",
 172                                                                         lpNewTask->unix_pid, hTask);
 173         GlobalUnlock(hTask);
 174         nTaskCount++;
 175     return hTask;
 176 }
 177
 178
 179 /**********************************************************************
 180  *                              AddWindowToTask         [internal]
 181  */
 182 BOOL AddWindowToTask(HTASK hTask, HWND hWnd)
 183 {
 184         HWND    *wptr;
 185         int             count = 0;
 186         LPWINETASKENTRY lpTask = lpTaskList;
 187         dprintf_task(stddeb,"AddWindowToTask(%04X, %04X); !\n", hTask, hWnd);
 188         while (TRUE) {
 189                 if (lpTask->te.hTask == hTask) break;
 190                 if (lpTask == NULL) {
 191                         fprintf(stderr,"AddWindowToTask // hTask=%04X not found !\n", hTask);
 192                         return FALSE;
 193                         }
 194                 lpTask = lpTask->lpNextTask;
 195                 }
 196         wptr = lpTask->lpWndList;
 197         if (wptr == NULL) return FALSE;
 198         while (*(wptr) != 0) {
 199                 if (++count >= MAXWIN_PER_TASK) return FALSE;
 200                 wptr++;
 201                 }
 202         *wptr = hWnd;
 203         dprintf_task(stddeb,"AddWindowToTask // window added, count=%d !\n", count);
 204         return TRUE;
 205 }
 206
 207
 208 /**********************************************************************
 209  *                              RemoveWindowFromTask            [internal]
 210  */
 211 BOOL RemoveWindowFromTask(HTASK hTask, HWND hWnd)
 212 {
 213         HWND    *wptr;
 214         int             count = 0;
 215         LPWINETASKENTRY lpTask = lpTaskList;
 216         dprintf_task(stddeb,"RemoveWindowFromTask (%04X, %04X); !\n", hTask, hWnd);
 217         while (TRUE) {
 218                 if (lpTask->te.hTask == hTask) break;
 219                 if (lpTask == NULL) {
 220                         fprintf(stderr,"RemoveWindowFromTask // hTask=%04X not found !\n", hTask);
 221                         return FALSE;
 222                         }
 223                 lpTask = lpTask->lpNextTask;
 224                 }
 225         wptr = lpTask->lpWndList;
 226         if (wptr == NULL) return FALSE;
 227         while (*(wptr) != hWnd) {
 228                 if (++count >= MAXWIN_PER_TASK) return FALSE;
 229                 wptr++;
 230                 }
 231         while (*(wptr) != 0) {
 232                 *(wptr) = *(wptr + 1);
 233                 if (++count >= MAXWIN_PER_TASK) return FALSE;
 234                 wptr++;
 235                 }
 236         dprintf_task(stddeb,"RemoveWindowFromTask // window removed, count=%d !\n", --count);
 237         return TRUE;
 238 }
 239
 240 BOOL TaskFirst(LPTASKENTRY lpTask)
 241 {
 242         dprintf_task(stddeb,"TaskFirst(%8x)\n", (int) lpTask);
 243         if (lpTaskList) {
 244                 memcpy(lpTask, &lpTaskList->te, lpTask->dwSize);
 245                 return TRUE;
 246         } else
 247                 return FALSE;
 248 }
 249
 250 BOOL TaskNext(LPTASKENTRY lpTask)
 251 {
 252         LPWINETASKENTRY list;
 253         dprintf_task(stddeb,"TaskNext(%8x)\n", (int) lpTask);
 254         list = lpTaskList;
 255         while (list) {
 256                 if (list->te.hTask == lpTask->hTask) {
 257                         list = list->lpNextTask;
 258                         if (list) {
 259                                 memcpy(lpTask, &list->te, lpTask->dwSize);
 260                                 return TRUE;
 261                         } else
 262                                 return FALSE;
 263                 }
 264                 list = list->lpNextTask;
 265         }
 266         return FALSE;
 267 }
 268
 269 BOOL TaskFindHandle(LPTASKENTRY lpTask, HTASK hTask)
 270 {
 271         static LPWINETASKENTRY list;
 272         dprintf_task(stddeb,"TaskFindHandle(%8x,%4x)\n", (int) lpTask, hTask);
 273         list = lpTaskList;
 274         while (list) {
 275                 if (list->te.hTask == hTask) {
 276                         list = list->lpNextTask;
 277                         if (list) {
 278                                 memcpy(lpTask, &list->te, lpTask->dwSize);
 279                                 return TRUE;
 280                         } else
 281                                 return FALSE;
 282                 }
 283                 list = list->lpNextTask;
 284         }
 285         return FALSE;
 286 }