int main(int argc, char **argv) { LOG("entering main\n"); int numProcs = 10; // if this is a child process, then just run the test if (argc > 1) { if (strcmp(argv[1], "-child") == 0) { RandomSleep(1000, 1000); LOG("running child test\n"); NS_InitXPCOM2(nsnull, nsnull, nsnull); DoTest(); NS_ShutdownXPCOM(nsnull); return 0; } else if (argv[1][0] == '-') { // argument is a number numProcs = atoi(argv[1] + 1); if (numProcs == 0) { printf("### usage: TestIPCLocks [-N]\n" "where, N is the number of test processes to spawn.\n"); return -1; } } } LOG("sleeping for 1 second\n"); PR_Sleep(PR_SecondsToInterval(1)); PRProcess **procs = (PRProcess **) malloc(sizeof(PRProcess*) * numProcs); int i; // else, spawn the child processes for (i=0; i<numProcs; ++i) { char *const argv[] = {"./TestIPCLocks", "-child", nsnull}; LOG("spawning child test\n"); procs[i] = PR_CreateProcess("./TestIPCLocks", argv, nsnull, nsnull); } PRInt32 exitCode; for (i=0; i<numProcs; ++i) PR_WaitProcess(procs[i], &exitCode); return 0; }
void nsAuthSambaNTLM::Shutdown() { if (mFromChildFD) { PR_Close(mFromChildFD); mFromChildFD = nullptr; } if (mToChildFD) { PR_Close(mToChildFD); mToChildFD = nullptr; } if (mChildPID) { PRInt32 exitCode; PR_WaitProcess(mChildPID, &exitCode); mChildPID = nullptr; } }
void sbProcess::WaitForDone() { PRStatus status = PR_SUCCESS; nsresult rv = NS_OK; // Wait for the process to complete and get the exit code. PRInt32 exitCode; status = PR_WaitProcess(mBaseProcess, &exitCode); if (status != PR_SUCCESS) rv = NS_ERROR_FAILURE; // Operate under the process lock. { nsAutoLock autoProcessLock(mProcessLock); // Handle the process done event. if (NS_SUCCEEDED(rv)) rv = HandleDone(); // Check done result of process. if (NS_SUCCEEDED(rv)) mExitCode = exitCode; mDoneResult = rv; } // Change the done condition to true. If a done monitor was provided, change // the condition under the monitor and send notification of the change. if (mDoneMonitor) { nsAutoMonitor monitor(mDoneMonitor); { nsAutoLock autoProcessLock(mProcessLock); mIsDone = PR_TRUE; } monitor.Notify(); } else { nsAutoLock autoProcessLock(mProcessLock); mIsDone = PR_TRUE; } }
// XXXldb |args| has the wrong const-ness NS_IMETHODIMP nsProcess::Run(PRBool blocking, const char **args, PRUint32 count, PRUint32 *pid) { NS_ENSURE_TRUE(mExecutable, NS_ERROR_NOT_INITIALIZED); PRStatus status = PR_SUCCESS; // make sure that when we allocate we have 1 greater than the // count since we need to null terminate the list for the argv to // pass into PR_CreateProcess char **my_argv = NULL; my_argv = (char **)nsMemory::Alloc(sizeof(char *) * (count + 2) ); if (!my_argv) { return NS_ERROR_OUT_OF_MEMORY; } // copy the args PRUint32 i; for (i=0; i < count; i++) { my_argv[i+1] = NS_CONST_CAST(char*, args[i]); } // we need to set argv[0] to the program name. my_argv[0] = mTargetPath.BeginWriting(); // null terminate the array my_argv[count+1] = NULL; #if defined(XP_WIN) STARTUPINFO startupInfo; PROCESS_INFORMATION procInfo; BOOL retVal; char *cmdLine; if (assembleCmdLine(my_argv, &cmdLine) == -1) { nsMemory::Free(my_argv); return NS_ERROR_FILE_EXECUTION_FAILED; } ZeroMemory(&startupInfo, sizeof(startupInfo)); startupInfo.cb = sizeof(startupInfo); retVal = CreateProcess(NULL, // NS_CONST_CAST(char*, mTargetPath.get()), cmdLine, NULL, /* security attributes for the new * process */ NULL, /* security attributes for the primary * thread in the new process */ FALSE, /* inherit handles */ 0, /* creation flags */ NULL, /* env */ NULL, /* current drive and directory */ &startupInfo, &procInfo ); PR_Free( cmdLine ); if (blocking) { // if success, wait for process termination. the early returns and such // are a bit ugly but preserving the logic of the nspr code I copied to // minimize our risk abit. if ( retVal == TRUE ) { DWORD dwRetVal; unsigned long exitCode; dwRetVal = WaitForSingleObject(procInfo.hProcess, INFINITE); if (dwRetVal == WAIT_FAILED) { nsMemory::Free(my_argv); return NS_ERROR_FAILURE; } if (GetExitCodeProcess(procInfo.hProcess, &exitCode) == FALSE) { mExitValue = exitCode; nsMemory::Free(my_argv); return NS_ERROR_FAILURE; } mExitValue = exitCode; CloseHandle(procInfo.hProcess); } else status = PR_FAILURE; } else { // map return value into success code if (retVal == TRUE) status = PR_SUCCESS; else status = PR_FAILURE; } #else // Note, this must not be an #elif ...! #if defined(XP_MACOSX) if (count == 0) { FSSpec resolvedSpec; OSErr err = noErr; nsCOMPtr<nsILocalFileMac> macExecutable = do_QueryInterface(mExecutable); macExecutable->GetFSSpec(&resolvedSpec); LaunchParamBlockRec launchPB; launchPB.launchAppSpec = &resolvedSpec; launchPB.launchAppParameters = NULL; launchPB.launchBlockID = extendedBlock; launchPB.launchEPBLength = extendedBlockLen; launchPB.launchFileFlags = NULL; launchPB.launchControlFlags = launchContinue + launchNoFileFlags + launchUseMinimum; if (!blocking) launchPB.launchControlFlags += launchDontSwitch; err = LaunchApplication(&launchPB); // NOTE: blocking mode assumes you are running on a thread // other than the UI thread that has the main event loop if (blocking && err == noErr) { while (1) { ProcessInfoRec info; info.processInfoLength = sizeof(ProcessInfoRec); info.processName = NULL; info.processAppSpec = NULL; err = GetProcessInformation(&launchPB.launchProcessSN, &info); if (err != noErr) { // The process is no longer in the process // manager's internal list, assume the process is // done. err = noErr; break; } // still running so sleep some more (200 msecs) PR_Sleep(200); } } if (err != noErr) { status = PR_FAILURE; } if (blocking) { mExitValue = err; } } else #endif { if (blocking) { mProcess = PR_CreateProcess(mTargetPath.get(), my_argv, NULL, NULL); if (mProcess) status = PR_WaitProcess(mProcess, &mExitValue); } else { status = PR_CreateProcessDetached(mTargetPath.get(), my_argv, NULL, NULL); } } #endif // free up our argv nsMemory::Free(my_argv); if (status != PR_SUCCESS) return NS_ERROR_FILE_EXECUTION_FAILED; return NS_OK; }
/* ///////////////////////////////////////////////////////////////////////// // actually run the installation, copying files to and fro */ static Pk11Install_Error DoInstall(JAR *jar, const char *installDir, const char *tempDir, Pk11Install_Platform *platform, PRFileDesc *feedback, PRBool noverify) { Pk11Install_File *file; Pk11Install_Error ret; char *reldir; char *dest; char *modDest; char *cp; int i; int status; char *tempname, *temp; StringList executables; StringNode *execNode; PRProcessAttr *attr; PRProcess *proc; char *argv[2]; char *envp[1]; int errcode; ret = PK11_INSTALL_UNSPECIFIED; reldir = NULL; dest = NULL; modDest = NULL; tempname = NULL; StringList_new(&executables); /* // Create Temporary directory */ tempname = PR_smprintf("%s/%s", tempDir, TEMPORARY_DIRECTORY_NAME); if (PR_Access(tempname, PR_ACCESS_EXISTS) == PR_SUCCESS) { /* Left over from previous run? Delete it. */ rm_dash_r(tempname); } if (PR_MkDir(tempname, 0700) != PR_SUCCESS) { error(PK11_INSTALL_CREATE_DIR, tempname); ret = PK11_INSTALL_CREATE_DIR; goto loser; } /* // Install all the files */ for (i = 0; i < platform->numFiles; i++) { file = &platform->files[i]; if (file->relativePath) { PRBool foundMarker = PR_FALSE; reldir = PR_Strdup(file->relativePath); /* Replace all the markers with the directories for which they stand */ while (1) { if ((cp = PL_strcasestr(reldir, ROOT_MARKER))) { /* Has a %root% marker */ *cp = '\0'; temp = PR_smprintf("%s%s%s", reldir, installDir, cp + strlen(ROOT_MARKER)); PR_Free(reldir); reldir = temp; foundMarker = PR_TRUE; } else if ((cp = PL_strcasestr(reldir, TEMP_MARKER))) { /* Has a %temp% marker */ *cp = '\0'; temp = PR_smprintf("%s%s%s", reldir, tempname, cp + strlen(TEMP_MARKER)); PR_Free(reldir); reldir = temp; foundMarker = PR_TRUE; } else { break; } } if (!foundMarker) { /* Has no markers...this isn't really a relative directory */ error(PK11_INSTALL_BOGUS_REL_DIR, file->relativePath); ret = PK11_INSTALL_BOGUS_REL_DIR; goto loser; } dest = reldir; reldir = NULL; } else if (file->absolutePath) { dest = PR_Strdup(file->absolutePath); } /* Remember if this is the module file, we'll need to add it later */ if (i == platform->modFile) { modDest = PR_Strdup(dest); } /* Remember is this is an executable, we'll need to run it later */ if (file->executable) { StringList_Append(&executables, dest); /*executables.Append(dest);*/ } /* Make sure the directory we are targetting exists */ if (make_dirs(dest, file->permissions)) { ret = PK11_INSTALL_CREATE_DIR; goto loser; } /* Actually extract the file onto the filesystem */ if (noverify) { status = JAR_extract(jar, (char *)file->jarPath, dest); } else { status = JAR_verified_extract(jar, (char *)file->jarPath, dest); } if (status) { if (status >= JAR_BASE && status <= JAR_BASE_END) { error(PK11_INSTALL_JAR_EXTRACT, file->jarPath, JAR_get_error(status)); } else { error(PK11_INSTALL_JAR_EXTRACT, file->jarPath, mySECU_ErrorString(PORT_GetError())); } ret = PK11_INSTALL_JAR_EXTRACT; goto loser; } if (feedback) { PR_fprintf(feedback, msgStrings[INSTALLED_FILE_MSG], file->jarPath, dest); } /* no NSPR command to change permissions? */ #ifdef XP_UNIX chmod(dest, file->permissions); #endif /* Memory clean-up tasks */ if (reldir) { PR_Free(reldir); reldir = NULL; } if (dest) { PR_Free(dest); dest = NULL; } } /* Make sure we found the module file */ if (!modDest) { /* Internal problem here, since every platform is supposed to have a module file */ error(PK11_INSTALL_NO_MOD_FILE, platform->moduleName); ret = PK11_INSTALL_NO_MOD_FILE; goto loser; } /* // Execute any executable files */ { argv[1] = NULL; envp[0] = NULL; for (execNode = executables.head; execNode; execNode = execNode->next) { attr = PR_NewProcessAttr(); argv[0] = PR_Strdup(execNode->str); /* Announce our intentions */ if (feedback) { PR_fprintf(feedback, msgStrings[EXEC_FILE_MSG], execNode->str); } /* start the process */ if (!(proc = PR_CreateProcess(execNode->str, argv, envp, attr))) { PR_Free(argv[0]); PR_DestroyProcessAttr(attr); error(PK11_INSTALL_EXEC_FILE, execNode->str); ret = PK11_INSTALL_EXEC_FILE; goto loser; } /* wait for it to finish */ if (PR_WaitProcess(proc, &errcode) != PR_SUCCESS) { PR_Free(argv[0]); PR_DestroyProcessAttr(attr); error(PK11_INSTALL_WAIT_PROCESS, execNode->str); ret = PK11_INSTALL_WAIT_PROCESS; goto loser; } /* What happened? */ if (errcode) { /* process returned an error */ error(PK11_INSTALL_PROC_ERROR, execNode->str, errcode); } else if (feedback) { /* process ran successfully */ PR_fprintf(feedback, msgStrings[EXEC_SUCCESS], execNode->str); } PR_Free(argv[0]); PR_DestroyProcessAttr(attr); } } /* // Add the module */ status = Pk11Install_AddNewModule((char *)platform->moduleName, (char *)modDest, platform->mechFlags, platform->cipherFlags); if (status != SECSuccess) { error(PK11_INSTALL_ADD_MODULE, platform->moduleName); ret = PK11_INSTALL_ADD_MODULE; goto loser; } if (feedback) { PR_fprintf(feedback, msgStrings[INSTALLED_MODULE_MSG], platform->moduleName); } if (feedback) { PR_fprintf(feedback, msgStrings[INSTALLATION_COMPLETE_MSG]); } ret = PK11_INSTALL_SUCCESS; loser: if (reldir) { PR_Free(reldir); } if (dest) { PR_Free(dest); } if (modDest) { PR_Free(modDest); } if (tempname) { PRFileInfo info; if (PR_GetFileInfo(tempname, &info) == PR_SUCCESS) { if (info.type == PR_FILE_DIRECTORY) { /* Recursively remove temporary directory */ if (rm_dash_r(tempname)) { error(PK11_INSTALL_REMOVE_DIR, tempname); ret = PK11_INSTALL_REMOVE_DIR; } } } PR_Free(tempname); } StringList_delete(&executables); return ret; }
int main(int argc, char **argv) { PRProcess *proc; PRIntn i; char *child_argv[32]; char **child_arg; char iterations_buf[32]; PRSharedMemory *shm; PRIntn *counter_addr; PRInt32 exit_code; PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "dc:h"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'd': /* debug mode */ debug_mode = PR_TRUE; break; case 'c': /* loop count */ iterations = atoi(opt->value); break; case 'h': default: Help(); return 2; } } PL_DestroyOptState(opt); if (PR_DeleteSharedMemory(SHM_NAME) == PR_SUCCESS) { fprintf(stderr, "warning: removed shared memory %s left over " "from previous run\n", SHM_NAME); } if (PR_DeleteSemaphore(SEM_NAME1) == PR_SUCCESS) { fprintf(stderr, "warning: removed semaphore %s left over " "from previous run\n", SEM_NAME1); } if (PR_DeleteSemaphore(SEM_NAME2) == PR_SUCCESS) { fprintf(stderr, "warning: removed semaphore %s left over " "from previous run\n", SEM_NAME2); } shm = PR_OpenSharedMemory(SHM_NAME, sizeof(*counter_addr), PR_SHM_CREATE, SHM_MODE); if (NULL == shm) { fprintf(stderr, "PR_OpenSharedMemory failed (%d, %d)\n", PR_GetError(), PR_GetOSError()); exit(1); } counter_addr = PR_AttachSharedMemory(shm, 0); if (NULL == counter_addr) { fprintf(stderr, "PR_AttachSharedMemory failed\n"); exit(1); } *counter_addr = 0; sem1 = PR_OpenSemaphore(SEM_NAME1, PR_SEM_CREATE, SEM_MODE, 1); if (NULL == sem1) { fprintf(stderr, "PR_OpenSemaphore failed (%d, %d)\n", PR_GetError(), PR_GetOSError()); exit(1); } sem2 = PR_OpenSemaphore(SEM_NAME2, PR_SEM_CREATE, SEM_MODE, 0); if (NULL == sem2) { fprintf(stderr, "PR_OpenSemaphore failed (%d, %d)\n", PR_GetError(), PR_GetOSError()); exit(1); } child_arg = &child_argv[0]; *child_arg++ = "semapong"; if (debug_mode != PR_FALSE) { *child_arg++ = "-d"; } if (iterations != ITERATIONS) { *child_arg++ = "-c"; PR_snprintf(iterations_buf, sizeof(iterations_buf), "%d", iterations); *child_arg++ = iterations_buf; } *child_arg = NULL; proc = PR_CreateProcess(child_argv[0], child_argv, NULL, NULL); if (NULL == proc) { fprintf(stderr, "PR_CreateProcess failed\n"); exit(1); } /* * Process 1 waits on semaphore 1 and posts to semaphore 2. */ for (i = 0; i < iterations; i++) { if (PR_WaitSemaphore(sem1) == PR_FAILURE) { fprintf(stderr, "PR_WaitSemaphore failed\n"); exit(1); } if (*counter_addr == 2*i) { if (debug_mode) printf("process 1: counter = %d\n", *counter_addr); } else { fprintf(stderr, "process 1: counter should be %d but is %d\n", 2*i, *counter_addr); exit(1); } (*counter_addr)++; if (PR_PostSemaphore(sem2) == PR_FAILURE) { fprintf(stderr, "PR_PostSemaphore failed\n"); exit(1); } } if (PR_DetachSharedMemory(shm, counter_addr) == PR_FAILURE) { fprintf(stderr, "PR_DetachSharedMemory failed\n"); exit(1); } if (PR_CloseSharedMemory(shm) == PR_FAILURE) { fprintf(stderr, "PR_CloseSharedMemory failed\n"); exit(1); } if (PR_CloseSemaphore(sem1) == PR_FAILURE) { fprintf(stderr, "PR_CloseSemaphore failed\n"); } if (PR_CloseSemaphore(sem2) == PR_FAILURE) { fprintf(stderr, "PR_CloseSemaphore failed\n"); } if (PR_WaitProcess(proc, &exit_code) == PR_FAILURE) { fprintf(stderr, "PR_WaitProcess failed\n"); exit(1); } if (exit_code != 0) { fprintf(stderr, "process 2 failed with exit code %d\n", exit_code); exit(1); } if (PR_DeleteSharedMemory(SHM_NAME) == PR_FAILURE) { fprintf(stderr, "PR_DeleteSharedMemory failed\n"); } if (PR_DeleteSemaphore(SEM_NAME1) == PR_FAILURE) { fprintf(stderr, "PR_DeleteSemaphore failed\n"); } if (PR_DeleteSemaphore(SEM_NAME2) == PR_FAILURE) { fprintf(stderr, "PR_DeleteSemaphore failed\n"); } printf("PASS\n"); return 0; }
int main(int argc, char **argv) { PRFileDesc *sock[2]; PRStatus status; PRProcess *process; PRProcessAttr *attr; char buf[1024]; PRInt32 nBytes; PRInt32 exitCode; int idx; status = PR_NewTCPSocketPair(sock); if (status == PR_FAILURE) { fprintf(stderr, "PR_NewTCPSocketPair failed\n"); exit(1); } status = PR_SetFDInheritable(sock[0], PR_FALSE); if (status == PR_FAILURE) { fprintf(stderr, "PR_SetFDInheritable failed: (%d, %d)\n", PR_GetError(), PR_GetOSError()); exit(1); } status = PR_SetFDInheritable(sock[1], PR_TRUE); if (status == PR_FAILURE) { fprintf(stderr, "PR_SetFDInheritable failed: (%d, %d)\n", PR_GetError(), PR_GetOSError()); exit(1); } attr = PR_NewProcessAttr(); if (attr == NULL) { fprintf(stderr, "PR_NewProcessAttr failed\n"); exit(1); } status = PR_ProcessAttrSetInheritableFD(attr, sock[1], "SOCKET"); if (status == PR_FAILURE) { fprintf(stderr, "PR_ProcessAttrSetInheritableFD failed\n"); exit(1); } process = PR_CreateProcess(child_argv[0], child_argv, NULL, attr); if (process == NULL) { fprintf(stderr, "PR_CreateProcess failed\n"); exit(1); } PR_DestroyProcessAttr(attr); status = PR_Close(sock[1]); if (status == PR_FAILURE) { fprintf(stderr, "PR_Close failed\n"); exit(1); } for (idx = 0; idx < NUM_ITERATIONS; idx++) { strcpy(buf, "ping"); printf("ping process: sending \"%s\"\n", buf); nBytes = PR_Write(sock[0], buf, 5); if (nBytes == -1) { fprintf(stderr, "PR_Write failed: (%d, %d)\n", PR_GetError(), PR_GetOSError()); exit(1); } memset(buf, 0, sizeof(buf)); nBytes = PR_Read(sock[0], buf, sizeof(buf)); if (nBytes == -1) { fprintf(stderr, "PR_Read failed: (%d, %d)\n", PR_GetError(), PR_GetOSError()); exit(1); } printf("ping process: received \"%s\"\n", buf); if (nBytes != 5) { fprintf(stderr, "ping process: expected 5 bytes but got %d bytes\n", nBytes); exit(1); } if (strcmp(buf, "pong") != 0) { fprintf(stderr, "ping process: expected \"pong\" but got \"%s\"\n", buf); exit(1); } } status = PR_Close(sock[0]); if (status == PR_FAILURE) { fprintf(stderr, "PR_Close failed\n"); exit(1); } status = PR_WaitProcess(process, &exitCode); if (status == PR_FAILURE) { fprintf(stderr, "PR_WaitProcess failed\n"); exit(1); } if (exitCode == 0) { printf("PASS\n"); return 0; } else { printf("FAIL\n"); return 1; } }
int main(int argc, char **argv) { PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "dh"); PRSem *sem; char *child_argv[32]; char **child_arg; PRProcess *proc; PRInt32 exit_code; while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 'd': /* debug mode */ debug_mode = PR_TRUE; break; case 'h': default: Help(); return 2; } } PL_DestroyOptState(opt); /* * Open a nonexistent semaphore without the PR_SEM_CREATE * flag should fail with PR_FILE_NOT_FOUND_ERROR. */ (void) PR_DeleteSemaphore(NO_SUCH_SEM_NAME); sem = PR_OpenSemaphore(NO_SUCH_SEM_NAME, 0, 0, 0); if (NULL != sem) { fprintf(stderr, "Opening nonexistent semaphore %s " "without the PR_SEM_CREATE flag should fail " "but succeeded\n", NO_SUCH_SEM_NAME); exit(1); } if (PR_GetError() != PR_FILE_NOT_FOUND_ERROR) { fprintf(stderr, "Expected error is %d but got (%d, %d)\n", PR_FILE_NOT_FOUND_ERROR, PR_GetError(), PR_GetOSError()); exit(1); } /* * Create a semaphore and let the another process * try PR_SEM_CREATE and PR_SEM_CREATE|PR_SEM_EXCL. */ if (PR_DeleteSemaphore(SEM_NAME1) == PR_SUCCESS) { fprintf(stderr, "warning: deleted semaphore %s from previous " "run of the test\n", SEM_NAME1); } sem = PR_OpenSemaphore(SEM_NAME1, PR_SEM_CREATE, SEM_MODE, 0); if (sem == NULL) { fprintf(stderr, "PR_OpenSemaphore failed (%d, %d)\n", PR_GetError(), PR_GetOSError()); exit(1); } child_arg = child_argv; *child_arg++ = EXE_NAME; if (debug_mode) { *child_arg++ = "-d"; } *child_arg = NULL; proc = PR_CreateProcess(child_argv[0], child_argv, NULL, NULL); if (proc == NULL) { fprintf(stderr, "PR_CreateProcess failed\n"); exit(1); } if (PR_WaitProcess(proc, &exit_code) == PR_FAILURE) { fprintf(stderr, "PR_WaitProcess failed\n"); exit(1); } if (exit_code != 0) { fprintf(stderr, "process semaerr1 failed\n"); exit(1); } if (PR_CloseSemaphore(sem) == PR_FAILURE) { fprintf(stderr, "PR_CloseSemaphore failed\n"); exit(1); } if (PR_DeleteSemaphore(SEM_NAME1) == PR_FAILURE) { fprintf(stderr, "PR_DeleteSemaphore failed\n"); exit(1); } printf("PASS\n"); return 0; }