![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to termq.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / q_a / samples / termq|
Return to termq.c CVS log | Up to [WindowsNT SDKs] / q_a / samples / termq |
1.1 ! root 1: ! 2: /****************************************************************** ! 3: * This program demonstrates how convert an OS/2 program that uses * ! 4: * termination queues to wait for multiple child processses to * ! 5: * terminate. This is done under Win32 by waiting for the newly * ! 6: * created child process handles to be signalled. * ! 7: * * ! 8: * This program demonstrates the use of the following Win32 APIs: * ! 9: * CreateProcess, WaitForMultipleObjects, GetExitCodeProcess. * ! 10: ******************************************************************/ ! 11: ! 12: #include <windows.h> ! 13: #include <stdio.h> ! 14: #include <stdlib.h> ! 15: ! 16: #define PERR(api) printf("%s: Error %d from %s on line %d\n", \ ! 17: __FILE__, GetLastError(), api, __LINE__); ! 18: ! 19: #define PROCESS_COUNT 3 ! 20: ! 21: int main() ! 22: { ! 23: /***************************************************************** ! 24: * The following are the OS/2 types used in the OS/2 version: * ! 25: * * ! 26: * USHORT usErr; * ! 27: * HQUEUE hQueue; * ! 28: * STARTDATA stdata; * ! 29: * QUEUERESULT qresc; * ! 30: * USHORT cbElement, i, idSession; * ! 31: * PUSHORT pusQelemBuf; * ! 32: * BYTE bElemPrty; * ! 33: * USHORT pid; * ! 34: *****************************************************************/ ! 35: ! 36: STARTUPINFO stdata; /* info for CreateProcess */ ! 37: BOOL fSuccess; /* Win32 API return code */ ! 38: PROCESS_INFORMATION ppi; /* info for CreateProcess */ ! 39: DWORD adwProcessId[PROCESS_COUNT]; /* array of process ID's */ ! 40: HANDLE ahProcess[PROCESS_COUNT]; /* array of process handles */ ! 41: DWORD dwResult; /* API result */ ! 42: DWORD dwExitCode; /* exit code from the new processes */ ! 43: int i, j; ! 44: ! 45: /******************************************************************* ! 46: * usErr = DosCreateQueue(&hQueue, QUE_FIFO, szTermQName); * ! 47: * assert(!usErr); * ! 48: * * ! 49: * Rather than use a queue mechanism to both signal us that the * ! 50: * child process has ended and to return an exit code with, under * ! 51: * Win32 we need to wait for the process object to be signalled, * ! 52: * then call GetExitCodeProcess to get the exit code. * ! 53: *******************************************************************/ ! 54: ! 55: /****************************************************************** ! 56: * In the original OS/2 version, the variable stdata is of type * ! 57: * STARTDATA. In this version, it is of type STARTUPINFO. In the * ! 58: * comment boxes I will show the OS/2 settings for the STARTDATA * ! 59: * structure. Following the comment will be the Win32 equivalent * ! 60: * setting, if any. * ! 61: * * ! 62: * stdata.Related = TRUE; * ! 63: * * ! 64: * Under Win32 there is no formal parent/child process * ! 65: * relationship between processes and no equivalent parameter to * ! 66: * set. * ! 67: * * ! 68: * stdata.TraceOpt = 0; * ! 69: * * ! 70: * If the new process was to be debugged under Win32, you would * ! 71: * set the DEBUG_PROCESS flag for the fdwCreate parameter for * ! 72: * CreateProcess. * ! 73: * * ! 74: * stdata.PgmTitle = "OS/2 Command Processor"; * ! 75: ******************************************************************/ ! 76: ! 77: stdata.lpTitle = "Win32 Command Processor"; ! 78: ! 79: /******************************************************************* ! 80: * stdata.PgmName = "c:\\os2\\cmd.exe"; * ! 81: * stdata.PgmInputs = NULL; * ! 82: * * ! 83: * The equivalent Win32 parameters are passed directly into * ! 84: * CreateProcess as the lpszImageName and lpszCommandLine * ! 85: * parameters. * ! 86: * * ! 87: * stdata.TermQ = szTermQName; * ! 88: * * ! 89: * Wait for the object process to be signalled in Win32 instead * ! 90: * of using queues under OS/2. * ! 91: * * ! 92: * stdata.Environment = NULL; * ! 93: * * ! 94: * In Win32, this is passed as a parameter to CreateProcess as * ! 95: * the lpvEnvironment parameter. * ! 96: * * ! 97: * stdata.InheritOpt = 0; * ! 98: * * ! 99: * Though there is no formal parent/child relationship between * ! 100: * two processes in Win32, process can have the new process * ! 101: * inherit open object handles by specifying TRUE for the * ! 102: * fInheritHandles flag for CreateProcess. * ! 103: * * ! 104: * stdata.SessionType = 2; * ! 105: * * ! 106: * In Win32, the sessiontype does not need to be specified. It * ! 107: * will be automatically determined. * ! 108: * * ! 109: * stdata.IconFile = NULL; * ! 110: * stdata.PgmHandle = 0; * ! 111: * * ! 112: * In Win32, no similar options exist. * ! 113: * * ! 114: * stdata.PgmControl = 32768; * ! 115: * stdata.InitXPos = 50; * ! 116: * stdata.InitYPos = 250; * ! 117: * stdata.InitXSize = 200; * ! 118: * stdata.InitYSize = 100; * ! 119: * * ! 120: * For console apps under Win32, you can specify the console size * ! 121: * in terms of characters instead of pixel positions. * ! 122: *******************************************************************/ ! 123: ! 124: stdata.dwX = 50; /* X starting position (pixels) */ ! 125: stdata.dwY = 50; /* X starting position (pixels) */ ! 126: stdata.dwXSize = 40; ! 127: stdata.dwYSize = 25; ! 128: ! 129: /* set additional parameters for Win32 CreateProcess call */ ! 130: stdata.cb = sizeof(stdata); ! 131: stdata.lpReserved = NULL; ! 132: stdata.lpDesktop = NULL; ! 133: stdata.dwFlags = 0; /* attributes for starting process */ ! 134: stdata.wShowWindow = 0; ! 135: stdata.cbReserved2 = 0; ! 136: stdata.lpReserved2 = NULL; ! 137: ! 138: /* start PROCESS_COUNT number of child sessions */ ! 139: for (i = 0; i < PROCESS_COUNT; i++) ! 140: { ! 141: /************************************************** ! 142: * DosStartSession(&stdata, &idSession, &pid); * ! 143: * * ! 144: * Replace this with the Win32 CreateProcess call. * ! 145: **************************************************/ ! 146: ! 147: fSuccess = CreateProcess(NULL, /* image name */ ! 148: "cmd.exe", /* program to run and command line */ ! 149: NULL, /* security attributes for new process */ ! 150: NULL, /* security attributes for new thread */ ! 151: FALSE, /* don't inherit open object handles */ ! 152: NORMAL_PRIORITY_CLASS | /* creation flags */ ! 153: CREATE_NEW_CONSOLE, /* creation flags - new console for process */ ! 154: NULL, /* use environment of this process for new process */ ! 155: NULL, /* use current directory for startup directory */ ! 156: &stdata, /* startup data structure */ ! 157: &ppi); /* process info from the call */ ! 158: if (!fSuccess) ! 159: PERR("CreateProcess"); ! 160: CloseHandle(ppi.hThread); /* we don't need this handle */ ! 161: ! 162: /******************************************************** ! 163: * printf("session id = %d started\n", idSession); * ! 164: * * ! 165: * In Win32 the session ID is contained in the * ! 166: * PROCESS_INFORMATION structure (variable ppi in this * ! 167: * example). * ! 168: ********************************************************/ ! 169: ! 170: printf("session id = %d started\n", ppi.dwProcessId); ! 171: ahProcess[i] = ppi.hProcess; /* save the process handles */ ! 172: adwProcessId[i] = ppi.dwProcessId; /* save process IDs */ ! 173: stdata.dwX += 50; /* shift next window to cascade */ ! 174: stdata.dwY += 50; ! 175: } ! 176: ! 177: /****************************************************************** ! 178: * for (i = 0; i < PROCESS_COUNT; i++) * ! 179: * { * ! 180: * usErr = DosReadQueue(hQueue, &qresc, &cbElement, * ! 181: * (PVOID FAR *) &pusQelemBuf, 0, DCWW_WAIT, &bElemPrty, 0); * ! 182: * assert(!usErr); * ! 183: * printf("queue return: session id = %d, resultcode = %d\n", * ! 184: * pusQelemBuf[0], pusQelemBuf[1]); * ! 185: * usErr = DosFreeSeg(SELECTOROF(pusQelemBuf)); * ! 186: * assert(!usErr); * ! 187: * } * ! 188: * * ! 189: * Rather than read from the termination queue, under Win32 we * ! 190: * wait for any of the returned process handles to be signalled. * ! 191: * We must also use GetExitCodeProcess to get the exit codes * ! 192: * rather than getting them from the queue packet. * ! 193: ******************************************************************/ ! 194: ! 195: for (i = 0; i < PROCESS_COUNT; i++) ! 196: { ! 197: dwResult = WaitForMultipleObjects( ! 198: PROCESS_COUNT - i, /* number of objects to wait on */ ! 199: ahProcess, /* array of object handles to wait on */ ! 200: FALSE, /* wait on any handle to signal, rather than all */ ! 201: (DWORD) -1); /* timeout (wait forever) */ ! 202: if (dwResult == -1) ! 203: PERR("WaitForMultipleObjects"); ! 204: dwResult -= WAIT_OBJECT_0; /* adjust to zero-based range */ ! 205: fSuccess = GetExitCodeProcess( ! 206: ahProcess[dwResult], /* process handle */ ! 207: &dwExitCode); /* returned exit code */ ! 208: if (!fSuccess) ! 209: PERR("GetExitCodeProcess"); ! 210: CloseHandle(ahProcess[dwResult]); ! 211: printf("process return: session id = %d, result code = %d\n", ! 212: adwProcessId[dwResult], dwExitCode); ! 213: /* now we need to compact the handle/process ID arrays to remove */ ! 214: /* closed handle slots */ ! 215: for (j = dwResult; j <= PROCESS_COUNT - i - 2; j++) ! 216: { ! 217: /* shift remaining process handles down one slot */ ! 218: ahProcess[j] = ahProcess[j + 1]; ! 219: /* shift remaining process IDs down one slot */ ! 220: adwProcessId[j] = adwProcessId[j + 1]; ! 221: } ! 222: } ! 223: return(0); ! 224: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.