driver_console_t *driver_console_create(select_group_t *group) /*, char *name, char *download, int first_chunk)*/ { driver_console_t *driver = (driver_console_t*) safe_malloc(sizeof(driver_console_t)); driver->group = group; driver->is_shutdown = FALSE; driver->outgoing_data = buffer_create(BO_LITTLE_ENDIAN); #ifdef WIN32 /* On Windows, the stdin_handle is quite complicated, and involves a sub-thread. */ HANDLE stdin_handle = get_stdin_handle(); select_group_add_pipe(group, -1, stdin_handle, driver); select_set_recv(group, -1, console_stdin_recv); select_set_closed(group, -1, console_stdin_closed); #else /* On Linux, the stdin_handle is easy. */ int stdin_handle = STDIN_FILENO; select_group_add_socket(group, stdin_handle, SOCKET_TYPE_STREAM, driver); select_set_recv(group, stdin_handle, console_stdin_recv); select_set_closed(group, stdin_handle, console_stdin_closed); #endif return driver; }
driver_console_t *driver_console_create(select_group_t *group, char *name, char *download, int first_chunk) { driver_console_t *driver = (driver_console_t*) safe_malloc(sizeof(driver_console_t)); message_options_t options[4]; #ifdef WIN32 /* On Windows, the stdin_handle is quite complicated, and involves a sub-thread. */ HANDLE stdin_handle = get_stdin_handle(); select_group_add_pipe(group, -1, stdin_handle, driver); select_set_recv(group, -1, console_stdin_recv); select_set_closed(group, -1, console_stdin_closed); #else /* On Linux, the stdin_handle is easy. */ int stdin_handle = STDIN_FILENO; select_group_add_socket(group, stdin_handle, SOCKET_TYPE_STREAM, driver); select_set_recv(group, stdin_handle, console_stdin_recv); select_set_closed(group, stdin_handle, console_stdin_closed); #endif driver->name = name ? name : "[unnamed console]"; driver->download = download; driver->first_chunk = first_chunk; /* Subscribe to the messages we care about. */ message_subscribe(MESSAGE_DATA_IN, handle_message, driver); options[0].name = "name"; options[0].value.s = driver->name; if(driver->download) { options[1].name = "download"; options[1].value.s = driver->download; options[2].name = "first_chunk"; options[2].value.i = driver->first_chunk; } else { options[1].name = NULL; } options[3].name = NULL; driver->session_id = message_post_create_session(options); return driver; }
void sessions_attach_stdin(sessions_t *sessions) { #ifdef WIN32 /* On Windows, the stdin_handle is quire complicated, and involves a sub-thread. */ HANDLE stdin_handle = get_stdin_handle(); select_group_add_pipe(sessions->select_group, -1, stdin_handle, sessions); select_set_recv(sessions->select_group, -1, stdin_callback); select_set_closed(sessions->select_group, -1, stdin_closed_callback); #else /* On Linux, the stdin_handle is easy. */ int stdin_handle = STDIN_FILENO; select_group_add_socket(sessions->select_group, stdin_handle, SOCKET_TYPE_STREAM, sessions); select_set_recv(sessions->select_group, stdin_handle, stdin_callback); select_set_closed(sessions->select_group, stdin_handle, stdin_closed_callback); #endif }
driver_exec_t *driver_exec_create(select_group_t *group, char *process, char *name) { driver_exec_t *driver_exec = (driver_exec_t*) safe_malloc(sizeof(driver_exec_t)); message_options_t options[2]; /* Declare some WIN32 variables needed for starting the sub-process. */ #ifdef WIN32 STARTUPINFOA startupInfo; PROCESS_INFORMATION processInformation; SECURITY_ATTRIBUTES sa; #endif driver_exec->process = process; driver_exec->group = group; driver_exec->name = name ? name : process; /* Subscribe to the messages we care about. */ message_subscribe(MESSAGE_DATA_IN, handle_message, driver_exec); /* Set up the session options and create the session. */ options[0].name = "name"; options[0].value.s = driver_exec->name; options[1].name = NULL; driver_exec->session_id = message_post_create_session(options); #ifdef WIN32 /* Create a security attributes structure. This is required to inherit handles. */ ZeroMemory(&sa, sizeof(SECURITY_ATTRIBUTES)); sa.nLength = sizeof(SECURITY_ATTRIBUTES); sa.lpSecurityDescriptor = NULL; sa.bInheritHandle = TRUE; /* Create the anonymous pipes. */ if(!CreatePipe(&driver_exec->exec_stdin[PIPE_READ], &driver_exec->exec_stdin[PIPE_WRITE], &sa, 0)) DIE("exec: Couldn't create pipe for stdin"); if(!CreatePipe(&driver_exec->exec_stdout[PIPE_READ], &driver_exec->exec_stdout[PIPE_WRITE], &sa, 0)) DIE("exec: Couldn't create pipe for stdout"); fprintf(stderr, "Attempting to load the program: %s\n", driver_exec->process); /* Initialize the STARTUPINFO structure. */ ZeroMemory(&startupInfo, sizeof(STARTUPINFO)); startupInfo.cb = sizeof(STARTUPINFO); startupInfo.dwFlags = STARTF_USESTDHANDLES; startupInfo.hStdInput = driver_exec->exec_stdin[PIPE_READ]; startupInfo.hStdOutput = driver_exec->exec_stdout[PIPE_WRITE]; startupInfo.hStdError = driver_exec->exec_stdout[PIPE_WRITE]; /* Initialize the PROCESS_INFORMATION structure. */ ZeroMemory(&processInformation, sizeof(PROCESS_INFORMATION)); /* Create the actual process with an overly-complicated CreateProcess function. */ if(!CreateProcessA(NULL, driver_exec->process, 0, &sa, TRUE, CREATE_NO_WINDOW, 0, NULL, &startupInfo, &processInformation)) { fprintf(stderr, "Failed to create the process"); exit(1); } /* Save the process id and the handle. */ driver_exec->pid = processInformation.dwProcessId; driver_exec->exec_handle = processInformation.hProcess; /* Close the duplicate pipes we created -- this lets us detect the proicess termination. */ CloseHandle(driver_exec->exec_stdin[PIPE_READ]); CloseHandle(driver_exec->exec_stdout[PIPE_WRITE]); CloseHandle(driver_exec->exec_stdout[PIPE_WRITE]); fprintf(stderr, "Successfully created the process!\n\n"); /* Create a socket_id value - this is a totally arbitrary value that's only used so we can find this entry later. */ driver_exec->socket_id = --driver_exec->socket_id; /* On Windows, add the sub-process's stdout as a pipe. */ select_group_add_pipe(driver_exec->group, driver_exec->socket_id, driver_exec->exec_stdout[PIPE_READ], driver_exec); select_set_recv(driver_exec->group, driver_exec->socket_id, exec_callback); select_set_closed(driver_exec->group, driver_exec->socket_id, exec_closed_callback); #else LOG_INFO("Attempting to start process '%s'...", driver_exec->process); /* Create communication channels. */ if(pipe(driver_exec->pipe_stdin) == -1) { LOG_FATAL("exec: couldn't create pipe (%d)", errno); exit(1); } if(pipe(driver_exec->pipe_stdout) == -1) { LOG_FATAL("exec: couldn't create pipe (%d)", errno); exit(1); } driver_exec->pid = fork(); if(driver_exec->pid == -1) { LOG_FATAL("exec: couldn't create process (%d)", errno); exit(1); } /* If we're in the child process... */ if(driver_exec->pid == 0) { /* Copy the pipes. */ if(dup2(driver_exec->pipe_stdin[PIPE_READ], STDIN_FILENO) == -1) nbdie("exec: couldn't duplicate STDIN handle"); if(dup2(driver_exec->pipe_stdout[PIPE_WRITE], STDOUT_FILENO) == -1) nbdie("exec: couldn't duplicate STDOUT handle"); if(dup2(driver_exec->pipe_stdout[PIPE_WRITE], STDERR_FILENO) == -1) nbdie("exec: couldn't duplicate STDERR handle"); /* Execute the new process. */ execlp("/bin/sh", "sh", "-c", driver_exec->process, (char*) NULL); /* If execlp returns, bad stuff happened. */ LOG_FATAL("exec: execlp failed (%d)", errno); exit(1); } LOG_WARNING("Started: %s (pid: %d)", driver_exec->process, driver_exec->pid); close(driver_exec->pipe_stdin[PIPE_READ]); close(driver_exec->pipe_stdout[PIPE_WRITE]); /* Add the sub-process's stdout as a socket. */ select_group_add_socket(driver_exec->group, driver_exec->pipe_stdout[PIPE_READ], SOCKET_TYPE_STREAM, driver_exec); select_set_recv(driver_exec->group, driver_exec->pipe_stdout[PIPE_READ], exec_callback); select_set_closed(driver_exec->group, driver_exec->pipe_stdout[PIPE_READ], exec_closed_callback); #endif return driver_exec; }
static NBBOOL session_attach_process(sessions_t *sessions, session_t *session, char *process) { #ifdef WIN32 STARTUPINFOA startupInfo; PROCESS_INFORMATION processInformation; SECURITY_ATTRIBUTES sa; session_group_t *session_group = (session_group_t*) safe_malloc(sizeof(session_group_t)); session_group->session = session; session_group->sessions = sessions; /* Create a security attributes structure. This is required to inherit handles. */ ZeroMemory(&sa, sizeof(SECURITY_ATTRIBUTES)); sa.nLength = sizeof(SECURITY_ATTRIBUTES); sa.lpSecurityDescriptor = NULL; sa.bInheritHandle = TRUE; /* Create the anonymous pipes. */ if(!CreatePipe(&session->exec_stdin[PIPE_READ], &session->exec_stdin[PIPE_WRITE], &sa, 0)) nbdie("exec: Couldn't create pipe for stdin"); if(!CreatePipe(&session->exec_stdout[PIPE_READ], &session->exec_stdout[PIPE_WRITE], &sa, 0)) nbdie("exec: Couldn't create pipe for stdout"); fprintf(stderr, "Attempting to load the program: %s\n", process); /* Initialize the STARTUPINFO structure. */ ZeroMemory(&startupInfo, sizeof(STARTUPINFO)); startupInfo.cb = sizeof(STARTUPINFO); startupInfo.dwFlags = STARTF_USESTDHANDLES; startupInfo.hStdInput = session->exec_stdin[PIPE_READ]; startupInfo.hStdOutput = session->exec_stdout[PIPE_WRITE]; if(!sessions->exec_no_stderr) startupInfo.hStdError = session->exec_stdout[PIPE_WRITE]; /* Initialize the PROCESS_INFORMATION structure. */ ZeroMemory(&processInformation, sizeof(PROCESS_INFORMATION)); /* Create the actual process with an overly-complicated CreateProcess function. */ if(!CreateProcessA(NULL, process, 0, &sa, TRUE, CREATE_NO_WINDOW, 0, NULL, &startupInfo, &processInformation)) { fprintf(stderr, "Failed to create the process"); exit(1); } /* Save the process id and the handle. */ session->pid = processInformation.dwProcessId; session->exec_handle = processInformation.hProcess; session->socket_id = --sessions->current_socket_id; /* Close the duplicate pipes we created -- this lets us detect the proicess termination. */ CloseHandle(session->exec_stdin[PIPE_READ]); CloseHandle(session->exec_stdout[PIPE_WRITE]); if(!sessions->exec_no_stderr) CloseHandle(session->exec_stdout[PIPE_WRITE]); fprintf(stderr, "Successfully created the process!\n\n"); /* On Windows, add the sub-process's stdout as a pipe. */ select_group_add_pipe(sessions->select_group, session->socket_id, session->exec_stdout[PIPE_READ], session_group); select_set_recv(sessions->select_group, session->socket_id, exec_callback); select_set_closed(sessions->select_group, session->socket_id, exec_closed_callback); #else session_group_t *session_group = (session_group_t*) safe_malloc(sizeof(session_group_t)); session_group->session = session; session_group->sessions = sessions; fprintf(stderr, "Attempting to start process '%s' for session %s\n", process, session->name); /* Create communication channels. */ if(pipe(session->exec_stdin) == -1) nbdie("exec: couldn't create pipe for STDIN"); if(pipe(session->exec_stdout) == -1) nbdie("exec: couldn't create pipe for STDOUT"); session->pid = fork(); if(session->pid == -1) nbdie("exec: couldn't create process"); if(session->pid == 0) { /* Copy the pipes. */ if(dup2(session->exec_stdin[PIPE_READ], STDIN_FILENO) == -1) nbdie("exec: couldn't duplicate STDIN handle"); if(dup2(session->exec_stdout[PIPE_WRITE], STDOUT_FILENO) == -1) nbdie("exec: couldn't duplicate STDOUT handle"); if(sessions->exec_no_stderr) { session->exec_stdout[PIPE_WRITE] = 0; } else { if(dup2(session->exec_stdout[PIPE_WRITE], STDERR_FILENO) == -1) nbdie("exec: couldn't duplicate STDERR handle"); } /* Execute the new process. */ execlp("/bin/sh", "sh", "-c", process, (char*) NULL); /* If execlp returns, bad stuff happened. */ fprintf(stderr, "exec: execlp failed"); return FALSE; } fprintf(stderr, "Started: %s (pid: %d)\n", process, session->pid); close(session->exec_stdin[PIPE_READ]); close(session->exec_stdout[PIPE_WRITE]); /* On Linux, add the sub-process's stdout as a socket. */ select_group_add_socket(sessions->select_group, session->exec_stdout[PIPE_READ], SOCKET_TYPE_STREAM, session_group); select_set_recv(sessions->select_group, session->exec_stdout[PIPE_READ], exec_callback); select_set_closed(sessions->select_group, session->exec_stdout[PIPE_READ], exec_closed_callback); #endif return TRUE; }