/*! \brief * Prepend own uri to Path header */ int add_path(struct sip_msg* _msg, char* _a, char* _b) { str user = {0,0}; int ret; path_param_t param = PATH_PARAM_NONE; struct via_body *via; if (path_obb.use_outbound != NULL && path_obb.use_outbound(_msg)) { if (path_obb.encode_flow_token(&user, _msg->rcv) != 0) { LM_ERR("encoding outbound flow-token\n"); return -1; } /* Only include ;ob parameter if this is the first-hop (that means only one Via:) */ if (parse_via_header(_msg, 2, &via) < 0) param = PATH_PARAM_OB; } ret = prepend_path(_msg, &user, param); if (user.s != NULL) pkg_free(user.s); return ret; }
/* * Runs commands in sequential mode. */ char sequential_mode(char **pointers_to_commands, Node *head) { char mode = 's'; pid_t cpid, w; char **command; char return_char = 's'; int i = 0; while (pointers_to_commands[i] != NULL) { command = tokenify(pointers_to_commands[i], " \n\t"); if (command[0] == NULL) { i++; free_tokens(command); continue; } if (handle_exit(command) != 'n') { free_tokens(command); return 'e'; } if (return_char != 'e' && is_mode(command)) { return_char = handle_mode(command, mode, return_char); i++; free_tokens(command); continue; } handle_parallel_builtins(command, NULL, NULL, mode); cpid = fork(); if (cpid == 0) { char *tempcommand; tempcommand = prepend_path(command, head); command[0] = tempcommand; if (execv(command[0], command) < 0) { fprintf(stderr, "execv failed: %s\n", strerror(errno)); printf("That's not a valid command! \n"); free_tokens(command); exit(EXIT_FAILURE); } free(tempcommand); } else { int status = 0; w = wait(&status); i++; } free_tokens(command); } return return_char; }
/* * Runs commands in parallel mode, with support for background processes. */ char parallel_mode(char **pointers_to_commands, Node *head, Node **paused_list, Node **cpidlist) { int count = 0; // counts the no. of times we've been in the loop; // if more than 1, we need to free // pointers_to_commands, which is different from what we got from main. while (1) { count++; char mode = 'p'; pid_t cpid; char **command; char return_char = 'p'; int i = 0; while (pointers_to_commands[i] != NULL) { command = tokenify(pointers_to_commands[i], " \n\t"); if (command[0] == NULL) { i++; free_tokens(command); continue; } if (handle_exit(command) != 'n') { if (*cpidlist == NULL && pointers_to_commands[i+1] == NULL) { return_char = 'e'; } else { printf("There are processes still running. You cannot exit yet. \n"); } free_tokens(command); i++; continue; } if (is_mode(command)) { return_char = handle_mode(command, mode, return_char); if (return_char == 's') { if (*cpidlist != NULL || pointers_to_commands[i+1] != NULL) { printf("There are processes running. You cannot switch modes yet.\n"); return_char = 'p'; } } free_tokens(command); i++; continue; } if (handle_parallel_builtins(command, paused_list, cpidlist, mode) == 1) { i++; free_tokens(command); continue; } cpid = fork(); if (cpid == 0) { char *tempcommand; tempcommand = prepend_path(command, head); command[0]= tempcommand; if (execv(command[0], command) < 0) { fprintf(stderr, "execv failed: %s\n", strerror(errno)); printf("That's not a valid command! \n"); free_tokens(command); exit(EXIT_FAILURE); } } else { char whole_command[128]; memset(whole_command, '\0', 128); strcat(whole_command, command[0]); if (command[1] != NULL) { strcat(whole_command, " "); strcat(whole_command, command[1]); } char cpidstr[128]; sprintf(cpidstr, "%d", cpid); list_append(cpidstr, whole_command, cpidlist); } i++; free_tokens(command); } if (count > 1) { free_tokens(pointers_to_commands); } if (return_char != 'p') { return return_char; } struct pollfd pfd[1]; pfd[0].fd = 0; pfd[0].events = POLLIN; pfd[0].revents = 0; display_prompt(); int some_process_completed = 0; while (1) { int status; int rv = poll(&pfd[0], 1, 800); Node *to_delete_list = NULL; Node *tempcpidlist = *cpidlist; pid_t w; if (rv == 0) { some_process_completed = 0; while (tempcpidlist != NULL) { w = atoi(tempcpidlist->data); // I know that the ideal way to check for child process death is to use a macro such as WIFEXITED on status, // but it wasn't working for me. // status always had the value 0. So I'm doing this instead to check for process completion. if (waitpid(w, &status, WUNTRACED|WNOHANG) == -1) { list_append(tempcpidlist->data, "", &to_delete_list); printf("\nProcess %s (%s) completed.\n", tempcpidlist->data, tempcpidlist->additional_data); some_process_completed = 1; } tempcpidlist = tempcpidlist->next; } Node *curr = to_delete_list; while (curr != NULL) { list_delete(curr->data, cpidlist); curr = curr->next; } list_clear(to_delete_list); if (some_process_completed == 1) { display_prompt(); } } else if (rv > 0) { char buffer[1024]; if (fgets(buffer, 1024, stdin) == NULL) { if (*cpidlist != NULL) { printf("There are processes still running. You can't exit now.\n"); display_prompt(); } else { return_char = 'e'; return return_char; } } else { char *newbuffer = replace_pound(buffer); newbuffer[strlen(newbuffer)-1] = '\0'; pointers_to_commands = tokenify(newbuffer, ";"); free(newbuffer); break; } } else { printf("there was some kind of error: %s \n", strerror(errno)); } } } }
/*! \brief * Prepend own uri to Path header and append received address as * "received"-param to that uri and take care of given user. */ int add_path_received_usr(struct sip_msg* _msg, char* _usr, char* _b) { return prepend_path(_msg, (str*)_usr, PATH_PARAM_RECEIVED); }
/*! \brief * Prepend own uri to Path header and append received address as * "received"-param to that uri. */ int add_path_received(struct sip_msg* _msg, char* _a, char* _b) { str user = {0,0}; return prepend_path(_msg, &user, PATH_PARAM_RECEIVED); }
/*! \brief * Prepend own uri to Path header and take care of given * user. */ int add_path_usr(struct sip_msg* _msg, char* _usr, char* _b) { return prepend_path(_msg, (str*)_usr, PATH_PARAM_NONE); }