/* * Process the commands arguments */ static const char *parse_cmd_args(sed_cmd_t *sed_cmd, const char *cmdstr) { /* handle (s)ubstitution command */ if (sed_cmd->cmd == 's') cmdstr += parse_subst_cmd(sed_cmd, cmdstr); /* handle edit cmds: (a)ppend, (i)nsert, and (c)hange */ else if (strchr("aic", sed_cmd->cmd)) { if ((sed_cmd->end_line || sed_cmd->end_match) && sed_cmd->cmd != 'c') bb_error_msg_and_die ("only a beginning address can be specified for edit commands"); for (;;) { if (*cmdstr == '\n' || *cmdstr == '\\') { cmdstr++; break; } else if (isspace(*cmdstr)) cmdstr++; else break; } sed_cmd->string = xstrdup(cmdstr); /* "\anychar" -> "anychar" */ parse_escapes(sed_cmd->string, sed_cmd->string, strlen(cmdstr), '\0', '\0'); cmdstr += strlen(cmdstr); /* handle file cmds: (r)ead */ } else if (strchr("rw", sed_cmd->cmd)) { if (sed_cmd->end_line || sed_cmd->end_match) bb_error_msg_and_die("command only uses one address"); cmdstr += parse_file_cmd(sed_cmd, cmdstr, &sed_cmd->string); if (sed_cmd->cmd == 'w') { sed_cmd->sw_file = xfopen(sed_cmd->string, "w"); sed_cmd->sw_last_char = '\n'; } /* handle branch commands */ } else if (strchr(":btT", sed_cmd->cmd)) { int length; cmdstr = skip_whitespace(cmdstr); length = strcspn(cmdstr, semicolon_whitespace); if (length) { sed_cmd->string = xstrndup(cmdstr, length); cmdstr += length; } } /* translation command */ else if (sed_cmd->cmd == 'y') { char *match, *replace; int i = cmdstr[0]; cmdstr += parse_regex_delim(cmdstr, &match, &replace)+1; /* \n already parsed, but \delimiter needs unescaping. */ parse_escapes(match, match, strlen(match), i, i); parse_escapes(replace, replace, strlen(replace), i, i); sed_cmd->string = xzalloc((strlen(match) + 1) * 2); for (i = 0; match[i] && replace[i]; i++) { sed_cmd->string[i*2] = match[i]; sed_cmd->string[i*2+1] = replace[i]; } free(match); free(replace); } /* if it wasnt a single-letter command that takes no arguments * then it must be an invalid command. */ else if (strchr("dDgGhHlnNpPqx={}", sed_cmd->cmd) == 0) { bb_error_msg_and_die("unsupported command %c", sed_cmd->cmd); } /* give back whatever's left over */ return cmdstr; }
int man_main(int argc UNUSED_PARAM, char **argv) { parser_t *parser; const char *pager; char **man_path_list; char *sec_list; char *cur_path, *cur_sect; int count_mp, cur_mp; int opt, not_found; char *token[2]; opt_complementary = "-1"; /* at least one argument */ opt = getopt32(argv, "+aw"); argv += optind; sec_list = xstrdup("1:2:3:4:5:6:7:8:9"); /* Last valid man_path_list[] is [0x10] */ count_mp = 0; man_path_list = xzalloc(0x11 * sizeof(man_path_list[0])); man_path_list[0] = getenv("MANPATH"); if (!man_path_list[0]) /* default, may be overridden by /etc/man.conf */ man_path_list[0] = (char*)"/usr/man"; else count_mp++; pager = getenv("MANPAGER"); if (!pager) { pager = getenv("PAGER"); if (!pager) pager = "more"; } /* Parse man.conf[ig] or man_db.conf */ /* man version 1.6f uses man.config */ /* man-db implementation of man uses man_db.conf */ parser = config_open2("/etc/man.config", fopen_for_read); if (!parser) parser = config_open2("/etc/man.conf", fopen_for_read); if (!parser) parser = config_open2("/etc/man_db.conf", fopen_for_read); while (config_read(parser, token, 2, 0, "# \t", PARSE_NORMAL)) { if (!token[1]) continue; if (strcmp("MANDATORY_MANPATH"+10, token[0]) == 0 /* "MANPATH"? */ || strcmp("MANDATORY_MANPATH", token[0]) == 0 ) { char *path = token[1]; while (*path) { char *next_path; char **path_element; next_path = strchr(path, ':'); if (next_path) { *next_path = '\0'; if (next_path++ == path) /* "::"? */ goto next; } /* Do we already have path? */ path_element = man_path_list; while (*path_element) { if (strcmp(*path_element, path) == 0) goto skip; path_element++; } man_path_list = xrealloc_vector(man_path_list, 4, count_mp); man_path_list[count_mp] = xstrdup(path); count_mp++; /* man_path_list is NULL terminated */ /*man_path_list[count_mp] = NULL; - xrealloc_vector did it */ skip: if (!next_path) break; next: path = next_path; } } if (strcmp("MANSECT", token[0]) == 0) { free(sec_list); sec_list = xstrdup(token[1]); } } config_close(parser); not_found = 0; do { /* for each argv[] */ int found = 0; cur_mp = 0; if (strchr(*argv, '/')) { found = show_manpage(pager, *argv, /*man:*/ 1, 0); goto check_found; } while ((cur_path = man_path_list[cur_mp++]) != NULL) { /* for each MANPATH */ cur_sect = sec_list; do { /* for each section */ char *next_sect = strchrnul(cur_sect, ':'); int sect_len = next_sect - cur_sect; char *man_filename; int cat0man1 = 0; /* Search for cat, then man page */ while (cat0man1 < 2) { int found_here; man_filename = xasprintf("%s/%s%.*s/%s.%.*s", cur_path, "cat\0man" + (cat0man1 * 4), sect_len, cur_sect, *argv, sect_len, cur_sect); found_here = show_manpage(pager, man_filename, cat0man1, 0); found |= found_here; cat0man1 += found_here + 1; free(man_filename); } if (found && !(opt & OPT_a)) goto next_arg; cur_sect = next_sect; while (*cur_sect == ':') cur_sect++; } while (*cur_sect); } check_found: if (!found) { bb_error_msg("no manual entry for '%s'", *argv); not_found = 1; } next_arg: argv++; } while (*argv); return not_found; }
static void cut_file(FILE *file, char delim, const struct cut_list *cut_lists, unsigned nlists) { char *line; unsigned linenum = 0; /* keep these zero-based to be consistent */ /* go through every line in the file */ while ((line = xmalloc_fgetline(file)) != NULL) { /* set up a list so we can keep track of what's been printed */ int linelen = strlen(line); char *printed = xzalloc(linelen + 1); char *orig_line = line; unsigned cl_pos = 0; int spos; /* cut based on chars/bytes XXX: only works when sizeof(char) == byte */ if (option_mask32 & (CUT_OPT_CHAR_FLGS | CUT_OPT_BYTE_FLGS)) { /* print the chars specified in each cut list */ for (; cl_pos < nlists; cl_pos++) { spos = cut_lists[cl_pos].startpos; while (spos < linelen) { if (!printed[spos]) { printed[spos] = 'X'; putchar(line[spos]); } spos++; if (spos > cut_lists[cl_pos].endpos /* NON_RANGE is -1, so if below is true, * the above was true too (spos is >= 0) */ /* || cut_lists[cl_pos].endpos == NON_RANGE */ ) { break; } } } } else if (delim == '\n') { /* cut by lines */ spos = cut_lists[cl_pos].startpos; /* get out if we have no more lists to process or if the lines * are lower than what we're interested in */ if (((int)linenum < spos) || (cl_pos >= nlists)) goto next_line; /* if the line we're looking for is lower than the one we were * passed, it means we displayed it already, so move on */ while (spos < (int)linenum) { spos++; /* go to the next list if we're at the end of this one */ if (spos > cut_lists[cl_pos].endpos || cut_lists[cl_pos].endpos == NON_RANGE ) { cl_pos++; /* get out if there's no more lists to process */ if (cl_pos >= nlists) goto next_line; spos = cut_lists[cl_pos].startpos; /* get out if the current line is lower than the one * we just became interested in */ if ((int)linenum < spos) goto next_line; } } /* If we made it here, it means we've found the line we're * looking for, so print it */ puts(line); goto next_line; } else { /* cut by fields */ int ndelim = -1; /* zero-based / one-based problem */ int nfields_printed = 0; char *field = NULL; char delimiter[2]; delimiter[0] = delim; delimiter[1] = 0; /* does this line contain any delimiters? */ if (strchr(line, delim) == NULL) { if (!(option_mask32 & CUT_OPT_SUPPRESS_FLGS)) puts(line); goto next_line; } /* process each list on this line, for as long as we've got * a line to process */ for (; cl_pos < nlists && line; cl_pos++) { spos = cut_lists[cl_pos].startpos; do { /* find the field we're looking for */ while (line && ndelim < spos) { field = strsep(&line, delimiter); ndelim++; } /* we found it, and it hasn't been printed yet */ if (field && ndelim == spos && !printed[ndelim]) { /* if this isn't our first time through, we need to * print the delimiter after the last field that was * printed */ if (nfields_printed > 0) putchar(delim); fputs(field, stdout); printed[ndelim] = 'X'; nfields_printed++; /* shouldn't overflow.. */ } spos++; /* keep going as long as we have a line to work with, * this is a list, and we're not at the end of that * list */ } while (spos <= cut_lists[cl_pos].endpos && line && cut_lists[cl_pos].endpos != NON_RANGE); } } /* if we printed anything at all, we need to finish it with a * newline cuz we were handed a chomped line */ putchar('\n'); next_line: linenum++; free(printed); free(orig_line); } }
/* Given a list of code lengths and a maximum table size, make a set of * tables to decode that set of codes. Return zero on success, one if * the given code set is incomplete (the tables are still built in this * case), two if the input is invalid (all zero length codes or an * oversubscribed set of lengths), and three if not enough memory. * * b: code lengths in bits (all assumed <= BMAX) * n: number of codes (assumed <= N_MAX) * s: number of simple-valued codes (0..s-1) * d: list of base values for non-simple codes * e: list of extra bits for non-simple codes * t: result: starting table * m: maximum lookup bits, returns actual */ static int huft_build(unsigned *b, const unsigned n, const unsigned s, const unsigned short *d, const unsigned char *e, huft_t ** t, unsigned *m) { unsigned a; /* counter for codes of length k */ unsigned c[BMAX + 1]; /* bit length count table */ unsigned eob_len; /* length of end-of-block code (value 256) */ unsigned f; /* i repeats in table every f entries */ int g; /* maximum code length */ int htl; /* table level */ unsigned i; /* counter, current code */ unsigned j; /* counter */ int k; /* number of bits in current code */ unsigned *p; /* pointer into c[], b[], or v[] */ huft_t *q; /* points to current table */ huft_t r; /* table entry for structure assignment */ huft_t *u[BMAX]; /* table stack */ unsigned v[N_MAX]; /* values in order of bit length */ int ws[BMAX+1]; /* bits decoded stack */ int w; /* bits decoded */ unsigned x[BMAX + 1]; /* bit offsets, then code stack */ unsigned *xp; /* pointer into x */ int y; /* number of dummy codes added */ unsigned z; /* number of entries in current table */ /* Length of EOB code, if any */ eob_len = n > 256 ? b[256] : BMAX; /* Generate counts for each bit length */ memset(c, 0, sizeof(c)); p = b; i = n; do { c[*p]++; /* assume all entries <= BMAX */ p++; /* Can't combine with above line (Solaris bug) */ } while (--i); if (c[0] == n) { /* null input--all zero length codes */ *t = NULL; *m = 0; return 2; } /* Find minimum and maximum length, bound *m by those */ for (j = 1; (c[j] == 0) && (j <= BMAX); j++); k = j; /* minimum code length */ for (i = BMAX; (c[i] == 0) && i; i--); g = i; /* maximum code length */ *m = (*m < j) ? j : ((*m > i) ? i : *m); /* Adjust last length count to fill out codes, if needed */ for (y = 1 << j; j < i; j++, y <<= 1) { y -= c[j]; if (y < 0) { return 2; /* bad input: more codes than bits */ } } y -= c[i]; if (y < 0) { return 2; } c[i] += y; /* Generate starting offsets into the value table for each length */ x[1] = j = 0; p = c + 1; xp = x + 2; while (--i) { /* note that i == g from above */ j += *p++; *xp++ = j; } /* Make a table of values in order of bit lengths */ p = b; i = 0; do { j = *p++; if (j != 0) { v[x[j]++] = i; } } while (++i < n); /* Generate the Huffman codes and for each, make the table entries */ x[0] = i = 0; /* first Huffman code is zero */ p = v; /* grab values in bit order */ htl = -1; /* no tables yet--level -1 */ w = ws[0] = 0; /* bits decoded */ u[0] = NULL; /* just to keep compilers happy */ q = NULL; /* ditto */ z = 0; /* ditto */ /* go through the bit lengths (k already is bits in shortest code) */ for (; k <= g; k++) { a = c[k]; while (a--) { /* here i is the Huffman code of length k bits for value *p */ /* make tables up to required level */ while (k > ws[htl + 1]) { w = ws[++htl]; /* compute minimum size table less than or equal to *m bits */ z = g - w; z = z > *m ? *m : z; /* upper limit on table size */ j = k - w; f = 1 << j; if (f > a + 1) { /* try a k-w bit table */ /* too few codes for k-w bit table */ f -= a + 1; /* deduct codes from patterns left */ xp = c + k; while (++j < z) { /* try smaller tables up to z bits */ f <<= 1; if (f <= *++xp) { break; /* enough codes to use up j bits */ } f -= *xp; /* else deduct codes from patterns */ } } j = (w + j > eob_len && w < eob_len) ? eob_len - w : j; /* make EOB code end at table */ z = 1 << j; /* table entries for j-bit table */ ws[htl+1] = w + j; /* set bits decoded in stack */ /* allocate and link in new table */ q = xzalloc((z + 1) * sizeof(huft_t)); *t = q + 1; /* link to list for huft_free() */ t = &(q->v.t); u[htl] = ++q; /* table starts after link */ /* connect to last table, if there is one */ if (htl) { x[htl] = i; /* save pattern for backing up */ r.b = (unsigned char) (w - ws[htl - 1]); /* bits to dump before this table */ r.e = (unsigned char) (16 + j); /* bits in this table */ r.v.t = q; /* pointer to this table */ j = (i & ((1 << w) - 1)) >> ws[htl - 1]; u[htl - 1][j] = r; /* connect to last table */ } } /* set up table entry in r */ r.b = (unsigned char) (k - w); if (p >= v + n) { r.e = 99; /* out of values--invalid code */ } else if (*p < s) { r.e = (unsigned char) (*p < 256 ? 16 : 15); /* 256 is EOB code */ r.v.n = (unsigned short) (*p++); /* simple code is just the value */ } else { r.e = (unsigned char) e[*p - s]; /* non-simple--look up in lists */ r.v.n = d[*p++ - s]; } /* fill code-like entries with r */ f = 1 << (k - w); for (j = i >> w; j < z; j += f) { q[j] = r; } /* backwards increment the k-bit code i */ for (j = 1 << (k - 1); i & j; j >>= 1) { i ^= j; } i ^= j; /* backup over finished tables */ while ((i & ((1 << w) - 1)) != x[htl]) { w = ws[--htl]; } } } /* return actual size of base table */ *m = ws[1]; /* Return true (1) if we were given an incomplete table */ return y != 0 && g != 1; }
/* hosts_info_get_by_name parses a UNIX like hosts file in * the following format: * IP_address canonical_hostname [aliases...] * * see RFC 592 and the manual pages for hosts(5), hostname(1), * resolver(3), resolver(5), hostname(7) */ int hosts_info_get_by_name(const char *filename, const char *hostname, size_t hostname_len, struct hosts_info **res) { FILE *file; int i; char line_buf[MAX_LINE_SIZE + 1], white_spaces[] = " \t\n"; char fileentry[MAX_LINE_SIZE]; char *buf, *cp; char *alias_array[MAX_ALIASES]; int alias_index; char *domain_name, *addr_name; struct hosts_info *hi, *hi_prev; hi = hi_prev = *res = NULL; if (filename == NULL || hostname == NULL || hostname_len <= 0) return -ERROR_CODE_ARGUMENT; file = fopen(filename, "r"); if (!file) return -ERROR_CODE_FILE; while (fgets(line_buf, MAX_LINE_SIZE, file) != NULL) { buf = cp = NULL; /* skip comments */ if (line_buf[0] == '#') continue; cp = strtok_r(line_buf, "#", &buf); if (!cp) continue; memset(fileentry, 0, MAX_LINE_SIZE); strncpy(fileentry, cp, MAX_LINE_SIZE); /* IPv{4,6} address */ cp = strtok_r(fileentry, white_spaces, &buf); if (!cp) continue; addr_name = cp; /* full domain name */ cp = strtok_r(NULL, white_spaces, &buf); if (!cp) continue; domain_name = cp; if (!strcasecmp(domain_name, hostname)) { struct addrinfo hosthints, *hostres; hi = xzalloc(sizeof(*hi)); hi->name = xstrdup(domain_name); hi->type = HOST_INFO_TYPE_DOMAIN; hi->addr_str = xstrdup(addr_name); /* validate address and convert into sockaddr_storage */ memset(&hosthints, 0, sizeof(hosthints)); hosthints.ai_family = AF_UNSPEC; hosthints.ai_flags = AI_NUMERICHOST; xgetaddrinfo(addr_name, NULL, &hosthints, &hostres); if (hostres != NULL) { memcpy(&hi->addr, &hostres->ai_addr, hostres->ai_addrlen); hi->addr_len = hostres->ai_addrlen; hi->family = hostres->ai_family; } hi->next = NULL; freeaddrinfo(hostres); hi_prev = *res = hi; } /* iterate over all aliases */ alias_index = 0; while (((cp = strtok_r(NULL, white_spaces, &buf)) != NULL) && alias_index < MAX_ALIASES) { if (!strcasecmp(cp, hostname)) alias_array[alias_index++] = cp; } for (i = 0; i < alias_index; i++) { struct addrinfo hosthints, *hostres; hi = xzalloc(sizeof(*hi)); hi->name = xstrdup(alias_array[i]); hi->type = HOST_INFO_TYPE_ALIAS; hi->addr_str = xstrdup(addr_name); if (hi_prev) hi_prev->next = hi; /* validate address and convert into sockaddr_storage */ memset(&hosthints, 0, sizeof(hosthints)); hosthints.ai_family = AF_UNSPEC; hosthints.ai_flags = AI_NUMERICHOST; xgetaddrinfo(addr_name, NULL, &hosthints, &hostres); if (hostres != NULL) { memcpy(&hi->addr, &hostres->ai_addr, hostres->ai_addrlen); hi->addr_len = hostres->ai_addrlen; hi->family = hostres->ai_family; } hi->next = NULL; freeaddrinfo(hostres); if (*res == NULL) *res = hi; hi_prev = hi; } hi->next = NULL; } fclose(file); return SUCCESS; }
bool_t p2m_mem_access_check(paddr_t gpa, vaddr_t gla, const struct npfec npfec) { int rc; bool_t violation; xenmem_access_t xma; vm_event_request_t *req; struct vcpu *v = current; struct p2m_domain *p2m = p2m_get_hostp2m(v->domain); /* Mem_access is not in use. */ if ( !p2m->mem_access_enabled ) return true; rc = p2m_get_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), &xma); if ( rc ) return true; /* Now check for mem_access violation. */ switch ( xma ) { case XENMEM_access_rwx: violation = false; break; case XENMEM_access_rw: violation = npfec.insn_fetch; break; case XENMEM_access_wx: violation = npfec.read_access; break; case XENMEM_access_rx: case XENMEM_access_rx2rw: violation = npfec.write_access; break; case XENMEM_access_x: violation = npfec.read_access || npfec.write_access; break; case XENMEM_access_w: violation = npfec.read_access || npfec.insn_fetch; break; case XENMEM_access_r: violation = npfec.write_access || npfec.insn_fetch; break; default: case XENMEM_access_n: case XENMEM_access_n2rwx: violation = true; break; } if ( !violation ) return true; /* First, handle rx2rw and n2rwx conversion automatically. */ if ( npfec.write_access && xma == XENMEM_access_rx2rw ) { rc = p2m_set_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), 1, 0, ~0, XENMEM_access_rw, 0); return false; } else if ( xma == XENMEM_access_n2rwx ) { rc = p2m_set_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), 1, 0, ~0, XENMEM_access_rwx, 0); } /* Otherwise, check if there is a vm_event monitor subscriber */ if ( !vm_event_check_ring(&v->domain->vm_event->monitor) ) { /* No listener */ if ( p2m->access_required ) { gdprintk(XENLOG_INFO, "Memory access permissions failure, " "no vm_event listener VCPU %d, dom %d\n", v->vcpu_id, v->domain->domain_id); domain_crash(v->domain); } else { /* n2rwx was already handled */ if ( xma != XENMEM_access_n2rwx ) { /* A listener is not required, so clear the access * restrictions. */ rc = p2m_set_mem_access(v->domain, _gfn(paddr_to_pfn(gpa)), 1, 0, ~0, XENMEM_access_rwx, 0); } } /* No need to reinject */ return false; } req = xzalloc(vm_event_request_t); if ( req ) { req->reason = VM_EVENT_REASON_MEM_ACCESS; /* Send request to mem access subscriber */ req->u.mem_access.gfn = gpa >> PAGE_SHIFT; req->u.mem_access.offset = gpa & ((1 << PAGE_SHIFT) - 1); if ( npfec.gla_valid ) { req->u.mem_access.flags |= MEM_ACCESS_GLA_VALID; req->u.mem_access.gla = gla; if ( npfec.kind == npfec_kind_with_gla ) req->u.mem_access.flags |= MEM_ACCESS_FAULT_WITH_GLA; else if ( npfec.kind == npfec_kind_in_gpt ) req->u.mem_access.flags |= MEM_ACCESS_FAULT_IN_GPT; } req->u.mem_access.flags |= npfec.read_access ? MEM_ACCESS_R : 0; req->u.mem_access.flags |= npfec.write_access ? MEM_ACCESS_W : 0; req->u.mem_access.flags |= npfec.insn_fetch ? MEM_ACCESS_X : 0; if ( monitor_traps(v, (xma != XENMEM_access_n2rwx), req) < 0 ) domain_crash(v->domain); xfree(req); } return false; }
rdpKey* key_new(const char* keyfile) { rdpKey* key; RSA *rsa; FILE *fp; key = (rdpKey*) xzalloc(sizeof(rdpKey)); if (key == NULL) return NULL; fp = fopen(keyfile, "r"); if (fp == NULL) { printf("unable to load RSA key from %s: %s.", keyfile, strerror(errno)); xfree(key) ; return NULL; } rsa = PEM_read_RSAPrivateKey(fp, NULL, NULL, NULL); if (rsa == NULL) { ERR_print_errors_fp(stdout); fclose(fp); xfree(key) ; return NULL; } fclose(fp); switch (RSA_check_key(rsa)) { case 0: RSA_free(rsa); printf("invalid RSA key in %s", keyfile); xfree(key) ; return NULL; case 1: /* Valid key. */ break; default: ERR_print_errors_fp(stdout); RSA_free(rsa); xfree(key) ; return NULL; } if (BN_num_bytes(rsa->e) > 4) { RSA_free(rsa); printf("RSA public exponent too large in %s", keyfile); xfree(key) ; return NULL; } freerdp_blob_alloc(&key->modulus, BN_num_bytes(rsa->n)); BN_bn2bin(rsa->n, key->modulus.data); crypto_reverse(key->modulus.data, key->modulus.length); freerdp_blob_alloc(&key->private_exponent, BN_num_bytes(rsa->d)); BN_bn2bin(rsa->d, key->private_exponent.data); crypto_reverse(key->private_exponent.data, key->private_exponent.length); memset(key->exponent, 0, sizeof(key->exponent)); BN_bn2bin(rsa->e, key->exponent + sizeof(key->exponent) - BN_num_bytes(rsa->e)); crypto_reverse(key->exponent, sizeof(key->exponent)); RSA_free(rsa); return key; }
/* * This routine seizes task putting it into a special * state where we can manipulate the task via ptrace * interface, and finally we can detach ptrace out of * of it so the task would not know if it was saddled * up with someone else. */ int seize_wait_task(pid_t pid, pid_t ppid, struct proc_status_creds **creds) { siginfo_t si; int status, nr_sigstop; int ret = 0, ret2, wait_errno = 0; struct proc_status_creds cr; /* * For the comparison below, let's zero out any padding. */ memzero(&cr, sizeof(struct proc_status_creds)); /* * It's ugly, but the ptrace API doesn't allow to distinguish * attaching to zombie from other errors. Thus we have to parse * the target's /proc/pid/stat. Sad, but parse whatever else * we might need at that early point. */ processes_to_wait--; try_again: ret = wait4(pid, &status, __WALL, NULL); if (ret < 0) { /* * wait4() can expectedly fail only in a first time * if a task is zombie. If we are here from try_again, * this means that we are tracing this task. * * processes_to_wait should be descrimented only once in this * function if a first wait was success. */ processes_to_wait++; wait_errno = errno; } ret2 = parse_pid_status(pid, &cr); if (ret2) goto err; if (ret < 0 || WIFEXITED(status) || WIFSIGNALED(status)) { if (cr.state != 'Z') { if (pid == getpid()) pr_err("The criu itself is within dumped tree.\n"); else pr_err("Unseizable non-zombie %d found, state %c, err %d/%d\n", pid, cr.state, ret, wait_errno); return -1; } return TASK_DEAD; } if ((ppid != -1) && (cr.ppid != ppid)) { pr_err("Task pid reused while suspending (%d: %d -> %d)\n", pid, ppid, cr.ppid); goto err; } if (!WIFSTOPPED(status)) { pr_err("SEIZE %d: task not stopped after seize\n", pid); goto err; } ret = ptrace(PTRACE_GETSIGINFO, pid, NULL, &si); if (ret < 0) { pr_perror("SEIZE %d: can't read signfo", pid); goto err; } if (SI_EVENT(si.si_code) != PTRACE_EVENT_STOP) { /* * Kernel notifies us about the task being seized received some * event other than the STOP, i.e. -- a signal. Let the task * handle one and repeat. */ if (ptrace(PTRACE_CONT, pid, NULL, (void *)(unsigned long)si.si_signo)) { pr_perror("Can't continue signal handling, aborting"); goto err; } ret = 0; goto try_again; } if (*creds == NULL) { *creds = xzalloc(sizeof(struct proc_status_creds)); if (!*creds) goto err; **creds = cr; } else if (!proc_status_creds_dumpable(*creds, &cr)) { pr_err("creds don't match %d %d\n", pid, ppid); goto err; } if (cr.seccomp_mode != SECCOMP_MODE_DISABLED && suspend_seccomp(pid) < 0) goto err; nr_sigstop = 0; if (cr.sigpnd & (1 << (SIGSTOP - 1))) nr_sigstop++; if (cr.shdpnd & (1 << (SIGSTOP - 1))) nr_sigstop++; if (si.si_signo == SIGSTOP) nr_sigstop++; if (nr_sigstop) { if (skip_sigstop(pid, nr_sigstop)) goto err_stop; return TASK_STOPPED; } if (si.si_signo == SIGTRAP) return TASK_ALIVE; else { pr_err("SEIZE %d: unsupported stop signal %d\n", pid, si.si_signo); goto err; } err_stop: kill(pid, SIGSTOP); err: if (ptrace(PTRACE_DETACH, pid, NULL, NULL)) pr_perror("Unable to detach from %d", pid); return -1; }
void rail_unicode_string_alloc(UNICODE_STRING* unicode_string, uint16 cbString) { unicode_string->length = cbString; unicode_string->string = xzalloc(cbString); }
int credssp_server_authenticate(rdpCredssp* credssp) { uint32 cbMaxToken; uint32 fContextReq; uint32 pfContextAttr; SECURITY_STATUS status; CredHandle credentials; TimeStamp expiration; SecPkgInfo* pPackageInfo; PSecBuffer p_buffer; SecBuffer input_buffer; SecBuffer output_buffer; SecBufferDesc input_buffer_desc; SecBufferDesc output_buffer_desc; boolean have_context; boolean have_input_buffer; boolean have_pub_key_auth; sspi_GlobalInit(); if (credssp_ntlm_server_init(credssp) == 0) return 0; credssp->table = InitSecurityInterface(); status = QuerySecurityPackageInfo(NTLM_PACKAGE_NAME, &pPackageInfo); if (status != SEC_E_OK) { printf("QuerySecurityPackageInfo status: 0x%08X\n", status); return 0; } cbMaxToken = pPackageInfo->cbMaxToken; status = credssp->table->AcquireCredentialsHandle(NULL, NTLM_PACKAGE_NAME, SECPKG_CRED_INBOUND, NULL, &credssp->identity, NULL, NULL, &credentials, &expiration); if (status != SEC_E_OK) { printf("AcquireCredentialsHandle status: 0x%08X\n", status); return 0; } have_context = false; have_input_buffer = false; have_pub_key_auth = false; memset(&input_buffer, 0, sizeof(SecBuffer)); memset(&output_buffer, 0, sizeof(SecBuffer)); memset(&credssp->ContextSizes, 0, sizeof(SecPkgContext_Sizes)); fContextReq = ISC_REQ_REPLAY_DETECT | ISC_REQ_SEQUENCE_DETECT | ISC_REQ_CONFIDENTIALITY | ISC_REQ_DELEGATE; while (true) { input_buffer_desc.ulVersion = SECBUFFER_VERSION; input_buffer_desc.cBuffers = 1; input_buffer_desc.pBuffers = &input_buffer; input_buffer.BufferType = SECBUFFER_TOKEN; /* receive authentication token */ input_buffer_desc.ulVersion = SECBUFFER_VERSION; input_buffer_desc.cBuffers = 1; input_buffer_desc.pBuffers = &input_buffer; input_buffer.BufferType = SECBUFFER_TOKEN; if (credssp_recv(credssp) < 0) return -1; #ifdef WITH_DEBUG_CREDSSP printf("Receiving Authentication Token\n"); credssp_buffer_print(credssp); #endif p_buffer = &input_buffer_desc.pBuffers[0]; p_buffer->pvBuffer = credssp->negoToken.pvBuffer; p_buffer->cbBuffer = credssp->negoToken.cbBuffer; output_buffer_desc.ulVersion = SECBUFFER_VERSION; output_buffer_desc.cBuffers = 1; output_buffer_desc.pBuffers = &output_buffer; output_buffer.BufferType = SECBUFFER_TOKEN; output_buffer.cbBuffer = cbMaxToken; output_buffer.pvBuffer = xmalloc(output_buffer.cbBuffer); status = credssp->table->AcceptSecurityContext(&credentials, have_context? &credssp->context: NULL, &input_buffer_desc, 0, SECURITY_NATIVE_DREP, &credssp->context, &output_buffer_desc, &pfContextAttr, &expiration); if (input_buffer.pvBuffer != NULL) { xfree(input_buffer.pvBuffer); input_buffer.pvBuffer = NULL; } p_buffer = &output_buffer_desc.pBuffers[0]; credssp->negoToken.pvBuffer = p_buffer->pvBuffer; credssp->negoToken.cbBuffer = p_buffer->cbBuffer; if ((status == SEC_I_COMPLETE_AND_CONTINUE) || (status == SEC_I_COMPLETE_NEEDED)) { if (credssp->table->CompleteAuthToken != NULL) credssp->table->CompleteAuthToken(&credssp->context, &output_buffer_desc); have_pub_key_auth = true; sspi_SecBufferFree(&credssp->negoToken); credssp->negoToken.pvBuffer = NULL; credssp->negoToken.cbBuffer = 0; if (credssp->table->QueryContextAttributes(&credssp->context, SECPKG_ATTR_SIZES, &credssp->ContextSizes) != SEC_E_OK) { printf("QueryContextAttributes SECPKG_ATTR_SIZES failure\n"); return 0; } if (have_pub_key_auth) { uint8* p; SecBuffer Buffers[2]; SecBufferDesc Message; Buffers[0].BufferType = SECBUFFER_DATA; /* TLS Public Key */ Buffers[1].BufferType = SECBUFFER_TOKEN; /* Signature */ Buffers[0].cbBuffer = credssp->PublicKey.cbBuffer; Buffers[0].pvBuffer = xmalloc(Buffers[0].cbBuffer); memcpy(Buffers[0].pvBuffer, credssp->PublicKey.pvBuffer, Buffers[0].cbBuffer); Buffers[1].cbBuffer = credssp->ContextSizes.cbMaxSignature; Buffers[1].pvBuffer = xzalloc(Buffers[1].cbBuffer); Message.cBuffers = 2; Message.ulVersion = SECBUFFER_VERSION; Message.pBuffers = (PSecBuffer) &Buffers; p = (uint8*) Buffers[0].pvBuffer; p[0]++; /* Public Key +1 */ sspi_SecBufferAlloc(&credssp->pubKeyAuth, Buffers[0].cbBuffer + Buffers[1].cbBuffer); credssp->table->EncryptMessage(&credssp->context, 0, &Message, 0); p = (uint8*) credssp->pubKeyAuth.pvBuffer; memcpy(p, Buffers[1].pvBuffer, Buffers[1].cbBuffer); /* Message Signature */ memcpy(&p[Buffers[1].cbBuffer], Buffers[0].pvBuffer, Buffers[0].cbBuffer); /* Encrypted Public Key */ } if (status == SEC_I_COMPLETE_NEEDED) status = SEC_E_OK; else if (status == SEC_I_COMPLETE_AND_CONTINUE) status = SEC_I_CONTINUE_NEEDED; } /* send authentication token */ #ifdef WITH_DEBUG_CREDSSP printf("Sending Authentication Token\n"); credssp_buffer_print(credssp); #endif credssp_send(credssp); credssp_buffer_free(credssp); if (status != SEC_I_CONTINUE_NEEDED) break; have_context = true; } /* Receive encrypted credentials */ if (credssp_recv(credssp) < 0) return -1; if (status != SEC_E_OK) { printf("AcceptSecurityContext status: 0x%08X\n", status); return 0; } status = credssp->table->ImpersonateSecurityContext(&credssp->context); if (status != SEC_E_OK) { printf("ImpersonateSecurityContext status: 0x%08X\n", status); return 0; } else { status = credssp->table->RevertSecurityContext(&credssp->context); if (status != SEC_E_OK) { printf("RevertSecurityContext status: 0x%08X\n", status); return 0; } } FreeContextBuffer(pPackageInfo); return 1; }
struct exclude * new_exclude (void) { return xzalloc (sizeof *new_exclude ()); }
int man_main(int argc UNUSED_PARAM, char **argv) { parser_t *parser; const char *pager = ENABLE_LESS ? "less" : "more"; char *sec_list; char *cur_path, *cur_sect; char **man_path_list; int count_mp; int cur_mp; int opt, not_found; char *token[2]; opt_complementary = "-1"; /* at least one argument */ opt = getopt32(argv, "+aw"); argv += optind; sec_list = xstrdup("0p:1:1p:2:3:3p:4:5:6:7:8:9"); count_mp = 0; man_path_list = add_MANPATH(NULL, &count_mp, getenv("MANDATORY_MANPATH"+10) /* "MANPATH" */ ); if (!man_path_list) { /* default, may be overridden by /etc/man.conf */ man_path_list = xzalloc(2 * sizeof(man_path_list[0])); man_path_list[0] = (char*)"/usr/man"; /* count_mp stays 0. * Thus, man.conf will overwrite man_path_list[0] * if a path is defined there. */ } /* Parse man.conf[ig] or man_db.conf */ /* man version 1.6f uses man.config */ /* man-db implementation of man uses man_db.conf */ parser = config_open2("/etc/man.config", fopen_for_read); if (!parser) parser = config_open2("/etc/man.conf", fopen_for_read); if (!parser) parser = config_open2("/etc/man_db.conf", fopen_for_read); while (config_read(parser, token, 2, 0, "# \t", PARSE_NORMAL)) { if (!token[1]) continue; if (strcmp("DEFINE", token[0]) == 0) { if (is_prefixed_with("pager", token[1])) { pager = xstrdup(skip_whitespace(token[1]) + 5); } } else if (strcmp("MANDATORY_MANPATH"+10, token[0]) == 0 /* "MANPATH"? */ || strcmp("MANDATORY_MANPATH", token[0]) == 0 ) { man_path_list = add_MANPATH(man_path_list, &count_mp, token[1]); } if (strcmp("MANSECT", token[0]) == 0) { free(sec_list); sec_list = xstrdup(token[1]); } } config_close(parser); { /* environment overrides setting from man.config */ char *env_pager = getenv("MANPAGER"); if (!env_pager) env_pager = getenv("PAGER"); if (env_pager) pager = env_pager; } not_found = 0; do { /* for each argv[] */ int found = 0; cur_mp = 0; if (strchr(*argv, '/')) { found = show_manpage(pager, *argv, /*man:*/ 1, 0); goto check_found; } while ((cur_path = man_path_list[cur_mp++]) != NULL) { /* for each MANPATH */ cur_sect = sec_list; do { /* for each section */ char *next_sect = strchrnul(cur_sect, ':'); int sect_len = next_sect - cur_sect; char *man_filename; int cat0man1 = 0; /* Search for cat, then man page */ while (cat0man1 < 2) { int found_here; man_filename = xasprintf("%s/%s%.*s/%s.%.*s", cur_path, "cat\0man" + (cat0man1 * 4), sect_len, cur_sect, *argv, sect_len, cur_sect); found_here = show_manpage(pager, man_filename, cat0man1, 0); found |= found_here; cat0man1 += found_here + 1; free(man_filename); } if (found && !(opt & OPT_a)) goto next_arg; cur_sect = next_sect; while (*cur_sect == ':') cur_sect++; } while (*cur_sect); } check_found: if (!found) { bb_error_msg("no manual entry for '%s'", *argv); not_found = 1; } next_arg: argv++; } while (*argv); return not_found; }
static void process_files(void) { char *pattern_space, *next_line; int linenum = 0; char last_puts_char = '\n'; char last_gets_char, next_gets_char; sed_cmd_t *sed_cmd; int substituted; /* Prime the pump */ next_line = get_next_line(&next_gets_char); /* go through every line in each file */ again: substituted = 0; /* Advance to next line. Stop if out of lines. */ pattern_space = next_line; if (!pattern_space) return; last_gets_char = next_gets_char; /* Read one line in advance so we can act on the last line, * the '$' address */ next_line = get_next_line(&next_gets_char); linenum++; restart: /* for every line, go through all the commands */ for (sed_cmd = G.sed_cmd_head.next; sed_cmd; sed_cmd = sed_cmd->next) { int old_matched, matched; old_matched = sed_cmd->in_match; /* Determine if this command matches this line: */ /* Are we continuing a previous multi-line match? */ sed_cmd->in_match = sed_cmd->in_match /* Or is no range necessary? */ || (!sed_cmd->beg_line && !sed_cmd->end_line && !sed_cmd->beg_match && !sed_cmd->end_match) /* Or did we match the start of a numerical range? */ || (sed_cmd->beg_line > 0 && (sed_cmd->beg_line == linenum)) /* Or does this line match our begin address regex? */ || (beg_match(sed_cmd, pattern_space)) /* Or did we match last line of input? */ || (sed_cmd->beg_line == -1 && next_line == NULL); /* Snapshot the value */ matched = sed_cmd->in_match; /* Is this line the end of the current match? */ if (matched) { sed_cmd->in_match = !( /* has the ending line come, or is this a single address command? */ (sed_cmd->end_line ? sed_cmd->end_line == -1 ? !next_line : (sed_cmd->end_line <= linenum) : !sed_cmd->end_match ) /* or does this line matches our last address regex */ || (sed_cmd->end_match && old_matched && (regexec(sed_cmd->end_match, pattern_space, 0, NULL, 0) == 0)) ); } /* Skip blocks of commands we didn't match. */ if (sed_cmd->cmd == '{') { if (sed_cmd->invert ? matched : !matched) { while (sed_cmd->cmd != '}') { sed_cmd = sed_cmd->next; if (!sed_cmd) bb_error_msg_and_die("unterminated {"); } } continue; } /* Okay, so did this line match? */ if (sed_cmd->invert ? !matched : matched) { /* Update last used regex in case a blank substitute BRE is found */ if (sed_cmd->beg_match) { G.previous_regex_ptr = sed_cmd->beg_match; } /* actual sedding */ switch (sed_cmd->cmd) { /* Print line number */ case '=': fprintf(G.nonstdout, "%d\n", linenum); break; /* Write the current pattern space up to the first newline */ case 'P': { char *tmp = strchr(pattern_space, '\n'); if (tmp) { *tmp = '\0'; /* TODO: explain why '\n' below */ sed_puts(pattern_space, '\n'); *tmp = '\n'; break; } /* Fall Through */ } /* Write the current pattern space to output */ case 'p': /* NB: we print this _before_ the last line * (of current file) is printed. Even if * that line is nonterminated, we print * '\n' here (gnu sed does the same) */ sed_puts(pattern_space, '\n'); break; /* Delete up through first newline */ case 'D': { char *tmp = strchr(pattern_space, '\n'); if (tmp) { tmp = xstrdup(tmp+1); free(pattern_space); pattern_space = tmp; goto restart; } } /* discard this line. */ case 'd': goto discard_line; /* Substitute with regex */ case 's': if (!do_subst_command(sed_cmd, &pattern_space)) break; substituted |= 1; /* handle p option */ if (sed_cmd->sub_p) sed_puts(pattern_space, last_gets_char); /* handle w option */ if (sed_cmd->sw_file) puts_maybe_newline( pattern_space, sed_cmd->sw_file, &sed_cmd->sw_last_char, last_gets_char); break; /* Append line to linked list to be printed later */ case 'a': append(sed_cmd->string); break; /* Insert text before this line */ case 'i': sed_puts(sed_cmd->string, '\n'); break; /* Cut and paste text (replace) */ case 'c': /* Only triggers on last line of a matching range. */ if (!sed_cmd->in_match) sed_puts(sed_cmd->string, NO_EOL_CHAR); goto discard_line; /* Read file, append contents to output */ case 'r': { FILE *rfile; rfile = fopen(sed_cmd->string, "r"); if (rfile) { char *line; while ((line = xmalloc_getline(rfile)) != NULL) append(line); xprint_and_close_file(rfile); } break; } /* Write pattern space to file. */ case 'w': puts_maybe_newline( pattern_space, sed_cmd->sw_file, &sed_cmd->sw_last_char, last_gets_char); break; /* Read next line from input */ case 'n': if (!G.be_quiet) sed_puts(pattern_space, last_gets_char); if (next_line) { free(pattern_space); pattern_space = next_line; last_gets_char = next_gets_char; next_line = get_next_line(&next_gets_char); linenum++; break; } /* fall through */ /* Quit. End of script, end of input. */ case 'q': /* Exit the outer while loop */ free(next_line); next_line = NULL; goto discard_commands; /* Append the next line to the current line */ case 'N': { int len; /* If no next line, jump to end of script and exit. */ if (next_line == NULL) { /* Jump to end of script and exit */ free(next_line); next_line = NULL; goto discard_line; /* append next_line, read new next_line. */ } len = strlen(pattern_space); pattern_space = realloc(pattern_space, len + strlen(next_line) + 2); pattern_space[len] = '\n'; strcpy(pattern_space + len+1, next_line); last_gets_char = next_gets_char; next_line = get_next_line(&next_gets_char); linenum++; break; } /* Test/branch if substitution occurred */ case 't': if (!substituted) break; substituted = 0; /* Fall through */ /* Test/branch if substitution didn't occur */ case 'T': if (substituted) break; /* Fall through */ /* Branch to label */ case 'b': if (!sed_cmd->string) goto discard_commands; else sed_cmd = branch_to(sed_cmd->string); break; /* Transliterate characters */ case 'y': { int i, j; for (i = 0; pattern_space[i]; i++) { for (j = 0; sed_cmd->string[j]; j += 2) { if (pattern_space[i] == sed_cmd->string[j]) { pattern_space[i] = sed_cmd->string[j + 1]; break; } } } break; } case 'g': /* Replace pattern space with hold space */ free(pattern_space); pattern_space = xstrdup(G.hold_space ? G.hold_space : ""); break; case 'G': /* Append newline and hold space to pattern space */ { int pattern_space_size = 2; int hold_space_size = 0; if (pattern_space) pattern_space_size += strlen(pattern_space); if (G.hold_space) hold_space_size = strlen(G.hold_space); pattern_space = xrealloc(pattern_space, pattern_space_size + hold_space_size); if (pattern_space_size == 2) pattern_space[0] = 0; strcat(pattern_space, "\n"); if (G.hold_space) strcat(pattern_space, G.hold_space); last_gets_char = '\n'; break; } case 'h': /* Replace hold space with pattern space */ free(G.hold_space); G.hold_space = xstrdup(pattern_space); break; case 'H': /* Append newline and pattern space to hold space */ { int hold_space_size = 2; int pattern_space_size = 0; if (G.hold_space) hold_space_size += strlen(G.hold_space); if (pattern_space) pattern_space_size = strlen(pattern_space); G.hold_space = xrealloc(G.hold_space, hold_space_size + pattern_space_size); if (hold_space_size == 2) *G.hold_space = 0; strcat(G.hold_space, "\n"); if (pattern_space) strcat(G.hold_space, pattern_space); break; } case 'x': /* Exchange hold and pattern space */ { char *tmp = pattern_space; pattern_space = G.hold_space ? : xzalloc(1); last_gets_char = '\n'; G.hold_space = tmp; break; } } } } /* * exit point from sedding... */ discard_commands: /* we will print the line unless we were told to be quiet ('-n') or if the line was suppressed (ala 'd'elete) */ if (!G.be_quiet) sed_puts(pattern_space, last_gets_char); /* Delete and such jump here. */ discard_line: flush_append(); free(pattern_space); goto again; }
static void add_cmd(const char *cmdstr) { sed_cmd_t *sed_cmd; int temp; /* Append this line to any unfinished line from last time. */ if (G.add_cmd_line) { char *tp = xasprintf("%s\n%s", G.add_cmd_line, cmdstr); free(G.add_cmd_line); cmdstr = G.add_cmd_line = tp; } /* If this line ends with backslash, request next line. */ temp = strlen(cmdstr); if (temp && cmdstr[--temp] == '\\') { if (!G.add_cmd_line) G.add_cmd_line = xstrdup(cmdstr); G.add_cmd_line[temp] = '\0'; return; } /* Loop parsing all commands in this line. */ while (*cmdstr) { /* Skip leading whitespace and semicolons */ cmdstr += strspn(cmdstr, semicolon_whitespace); /* If no more commands, exit. */ if (!*cmdstr) break; /* if this is a comment, jump past it and keep going */ if (*cmdstr == '#') { /* "#n" is the same as using -n on the command line */ if (cmdstr[1] == 'n') G.be_quiet++; cmdstr = strpbrk(cmdstr, "\n\r"); if (!cmdstr) break; continue; } /* parse the command * format is: [addr][,addr][!]cmd * |----||-----||-| * part1 part2 part3 */ sed_cmd = xzalloc(sizeof(sed_cmd_t)); /* first part (if present) is an address: either a '$', a number or a /regex/ */ cmdstr += get_address(cmdstr, &sed_cmd->beg_line, &sed_cmd->beg_match); /* second part (if present) will begin with a comma */ if (*cmdstr == ',') { int idx; cmdstr++; idx = get_address(cmdstr, &sed_cmd->end_line, &sed_cmd->end_match); if (!idx) bb_error_msg_and_die("no address after comma"); cmdstr += idx; } /* skip whitespace before the command */ cmdstr = skip_whitespace(cmdstr); /* Check for inversion flag */ if (*cmdstr == '!') { sed_cmd->invert = 1; cmdstr++; /* skip whitespace before the command */ cmdstr = skip_whitespace(cmdstr); } /* last part (mandatory) will be a command */ if (!*cmdstr) bb_error_msg_and_die("missing command"); sed_cmd->cmd = *(cmdstr++); cmdstr = parse_cmd_args(sed_cmd, cmdstr); /* Add the command to the command array */ G.sed_cmd_tail->next = sed_cmd; G.sed_cmd_tail = G.sed_cmd_tail->next; } /* If we glued multiple lines together, free the memory. */ free(G.add_cmd_line); G.add_cmd_line = NULL; }
boolean wf_pre_connect(freerdp* instance) { int i1; wfInfo* wfi; wfContext* context; rdpSettings* settings; wfi = (wfInfo*) xzalloc(sizeof(wfInfo)); context = (wfContext*) instance->context; wfi->instance = instance; context->wfi = wfi; settings = instance->settings; settings->os_major_type = OSMAJORTYPE_WINDOWS; settings->os_minor_type = OSMINORTYPE_WINDOWS_NT; settings->order_support[NEG_DSTBLT_INDEX] = true; settings->order_support[NEG_PATBLT_INDEX] = true; settings->order_support[NEG_SCRBLT_INDEX] = true; settings->order_support[NEG_OPAQUE_RECT_INDEX] = true; settings->order_support[NEG_DRAWNINEGRID_INDEX] = false; settings->order_support[NEG_MULTIDSTBLT_INDEX] = false; settings->order_support[NEG_MULTIPATBLT_INDEX] = false; settings->order_support[NEG_MULTISCRBLT_INDEX] = false; settings->order_support[NEG_MULTIOPAQUERECT_INDEX] = true; settings->order_support[NEG_MULTI_DRAWNINEGRID_INDEX] = false; settings->order_support[NEG_LINETO_INDEX] = true; settings->order_support[NEG_POLYLINE_INDEX] = true; settings->order_support[NEG_MEMBLT_INDEX] = true; settings->order_support[NEG_MEM3BLT_INDEX] = false; settings->order_support[NEG_SAVEBITMAP_INDEX] = false; settings->order_support[NEG_GLYPH_INDEX_INDEX] = false; settings->order_support[NEG_FAST_INDEX_INDEX] = false; settings->order_support[NEG_FAST_GLYPH_INDEX] = false; settings->order_support[NEG_POLYGON_SC_INDEX] = false; settings->order_support[NEG_POLYGON_CB_INDEX] = false; settings->order_support[NEG_ELLIPSE_SC_INDEX] = false; settings->order_support[NEG_ELLIPSE_CB_INDEX] = false; settings->glyph_cache = false; wfi->cursor = g_default_cursor; wfi->fullscreen = settings->fullscreen; wfi->fs_toggle = wfi->fullscreen; wfi->sw_gdi = settings->sw_gdi; wfi->clrconv = (HCLRCONV) xzalloc(sizeof(CLRCONV)); wfi->clrconv->palette = NULL; wfi->clrconv->alpha = 0; instance->context->cache = cache_new(settings); if (wfi->percentscreen > 0) { i1 = (GetSystemMetrics(SM_CXSCREEN) * wfi->percentscreen) / 100; settings->width = i1; i1 = (GetSystemMetrics(SM_CYSCREEN) * wfi->percentscreen) / 100; settings->height = i1; } if (wfi->fs_toggle) { settings->width = GetSystemMetrics(SM_CXSCREEN); settings->height = GetSystemMetrics(SM_CYSCREEN); } i1 = settings->width; i1 = (i1 + 3) & (~3); settings->width = i1; if ((settings->width < 64) || (settings->height < 64) || (settings->width > 4096) || (settings->height > 4096)) { printf("wf_pre_connect: invalid dimensions %d %d\n", settings->width, settings->height); return 1; } settings->kbd_layout = (int) GetKeyboardLayout(0) & 0x0000FFFF; freerdp_channels_pre_connect(instance->context->channels, instance); return true; }
static int imx_ocotp_probe(struct device_d *dev) { struct resource *iores; struct ocotp_priv *priv; int ret = 0; const struct imx_ocotp_data *data; struct nvmem_device *nvmem; ret = dev_get_drvdata(dev, (const void **)&data); if (ret) return ret; iores = dev_request_mem_resource(dev, 0); if (IS_ERR(iores)) return PTR_ERR(iores); priv = xzalloc(sizeof(*priv)); priv->data = data; priv->base = IOMEM(iores->start); priv->clk = clk_get(dev, NULL); if (IS_ERR(priv->clk)) return PTR_ERR(priv->clk); strcpy(priv->dev.name, "ocotp"); priv->dev.parent = dev; register_device(&priv->dev); priv->map_config.reg_bits = 32; priv->map_config.val_bits = 32; priv->map_config.reg_stride = 4; priv->map_config.max_register = data->num_regs - 1; priv->map = regmap_init(dev, &imx_ocotp_regmap_bus, priv, &priv->map_config); if (IS_ERR(priv->map)) return PTR_ERR(priv->map); priv->config.name = "imx-ocotp"; priv->config.dev = dev; priv->config.stride = 4; priv->config.word_size = 4; priv->config.size = data->num_regs; priv->config.bus = &imx_ocotp_nvmem_bus; dev->priv = priv; nvmem = nvmem_register(&priv->config); if (IS_ERR(nvmem)) return PTR_ERR(nvmem); imx_ocotp = priv; if (IS_ENABLED(CONFIG_IMX_OCOTP_WRITE)) { dev_add_param_bool(&(priv->dev), "permanent_write_enable", NULL, NULL, &priv->permanent_write_enable, NULL); } if (IS_ENABLED(CONFIG_NET)) { int i; struct ocotp_priv_ethaddr *ethaddr; for (i = 0; i < priv->data->mac_offsets_num; i++) { ethaddr = &priv->ethaddr[i]; ethaddr->map = priv->map; ethaddr->offset = priv->data->mac_offsets[i]; ethaddr->data = data; dev_add_param_mac(&priv->dev, xasprintf("mac_addr%d", i), imx_ocotp_set_mac, imx_ocotp_get_mac, ethaddr->value, ethaddr); } /* * Alias to mac_addr0 for backwards compatibility */ ethaddr = &priv->ethaddr[0]; dev_add_param_mac(&priv->dev, "mac_addr", imx_ocotp_set_mac, imx_ocotp_get_mac, ethaddr->value, ethaddr); } imx_ocotp_init_dt(priv); dev_add_param_bool(&(priv->dev), "sense_enable", NULL, NULL, &priv->sense_enable, priv); return 0; }
INT WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) { freerdp* instance; thread_data* data; WSADATA wsa_data; WNDCLASSEX wnd_cls; if (NULL == getenv("HOME")) { char home[MAX_PATH * 2] = "HOME="; strcat(home, getenv("HOMEDRIVE")); strcat(home, getenv("HOMEPATH")); _putenv(home); } if (WSAStartup(0x101, &wsa_data) != 0) return 1; g_done_event = CreateEvent(0, 1, 0, 0); #if defined(WITH_DEBUG) || defined(_DEBUG) wf_create_console(); #endif g_default_cursor = LoadCursor(NULL, IDC_ARROW); wnd_cls.cbSize = sizeof(WNDCLASSEX); wnd_cls.style = CS_HREDRAW | CS_VREDRAW; wnd_cls.lpfnWndProc = wf_event_proc; wnd_cls.cbClsExtra = 0; wnd_cls.cbWndExtra = 0; wnd_cls.hIcon = LoadIcon(NULL, IDI_APPLICATION); wnd_cls.hCursor = g_default_cursor; wnd_cls.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH); wnd_cls.lpszMenuName = NULL; wnd_cls.lpszClassName = g_wnd_class_name; wnd_cls.hInstance = hInstance; wnd_cls.hIconSm = LoadIcon(NULL, IDI_APPLICATION); RegisterClassEx(&wnd_cls); g_hInstance = hInstance; freerdp_channels_global_init(); instance = freerdp_new(); instance->PreConnect = wf_pre_connect; instance->PostConnect = wf_post_connect; instance->VerifyCertificate = wf_verify_certificate; instance->ReceiveChannelData = wf_receive_channel_data; instance->context_size = sizeof(wfContext); instance->ContextNew = wf_context_new; instance->ContextFree = wf_context_free; freerdp_context_new(instance); instance->context->argc = __argc; instance->context->argv = __argv; if (!CreateThread(NULL, 0, kbd_thread_func, NULL, 0, NULL)) printf("error creating keyboard handler thread"); //while (1) { data = (thread_data*) xzalloc(sizeof(thread_data)); data->instance = instance; freerdp_parse_args(instance->settings, __argc, __argv, wf_process_plugin_args, instance->context->channels, wf_process_client_args, NULL); if (CreateThread(NULL, 0, thread_func, data, 0, NULL) != 0) g_thread_count++; } if (g_thread_count > 0) WaitForSingleObject(g_done_event, INFINITE); else MessageBox(GetConsoleWindow(), L"Failed to start wfreerdp.\n\nPlease check the debug output.", L"FreeRDP Error", MB_ICONSTOP); WSACleanup(); #ifdef _DEBUG system("pause"); #endif return 0; }
int FAST_FUNC volume_id_probe_msdos_part_table(struct volume_id *id, uint64_t off) { const uint8_t *buf; int i; uint64_t poff; uint64_t plen; uint64_t extended = 0; uint64_t current; uint64_t next; int limit; int empty = 1; struct msdos_partition_entry *part; struct volume_id_partition *p; dbg("probing at offset 0x%llx", (unsigned long long) off); buf = volume_id_get_buffer(id, off, 0x200); if (buf == NULL) return -1; if (buf[MSDOS_SIG_OFF] != 0x55 || buf[MSDOS_SIG_OFF + 1] != 0xaa) return -1; /* check flags on all entries for a valid partition table */ part = (struct msdos_partition_entry*) &buf[MSDOS_PARTTABLE_OFFSET]; for (i = 0; i < 4; i++) { if (part[i].boot_ind != 0 && part[i].boot_ind != 0x80 ) { return -1; } if (part[i].nr_sects != 0) empty = 0; } if (empty == 1) return -1; if (id->partitions != NULL) free(id->partitions); id->partitions = xzalloc(VOLUME_ID_PARTITIONS_MAX * sizeof(struct volume_id_partition)); for (i = 0; i < 4; i++) { poff = (uint64_t) le32_to_cpu(part[i].start_sect) * BSIZE; plen = (uint64_t) le32_to_cpu(part[i].nr_sects) * BSIZE; if (plen == 0) continue; p = &id->partitions[i]; // p->pt_type_raw = part[i].sys_ind; if (is_extended(part[i].sys_ind)) { dbg("found extended partition at 0x%llx", (unsigned long long) poff); // volume_id_set_usage_part(p, VOLUME_ID_PARTITIONTABLE); // p->type = "msdos_extended_partition"; if (extended == 0) extended = off + poff; } else { dbg("found 0x%x data partition at 0x%llx, len 0x%llx", part[i].sys_ind, (unsigned long long) poff, (unsigned long long) plen); // if (is_raid(part[i].sys_ind)) // volume_id_set_usage_part(p, VOLUME_ID_RAID); // else // volume_id_set_usage_part(p, VOLUME_ID_UNPROBED); } // p->pt_off = off + poff; // p->pt_len = plen; id->partition_count = i+1; } next = extended; current = extended; limit = 50; /* follow extended partition chain and add data partitions */ while (next != 0) { if (limit-- == 0) { dbg("extended chain limit reached"); break; } buf = volume_id_get_buffer(id, current, 0x200); if (buf == NULL) break; part = (struct msdos_partition_entry*) &buf[MSDOS_PARTTABLE_OFFSET]; if (buf[MSDOS_SIG_OFF] != 0x55 || buf[MSDOS_SIG_OFF + 1] != 0xaa) break; next = 0; for (i = 0; i < 4; i++) { poff = (uint64_t) le32_to_cpu(part[i].start_sect) * BSIZE; plen = (uint64_t) le32_to_cpu(part[i].nr_sects) * BSIZE; if (plen == 0) continue; if (is_extended(part[i].sys_ind)) { dbg("found extended partition at 0x%llx", (unsigned long long) poff); if (next == 0) next = extended + poff; } else { dbg("found 0x%x data partition at 0x%llx, len 0x%llx", part[i].sys_ind, (unsigned long long) poff, (unsigned long long) plen); /* we always start at the 5th entry */ // while (id->partition_count < 4) // volume_id_set_usage_part(&id->partitions[id->partition_count++], VOLUME_ID_UNUSED); if (id->partition_count < 4) id->partition_count = 4; p = &id->partitions[id->partition_count]; // if (is_raid(part[i].sys_ind)) // volume_id_set_usage_part(p, VOLUME_ID_RAID); // else // volume_id_set_usage_part(p, VOLUME_ID_UNPROBED); // p->pt_off = current + poff; // p->pt_len = plen; id->partition_count++; // p->pt_type_raw = part[i].sys_ind; if (id->partition_count >= VOLUME_ID_PARTITIONS_MAX) { dbg("too many partitions"); next = 0; } } } current = next; } // volume_id_set_usage(id, VOLUME_ID_PARTITIONTABLE); // id->type = "msdos_partition_table"; return 0; }
int split_main(int argc UNUSED_PARAM, char **argv) { unsigned suffix_len = 2; char *pfx; char *count_p; const char *sfx; off_t cnt = 1000; off_t remaining = 0; unsigned opt; ssize_t bytes_read, to_write; char *src; opt_complementary = "?2:a+"; /* max 2 args; -a N */ opt = getopt32(argv, "l:b:a:", &count_p, &count_p, &suffix_len); if (opt & SPLIT_OPT_l) cnt = XATOOFF(count_p); if (opt & SPLIT_OPT_b) // FIXME: also needs XATOOFF cnt = xatoull_sfx(count_p, split_suffices); sfx = "x"; argv += optind; if (argv[0]) { int fd; if (argv[1]) sfx = argv[1]; fd = open_or_warn_stdin(argv[0]); if (fd == -1) return EXIT_FAILURE; xmove_fd(fd, STDIN_FILENO); } else { argv[0] = (char *) bb_msg_standard_input; } if (NAME_MAX < strlen(sfx) + suffix_len) bb_error_msg_and_die("suffix too long"); { char *char_p = xzalloc(suffix_len + 1); memset(char_p, 'a', suffix_len); pfx = xasprintf("%s%s", sfx, char_p); if (ENABLE_FEATURE_CLEAN_UP) free(char_p); } while (1) { bytes_read = safe_read(STDIN_FILENO, read_buffer, READ_BUFFER_SIZE); if (!bytes_read) break; if (bytes_read < 0) bb_simple_perror_msg_and_die(argv[0]); src = read_buffer; do { if (!remaining) { if (!pfx) bb_error_msg_and_die("suffixes exhausted"); xmove_fd(xopen(pfx, O_WRONLY | O_CREAT | O_TRUNC), 1); pfx = next_file(pfx, suffix_len); remaining = cnt; } if (opt & SPLIT_OPT_b) { /* split by bytes */ to_write = (bytes_read < remaining) ? bytes_read : remaining; remaining -= to_write; } else { /* split by lines */ /* can be sped up by using _memrchr_ * and writing many lines at once... */ char *end = memchr(src, '\n', bytes_read); if (end) { --remaining; to_write = end - src + 1; } else { to_write = bytes_read; } } xwrite(STDOUT_FILENO, src, to_write); bytes_read -= to_write; src += to_write; } while (bytes_read); } return EXIT_SUCCESS; }
void update_read_window_icon_order(STREAM* s, WINDOW_ORDER_INFO* orderInfo, WINDOW_ICON_ORDER* window_icon) { window_icon->iconInfo = (ICON_INFO*) xzalloc(sizeof(ICON_INFO)); update_read_icon_info(s, window_icon->iconInfo); /* iconInfo (ICON_INFO) */ }
static state_t* alloc_state(void) { state_t* state = xzalloc(sizeof(*state)); INIT_STATE; return state; }
static tbool tsmf_ffmpeg_init_stream(ITSMFDecoder* decoder, const TS_AM_MEDIA_TYPE* media_type) { TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder; uint32 size; const uint8* s; uint8* p; mdecoder->codec = avcodec_find_decoder(mdecoder->codec_id); if (!mdecoder->codec) { DEBUG_WARN("avcodec_find_decoder failed."); return false; } mdecoder->codec_context->codec_id = mdecoder->codec_id; mdecoder->codec_context->codec_type = mdecoder->media_type; if (mdecoder->media_type == AVMEDIA_TYPE_VIDEO) { if (!tsmf_ffmpeg_init_video_stream(decoder, media_type)) return false; } else if (mdecoder->media_type == AVMEDIA_TYPE_AUDIO) { if (!tsmf_ffmpeg_init_audio_stream(decoder, media_type)) return false; } if (media_type->ExtraData) { if (media_type->SubType == TSMF_SUB_TYPE_AVC1 && media_type->FormatType == TSMF_FORMAT_TYPE_MPEG2VIDEOINFO) { /* The extradata format that FFmpeg uses is following CodecPrivate in Matroska. See http://haali.su/mkv/codecs.pdf */ mdecoder->codec_context->extradata_size = media_type->ExtraDataSize + 8; mdecoder->codec_context->extradata = xzalloc(mdecoder->codec_context->extradata_size); p = mdecoder->codec_context->extradata; *p++ = 1; /* Reserved? */ *p++ = media_type->ExtraData[8]; /* Profile */ *p++ = 0; /* Profile */ *p++ = media_type->ExtraData[12]; /* Level */ *p++ = 0xff; /* Flag? */ *p++ = 0xe0 | 0x01; /* Reserved | #sps */ s = media_type->ExtraData + 20; size = ((uint32)(*s)) * 256 + ((uint32)(*(s + 1))); memcpy(p, s, size + 2); s += size + 2; p += size + 2; *p++ = 1; /* #pps */ size = ((uint32)(*s)) * 256 + ((uint32)(*(s + 1))); memcpy(p, s, size + 2); } else { /* Add a padding to avoid invalid memory read in some codec */ mdecoder->codec_context->extradata_size = media_type->ExtraDataSize + 8; mdecoder->codec_context->extradata = xzalloc(mdecoder->codec_context->extradata_size); memcpy(mdecoder->codec_context->extradata, media_type->ExtraData, media_type->ExtraDataSize); memset(mdecoder->codec_context->extradata + media_type->ExtraDataSize, 0, 8); } } if (mdecoder->codec->capabilities & CODEC_CAP_TRUNCATED) mdecoder->codec_context->flags |= CODEC_FLAG_TRUNCATED; return true; }
void ipsvd_perhost_init(unsigned c) { // free(cc); cc = xzalloc(c * sizeof(*cc)); cclen = c; }
static tbool tsmf_ffmpeg_decode_video(ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions) { TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder; int decoded; int len; AVFrame* frame; tbool ret = true; #if LIBAVCODEC_VERSION_MAJOR < 52 || (LIBAVCODEC_VERSION_MAJOR == 52 && LIBAVCODEC_VERSION_MINOR <= 20) len = avcodec_decode_video(mdecoder->codec_context, mdecoder->frame, &decoded, data, data_size); #else { AVPacket pkt; av_init_packet(&pkt); pkt.data = (uint8*) data; pkt.size = data_size; if (extensions & TSMM_SAMPLE_EXT_CLEANPOINT) pkt.flags |= AV_PKT_FLAG_KEY; len = avcodec_decode_video2(mdecoder->codec_context, mdecoder->frame, &decoded, &pkt); } #endif if (len < 0) { DEBUG_WARN("data_size %d, avcodec_decode_video failed (%d)", data_size, len); ret = false; } else if (!decoded) { DEBUG_WARN("data_size %d, no frame is decoded.", data_size); ret = false; } else { DEBUG_DVC("linesize[0] %d linesize[1] %d linesize[2] %d linesize[3] %d " "pix_fmt %d width %d height %d", mdecoder->frame->linesize[0], mdecoder->frame->linesize[1], mdecoder->frame->linesize[2], mdecoder->frame->linesize[3], mdecoder->codec_context->pix_fmt, mdecoder->codec_context->width, mdecoder->codec_context->height); mdecoder->decoded_size = avpicture_get_size(mdecoder->codec_context->pix_fmt, mdecoder->codec_context->width, mdecoder->codec_context->height); mdecoder->decoded_data = xzalloc(mdecoder->decoded_size); frame = avcodec_alloc_frame(); avpicture_fill((AVPicture *) frame, mdecoder->decoded_data, mdecoder->codec_context->pix_fmt, mdecoder->codec_context->width, mdecoder->codec_context->height); av_picture_copy((AVPicture *) frame, (AVPicture *) mdecoder->frame, mdecoder->codec_context->pix_fmt, mdecoder->codec_context->width, mdecoder->codec_context->height); av_free(frame); } #if SAVE_VIDEO n_save_data(data, data_size, mdecoder->codec_context->width, mdecoder->codec_context->height); #endif return ret; }
unsigned parse_opts(int argc, char **argv, const struct options *opt, const char *usage) { int help = 0; int size = parse_opt_size(opt); const int LONGOPT_OFFSET = 256; struct strbuf *shortopts = strbuf_new(); struct option *longopts = xzalloc(sizeof(longopts[0]) * (size+2)); struct option *curopt = longopts; int ii; for (ii = 0; ii < size; ++ii) { curopt->name = opt[ii].long_name; /*curopt->flag = 0; - xzalloc did it */ if (opt[ii].short_name) curopt->val = opt[ii].short_name; else curopt->val = LONGOPT_OFFSET + ii; switch (opt[ii].type) { case OPTION_BOOL: curopt->has_arg = no_argument; if (opt[ii].short_name) strbuf_append_char(shortopts, opt[ii].short_name); break; case OPTION_INTEGER: case OPTION_STRING: case OPTION_LIST: curopt->has_arg = required_argument; if (opt[ii].short_name) strbuf_append_strf(shortopts, "%c:", opt[ii].short_name); break; case OPTION_OPTSTRING: curopt->has_arg = optional_argument; if (opt[ii].short_name) strbuf_append_strf(shortopts, "%c::", opt[ii].short_name); break; case OPTION_GROUP: case OPTION_END: break; } //log("curopt[%d].name:'%s' .has_arg:%d .flag:%p .val:%d", (int)(curopt-longopts), // curopt->name, curopt->has_arg, curopt->flag, curopt->val); /* * getopt_long() thinks that NULL name marks the end of longopts. * Example: * [0] name:'verbose' val:'v' * [1] name:NULL val:'c' * [2] name:'force' val:'f' * ... ... ... * In this case, --force won't be accepted! * Therefore we can only advance if name is not NULL. */ if (curopt->name) curopt++; } curopt->name = "help"; curopt->has_arg = no_argument; curopt->flag = &help; curopt->val = 1; /* xzalloc did it already: curopt++; curopt->name = NULL; curopt->has_arg = 0; curopt->flag = NULL; curopt->val = 0; */ unsigned retval = 0; while (1) { int c = getopt_long(argc, argv, shortopts->buf, longopts, NULL); if (c == -1) break; if (c == '?' || help) { free(longopts); strbuf_free(shortopts); xfunc_error_retval = 0; /* this isn't error, exit code = 0 */ show_usage_and_die(usage, opt); } for (ii = 0; ii < size; ++ii) { if (opt[ii].short_name == c || LONGOPT_OFFSET + ii == c) { if (ii < sizeof(retval)*8) retval |= (1 << ii); if (opt[ii].value != NULL) switch (opt[ii].type) { case OPTION_BOOL: *(int*)(opt[ii].value) += 1; break; case OPTION_INTEGER: *(int*)(opt[ii].value) = xatoi(optarg); break; case OPTION_STRING: case OPTION_OPTSTRING: if (optarg) *(char**)(opt[ii].value) = (char*)optarg; break; case OPTION_LIST: *(GList**)(opt[ii].value) = g_list_append(*(GList**)(opt[ii].value), optarg); break; case OPTION_GROUP: case OPTION_END: break; } } } } free(longopts); strbuf_free(shortopts); return retval; }
static tbool tsmf_ffmpeg_decode_audio(ITSMFDecoder* decoder, const uint8* data, uint32 data_size, uint32 extensions) { TSMFFFmpegDecoder* mdecoder = (TSMFFFmpegDecoder*) decoder; int len; int frame_size; uint32 src_size; const uint8* src; uint8* dst; int dst_offset; #if 0 LLOGLN(0, ("tsmf_ffmpeg_decode_audio: data_size %d", data_size)); int i; for (i = 0; i < data_size; i++) { LLOG(0, ("%02X ", data[i])); if (i % 16 == 15) LLOG(0, ("\n")); } LLOG(0, ("\n")); #endif if (mdecoder->decoded_size_max == 0) mdecoder->decoded_size_max = AVCODEC_MAX_AUDIO_FRAME_SIZE + 16; mdecoder->decoded_data = xzalloc(mdecoder->decoded_size_max); /* align the memory for SSE2 needs */ dst = (uint8*) (((uintptr_t)mdecoder->decoded_data + 15) & ~ 0x0F); dst_offset = dst - mdecoder->decoded_data; src = data; src_size = data_size; while (src_size > 0) { /* Ensure enough space for decoding */ if (mdecoder->decoded_size_max - mdecoder->decoded_size < AVCODEC_MAX_AUDIO_FRAME_SIZE) { mdecoder->decoded_size_max = mdecoder->decoded_size_max * 2 + 16; mdecoder->decoded_data = xrealloc(mdecoder->decoded_data, mdecoder->decoded_size_max); dst = (uint8*) (((uintptr_t)mdecoder->decoded_data + 15) & ~ 0x0F); if (dst - mdecoder->decoded_data != dst_offset) { /* re-align the memory if the alignment has changed after realloc */ memmove(dst, mdecoder->decoded_data + dst_offset, mdecoder->decoded_size); dst_offset = dst - mdecoder->decoded_data; } dst += mdecoder->decoded_size; } frame_size = mdecoder->decoded_size_max - mdecoder->decoded_size; #if LIBAVCODEC_VERSION_MAJOR < 52 || (LIBAVCODEC_VERSION_MAJOR == 52 && LIBAVCODEC_VERSION_MINOR <= 20) len = avcodec_decode_audio2(mdecoder->codec_context, (int16_t*) dst, &frame_size, src, src_size); #else { AVPacket pkt; av_init_packet(&pkt); pkt.data = (uint8*) src; pkt.size = src_size; len = avcodec_decode_audio3(mdecoder->codec_context, (int16_t*) dst, &frame_size, &pkt); } #endif if (len <= 0 || frame_size <= 0) { DEBUG_WARN("error decoding"); break; } src += len; src_size -= len; mdecoder->decoded_size += frame_size; dst += frame_size; } if (mdecoder->decoded_size == 0) { xfree(mdecoder->decoded_data); mdecoder->decoded_data = NULL; } else if (dst_offset) { /* move the aligned decoded data to original place */ memmove(mdecoder->decoded_data, mdecoder->decoded_data + dst_offset, mdecoder->decoded_size); } DEBUG_DVC("data_size %d decoded_size %d", data_size, mdecoder->decoded_size); return true; }
int date_main(int argc, char **argv) { time_t tm; struct tm tm_time; unsigned opt; int ifmt = -1; char *date_str = NULL; char *date_fmt = NULL; char *filename = NULL; char *isofmt_arg; char *hintfmt_arg; opt_complementary = "d--s:s--d" USE_FEATURE_DATE_ISOFMT(":R--I:I--R"); opt = getopt32(argv, "Rs:ud:r:" USE_FEATURE_DATE_ISOFMT("I::D:"), &date_str, &date_str, &filename USE_FEATURE_DATE_ISOFMT(, &isofmt_arg, &hintfmt_arg)); maybe_set_utc(opt); if (ENABLE_FEATURE_DATE_ISOFMT && (opt & DATE_OPT_TIMESPEC)) { if (!isofmt_arg) { ifmt = 0; /* default is date */ } else { static const char *const isoformats[] = { "date", "hours", "minutes", "seconds" }; for (ifmt = 0; ifmt < 4; ifmt++) if (!strcmp(isofmt_arg, isoformats[ifmt])) goto found; /* parse error */ bb_show_usage(); found: ; } } /* XXX, date_fmt == NULL from this always */ if ((date_fmt == NULL) && (optind < argc) && (argv[optind][0] == '+')) { date_fmt = &argv[optind][1]; /* Skip over the '+' */ } else if (date_str == NULL) { opt |= DATE_OPT_SET; date_str = argv[optind]; } /* Now we have parsed all the information except the date format which depends on whether the clock is being set or read */ if (filename) { struct stat statbuf; xstat(filename, &statbuf); tm = statbuf.st_mtime; } else time(&tm); memcpy(&tm_time, localtime(&tm), sizeof(tm_time)); /* Zero out fields - take her back to midnight! */ if (date_str != NULL) { tm_time.tm_sec = 0; tm_time.tm_min = 0; tm_time.tm_hour = 0; /* Process any date input to UNIX time since 1 Jan 1970 */ if (ENABLE_FEATURE_DATE_ISOFMT && (opt & DATE_OPT_HINT)) { strptime(date_str, hintfmt_arg, &tm_time); } else if (strchr(date_str, ':') != NULL) { /* Parse input and assign appropriately to tm_time */ if (sscanf(date_str, "%d:%d:%d", &tm_time.tm_hour, &tm_time.tm_min, &tm_time.tm_sec) == 3) { /* no adjustments needed */ } else if (sscanf(date_str, "%d:%d", &tm_time.tm_hour, &tm_time.tm_min) == 2) { /* no adjustments needed */ } else if (sscanf(date_str, "%d.%d-%d:%d:%d", &tm_time.tm_mon, &tm_time.tm_mday, &tm_time.tm_hour, &tm_time.tm_min, &tm_time.tm_sec) == 5) { /* Adjust dates from 1-12 to 0-11 */ tm_time.tm_mon -= 1; } else if (sscanf(date_str, "%d.%d-%d:%d", &tm_time.tm_mon, &tm_time.tm_mday, &tm_time.tm_hour, &tm_time.tm_min) == 4) { /* Adjust dates from 1-12 to 0-11 */ tm_time.tm_mon -= 1; } else if (sscanf(date_str, "%d.%d.%d-%d:%d:%d", &tm_time.tm_year, &tm_time.tm_mon, &tm_time.tm_mday, &tm_time.tm_hour, &tm_time.tm_min, &tm_time.tm_sec) == 6) { tm_time.tm_year -= 1900; /* Adjust years */ tm_time.tm_mon -= 1; /* Adjust dates from 1-12 to 0-11 */ } else if (sscanf(date_str, "%d.%d.%d-%d:%d", &tm_time.tm_year, &tm_time.tm_mon, &tm_time.tm_mday, &tm_time.tm_hour, &tm_time.tm_min) == 5) { tm_time.tm_year -= 1900; /* Adjust years */ tm_time.tm_mon -= 1; /* Adjust dates from 1-12 to 0-11 */ } else { bb_error_msg_and_die(bb_msg_invalid_date, date_str); } } else { int nr; char *cp; nr = sscanf(date_str, "%2d%2d%2d%2d%d", &tm_time.tm_mon, &tm_time.tm_mday, &tm_time.tm_hour, &tm_time.tm_min, &tm_time.tm_year); if (nr < 4 || nr > 5) { bb_error_msg_and_die(bb_msg_invalid_date, date_str); } cp = strchr(date_str, '.'); if (cp) { nr = sscanf(cp + 1, "%2d", &tm_time.tm_sec); if (nr != 1) { bb_error_msg_and_die(bb_msg_invalid_date, date_str); } } /* correct for century - minor Y2K problem here? */ if (tm_time.tm_year >= 1900) { tm_time.tm_year -= 1900; } /* adjust date */ tm_time.tm_mon -= 1; } /* Correct any day of week and day of year etc. fields */ tm_time.tm_isdst = -1; /* Be sure to recheck dst. */ tm = mktime(&tm_time); if (tm < 0) { bb_error_msg_and_die(bb_msg_invalid_date, date_str); } maybe_set_utc(opt); /* if setting time, set it */ if ((opt & DATE_OPT_SET) && stime(&tm) < 0) { bb_perror_msg("cannot set date"); } } /* Display output */ /* Deal with format string */ if (date_fmt == NULL) { int i; date_fmt = xzalloc(32); if (ENABLE_FEATURE_DATE_ISOFMT && ifmt >= 0) { strcpy(date_fmt, "%Y-%m-%d"); if (ifmt > 0) { i = 8; date_fmt[i++] = 'T'; date_fmt[i++] = '%'; date_fmt[i++] = 'H'; if (ifmt > 1) { date_fmt[i++] = ':'; date_fmt[i++] = '%'; date_fmt[i++] = 'M'; } if (ifmt > 2) { date_fmt[i++] = ':'; date_fmt[i++] = '%'; date_fmt[i++] = 'S'; } format_utc: date_fmt[i++] = '%'; date_fmt[i] = (opt & DATE_OPT_UTC) ? 'Z' : 'z'; } } else if (opt & DATE_OPT_RFC2822) { /* Undo busybox.c for date -R */ if (ENABLE_LOCALE_SUPPORT) setlocale(LC_TIME, "C"); strcpy(date_fmt, "%a, %d %b %Y %H:%M:%S "); i = 22; goto format_utc; } else /* default case */ date_fmt = (char*)"%a %b %e %H:%M:%S %Z %Y"; } #define date_buf bb_common_bufsiz1 if (*date_fmt == '\0') { /* With no format string, just print a blank line */ date_buf[0] = '\0'; } else { /* Handle special conversions */ if (strncmp(date_fmt, "%f", 2) == 0) { date_fmt = (char*)"%Y.%m.%d-%H:%M:%S"; } /* Generate output string */ strftime(date_buf, sizeof(date_buf), date_fmt, &tm_time); } puts(date_buf); return EXIT_SUCCESS; }
/* * Kernel stores patchnames to AUFS branches in the br<n> files in * the /sys/fs/aufs/si_<sbinfo> directory where <n> denotes a branch * number and <sbinfo> is a hexadecimal number in %lx format. For * example: * * $ cat /sys/fs/aufs/si_f598876b087ed883/br0 * /path/to/branch0/directory=rw * * This function sets up an array of pointers to branch pathnames. */ int parse_aufs_branches(struct mount_info *mi) { char path[AUFSBR_PATH_LEN]; char *cp; int n; int ret; unsigned int br_num; unsigned int br_max; DIR *dp; FILE *fp; struct dirent *de; pr_info("Collecting AUFS branch pathnames ...\n"); if (mi->nsid == 0) { pr_err("No nsid to parse its aufs branches\n"); return -1; } if (mi->nsid == aufs_nsid) { pr_debug("Using cached aufs branch paths for nsid %p\n", aufs_nsid); return 0; } if (aufs_nsid) free_aufs_branches(); strcpy(path, SYSFS_AUFS); /* /sys/fs/aufs/ */ if (parse_aufs_sbinfo(mi, &path[sizeof SYSFS_AUFS - 1], SBINFO_LEN) < 0) return -1; if ((dp = opendir(path)) == NULL) { pr_perror("Cannot opendir %s", path); return -1; } /* * Find out how many branches we have. */ br_max = 0; ret = 0; while (1) { errno = 0; if ((de = readdir(dp)) == NULL) { if (errno) { pr_perror("Cannot readdir %s", path); ret = -1; } break; } ret = sscanf(de->d_name, "br%d", &br_num); if (ret == 1 && br_num > br_max) br_max = br_num; } closedir(dp); if (ret == -1) return -1; /* * Default AUFS maximum is 127, so 1000 should be plenty. * If you increase the maximum to more than 3 digits, * make sure to change AUFSBR_PATH_LEN accordingly. */ if (br_max > 999) { pr_err("Too many branches %d\n", br_max); return -1; } /* * Allocate an array of pointers to branch pathnames to be read. * Branches are indexed from 0 and we need a NULL pointer at the end. */ aufs_branches = xzalloc((br_max + 2) * sizeof (char *)); if (!aufs_branches) return -1; /* * Now read branch pathnames from the branch files. */ n = strlen(path); fp = NULL; for (br_num = 0; br_num <= br_max; br_num++) { ret = snprintf(&path[n], sizeof path - n, "/br%d", br_num); if (ret >= sizeof path - n) { pr_err("Buffer overrun creating path for branch %d\n", br_num); goto err; } if ((fp = fopen(path, "r")) == NULL) { pr_perror("Cannot fopen %s", path); goto err; } if (fscanf(fp, "%ms=", &aufs_branches[br_num]) != 1 || aufs_branches[br_num] == NULL) { pr_perror("Parse error reading %s", path); goto err; } /* chop off the trailing "=..." stuff */ if ((cp = strchr(aufs_branches[br_num], '=')) == NULL) { pr_err("Bad format in branch pathname %s\n", aufs_branches[br_num]); goto err; } *cp = '\0'; fclose(fp); /* * Log branch information for extenal utitilies that * want to recreate the process's AUFS filesystem * before calling criu restore. * * DO NOT CHANGE this format! */ pr_info("%s : %s\n", path, aufs_branches[br_num]); } aufs_nsid = mi->nsid; return 0; err: if (fp) fclose(fp); free_aufs_branches(); return -1; }
static void parse_options(struct videohub_data *data, int argc, char **argv) { int j, err = 0; // Check environment data->dev_host = getenv("VIDEOHUB_HOST"); data->dev_port = getenv("VIDEOHUB_PORT"); // Set defaults if (!data->dev_port) data->dev_port = "9990"; while ((j = getopt_long(argc, argv, short_options, long_options, NULL)) != -1) { if (j == '?') // Invalid parameter exit(EXIT_FAILURE); switch (j) { case 'h': // --host data->dev_host = optarg; break; case 'p': // --port data->dev_port = optarg; break; case 'T': { // --test-input struct stat st; FILE *f; if (stat(optarg, &st) != 0) die("Can't stat %s: %s", optarg, strerror(errno)); f = fopen(optarg, "r"); if (!f) die("Can't open %s: %s", optarg, strerror(errno)); test_data = xzalloc(st.st_size + 1); if (fread(test_data, st.st_size, 1, f) < 1) die("Can't read from %s: %s", optarg, strerror(errno)); fclose(f); data->dev_host = "sdi-matrix"; break; } case 'd': // --debug debug++; if (debug) quiet = 0; // Disable quiet break; case 'q': // --quiet quiet = !quiet; break; case 'i': // --info show_info = 1; break; case 'm': // --monitor show_monitor = 1; break; case 'b': // --backup show_backup = 1; break; case 901: show_list |= action_list_device; break; // --list-device case 902: show_list |= action_list_vinputs; break; // --list-vinputs case 903: show_list |= action_list_voutputs; break; // --list-voutputs case 904: show_list |= action_list_moutputs; break; // --list-moutputs case 905: show_list |= action_list_serial; break; // --list-serial case 906: show_list |= action_list_proc_units; break; // --list-proc-units case 907: show_list |= action_list_frames; break; // --list-frames case 950: set_device_option("Friendly name", optarg); break; // --set-name case 1001: parse_cmd2(argc, argv, CMD_INPUT_LABELS); break; // --in-name case 1002: parse_cmd2(argc, argv, CMD_VIDEO_OUTPUT_ROUTING); switch_cmd_args(); break; // --in-output case 1003: parse_cmd2(argc, argv, CMD_MONITORING_OUTPUT_ROUTING); switch_cmd_args(); break; // --in-monitor case 2001: parse_cmd2(argc, argv, CMD_OUTPUT_LABELS); break; // --out-name case 2002: parse_cmd2(argc, argv, CMD_VIDEO_OUTPUT_ROUTING); break; // --out-input case 2003: parse_cmd1(argc, argv, CMD_VIDEO_OUTPUT_LOCKS, true); break; // --out-lock case 2004: parse_cmd1(argc, argv, CMD_VIDEO_OUTPUT_LOCKS, false); break; // --out-unlock case 3001: parse_cmd2(argc, argv, CMD_MONITORING_OUTPUT_LABELS); break; // --mon-name case 3002: parse_cmd2(argc, argv, CMD_MONITORING_OUTPUT_ROUTING); break; // --mon-input case 3003: parse_cmd1(argc, argv, CMD_MONITORING_OUTPUT_LOCKS, true); break; // --mon-lock case 3004: parse_cmd1(argc, argv, CMD_MONITORING_OUTPUT_LOCKS, false); break; // --mon-unlock case 4001: parse_cmd2(argc, argv, CMD_SERIAL_PORT_LABELS); break; // --ser-name case 4002: parse_cmd2(argc, argv, CMD_SERIAL_PORT_ROUTING); break; // --ser-input case 4003: parse_cmd1(argc, argv, CMD_SERIAL_PORT_LOCKS, true); break; // --ser-lock case 4004: parse_cmd1(argc, argv, CMD_SERIAL_PORT_LOCKS, false); break; // --ser-unlock case 4005: parse_cmd2(argc, argv, CMD_SERIAL_PORT_DIRECTIONS); break; // --ser-dir case 4006: parse_cmd2s(argc, argv, CMD_SERIAL_PORT_ROUTING); break; // --ser-clear case 5001: parse_cmd2(argc, argv, CMD_PROCESSING_UNIT_ROUTING); break; // --pu-input case 5002: parse_cmd1(argc, argv, CMD_PROCESSING_UNIT_LOCKS, true); break; // --pu-lock case 5003: parse_cmd1(argc, argv, CMD_PROCESSING_UNIT_LOCKS, false); break; // --pu-unlock case 5004: parse_cmd2s(argc, argv, CMD_PROCESSING_UNIT_ROUTING); break; // --pu-clear case 6001: parse_cmd2(argc, argv, CMD_FRAME_LABELS); break; // --fr-name case 6002: parse_cmd2(argc, argv, CMD_FRAME_BUFFER_ROUTING); break; // --fr-input case 6003: parse_cmd1(argc, argv, CMD_FRAME_BUFFER_LOCKS, true); break; // --fr-lock case 6004: parse_cmd1(argc, argv, CMD_FRAME_BUFFER_LOCKS, false); break; // --fr-unlock case 6005: parse_cmd2s(argc, argv, CMD_FRAME_BUFFER_ROUTING); break; // --fr-clear case 'H': // --help show_help(data); exit(EXIT_SUCCESS); case 'V': // --version printf("%s\n", program_id); exit(EXIT_SUCCESS); } } if (!data->dev_host || !strtoul(data->dev_port, NULL, 10)) err = 1; if (err) { show_help(data); if (!data->dev_host) fprintf(stderr, "ERROR: host is not set. Use --host option.\n"); exit(EXIT_FAILURE); } d("Device address: %s:%s\n", data->dev_host, data->dev_port); }
static NOINLINE void rewrite(priv_dumper_t *dumper, FS *fs) { enum { NOTOKAY, USEBCNT, USEPREC } sokay; PR *pr, **nextpr = NULL; FU *fu; char *p1, *p2, *p3; char savech, *fmtp; const char *byte_count_str; int nconv, prec = 0; for (fu = fs->nextfu; fu; fu = fu->nextfu) { /* * break each format unit into print units; each * conversion character gets its own. */ for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) { /* NOSTRICT */ /* DBU:[[email protected]] zalloc so that forward ptrs start out NULL*/ pr = xzalloc(sizeof(PR)); if (!fu->nextpr) fu->nextpr = pr; /* ignore nextpr -- its unused inside the loop and is * uninitialized 1st time through. */ /* skip preceding text and up to the next % sign */ for (p1 = fmtp; *p1 && *p1 != '%'; ++p1) continue; /* only text in the string */ if (!*p1) { pr->fmt = fmtp; pr->flags = F_TEXT; break; } /* * get precision for %s -- if have a byte count, don't * need it. */ if (fu->bcnt) { sokay = USEBCNT; /* skip to conversion character */ for (++p1; strchr(index_str, *p1); ++p1) continue; } else { /* skip any special chars, field width */ while (strchr(index_str + 1, *++p1)) continue; if (*p1 == '.' && isdigit(*++p1)) { sokay = USEPREC; prec = atoi(p1); while (isdigit(*++p1)) continue; } else sokay = NOTOKAY; } p2 = p1 + 1; /* set end pointer */ /* * figure out the byte count for each conversion; * rewrite the format as necessary, set up blank- * pbb_dump_adding for end of data. */ if (*p1 == 'c') { pr->flags = F_CHAR; DO_BYTE_COUNT_1: byte_count_str = "\001"; DO_BYTE_COUNT: if (fu->bcnt) { do { if (fu->bcnt == *byte_count_str) { break; } } while (*++byte_count_str); } /* Unlike the original, output the remainder of the format string. */ if (!*byte_count_str) { bb_error_msg_and_die("bad byte count for conversion character %s", p1); } pr->bcnt = *byte_count_str; } else if (*p1 == 'l') { ++p2; ++p1; DO_INT_CONV: { const char *e; e = strchr(lcc, *p1); if (!e) { goto DO_BAD_CONV_CHAR; } pr->flags = F_INT; if (e > lcc + 1) { pr->flags = F_UINT; } byte_count_str = "\004\002\001"; goto DO_BYTE_COUNT; } /* NOTREACHED */ } else if (strchr(lcc, *p1)) { goto DO_INT_CONV; } else if (strchr("eEfgG", *p1)) { pr->flags = F_DBL; byte_count_str = "\010\004"; goto DO_BYTE_COUNT; } else if (*p1 == 's') { pr->flags = F_STR; if (sokay == USEBCNT) { pr->bcnt = fu->bcnt; } else if (sokay == USEPREC) { pr->bcnt = prec; } else { /* NOTOKAY */ bb_error_msg_and_die("%%s requires a precision or a byte count"); } } else if (*p1 == '_') { ++p2; switch (p1[1]) { case 'A': dumper->endfu = fu; fu->flags |= F_IGNORE; /* FALLTHROUGH */ case 'a': pr->flags = F_ADDRESS; ++p2; if ((p1[2] != 'd') && (p1[2] != 'o') && (p1[2] != 'x')) { goto DO_BAD_CONV_CHAR; } *p1 = p1[2]; break; case 'c': pr->flags = F_C; /* *p1 = 'c'; set in conv_c */ goto DO_BYTE_COUNT_1; case 'p': pr->flags = F_P; *p1 = 'c'; goto DO_BYTE_COUNT_1; case 'u': pr->flags = F_U; /* *p1 = 'c'; set in conv_u */ goto DO_BYTE_COUNT_1; default: goto DO_BAD_CONV_CHAR; } } else { DO_BAD_CONV_CHAR: bb_error_msg_and_die("bad conversion character %%%s", p1); } /* * copy to PR format string, set conversion character * pointer, update original. */ savech = *p2; p1[1] = '\0'; pr->fmt = xstrdup(fmtp); *p2 = savech; //Too early! xrealloc can move pr->fmt! //pr->cchar = pr->fmt + (p1 - fmtp); /* DBU:[[email protected]] w/o this, trailing fmt text, space is lost. * Skip subsequent text and up to the next % sign and tack the * additional text onto fmt: eg. if fmt is "%x is a HEX number", * we lose the " is a HEX number" part of fmt. */ for (p3 = p2; *p3 && *p3 != '%'; p3++) continue; if (p3 > p2) { savech = *p3; *p3 = '\0'; pr->fmt = xrealloc(pr->fmt, strlen(pr->fmt) + (p3-p2) + 1); strcat(pr->fmt, p2); *p3 = savech; p2 = p3; } pr->cchar = pr->fmt + (p1 - fmtp); fmtp = p2; /* only one conversion character if byte count */ if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) { bb_error_msg_and_die("byte count with multiple conversion characters"); } } /* * if format unit byte count not specified, figure it out * so can adjust rep count later. */ if (!fu->bcnt) for (pr = fu->nextpr; pr; pr = pr->nextpr) fu->bcnt += pr->bcnt; } /* * if the format string interprets any data at all, and it's * not the same as the blocksize, and its last format unit * interprets any data at all, and has no iteration count, * repeat it as necessary. * * if, rep count is greater than 1, no trailing whitespace * gets output from the last iteration of the format unit. */ for (fu = fs->nextfu; fu; fu = fu->nextfu) { if (!fu->nextfu && fs->bcnt < dumper->blocksize && !(fu->flags & F_SETREP) && fu->bcnt ) { fu->reps += (dumper->blocksize - fs->bcnt) / fu->bcnt; } if (fu->reps > 1) { for (pr = fu->nextpr;; pr = pr->nextpr) if (!pr->nextpr) break; for (p1 = pr->fmt, p2 = NULL; *p1; ++p1) p2 = isspace(*p1) ? p1 : NULL; if (p2) pr->nospace = p2; } if (!fu->nextfu) break; } }