/**
* Start a background process.
*/
void background(char *args[ARGS_SIZE]) {
char *command = args[0];
pid_t pid;
pid_t group_id = getpid();
int return_value = 0;
signal(SIGINT, SIG_IGN);
pid = fork();
if (pid == 0) {
return_value = setpgid(0, group_id);
check_return_value(return_value, "FAILED DUDE");
run_child(args, command);
return;
} else if (pid > 0) {
return_value = setpgid(pid, group_id);
check_return_value(return_value, "FAILED DUDE2");
} else if (pid < 0) {
/* System fork err */
printf("Fork failed");
exit(0xCC);
}
}
void
login(CK_SESSION_HANDLE session, CK_BYTE *pin) {
CK_RV rv;
if (pin) {
rv = C_Login(session, CKU_USER, pin, strlen((char *) pin));
check_return_value(rv, "log in");
}
}
void
logout(CK_SESSION_HANDLE session) {
CK_RV rv;
rv = C_Logout(session);
if (rv != CKR_USER_NOT_LOGGED_IN) {
check_return_value(rv, "log out");
}
}
CK_SESSION_HANDLE
start_session(CK_SLOT_ID slotId) {
CK_RV rv;
CK_SESSION_HANDLE session;
rv = C_OpenSession(slotId,
CKF_SERIAL_SESSION | CKF_RW_SESSION,
NULL,
NULL,
&session);
check_return_value(rv, "open session");
return session;
}
void change_var(t_ast *node, t_shpt *g_shpt, int i)
{
t_ast *tmp;
t_ast *ret;
tmp = node;
while (tmp->token->token[0] == '-')
tmp = tmp->brother;
ret = tmp;
change_sht(tmp, i, g_shpt);
g_pid_loop->return_value = check_return_value(ret, 2);
}
CK_SLOT_ID
get_slot() {
CK_RV rv;
CK_SLOT_ID slotId;
CK_ULONG slotCount = 10;
CK_SLOT_ID *slotIds = malloc(sizeof(CK_SLOT_ID) * slotCount);
rv = C_GetSlotList(CK_TRUE, slotIds, &slotCount);
check_return_value(rv, "get slot list");
if (slotCount < 1) {
free(slotIds);
fprintf(stderr, "Error; could not find any slots\n");
exit(1);
}
slotId = slotIds[0];
free(slotIds);
printf("slot count: %d\n", (int) slotCount);
return slotId;
}
/**
* Wait for a child to terminate.
*/
void wait_for_child() {
int status;
pid_t child_pid;
child_pid = wait(&status);
check_return_value(child_pid, "Wait failed.");
if (WIFEXITED((status))) {
int child_status = WEXITSTATUS((status));
if (0 != child_status) /* child had problems */
{
fprintf(stderr, "Child (pid %ld) failed with exit code %d\n",
(long int) child_pid, child_status);
}
} else {
if (WIFSIGNALED((status))) /* child-processen avbröts av signal */
{
int child_signal = WTERMSIG((status));
fprintf(stderr, "Child (pid %ld) was terminated by signal no. %d\n",
(long int) child_pid, child_signal);
}
}
}
int my_shopt(t_ast *node)
{
t_ast *tmp;
if (node->brother == NULL)
{
print_shopt(g_shpt);
g_pid_loop->return_value = 0;
return (0);
}
if (node->brother->token->token[0] == '-')
option(node);
else
{
tmp = node;
while (tmp)
{
valid_or_not_valid(tmp);
tmp = tmp->brother;
}
g_pid_loop->return_value = check_return_value(node, 1);
}
return (g_pid_loop->return_value);
}
void
end_session(CK_SESSION_HANDLE session) {
CK_RV rv;
rv = C_CloseSession(session);
check_return_value(rv, "close session");
}
/**
* execute the checkEnv command.
*/
void cmd_check_env(char *args[ARGS_SIZE]) {
int fd_descriptor_env_sort[2];
int fd_descriptor_sort_pager[2];
int fd_descriptor_grep_sort[2];
pid_t env_child, sort_child, grep_child, pager_child;
int grep = FALSE;
int return_value;
sighold(SIGCHLD);
create_pipe(fd_descriptor_env_sort);
create_pipe(fd_descriptor_sort_pager);
create_pipe(fd_descriptor_grep_sort);
env_child = fork();
if (env_child == 0) {
return_value = dup2(fd_descriptor_env_sort[PIPE_WRITE], STDOUT_FILENO);
check_return_value(return_value, "Error: cannot dup2 1");
close_all_pipes(fd_descriptor_env_sort, fd_descriptor_sort_pager, fd_descriptor_grep_sort);
print_environment();
exit(EXIT_SUCCESS);
} else if (env_child == -1) {
perror("Error forking.");
exit(EXIT_FAILURE);
}
if(args[1] != NULL) {
grep = TRUE;
grep_child = fork();
if(grep_child == 0) {
return_value = dup2(fd_descriptor_env_sort[PIPE_READ], STDIN_FILENO);
check_return_value(return_value, "Error: cannot dup2 2");
return_value = dup2(fd_descriptor_grep_sort[PIPE_WRITE], STDOUT_FILENO);
check_return_value(return_value, "Error: cannot dup2 3");
close_all_pipes(fd_descriptor_env_sort, fd_descriptor_sort_pager, fd_descriptor_grep_sort);
args[0] = "grep";
return_value = execvp(args[0], args);
check_return_value(return_value, "Error: execution failed.");
} else if(grep_child == -1){
perror("Error forking.");
exit(EXIT_FAILURE);
}
}
sort_child = fork();
if (sort_child == 0) {
char * argp[] = {"sort", NULL};
if(grep == TRUE) {
return_value = dup2(fd_descriptor_grep_sort[PIPE_READ], STDIN_FILENO);
check_return_value(return_value, "Error: cannot dup2 3");
} else {
return_value = dup2(fd_descriptor_env_sort[PIPE_READ], STDIN_FILENO);
check_return_value(return_value, "Error: cannot dup2 4");
}
return_value = dup2(fd_descriptor_sort_pager[PIPE_WRITE], STDOUT_FILENO);
check_return_value(return_value, "Error: cannot dup2 5");
close_all_pipes(fd_descriptor_env_sort, fd_descriptor_sort_pager, fd_descriptor_grep_sort);
args[0] = "sort";
return_value = execvp(args[0], argp);
check_return_value(return_value, "Error: execution failed.");
} else if (sort_child == -1) {
perror("Error forking.");
exit(EXIT_FAILURE);
}
pager_child = fork();
if (pager_child == 0) {
char * argp[] = {"less", NULL};
return_value = dup2(fd_descriptor_sort_pager[PIPE_READ], STDIN_FILENO);
check_return_value(return_value, "Error: cannot dup2 6");
close_all_pipes(fd_descriptor_env_sort, fd_descriptor_sort_pager, fd_descriptor_grep_sort);
if(getenv("PAGER") != NULL) {
argp[0] = getenv("PAGER");
}
return_value = execvp(argp[0], argp);
check_return_value(return_value, "Error: execution failed.");
} else if (pager_child == -1) {
perror("Error forking.");
exit(EXIT_FAILURE);
}
close_all_pipes(fd_descriptor_env_sort, fd_descriptor_sort_pager, fd_descriptor_grep_sort);
wait_for_child();
wait_for_child();
wait_for_child();
if(grep == TRUE) wait_for_child();
sigrelse(SIGCHLD);
}
