PRProcess * haveAChild(int argc, char **argv, PRProcessAttr * attr) { PRProcess * newProcess; newProcess = PR_CreateProcess(argv[0], argv, NULL, attr); if (!newProcess) { errWarn("Can't create new process."); } else { child[numChildren++] = newProcess; } return newProcess; }
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; }
static bool SpawnIOChild(char* const* aArgs, PRProcess** aPID, PRFileDesc** aFromChildFD, PRFileDesc** aToChildFD) { PRFileDesc* toChildPipeRead; PRFileDesc* toChildPipeWrite; if (PR_CreatePipe(&toChildPipeRead, &toChildPipeWrite) != PR_SUCCESS) return false; PR_SetFDInheritable(toChildPipeRead, true); PR_SetFDInheritable(toChildPipeWrite, false); PRFileDesc* fromChildPipeRead; PRFileDesc* fromChildPipeWrite; if (PR_CreatePipe(&fromChildPipeRead, &fromChildPipeWrite) != PR_SUCCESS) { PR_Close(toChildPipeRead); PR_Close(toChildPipeWrite); return false; } PR_SetFDInheritable(fromChildPipeRead, false); PR_SetFDInheritable(fromChildPipeWrite, true); PRProcessAttr* attr = PR_NewProcessAttr(); if (!attr) { PR_Close(fromChildPipeRead); PR_Close(fromChildPipeWrite); PR_Close(toChildPipeRead); PR_Close(toChildPipeWrite); return false; } PR_ProcessAttrSetStdioRedirect(attr, PR_StandardInput, toChildPipeRead); PR_ProcessAttrSetStdioRedirect(attr, PR_StandardOutput, fromChildPipeWrite); PRProcess* process = PR_CreateProcess(aArgs[0], aArgs, nullptr, attr); PR_DestroyProcessAttr(attr); PR_Close(fromChildPipeWrite); PR_Close(toChildPipeRead); if (!process) { LOG(("ntlm_auth exec failure [%d]", PR_GetError())); PR_Close(fromChildPipeRead); PR_Close(toChildPipeWrite); return false; } *aPID = process; *aFromChildFD = fromChildPipeRead; *aToChildFD = toChildPipeWrite; return true; }
PR_IMPLEMENT(PRStatus) PR_CreateProcessDetached( const char *path, char *const *argv, char *const *envp, const PRProcessAttr *attr) { PRProcess *process; PRStatus rv; process = PR_CreateProcess(path, argv, envp, attr); if (NULL == process) { return PR_FAILURE; } rv = PR_DetachProcess(process); PR_ASSERT(PR_SUCCESS == rv); if (rv == PR_FAILURE) { PR_DELETE(process); return PR_FAILURE; } return PR_SUCCESS; }
// 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; } }
NPError NPP_SetWindow(NPP instance, NPWindow* window) { PluginInstance* This; NPSetWindowCallbackStruct *ws_info; const SDL_VideoInfo* info = NULL; char windowEnv[3][500]; if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; This = (PluginInstance*) instance->pdata; if (This == NULL) return NPERR_INVALID_INSTANCE_ERROR; ws_info = (NPSetWindowCallbackStruct *)window->ws_info; fprintf(stderr,"Setting up events for viewer\n"); int app_event_mask = !ButtonPressMask; XSelectInput(ws_info->display, (int)(window->window), app_event_mask); fprintf(stderr,"Loading environment for viewer:\n"); sprintf(windowEnv[0],"SDL_WINDOWID=%d",(int)(window->window)); sprintf(windowEnv[1],"FFW_WINX=%d",(int)(window->width)); sprintf(windowEnv[2],"FFW_WINY=%d",(int)(window->height)); int i=0; for(i=0; i<3; i++) putenv(windowEnv[i]); fprintf(stderr, "Window=(%i)\n", (int)(window->window)); fprintf(stderr, "W=(%i) H=(%i)\n",(int)window->width, (int)window->height); /* if(SDL_Init(SDL_INIT_EVERYTHING)==-1) return NPERR_GENERIC_ERROR; info = SDL_GetVideoInfo(); if(!info) { fprintf(stderr,"err1\n"); return NPERR_GENERIC_ERROR; } SDL_GL_SetAttribute(SDL_GL_RED_SIZE,8); SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE,8); SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE,8); SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE,16); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER,1); SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE,8); if((SDL_SetVideoMode(window->x,window->y,0,SDL_OPENGL | SDL_RESIZABLE | SDL_DOUBLEBUF | SDL_ASYNCBLIT ))==0) { fprintf(stderr,"err2\n"); return NPERR_GENERIC_ERROR; } glViewport(0,0,(GLsizei) window->x , (GLsizei) window->y ); glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluOrtho2D (0.0, (GLdouble) window->x, 0.0, (GLdouble) window->y); /*glEnable(GL_LINE_SMOOTH); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA); glClearColor(1,0,0,1);*/ /**/ #ifdef MOZ_X11 // if (This->window == (Window) window->window) { /* The page with the plugin is being resized. Save any UI information because the next time around expect a SetWindow with a new window id. */ // return NPERR_NO_ERROR; // } else { This->window = (Window) window->window; This->x = window->x; This->y = window->y; This->width = window->width; This->height = window->height; This->display = ws_info->display; This->visual = ws_info->visual; This->depth = ws_info->depth; This->colormap = ws_info->colormap; makePixmap(This); makeWidget(This); // } #endif /* #ifdef MOZ_X11 */ if (viewer_proc == NULL) { char viewerArgs[2][50]; PRProcessAttr* viewerProcAttr = PR_NewProcessAttr(); PR_ProcessAttrSetCurrentDirectory(viewerProcAttr,"/slbrowser/"); sprintf(viewerArgs[0],"/slbrowser/packaged/secondlife\0"); sprintf(viewerArgs[1],"--autologin\0"); fprintf(stderr,"Starting viewer!\n"); viewer_proc = PR_CreateProcess("/slbrowser/secondlife",NULL,NULL,viewerProcAttr); PR_DetachProcess(viewer_proc); } return NPERR_NO_ERROR; }
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; }
nsresult sbProcess::Run() { PRStatus status; nsresult rv; // Set up to auto-kill process. sbAutoKillProcess autoSelf(this); // Operate under the process lock. { NS_ENSURE_TRUE(mProcessLock, NS_ERROR_NOT_INITIALIZED); nsAutoLock autoProcessLock(mProcessLock); // Get the number of arguments. PRUint32 argCount = mArgList.Length(); NS_ENSURE_TRUE(argCount > 0, NS_ERROR_ILLEGAL_VALUE); // Convert the UTF-16 argument list to a UTF-8 argument list. nsTArray<nsCString> argListUTF8; for (PRUint32 i = 0; i < argCount; i++) { NS_ENSURE_TRUE(argListUTF8.AppendElement (NS_ConvertUTF16toUTF8(mArgList[i])), NS_ERROR_OUT_OF_MEMORY); } // Allocate a null-terminated char* argument list and set it up for // auto-disposal. char** argList = reinterpret_cast<char**> (NS_Alloc((argCount + 1) * sizeof(char*))); NS_ENSURE_TRUE(argList, NS_ERROR_OUT_OF_MEMORY); sbAutoNSTypePtr<char*> autoArgList(argList); // Convert the argument list to a null-terminated char* argument list. for (PRUint32 i = 0; i < argCount; i++) { argList[i] = const_cast<char*>(argListUTF8[i].get()); } argList[argCount] = NULL; // Set up the process attributes and set them up for auto-disposal. PRProcessAttr* processAttr = PR_NewProcessAttr(); NS_ENSURE_TRUE(processAttr, NS_ERROR_FAILURE); sbAutoPRProcessAttr autoProcessAttr(processAttr); // Set up process stdin. if (mPipeStdinString) { // Create a process stdin pipe and set it up for auto-disposal. PRFileDesc* stdinReadFD; PRFileDesc* stdinWriteFD; status = PR_CreatePipe(&stdinReadFD, &stdinWriteFD); NS_ENSURE_TRUE(status == PR_SUCCESS, NS_ERROR_FAILURE); sbAutoPRFileDesc autoStdinReadFD(stdinReadFD); sbAutoPRFileDesc autoStdinWriteFD(stdinWriteFD); // Set up stdin pipe file descriptors. status = PR_SetFDInheritable(stdinReadFD, PR_TRUE); NS_ENSURE_TRUE(status == PR_SUCCESS, NS_ERROR_FAILURE); status = PR_SetFDInheritable(stdinWriteFD, PR_FALSE); NS_ENSURE_TRUE(status == PR_SUCCESS, NS_ERROR_FAILURE); // Fill pipe. nsCAutoString writeData = NS_ConvertUTF16toUTF8(mStdinString); PRInt32 bytesWritten; bytesWritten = PR_Write(stdinWriteFD, writeData.get(), writeData.Length()); NS_ENSURE_TRUE(bytesWritten == writeData.Length(), NS_ERROR_FAILURE); // Redirect process stdin. PR_ProcessAttrSetStdioRedirect(processAttr, PR_StandardInput, stdinReadFD); // Keep stdin read descriptor open for the process to read. Close the // stdin write descriptor so that the process gets EOF when all of the // data is read. mStdinReadFD = autoStdinReadFD.forget(); PR_Close(autoStdinWriteFD.forget()); } // Set up process stdout. if (mPipeStdoutString) { // Create a process stdout pipe and set it up for auto-disposal. PRFileDesc* stdoutReadFD; PRFileDesc* stdoutWriteFD; status = PR_CreatePipe(&stdoutReadFD, &stdoutWriteFD); NS_ENSURE_TRUE(status == PR_SUCCESS, NS_ERROR_FAILURE); sbAutoPRFileDesc autoStdoutReadFD(stdoutReadFD); sbAutoPRFileDesc autoStdoutWriteFD(stdoutWriteFD); // Set up stdout pipe file descriptors. status = PR_SetFDInheritable(stdoutReadFD, PR_FALSE); NS_ENSURE_TRUE(status == PR_SUCCESS, NS_ERROR_FAILURE); status = PR_SetFDInheritable(stdoutWriteFD, PR_TRUE); NS_ENSURE_TRUE(status == PR_SUCCESS, NS_ERROR_FAILURE); // Redirect process stdout. PR_ProcessAttrSetStdioRedirect(processAttr, PR_StandardOutput, stdoutWriteFD); // Keep descriptors. mStdoutReadFD = autoStdoutReadFD.forget(); mStdoutWriteFD = autoStdoutWriteFD.forget(); } // Create and start running the process. mBaseProcess = PR_CreateProcess(argList[0], argList, NULL, processAttr); NS_ENSURE_TRUE(mBaseProcess, NS_ERROR_FAILURE); // Wait for process done on another thread. nsCOMPtr<nsIRunnable> runnable = NS_NEW_RUNNABLE_METHOD(sbProcess, this, WaitForDone); NS_ENSURE_TRUE(runnable, NS_ERROR_OUT_OF_MEMORY); rv = NS_NewThread(getter_AddRefs(mWaitForDoneThread), runnable); NS_ENSURE_SUCCESS(rv, rv); } // Clear process auto-kill. autoSelf.forget(); return NS_OK; }
int main(int argc, char* argv[]) { PRStatus status; // launch daemon printf("### launch daemon...\n"); PRProcessAttr *attributes = PR_NewProcessAttr(); if (attributes == nsnull) { printf("PR_NewProcessAttr() failed.\n"); return -1; } PRProcess *daemon = PR_CreateProcess("nsDnsAsyncLookup", nsnull, nsnull, attributes); if (daemon == nsnull) { printf("PR_CreateProcess failed.\n"); } else { // status = PR_DetachProcess(daemon); //if (status != 0) // printf("PR_DetachProcess returned %d\n", status); //daemon = nsnull; } PR_DestroyProcessAttr(attributes); // create socket and connect to daemon int socket_fd = 0; bool notDone = true; char buf[1024]; while(notDone) { int status = 0; fd_set fdset; FD_ZERO(&fdset); FD_SET(fileno(stdin), &fdset); if (socket_fd > 0) FD_SET(socket_fd, &fdset); status = select(getdtablehi(), &fdset, 0, 0, 0); if (status <= 0) { fprintf(stderr, "%s: select() returned %d\n", argv[0], status); exit(-1); } // which fd is set? if (FD_ISSET(fileno(stdin), &fdset)) { char *line = fgets(buf, sizeof(buf)-1, stdin); line = string_trim(line); if(!strcmp(line, "quit") || !strcmp(line, "exit")) { fprintf(stderr, "bye now.\n"); notDone = false; } else if (!strncmp(line, "abort ", 6)) { // abort id } else if (strchr(line, ' ') || strchr(line, '\t')) { fprintf(stderr, "%s: unrecognized command %s.\n", argv[0], line); } else { fprintf(stderr, "%s: looking up %s...\n", argv[0], line); // initiate dns lookup socket_fd = async_dns_lookup(line); } } if (socket_fd && FD_ISSET(socket_fd, &fdset)) { // read from socket, parse results int size = read(socket_fd, buf, 1024); if (size > 0) { // parse buffer into hostent char *p = buf; fprintf(stderr, "bytes read: %d\n", size); fprintf(stderr, "response code: %d\n", *(int *)p); p += sizeof(int); for (int i=0; i < size; i++) { if (!(i%8)) fprintf(stderr, "\n"); fprintf(stderr, "%2.2x ",(unsigned char)buf[i]); } fprintf(stderr, "\n"); hostent *h; h = bytesToHostent(p); } close(socket_fd); socket_fd = 0; } } return 0; }