t_token *glob_gest_tok_list(t_token *t, t_global *glob, int flag, char *str) { t_token *tmp; t_token *tmp2; t_token *tmp3; (flag == 0) ? (tmp = creat_list_token(t->content, glob, 0)) : (tmp = analyse_cmd(t->content)); if (str) (check_alias(tmp, str)); if (t && tmp) { tmp2 = t->next; (t->content) ? free(t->content) : (NULL); t->content = my_strdup(tmp->content); t->id = tmp->id; t->spec = tmp->spec; (tmp->content) ? (free(tmp->content)) : (tmp->content = NULL); (tmp->next) ? (t->next = tmp->next) : (t->next = t->next); tmp3 = tmp; tmp = tmp->next; tmp3 ? (free(tmp3)) : (tmp3 = tmp3); while (tmp && tmp->next) tmp = tmp->next; (tmp) ? tmp->next = tmp2 : (tmp = t); } return (t); }
int EVP_AEAD_CTX_seal(const EVP_AEAD_CTX *ctx, uint8_t *out, size_t *out_len, size_t max_out_len, const uint8_t *nonce, size_t nonce_len, const uint8_t *in, size_t in_len, const uint8_t *ad, size_t ad_len) { size_t possible_out_len = in_len + ctx->aead->overhead; if (possible_out_len < in_len /* overflow */) { OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE); goto error; } if (!check_alias(in, in_len, out)) { OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_OUTPUT_ALIASES_INPUT); goto error; } if (ctx->aead->seal(ctx, out, out_len, max_out_len, nonce, nonce_len, in, in_len, ad, ad_len)) { return 1; } error: /* In the event of an error, clear the output buffer so that a caller * that doesn't check the return value doesn't send raw data. */ memset(out, 0, max_out_len); *out_len = 0; return 0; }
t_token *glob_gest_tok_list(t_token *t, t_global *glob, int flag, char *str) { t_token *tmp; t_token *tmp2; if (flag == 0) tmp = creat_list_token(t->content, glob); else tmp = analyse_cmd(t->content); if (str) check_alias(tmp, str); if (t && tmp) { tmp2 = t->next; t->content = tmp->content; t->id = tmp->id; t->spec = tmp->spec; if (tmp->next) t->next = tmp->next; tmp = tmp->next; while (tmp && tmp->next) tmp = tmp->next; if (tmp) tmp->next = tmp2; } return (t); }
int EVP_AEAD_CTX_seal(const EVP_AEAD_CTX *ctx, unsigned char *out, size_t *out_len, size_t max_out_len, const unsigned char *nonce, size_t nonce_len, const unsigned char *in, size_t in_len, const unsigned char *ad, size_t ad_len) { size_t possible_out_len = in_len + ctx->aead->overhead; /* Overflow. */ if (possible_out_len < in_len) { EVPerr(EVP_F_AEAD_CTX_SEAL, EVP_R_TOO_LARGE); goto error; } if (!check_alias(in, in_len, out)) { EVPerr(EVP_F_AEAD_CTX_SEAL, EVP_R_OUTPUT_ALIASES_INPUT); goto error; } if (ctx->aead->seal(ctx, out, out_len, max_out_len, nonce, nonce_len, in, in_len, ad, ad_len)) { return 1; } error: /* In the event of an error, clear the output buffer so that a caller * that doesn't check the return value doesn't send raw data. */ memset(out, 0, max_out_len); *out_len = 0; return 0; }
char my_execve(char **command, t_list *env, char *path) { char **tabenv; int status; pid_t pid; int i; char *error; pid = fork(); tabenv = NULL; error = NULL; if (pid == -1) my_puterror("Impossible, error with pid"); else if (pid == 0) { i = 0; tabenv = conv_list(env); error = recursive_execve(my_str_to_wordtab(path, ':'), check_alias(command), tabenv, i); execve_error(error, command, tabenv); } else if (wait(&status) == -1) my_puterror("Impossible to use wait\n"); if (WTERMSIG(status) == 11) my_putstr("Segmentation fault (core dumped)\n"); return (0); }
void execute(char *cmd) { /* Arguments: *cmd --- the program to run Purpose: this function takes a string and forks off a new process with the global args array this will first check to see if aliases exist for the command. check_alias will deal with changing arg[0] if an alias exists, so always call execvp with arg[0] (instead of cmd arg) in case check_alias changes the cmd it will then check to see if the cmd is a built in command. if it is, then this doesnt fork any process */ int i; check_alias(cmd); i = check_builtin(args[0]); if(!i) { return;} //cmd was a built in (like "cd") if(fork() == 0) { //now in child process check_redir(); //check for redirections i = execvp(args[0], args); //using execvp to avoid PATH crap if(i < 0) { printf("-fash: %s: command not found\n", cmd); //error, we'll just say not found exit(1); } } else { handleSig = 1; wait(NULL); } handleSig = 0; }
void pipe_execute(char *cmd, int readWrite) { /* Arguments: *cmd --- the program to run *fds --- array of two file descriptors for pipe readWrite --- 0 = read, 1 = write, 2 = both Purpose: this function takes a string and forks off a new process with the global args array this will first check to see if aliases exist for the command. check_alias will deal with changing arg[0] if an alias exists, so always call execvp with arg[0] (instead of cmd arg) in case check_alias changes the cmd it will then check to see if the cmd is a built in command. if it is, then this doesnt fork any process */ int i; check_alias(cmd); i = check_builtin(args[0]); if(!i) { return;} //cmd was a built in (like "cd") if(fork() == 0) { //in child check_redir(); int newfd, readfd, writefd; if(readWrite == 2){ //this is a middle command, no closing, dup both stdin and stdout readfd = open("pipe", O_RDONLY); writefd = open("pipe_middle", O_WRONLY | O_CREAT, S_IRWXU | S_IRGRP | S_IROTH); close(0); dup(readfd); close(1); dup(writefd); }else if (readWrite == 1){ //first command, purely writing newfd = open("pipe", O_WRONLY | O_CREAT, S_IRWXU | S_IRGRP | S_IROTH); dup2(newfd,1); close(newfd); }else{ //last command, purely reading newfd = open("pipe", O_RDONLY); close(0); dup(newfd); close(newfd); } i = execvp(args[0], args); if(i < 0) { printf("-fash: %s: command not found\n", cmd); //error, we'll just say not found exit(1); } if(readWrite == 0){ close(0);close(newfd);} else if(readWrite ==1){close(1);close(newfd);} else{ close(0);close(1);close(readfd);close(writefd);system("mv pipe_middle pipe");} } else {wait(NULL);} //wait for everyone }
char *remplace_alias(char *cmd, char **alias) { char **wordtab; int a; if ((a = check_alias(cmd, alias)) != -1) { wordtab = my_wordtab_sep(alias[a], '"'); return (wordtab[1]); } else return (cmd); }
void s3_list_cb(gpointer ignored, gpointer bean) { (void) ignored; if(max > 0) { if(DESCR(bean) == &descr_struct_ALIASES) { check_alias(bean); max--; if(0 == max) next_marker = g_strdup(ALIASES_get_alias(bean)->str); } else { _get_cb(obc, bean); } return; } if(DESCR(bean) == &descr_struct_ALIASES) { truncated = TRUE; } _bean_clean(bean); }
int main(int argc, char *argv[]) { void *fdt; test_init(argc, argv); fdt = load_blob_arg(argc, argv); check_alias(fdt, "/subnode@1", "s1"); check_alias(fdt, "/subnode@1/subsubnode", "ss1"); check_alias(fdt, "/subnode@1/subsubnode", "s1/subsubnode"); check_alias(fdt, "/subnode@1/subsubnode/subsubsubnode", "sss1"); check_alias(fdt, "/subnode@1/subsubnode/subsubsubnode", "ss1/subsubsubnode"); check_alias(fdt, "/subnode@1/subsubnode/subsubsubnode", "s1/subsubnode/subsubsubnode"); PASS(); }
int EVP_AEAD_CTX_open(const EVP_AEAD_CTX *ctx, uint8_t *out, size_t *out_len, size_t max_out_len, const uint8_t *nonce, size_t nonce_len, const uint8_t *in, size_t in_len, const uint8_t *ad, size_t ad_len) { if (!check_alias(in, in_len, out)) { OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_OUTPUT_ALIASES_INPUT); goto error; } if (ctx->aead->open(ctx, out, out_len, max_out_len, nonce, nonce_len, in, in_len, ad, ad_len)) { return 1; } error: /* In the event of an error, clear the output buffer so that a caller * that doesn't check the return value doesn't try and process bad * data. */ memset(out, 0, max_out_len); *out_len = 0; return 0; }
int parse_and_execute (char *line) { char *cmd = NULL; char * args [MAX_TOKENS]; cmdnode_t *cmd_node = NULL; int error_code = -1; if (!(cmd = check_alias (line))) { cmd = line; } if (!(cmd_node = search_command (cmd, &args, &error_code))) { write_string (cli_error[error_code]); return -1; } if (!(get_curr_priv_level () & cmd_node->priv_mode)) { write_string (cli_error[ERR_INVALID_COMMAND]); return 0; } execute_cmd (cmd_node, args); return 0; }
void exe_alias(char **args, int argc, struct alias_List * list) { char buf[256+1]; if(argc==1){ //show the alias list. // printf("%s\n", "show alias"); show_alias(list); return; } else if(argc==2){ if(strcmp(args[1],"-a")==0){ // add here if have time! // remove all the node in alias list alias_List_remove_all(list); return; }else{ // printf("%s\n", "add or check alias"); if(strlen(args[1])>256){ fprintf(stderr, "%s\n", "alias: too long"); return; } strncpy(buf,args[1],strlen(args[1])+1); buf[strlen(args[1])]='\0'; char *left; char *right; parseAlias(buf,&left,&right); if(!right){ //add new show_alias_one(list,left); }else{ // printf("%s\n", "add"); //add the alias to the list if(check_alias(list,left)){ update_alias(list,left,right); }else{ char *left_value = calloc(strlen(left)+1,sizeof(char)); strncpy(left_value,left,strlen(left)+1); char *right_value = calloc(strlen(right)+1,sizeof(char)); strncpy(right_value,right,strlen(right)+1); alias_List_push(list,left_value,right_value); } } } } else { fprintf(stderr, "%s\n", "format error"); } }
static int get_aliasname(char *aliasname, char *buffer, int *duplicate) { /* * Have the user enter an aliasname, check to see if it * is legal, then check for duplicates. If a duplicate * is found offer to replace existing alias. * * Return values: * * -1 Either the aliasname was zero length, had bad * characters and was a duplicate which the user * chose not to replace. * * 0 A new alias was entered successfully. * * 1 The entered alias was an existing USER alias * that the user has chosen to replace. In this * case the alias to replace is passed back in * in the variable 'duplicate'. */ int loc; do { if (enter_string(aliasname, SLEN, LINES-2, strlen(buffer), ESTR_REPLACE) < 0 || aliasname[0] == '\0') return(-1); } while (check_alias(aliasname) == -1); clear_error(); /* Just in case */ /* * Check to see if there is already a USER alias by this name. */ if ((loc = find_alias(aliasname, USER)) >= 0) { dprint(3, (debugfile, "Attempt to add a duplicate alias [%s] in get_aliasname\n", aliases[loc]->alias)); if (aliases[loc]->type & GROUP ) PutLine(LINES-2,0, catgets(elm_msg_cat, AliasesSet, AliasesAlreadyGroup, "Already a group with name %s."), aliases[loc]->alias); else PutLine(LINES-2,0, catgets(elm_msg_cat, AliasesSet, AliasesAlreadyAlias, "Already an alias for %s."), aliases[loc]->alias); CleartoEOLN(); /* * If they don't want to replace the alias by that name * then just return. */ if (!enter_yn(catgets(elm_msg_cat, AliasesSet, AliasesReplaceExisting, "Replace existing alias?"), FALSE, LINES-3, FALSE)) return(-1); *duplicate = loc; return(1); } /* * If they have elected to replace an existing alias then * we assume that they would also elect to superceed a * system alias by that name (since they have already * done so). So we don't even bother to check or ask. * * Of course we do check if there was no USER alias match. */ if ((loc = find_alias(aliasname, SYSTEM)) >= 0) { dprint(3, (debugfile, "Attempt to add a duplicate system alias [%s] in get_aliasname\n", aliases[loc]->address)); if( ! superceed_system(loc)) return(-1); } return(0); }
static EncaCharsetRaw* read_raw_charset_data(FILE *stream, int *rsize) { char *line; EncaCharsetRaw *r, *raw; int rs; char *gl; line = (char*)malloc(LEN); r = raw = (EncaCharsetRaw*)malloc(sizeof(EncaCharsetRaw)); *r = RawNULL; rs = 1; while (1) { gl = fgets(line, LEN, stream); if (r->enca && r->rfc1345 && r->cstocs && r->human && r->iconv && r->mime && r->flags && r->nsurface && r->aliases) { if (r->enca[0] == '\0') { fprintf(stderr, "Enca's charset name #%d empty\n", (int)(r - raw + 1)); exit(1); } if (r->rfc1345[0] == '\0') { fprintf(stderr, "RFC-1345 charset name #%d empty\n", (int)(r - raw + 1)); exit(1); } if (r->iconv[0] == '\0') r->iconv = NULL; if (r->cstocs[0] == '\0') r->cstocs = NULL; if (r->mime[0] == '\0') r->mime = NULL; if (r->nsurface[0] == '\0') r->nsurface = strdup("0"); r->aliases = check_alias(r->aliases, &r->naliases, r->enca); r->aliases = check_alias(r->aliases, &r->naliases, r->iconv); r->aliases = check_alias(r->aliases, &r->naliases, r->rfc1345); r->aliases = check_alias(r->aliases, &r->naliases, r->mime); r->aliases = check_alias(r->aliases, &r->naliases, r->cstocs); if (!gl) break; rs++; { int d = r - raw; raw = (EncaCharsetRaw*)realloc(raw, rs*sizeof(EncaCharsetRaw)); r = raw + d + 1; } *r = RawNULL; } line[LEN-1] = '\0'; fixspaces(line); if (line[0] == '\0' || line[0] == '#') continue; if (add_item(line, "enca:", &r->enca)) continue; if (add_item(line, "rfc:", &r->rfc1345)) continue; if (add_item(line, "iconv:", &r->iconv)) continue; if (add_item(line, "mime:", &r->mime)) continue; if (add_item(line, "cstocs:", &r->cstocs)) continue; if (add_item(line, "human:", &r->human)) continue; if (add_item(line, "flags:", &r->flags)) continue; if (add_item(line, "nsurface:", &r->nsurface)) continue; if (strncmp(line, "aliases:", 8) == 0 && !r->aliases) { int i; char *next, *l = fixspaces(line+8); r->naliases = 1; while ((l = strchr(l, ' ')) != NULL) { r->naliases++; l++; } r->aliases = (char**)malloc((r->naliases)*sizeof(char*)); l = line+8; for (i = 0; i < r->naliases; i++) { next = strchr(l, ' '); if (next) *next = '\0'; r->aliases[i] = strdup(l); l = next+1; } continue; } fprintf(stderr, "Unexpected `%s'\n", line); exit(1); } *rsize = rs; return raw; }
/*************************************************************************** Function: modify_alias Description: read old alias and check, write new alias to alias.conf & push to cloud server Input: cgi_result, the return value of cgiFormString old_alias_str, null terminated, not check yet new_alias_str, null terminated, already check Output: Return: 0 OK, other Error Others: none ***************************************************************************/ int modify_alias(cgiFormResultType cgi_result, const char * old_alias_str, const char * new_alias_str) { int fd_alias; char gateway_alias[FEATURE_GDGL_ACCOUNT_MAX_LEN + 1]; int res; int len, tries = 5; int mqid; struct client_admin_msgbuf mesg; fd_alias = open(FEATURE_GDGL_ALIAS_PATH, O_RDWR, 0777); if (fd_alias < 0) { return clientAdminAliasFileOpenErr; } res = write_lock(fd_alias, 0, SEEK_SET, 0); if (res == -1) { close(fd_alias); return clientAdminAliasFileLockErr; } // Read old alias res = read(fd_alias, gateway_alias, FEATURE_GDGL_ACCOUNT_MAX_LEN); if (res < 0) { close(fd_alias); return clientAdminAliasFileReadErr; } gateway_alias[res] = '\0'; //add yanly150625 if((gateway_alias[res-1] == 0x0a)||(gateway_alias[res-1] == 0x0d)) { //如果最后一个字符等于换行符号或者回车键,就换成结束符 gateway_alias[res-1] = '\0'; } // Check old alias res = check_alias(cgi_result, old_alias_str, gateway_alias); if (res != 0) { close(fd_alias); return res; } // Check if old == new if (strcmp(old_alias_str, new_alias_str) == 0) { close(fd_alias); return clientAdminTwoAliasEqualErr; } // Push to cloud //if push failed, return push error if ( (res = push_to_cloud(modifyAliasType, "modifyalias", old_alias_str, new_alias_str)) < 0 ) { close(fd_alias); return clientAdminPushToCloudErr; } else if (res > 0) { close(fd_alias); return res; } // Write new alias len = strlen(new_alias_str); while (tries > 0) { // seek to beginning of file res = lseek(fd_alias, 0, SEEK_SET); if (res < 0) { close(fd_alias); return clientAdminAliasFileSeekErr; } // truncate the file to 0 byte res = ftruncate(fd_alias, 0); if (res < 0) { close(fd_alias); return clientAdminAliasFileTruncErr; } res = writen(fd_alias, new_alias_str, len); if (res != len) { tries--; } else { break; } } if (tries == 0) { close(fd_alias); return clientAdminAliasFileWriteErr; } close(fd_alias); //also unlock // Send IPC msg mqid = msgget(CLIENTADMIN_MQ_KEY, 0); if (mqid == -1) { CA_DEBUG("msgget error %d:%s\n", mqid, strerror(errno)); } else { len = construct_msg(clientAdmintMsgAlias, new_alias_str, &mesg); if (len > 0) { res = msgsnd(mqid, &mesg, len, 0); if (res == -1) { CA_DEBUG("msgsnd error %s\n", strerror(errno)); } } } return 0; }