// increment value io_t inc_param_value(u32 idx, io_t inc) { io_t in; s32 scaled; print_dbg("\r\n inc_param_value, index: "); print_dbg_ulong(idx); print_dbg(" , input: 0x"); print_dbg_hex(get_param_value(idx)); print_dbg(" , increment: 0x"); print_dbg_hex(inc); in = get_param_value(idx); // use scaler to increment and lookup scaled = scaler_inc( &(net->params[idx].scaler), &in, inc); print_dbg(" , new input: 0x"); print_dbg_hex(in); print_dbg(" , scaled: 0x"); print_dbg_hex(scaled); print_dbg("\r\n\r\n "); // store input value in pnode net->params[idx].data.value = in; net->params[idx].data.changed = 1; ctl_param_change(idx, scaled ); return in; }
void st(char **params, t_champ *champ, t_vm *vm, int flag) { to_int size; int addr; to_int reg; size.value = 0; reg.value = champ->reg[(int)params[1][1] - 1]; get_param_value(&size, params[2], champ); addr = (size.value % IDX_MOD) + champ->data[ADDR] + champ->data[PC] + 2 + get_size_param(params[2][0]); addr = addr % MEM_SIZE; params[0][0] = ACTIF; if (params[2][0] == T_REG) champ->reg[(int)params[2][1] - 1] = champ->reg[(int)params[1][1] - 1]; else { if (!flag || (addr >= champ->data[ADDR] && addr <= champ->data[ADDR] + champ->prog_size)) modif_mem_case(champ, vm->mem, reg.param, addr); } color_mem_case(champ, vm->mem, params[0]); if (vm->no_graph == EXIT_FAILURE) my_printf("[%d] st (r%d=%d -> i@pc+%d)\n", champ->data[PC], (int)params[1][1], reg.value, size.value); champ->data[PC] = (champ->data[PC] + params[0][1]) % MEM_SIZE; }
/** * @brief set the parameters for the node */ int set_dmq_node_params(dmq_node_t *node, param_t *params) { str *status; if(!params) { LM_DBG("no parameters given\n"); return 0; } status = get_param_value(params, &dmq_node_status_str); if(status) { if(STR_EQ(*status, dmq_node_active_str)) { node->status = DMQ_NODE_ACTIVE; } else if(STR_EQ(*status, dmq_node_timeout_str)) { node->status = DMQ_NODE_TIMEOUT; } else if(STR_EQ(*status, dmq_node_disabled_str)) { node->status = DMQ_NODE_DISABLED; } else if(STR_EQ(*status, dmq_node_pending_str)) { node->status = DMQ_NODE_PENDING; } else { LM_ERR("invalid status parameter: %.*s\n", STR_FMT(status)); goto error; } } return 0; error: return -1; }
static void template_send_form_method(int idx, struct template_content *tpc) { if (get_param_value(idx, "dontpost")) dprintf(idx, "GET"); else dprintf(idx, "POST"); }
query_status_t send_tm_request_packet( struct qserver *server ) { char buf[2048]; char *xmlp = buf + 8; unsigned int len; char *user = get_param_value( server, "user", NULL ); char *password = get_param_value( server, "password", NULL ); if ( ! server->protocol_version ) { // No seen the version yet wait // register_send here to ensure that timeouts function correctly return register_send( server ); } // build the query xml len = sprintf( xmlp, TM_XML_PREFIX ); if ( user != NULL && password != NULL ) { len += sprintf( xmlp + len, TM_AUTH_TEMPLATE, user, password ); } else { // Default to User / User len += sprintf( xmlp + len, TM_AUTH_TEMPLATE, "User", "User" ); } // Always get Player info otherwise player count is invalid // TODO: add more calls to get full player info? server->flags |= TF_PLAYER_QUERY|TF_RULES_QUERY; len += sprintf( xmlp + len, TM_SERVERINFO ); len += sprintf( xmlp + len, TM_PLAYERLIST ); len += sprintf( xmlp + len, TM_XML_SUFFIX ); // First 4 bytes is the length of the request memcpy( buf, &len, 4 ); // Second 4 bytes is the handle identifier ( id ) memcpy( buf+4, &server->challenge, 4 ); // prep the details we need for multi packet responses // we expect at least 1 packet response server->saved_data.pkt_max = 1; return send_packet( server, buf, len + 8 ); }
void update() { if (!cascade) { cvSetNumThreads(cvRound(threads * 100)); f0r_param_string classifier; get_param_value(&classifier, FACEBL0R_PARAM_CLASSIFIER); if (classifier) { cascade = (CvHaarClassifierCascade*) cvLoad(classifier, 0, 0, 0 ); if (!cascade) fprintf(stderr, "ERROR: Could not load classifier cascade %s\n", classifier); storage = cvCreateMemStorage(0); } else { memcpy(out, in, size * 4); return; } } // copy input image to OpenCV if( !image ) image = cvCreateImage(cvSize(width, height), IPL_DEPTH_8U, 4); memcpy(image->imageData, in, size * 4); // only re-detect periodically to control performance and reduce shape jitter int recheckInt = abs(cvRound(recheck * 1000)); if ( recheckInt > 0 && count % recheckInt ) { // skip detect count++; // fprintf(stderr, "draw-only counter %u\n", count); } else { count = 1; // reset the recheck counter if (objects) // reset the list of objects cvClearSeq(objects); double elapsed = (double) cvGetTickCount(); objects = detect(); // use detection time to throttle frequency of re-detect vs. redraw (automatic recheck) elapsed = cvGetTickCount() - elapsed; elapsed = elapsed / ((double) cvGetTickFrequency() * 1000.0); // Automatic recheck uses an undocumented negative parameter value, // which is not compliant, but technically feasible. if (recheck < 0 && cvRound( elapsed / (1000.0 / (recheckInt + 1)) ) <= recheckInt) count += recheckInt - cvRound( elapsed / (1000.0 / (recheckInt + 1))); // fprintf(stderr, "detection time = %gms counter %u\n", elapsed, count); } draw(); // copy filtered OpenCV image to output memcpy(out, image->imageData, size * 4); cvReleaseImage(&image); }
//--- get / set / increment input value io_t net_get_in_value(s32 inIdx) { if(inIdx < 0) { return 0; } if (inIdx >= net->numIns) { inIdx -= net->numIns; return get_param_value(inIdx); } else { return op_get_in_val(net->ops[net->ins[inIdx].opIdx], net->ins[inIdx].opInIdx); } }
static void parse_devicetree_param(const config_t *config, FSP_S_CONFIG *params) { uint32_t dev_offset = 0; uint32_t i = 0; for (i = 0; i < CONFIG_SOC_INTEL_I2C_DEV_MAX; i++, dev_offset++) { params->SerialIoI2cMode[i] = get_param_value(config, dev_offset); } for (i = 0; i < CONFIG_SOC_INTEL_COMMON_BLOCK_GSPI_MAX; i++, dev_offset++) { params->SerialIoSpiMode[i] = get_param_value(config, dev_offset); } for (i = 0; i < SOC_INTEL_CML_UART_DEV_MAX; i++, dev_offset++) { params->SerialIoUartMode[i] = get_param_value(config, dev_offset); } }
query_status_t send_ts3_all_servers_packet(struct qserver *server) { char buf[256], *password, *username; switch (server->challenge) { case 0: // Not seen a challenge yet, wait for it server->n_servers = 999; return (INPROGRESS); case 1: password = get_param_value(server, "password", ""); if (0 != strlen(password)) { username = get_param_value(server, "username", "serveradmin"); sprintf(buf, "login %s %s\015\012", username, password); break; } // NOTE: no break so we fall through server->challenge++; case 2: // NOTE: we currently don't support player info server->flags |= TF_STATUS_QUERY; server->n_servers = 3; sprintf(buf, "serverlist\015\012"); break; case 3: sprintf(buf, "quit\015\012"); break; case 4: return (DONE_FORCE); } server->saved_data.pkt_max = -1; return (send_packet(server, buf, strlen(buf))); }
static unsigned put_param_string(struct qserver* server, const char* paramname, char* buf, unsigned buflen, unsigned off) { char* val = get_param_value( server, paramname, NULL); if(val && strlen(val) < buflen-off-2) { strcpy(buf+off, val); off += strlen(val) + 1; } else { buf[off++] = '\0'; } return off; }
int load_configuration_file (FILE* config_file,CONFIG* config_struct ){ char line[257] ; int cur_val ; char cur_param [256] ; int x = 0 ; while(fgets(line,256,config_file) !=NULL){ if (strlen(line) <= 1 || contain_ch (line,'=')==false ) continue ; cur_val = get_param_value(line,cur_param); x= update_field(config_struct,cur_param,cur_val) ; assert(x!=0); } return 1 ; }
/* * Change a value of parameter * * vivi> param set <name> <value> * * set (argv[0]): command of parameter * <name> (argv[1]): name of parameter * <value> (argv[2]): value to set */ static void command_set(int argc, const char **argv) { int ret; char *name; param_value_t pre_value, value; if (argc != 3) { printk("invalid 'param set' command: too few(many) arguments\n"); return; } /* parsing arguments */ name = (char *)argv[1]; /* if a user want to set the 'linux command line' */ if (strncmp(name, "linux_cmd_line", strlen(name)) == 0) { ret = set_linux_cmd_line(argv[2]); if (!ret) { printk("Change linux command line to \"%s\"\n", linux_cmd_line); } else { printk("Failed changing linux command line\n"); } return; } /* Change normag vivi parameters */ value = (param_value_t)strtoul(argv[2], NULL, 0, &ret); if (ret) { printk("Can not parsing arguments\n"); } pre_value = get_param_value(name, &ret); ret = set_param_value(name, value); if (ret) { printk("Error: can not change '%s' parameter value\n", name); } printk("Change '%s' value. 0x%08lx(%d) to 0x%08lx(%d)\n", name, pre_value, pre_value, value, value); return; }
query_status_t send_dirtybomb_request_packet(struct qserver *server) { char buf[1024], *password, chunks, len; password = get_param_value(server, "password", ""); len = strlen(password); chunks = 0x01; if (server->flags & TF_RULES_QUERY) { chunks |= 0x02; } if (server->flags & TF_PLAYER_QUERY) { chunks |= 0x04; // Player chunks |= 0x08; // Team - Currently not supported } sprintf(buf, "%c%c%s%c", 0x01, len, password, chunks); server->saved_data.pkt_max = -1; return send_packet(server, buf, len + 3); }
query_status_t send_crysis_request_packet(struct qserver *server) { char cmd[256], buf[1024], *password, *md5; debug(2, "challenge: %ld", server->challenge); switch (server->challenge) { case 0: // Not seen a challenge yet, request it server->challenge++; sprintf(cmd, "challenge"); break; case 1: server->challenge++; password = get_param_value(server, "password", ""); sprintf(cmd, "%s:%s", server->challenge_string, password); md5 = md5_hex(cmd, strlen(cmd)); sprintf(cmd, "authenticate %s", md5); free(md5); break; case 2: // NOTE: we currently don't support player info server->challenge++; server->flags |= TF_STATUS_QUERY; server->n_servers = 3; sprintf(cmd, "status"); break; case 3: return (DONE_FORCE); } server->saved_data.pkt_max = -1; sprintf(buf, "POST /RPC2 HTTP/1.1\015\012Keep-Alive: 300\015\012User-Agent: qstat %s\015\012Content-Length: %d\015\012Content-Type: text/xml\015\012\015\012<?xml version=\"1.0\" encoding=\"UTF-8\"?><methodCall><methodName>%s</methodName><params /></methodCall>", VERSION, (int)(98 + strlen(cmd)), cmd); return (send_packet(server, buf, strlen(buf))); }
void ld(char **params, t_champ *champ, t_vm *vm, int flag) { to_int size; int value; size.value = 0; value = 0; get_param_value(&size, params[1], champ); params[0][0] = ACTIF; if (params[1][0] == T_REG) champ->reg[(int)params[2][1] - 1] = champ->reg[(int)params[1][1] - 1]; else if (params[1][0] == T_IND) ld_ind(flag, champ, vm, params); if (params[1][0] == T_DIR) champ->reg[(int)params[2][1] - 1] = size.value; color_mem_case(champ, vm->mem, params[0]); champ->data[PC] = (champ->data[PC] + params[0][1]) % MEM_SIZE; if (vm->no_graph == EXIT_FAILURE) my_printf("[%d] ld (d=%d -> r%d) carry=%d\n", champ->data[PC], size.value, (int)params[2][1], champ->data[CARRY]); champ->data[CARRY] != 1 ? (champ->data[CARRY] = 1) : (42); }
static void armadillo8x0_setup_console(struct platform_info *pinfo) { char console[128]; int ret; int autoboot = armadillo8x0_is_autoboot(pinfo); #if defined(CONFIG_CMD_SETENV) ret = get_param_value("console", console, 128); if (ret == 0 && strcmp(console, "none") == 0) if (!autoboot) ret = 1; if (ret) #endif hsprintf(console, "%s", CONFIG_DEFAULT_CONSOLE); /* we must set up to STANDARD_CONSOLE to match our hardware. FIXME: this is redundant and just using a side effect of the function to initialize it */ change_console(CONFIG_STANDARD_CONSOLE); ret = change_console(console); if (ret && !autoboot) change_console(CONFIG_STANDARD_CONSOLE); }
/* XXX fixme: this function uses obsolete argument parsing interface */ int acpi_table_add(const char *t) { char buf[1024], *p, *f; unsigned long val; size_t len, start, allen; bool has_header; int changed; int r; struct acpi_table_header hdr; r = 0; r |= get_param_value(buf, sizeof(buf), "data", t) ? 1 : 0; r |= get_param_value(buf, sizeof(buf), "file", t) ? 2 : 0; switch (r) { case 0: buf[0] = '\0'; /* fallthrough for default behavior */ case 1: has_header = false; break; case 2: has_header = true; break; default: fprintf(stderr, "acpitable: both data and file are specified\n"); return -1; } if (!acpi_tables) { allen = sizeof(uint16_t); acpi_tables = g_malloc0(allen); } else { allen = acpi_tables_len; } start = allen; acpi_tables = g_realloc(acpi_tables, start + ACPI_TABLE_HDR_SIZE); allen += has_header ? ACPI_TABLE_PFX_SIZE : ACPI_TABLE_HDR_SIZE; /* now read in the data files, reallocating buffer as needed */ for (f = strtok(buf, ":"); f; f = strtok(NULL, ":")) { int fd = open(f, O_RDONLY | O_BINARY); if (fd < 0) { fprintf(stderr, "can't open file %s: %s\n", f, strerror(errno)); return -1; } for (;;) { char data[8192]; r = read(fd, data, sizeof(data)); if (r == 0) { break; } else if (r > 0) { acpi_tables = g_realloc(acpi_tables, allen + r); memcpy(acpi_tables + allen, data, r); allen += r; } else if (errno != EINTR) { fprintf(stderr, "can't read file %s: %s\n", f, strerror(errno)); close(fd); return -1; } } close(fd); } /* now fill in the header fields */ f = acpi_tables + start; /* start of the table */ changed = 0; /* copy the header to temp place to align the fields */ memcpy(&hdr, has_header ? f : dfl_hdr, ACPI_TABLE_HDR_SIZE); /* length of the table minus our prefix */ len = allen - start - ACPI_TABLE_PFX_SIZE; hdr._length = cpu_to_le16(len); if (get_param_value(buf, sizeof(buf), "sig", t)) { /* strncpy is justified: the field need not be NUL-terminated. */ strncpy(hdr.sig, buf, sizeof(hdr.sig)); ++changed; } /* length of the table including header, in bytes */ if (has_header) { /* check if actual length is correct */ val = le32_to_cpu(hdr.length); if (val != len) { fprintf(stderr, "warning: acpitable has wrong length," " header says %lu, actual size %zu bytes\n", val, len); ++changed; } } /* we may avoid putting length here if has_header is true */ hdr.length = cpu_to_le32(len); if (get_param_value(buf, sizeof(buf), "rev", t)) { val = strtoul(buf, &p, 0); if (val > 255 || *p) { fprintf(stderr, "acpitable: \"rev=%s\" is invalid\n", buf); return -1; } hdr.revision = (uint8_t)val; ++changed; } if (get_param_value(buf, sizeof(buf), "oem_id", t)) { /* strncpy is justified: the field need not be NUL-terminated. */ strncpy(hdr.oem_id, buf, sizeof(hdr.oem_id)); ++changed; } if (get_param_value(buf, sizeof(buf), "oem_table_id", t)) { /* strncpy is justified: the field need not be NUL-terminated. */ strncpy(hdr.oem_table_id, buf, sizeof(hdr.oem_table_id)); ++changed; } if (get_param_value(buf, sizeof(buf), "oem_rev", t)) { val = strtol(buf, &p, 0); if (*p) { fprintf(stderr, "acpitable: \"oem_rev=%s\" is invalid\n", buf); return -1; } hdr.oem_revision = cpu_to_le32(val); ++changed; } if (get_param_value(buf, sizeof(buf), "asl_compiler_id", t)) { /* strncpy is justified: the field need not be NUL-terminated. */ strncpy(hdr.asl_compiler_id, buf, sizeof(hdr.asl_compiler_id)); ++changed; } if (get_param_value(buf, sizeof(buf), "asl_compiler_rev", t)) { val = strtol(buf, &p, 0); if (*p) { fprintf(stderr, "acpitable: \"%s=%s\" is invalid\n", "asl_compiler_rev", buf); return -1; } hdr.asl_compiler_revision = cpu_to_le32(val); ++changed; } if (!has_header && !changed) { fprintf(stderr, "warning: acpitable: no table headers are specified\n"); } /* now calculate checksum of the table, complete with the header */ /* we may as well leave checksum intact if has_header is true */ /* alternatively there may be a way to set cksum to a given value */ hdr.checksum = 0; /* for checksum calculation */ /* put header back */ memcpy(f, &hdr, sizeof(hdr)); if (changed || !has_header || 1) { ((struct acpi_table_header *)f)->checksum = acpi_checksum((uint8_t *)f + ACPI_TABLE_PFX_SIZE, len); } /* increase number of tables */ (*(uint16_t *)acpi_tables) = cpu_to_le32(le32_to_cpu(*(uint16_t *)acpi_tables) + 1); acpi_tables_len = allen; return 0; }
static void template_send_if_dontpost(int idx, struct template_content *tpc) { if (get_param_value(idx, "dontpost")) templates_content_send(tpc->subcontent, idx); }
int acpi_table_add(const char *t) { static const char *dfl_id = "QEMUQEMU"; char buf[1024], *p, *f; struct acpi_table_header acpi_hdr; unsigned long val; size_t off; memset(&acpi_hdr, 0, sizeof(acpi_hdr)); if (get_param_value(buf, sizeof(buf), "sig", t)) { strncpy(acpi_hdr.signature, buf, 4); } else { strncpy(acpi_hdr.signature, dfl_id, 4); } if (get_param_value(buf, sizeof(buf), "rev", t)) { val = strtoul(buf, &p, 10); if (val > 255 || *p != '\0') goto out; } else { val = 1; } acpi_hdr.revision = (int8_t)val; if (get_param_value(buf, sizeof(buf), "oem_id", t)) { strncpy(acpi_hdr.oem_id, buf, 6); } else { strncpy(acpi_hdr.oem_id, dfl_id, 6); } if (get_param_value(buf, sizeof(buf), "oem_table_id", t)) { strncpy(acpi_hdr.oem_table_id, buf, 8); } else { strncpy(acpi_hdr.oem_table_id, dfl_id, 8); } if (get_param_value(buf, sizeof(buf), "oem_rev", t)) { val = strtol(buf, &p, 10); if(*p != '\0') goto out; } else { val = 1; } acpi_hdr.oem_revision = cpu_to_le32(val); if (get_param_value(buf, sizeof(buf), "asl_compiler_id", t)) { strncpy(acpi_hdr.asl_compiler_id, buf, 4); } else { strncpy(acpi_hdr.asl_compiler_id, dfl_id, 4); } if (get_param_value(buf, sizeof(buf), "asl_compiler_rev", t)) { val = strtol(buf, &p, 10); if(*p != '\0') goto out; } else { val = 1; } acpi_hdr.asl_compiler_revision = cpu_to_le32(val); if (!get_param_value(buf, sizeof(buf), "data", t)) { buf[0] = '\0'; } acpi_hdr.length = sizeof(acpi_hdr); f = buf; while (buf[0]) { struct stat s; char *n = strchr(f, ':'); if (n) *n = '\0'; if(stat(f, &s) < 0) { fprintf(stderr, "Can't stat file '%s': %s\n", f, strerror(errno)); goto out; } acpi_hdr.length += s.st_size; if (!n) break; *n = ':'; f = n + 1; } if (!acpi_tables) { acpi_tables_len = sizeof(uint16_t); acpi_tables = qemu_mallocz(acpi_tables_len); } p = acpi_tables + acpi_tables_len; acpi_tables_len += sizeof(uint16_t) + acpi_hdr.length; acpi_tables = qemu_realloc(acpi_tables, acpi_tables_len); acpi_hdr.length = cpu_to_le32(acpi_hdr.length); *(uint16_t*)p = acpi_hdr.length; p += sizeof(uint16_t); memcpy(p, &acpi_hdr, sizeof(acpi_hdr)); off = sizeof(acpi_hdr); f = buf; while (buf[0]) { struct stat s; int fd; char *n = strchr(f, ':'); if (n) *n = '\0'; fd = open(f, O_RDONLY); if(fd < 0) goto out; if(fstat(fd, &s) < 0) { close(fd); goto out; } do { int r; r = read(fd, p + off, s.st_size); if (r > 0) { off += r; s.st_size -= r; } else if ((r < 0 && errno != EINTR) || r == 0) { close(fd); goto out; } } while(s.st_size); close(fd); if (!n) break; f = n + 1; } ((struct acpi_table_header*)p)->checksum = acpi_checksum((uint8_t*)p, off); /* increase number of tables */ (*(uint16_t*)acpi_tables) = cpu_to_le32(le32_to_cpu(*(uint16_t*)acpi_tables) + 1); return 0; out: if (acpi_tables) { qemu_free(acpi_tables); acpi_tables = NULL; } return -1; }
static int extract_reqmod_data(const char *data, SiteInfoType *si, unsigned int *eid, unsigned int *pid, unsigned int *uid, unsigned int *gid) { int ret = -1; char *enc = NULL, *dec = NULL, *dummy_url = NULL; ParamNodeType *pl = NULL; const char *s, *bldata; size_t len_output; uint32_t _eid, _pid, _uid, _gid; enc = Strdup(data); if(!enc) { goto cleanup; } nag("Processing policy data header: %s\n", enc); dec = (char *)decrypt_data(poldata_key, strlen(poldata_key), enc, &len_output); if(!dec) { goto cleanup; } nag("Decrypted: %s\n", dec); pl = parse_params(dec, "&"); #define GET_PARAM_VAL(param) \ if(!(s = get_param_value(pl, #param, 0))) { \ nag(#param " param not found\n"); \ goto cleanup; \ } \ if(lex_u32(&s, &_ ## param)) { \ nag("Error lexing " #param " [%s]\n", s); \ goto cleanup; \ } GET_PARAM_VAL(eid) GET_PARAM_VAL(pid) GET_PARAM_VAL(uid) GET_PARAM_VAL(gid) #undef GET_PARAM_VAL // si bldata = get_param_value(pl, "bldata", 0); if(!decode_block_page_data(bldata, &dummy_url, si, 0)) { // returns false on error... argh! nag("Error decoding meta data\n"); goto cleanup; } *eid = _eid; *pid = _pid; *uid = _uid; *gid = _gid; ret = 0; cleanup: Free(dummy_url); Free(enc); Free(dec); delete_param_list(pl); return ret; }
static char* build_doom3_masterfilter(struct qserver* server, char* buf, unsigned* buflen, int q4) { int flen = 0; char *pkt, *r, *sep= ""; unsigned char b = 0; char *proto = server->query_arg; unsigned ver; unsigned off = 13; if(!proto) { if(q4) { *buflen = sizeof(quake4_master_query); return (char*)quake4_master_query; } else { *buflen = sizeof(doom3_master_query); return (char*)doom3_master_query; } } ver = (atoi(proto) & 0xFFFF) << 16; proto = strchr(proto, '.'); if(proto && *++proto) { ver |= (atoi(proto) & 0xFFFF); } if(q4) { ver |= 1 << 31; // third party flag } memcpy(buf, doom3_master_query, sizeof(doom3_master_query)); put_long_little(ver, buf+off); off += 4; off = put_param_string(server, "game", buf, *buflen, off); if(q4) { off = put_param_string(server, "player", buf, *buflen, off); off = put_param_string(server, "clan", buf, *buflen, off); } pkt = get_param_value( server, "status", NULL); r = pkt ; while ( pkt && sep ) { sep= strchr( r, ':'); if ( sep ) flen= sep-r; else flen= strlen(r); if ( strncmp( r, "password", flen) == 0) b |= 0x01; else if ( strncmp( r, "nopassword", flen) == 0) b |= 0x02; else if ( strncmp( r, "notfull", flen) == 0) b |= 0x04; else if ( strncmp( r, "notfullnotempty", flen) == 0) b |= 0x08; r= sep+1; } pkt = get_param_value( server, "gametype", NULL); if(pkt) { if ( strncmp( pkt, "dm", flen) == 0) b |= 0x10; else if ( strncmp( pkt, "tourney", flen) == 0) b |= 0x20; else if ( strncmp( pkt, "tdm", flen) == 0) b |= 0x30; } buf[off++] = (char)b; *buflen = off; return buf; }
static void parse_devicetree_param(const config_t *config, FSP_S_CONFIG *params) { for (int i = 0; i < ARRAY_SIZE(serial_io_dev); i++) params->SerialIoDevMode[i] = get_param_value(config, i); }
query_status_t deal_with_ts3_packet(struct qserver *server, char *rawpkt, int pktlen) { char *s, *player_name = "unknown"; int valid_response = 0, mode = 0, all_servers = 0; char last_char; unsigned short port = 0, down = 0, auth_seen = 0; debug(2, "processing..."); if (0 == pktlen) { // Invalid password return (REQ_ERROR); } last_char = rawpkt[pktlen - 1]; rawpkt[pktlen - 1] = '\0'; s = rawpkt; all_servers = all_ts3_servers(server); debug(3, "packet: combined = %d, challenge = %ld, n_servers = %d", server->combined, server->challenge, server->n_servers); if (!server->combined) { server->retry1 = n_retries; if (0 == server->n_requests) { server->ping_total = time_delta(&packet_recv_time, &server->packet_time1); server->n_requests++; } if (server->n_servers >= server->challenge) { // response fragment recieved int pkt_id; int pkt_max; // We're expecting more to come debug(5, "fragment recieved..."); pkt_id = packet_count(server); pkt_max = pkt_id + 1; rawpkt[pktlen - 1] = last_char; // restore the last character if (!add_packet(server, 0, pkt_id, pkt_max, pktlen, rawpkt, 1)) { // fatal error e.g. out of memory return (MEM_ERROR); } // combine_packets will call us recursively return (combine_packets(server)); } } else { valid_response = valid_ts3_response(server, rawpkt + server->master_pkt_len, pktlen - server->master_pkt_len); debug(2, "combined packet: valid_response: %d, challenge: %ld, n_servers: %d, offset: %d", valid_response, server->challenge, server->n_servers, server->master_pkt_len); if (0 > valid_response) { // Error occured return (valid_response); } server->challenge += valid_response; if (valid_response) { // Got a valid response, send the next request int ret = send_ts3_request_packet(server); if (0 != ret) { // error sending packet debug(4, "Request failed: %d", ret); return (ret); } } if (server->n_servers > server->challenge) { // recursive call which is still incomplete return (INPROGRESS); } } // Correct ping // Not quite right but gives a good estimate server->ping_total = (server->ping_total * server->n_requests) / 2; debug(3, "processing response..."); s = strtok(rawpkt, "\012\015 |"); // NOTE: id=XXX and msg=XXX will be processed by the mod following the one they where the response of while (NULL != s) { debug(4, "LINE: %d, %s\n", mode, s); switch (mode) { case 0: // prompt, use or serverlist response if (0 == strcmp("TS3", s)) { // nothing to do unless in all servers mode if (1 == all_servers) { mode++; } } else if (0 == strncmp("error", s, 5)) { // end of use response mode++; } break; case 1: // serverinfo or serverlist response including condition authentication if ((0 == auth_seen) && (0 != strlen(get_param_value(server, "password", ""))) && (0 == strncmp("error", s, 5))) { // end of auth response auth_seen = 1; } else if (0 == strncmp("error", s, 5)) { // end of serverinfo response mode++; } else { // Server Rule char *key = s; char *value = strchr(key, '='); if (NULL != value) { *value = '\0'; value++; debug(6, "Rule: %s = %s\n", key, value); if (0 == strcmp("virtualserver_name", key)) { if (1 == all_servers) { struct qserver *new_server = add_qserver_byaddr(ntohl(server->ipaddr), port, server->type, NULL); if (NULL != new_server) { if (down) { // Status indicates this server is actually offline new_server->server_name = DOWN; } else { new_server->max_players = server->max_players; new_server->num_players = server->num_players; new_server->server_name = strdup(decode_ts3_val(value)); new_server->map_name = strdup("N/A"); new_server->ping_total = server->ping_total; new_server->n_requests = server->n_requests; } cleanup_qserver(new_server, FORCE); } down = 0; } else { server->server_name = strdup(decode_ts3_val(value)); } } else if (0 == strcmp("virtualserver_port", key)) { port = atoi(value); change_server_port(server, port, 0); add_rule(server, key, value, NO_FLAGS); } else if (0 == strcmp("virtualserver_maxclients", key)) { server->max_players = atoi(value); } else if (0 == strcmp("virtualserver_clientsonline", key)) { server->num_players = atoi(value); } else if (0 == strcmp("virtualserver_queryclientsonline", key)) { // clientsonline includes queryclientsonline so remove these from our count server->num_players -= atoi(value); } else if ((0 == strcmp("virtualserver_status", key)) && (0 != strcmp("online", value))) { // Server is actually offline to client so display as down down = 1; if (1 != all_servers) { server->server_name = DOWN; //server->saved_data.pkt_index = 0; return (DONE_FORCE); } } else if ((0 == strcmp("id", key)) || (0 == strcmp("msg", key))) { // Ignore details from the response code } else if (1 != all_servers) { add_rule(server, key, value, NO_FLAGS); } } } break; case 2: // clientlist response if (0 == strncmp("error", s, 5)) { // end of serverinfo response mode++; } else { // Client char *key = s; char *value = strchr(key, '='); if (NULL != value) { *value = '\0'; value++; debug(6, "Player: %s = %s\n", key, value); if (0 == strcmp("client_nickname", key)) { player_name = value; } else if (0 == strcmp("clid", key)) { } else if ((0 == strcmp("client_type", key)) && (0 == strcmp("0", value))) { struct player *player = add_player(server, server->n_player_info); if (NULL != player) { player->name = strdup(decode_ts3_val(player_name)); } } else if ((0 == strcmp("id", key)) || (0 == strcmp("msg", key))) { // Ignore details from the response code } } } break; } s = strtok(NULL, "\012\015 |"); } gettimeofday(&server->packet_time1, NULL); server->map_name = strdup("N/A"); return (DONE_FORCE); }
void FaceBl0r::update() { if (!cascade) { cvSetNumThreads(cvRound(threads * 100)); get_param_value(&classifier, FACEBL0R_PARAM_CLASSIFIER); if (classifier && strcmp(classifier, "")) { if ( strcmp(classifier, old_classifier) == 0) { // same as before, avoid repeating error messages memcpy(out, in, size * 4); // of course assuming we are RGBA only return; } else strcpy(old_classifier, classifier); cascade = (CvHaarClassifierCascade*) cvLoad(classifier, 0, 0, 0 ); if (!cascade) { fprintf(stderr, "ERROR in filter facebl0r, classifier cascade not found:\n"); fprintf(stderr, " %s\n", classifier); memcpy(out, in, size * 4); return; } storage = cvCreateMemStorage(0); } else { memcpy(out, in, size * 4); return; } } // sanitize parameters recheck = CLAMP(recheck, 0.001, 1.0); search_scale = CLAMP(search_scale, 0.11, 1.0); neighbors = CLAMP(neighbors, 0.01, 1.0); if( !image ) image = cvCreateImage( cvSize(width,height), IPL_DEPTH_8U, 4 ); memcpy(image->imageData, in, size * 4); /* no face* - look for (detect_face) yes face - track face - no more face no face* */ if(face_notfound>0) { if(face_notfound % cvRound(recheck * 1000) == 0) face_rect = detect_face(image, cascade, storage); // if no face detected if (!face_rect) { face_notfound++; } else { //track detected face with camshift if(tracked_obj) destroy_tracked_object(tracked_obj); tracked_obj = create_tracked_object(image, face_rect); face_notfound = 0; face_found++; } } if(face_found>0) { //track the face in the new frame face_box = camshift_track_face(image, tracked_obj); int min = cvRound(smallest * 1000); min = min? min : 10; int max = cvRound(largest * 10000); if( ( face_box.size.width < min ) || (face_box.size.height < min ) || (face_box.size.width > max ) || (face_box.size.height > max ) ) { face_found = 0; face_notfound++; } else { //////////////////////////////////////////////////////////////////////// cvSetImageROI (image, tracked_obj->prev_rect); // cvSmooth (image, image, CV_BLUR, 22, 22, 0, 0); cvSmooth (image, image, CV_BLUR, 23, 23, 0, 0); // cvSmooth (image, image, CV_GAUSSIAN, 11, 11, 0, 0); cvResetImageROI (image); //////////////////////////////////////////////////////////////////////// //outline face ellipse if (ellipse) cvEllipseBox(image, face_box, CV_RGB(255,0,0), 2, CV_AA, 0); face_found++; if(face_found % cvRound(recheck * 1000) == 0) face_notfound = cvRound(recheck * 1000); // try recheck } } memcpy(out, image->imageData, size * 4); cvReleaseImage(&image); }
/****************************************************************************** * * * Function: get_value_db * * * * Purpose: retrieve data from database * * * * Parameters: item - item we are interested in * * * * Return value: SUCCEED - data successfully retrieved and stored in result * * NOTSUPPORTED - requested item is not supported * * * * Author: Eugene Grigorjev * * * * Comments: * * * ******************************************************************************/ int get_value_db(DC_ITEM *item, AGENT_RESULT *result) { const char *__function_name = "get_value_db"; #ifdef HAVE_ODBC ZBX_ODBC_DBH dbh; ZBX_ODBC_ROW row; char *db_dsn = NULL, *db_user = NULL, *db_pass = NULL, *db_sql = NULL; #endif int ret = NOTSUPPORTED; init_result(result); zabbix_log(LOG_LEVEL_DEBUG, "In %s() key_orig:'%s'", __function_name, item->key_orig); #ifdef HAVE_ODBC #define DB_ODBC_SELECT_KEY "db.odbc.select[" if (0 == strncmp(item->key, DB_ODBC_SELECT_KEY, strlen(DB_ODBC_SELECT_KEY))) { db_dsn = get_param_value(item->params, "DSN"); db_user = get_param_value(item->params, "user"); db_pass = get_param_value(item->params, "password"); db_sql = get_param_value(item->params, "sql"); if (SUCCEED == odbc_DBconnect(&dbh, db_dsn, db_user, db_pass, CONFIG_TIMEOUT)) { if (NULL != odbc_DBselect(&dbh, db_sql)) { if (NULL != (row = odbc_DBfetch(&dbh))) { if (NULL == row[0]) { SET_MSG_RESULT(result, zbx_strdup(NULL, "SQL query returned NULL " "value.")); } else if (SUCCEED == set_result_type(result, item->value_type, item->data_type, row[0])) { ret = SUCCEED; } } else { const char *last_error = get_last_odbc_strerror(); if ('\0' != *last_error) SET_MSG_RESULT(result, zbx_strdup(NULL, last_error)); else SET_MSG_RESULT(result, zbx_strdup(NULL, "SQL query returned empty " "result.")); } } else SET_MSG_RESULT(result, zbx_strdup(NULL, get_last_odbc_strerror())); odbc_DBclose(&dbh); } else SET_MSG_RESULT(result, zbx_strdup(NULL, get_last_odbc_strerror())); zbx_free(db_dsn); zbx_free(db_user); zbx_free(db_pass); zbx_free(db_sql); } #undef DB_ODBC_SELECT_KEY #endif /* HAVE_ODBC */ zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret)); return ret; }
static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon, const char *devaddr, const char *opts) { PCIDevice *dev; DriveInfo *dinfo = NULL; int type = -1; char buf[128]; PCIBus *root = pci_find_primary_bus(); PCIBus *bus; int devfn; if (get_param_value(buf, sizeof(buf), "if", opts)) { if (!strcmp(buf, "scsi")) type = IF_SCSI; else if (!strcmp(buf, "virtio")) { type = IF_VIRTIO; } else { monitor_printf(mon, "type %s not a hotpluggable PCI device.\n", buf); return NULL; } } else { monitor_printf(mon, "no if= specified\n"); return NULL; } if (get_param_value(buf, sizeof(buf), "file", opts)) { dinfo = add_init_drive(opts); if (!dinfo) return NULL; if (dinfo->devaddr) { monitor_printf(mon, "Parameter addr not supported\n"); return NULL; } } else { dinfo = NULL; } if (!root) { monitor_printf(mon, "no primary PCI bus (if there are multiple" " PCI roots, you must use device_add instead)"); return NULL; } bus = pci_get_bus_devfn(&devfn, root, devaddr); if (!bus) { monitor_printf(mon, "Invalid PCI device address %s\n", devaddr); return NULL; } if (!qbus_is_hotpluggable(BUS(bus))) { monitor_printf(mon, "PCI bus doesn't support hotplug\n"); return NULL; } switch (type) { case IF_SCSI: dev = pci_create(bus, devfn, "lsi53c895a"); if (qdev_init(&dev->qdev) < 0) dev = NULL; if (dev && dinfo) { if (scsi_hot_add(mon, &dev->qdev, dinfo, 0) != 0) { qdev_unplug(&dev->qdev, NULL); dev = NULL; } } break; case IF_VIRTIO: if (!dinfo) { monitor_printf(mon, "virtio requires a backing file/device.\n"); return NULL; } dev = pci_create(bus, devfn, "virtio-blk-pci"); if (qdev_prop_set_drive(&dev->qdev, "drive", blk_by_legacy_dinfo(dinfo)) < 0) { object_unparent(OBJECT(dev)); dev = NULL; break; } if (qdev_init(&dev->qdev) < 0) dev = NULL; break; default: dev = NULL; } return dev; }
query_status_t send_ts3_single_server_packet(struct qserver *server) { char buf[256], *password, *username; int serverport; switch (server->challenge) { case 0: // Not seen a challenge yet, wait for it server->n_servers = 999; return (INPROGRESS); case 1: // Login if needed password = get_param_value(server, "password", ""); if (0 != strlen(password)) { username = get_param_value(server, "username", "serveradmin"); sprintf(buf, "login %s %s\015\012", username, password); break; } // NOTE: no break so we fall through server->challenge++; case 2: // Select port serverport = get_param_i_value(server, "port", 0); change_server_port(server, serverport, 1); // NOTE: we use n_servers as an indication of how many responses we are expecting to get if (get_player_info) { server->flags |= TF_PLAYER_QUERY | TF_RULES_QUERY; server->n_servers = 5; } else { server->flags |= TF_STATUS_QUERY; server->n_servers = 4; } sprintf(buf, "use port=%d\015\012", serverport); break; case 3: // Server Info sprintf(buf, "serverinfo\015\012"); break; case 4: // Player Info, Quit or Done sprintf(buf, (get_player_info) ? "clientlist\015\012" : "quit\015\012"); break; case 5: // Quit or Done if (get_player_info) { sprintf(buf, "quit\015\012"); } else { return (DONE_FORCE); } break; } server->saved_data.pkt_max = -1; return (send_packet(server, buf, strlen(buf))); }
static PCIDevice *qemu_pci_hot_add_storage(Monitor *mon, const char *devaddr, const char *opts) { PCIDevice *dev; DriveInfo *dinfo = NULL; int type = -1; char buf[128]; PCIBus *bus; int devfn; if (get_param_value(buf, sizeof(buf), "if", opts)) { if (!strcmp(buf, "scsi")) type = IF_SCSI; else if (!strcmp(buf, "virtio")) { type = IF_VIRTIO; } else { monitor_printf(mon, "type %s not a hotpluggable PCI device.\n", buf); return NULL; } } else { monitor_printf(mon, "no if= specified\n"); return NULL; } if (get_param_value(buf, sizeof(buf), "file", opts)) { dinfo = add_init_drive(opts); if (!dinfo) return NULL; if (dinfo->devaddr) { monitor_printf(mon, "Parameter addr not supported\n"); return NULL; } } else { dinfo = NULL; } bus = pci_get_bus_devfn(&devfn, devaddr); if (!bus) { monitor_printf(mon, "Invalid PCI device address %s\n", devaddr); return NULL; } if (!((BusState*)bus)->allow_hotplug) { monitor_printf(mon, "PCI bus doesn't support hotplug\n"); return NULL; } switch (type) { case IF_SCSI: dev = pci_create(bus, devfn, "lsi53c895a"); if (qdev_init(&dev->qdev) < 0) dev = NULL; if (dev && dinfo) { if (scsi_hot_add(mon, &dev->qdev, dinfo, 0) != 0) { qdev_unplug(&dev->qdev, NULL); dev = NULL; } } break; case IF_VIRTIO: if (!dinfo) { monitor_printf(mon, "virtio requires a backing file/device.\n"); return NULL; } dev = pci_create(bus, devfn, "virtio-blk-pci"); if (qdev_prop_set_drive(&dev->qdev, "drive", dinfo->bdrv) < 0) { qdev_free(&dev->qdev); dev = NULL; break; } if (qdev_init(&dev->qdev) < 0) dev = NULL; break; default: dev = NULL; } return dev; }
static void param_show_info(void) { signed int value = 0; signed char str_val[512]; klogi("-----------------------------------------------------"); klogi(" Information of Parameters"); klogi("-----------------------------------------------------"); klogi(" - param_magic : 0x%x", param_status.param_magic); klogi(" - param_version : 0x%x", param_status.param_version); get_param_value(__SERIAL_SPEED, &value); klogi(" - 00. SERIAL_SPEED : %d", value); get_param_value(__LOAD_TESTKERNEL, &value); klogi(" - 01. LOAD_TESTKERNEL : %d", value); get_param_value(__BOOT_DELAY, &value); klogi(" - 02. BOOT_DELAY : %d", value); get_param_value(__LCD_LEVEL, &value); klogi(" - 03. LCD_LEVEL : %d", value); get_param_value(__SWITCH_SEL, &value); klogi(" - 04. SWITCH_SEL : %d", value); get_param_value(__PHONE_DEBUG_ON, &value); klogi(" - 05. PHONE_DEBUG_ON : %d", value); get_param_value(__LCD_DIM_LEVEL, &value); klogi(" - 06. LCD_DIM_LEVEL : %d", value); get_param_value(__LCD_DIM_TIME, &value); klogi(" - 07. LCD_DIM_TIME : %d", value); get_param_value(__FORCE_PRERECOVERY, &value); klogi(" - 08. FORCE_PRERECOVERY : %d", value); get_param_value(__REBOOT_MODE, &value); klogi(" - 09. REBOOT_MODE : %d", value); get_param_value(__NATION_SEL, &value); klogi(" - 10. NATION_SEL : %d", value); get_param_value(__DEBUG_LEVEL, &value); klogi(" - 11. DEBUG_LEVEL : %d", value); get_param_value(__SET_DEFAULT_PARAM, &value); klogi(" - 12. SET_DEFAULT_PARAM : %d", value); get_param_value(__BATT_CAPACITY, &value); klogi(" - 13. BATTERY_CAPACITY : %d", value); get_param_value(__LOAD_KERNEL2, &value); klogi(" - 14. LOAD_KERNEL2 : %d", value); get_param_value(__FLASH_LOCK_STATUS, &value); klogi(" - 15. FLASH_LOCK_STATUS : %d", value); get_param_value(__PARAM_INT_14, &value); klogi(" - 16. PARAM_INT_14 : %d", value); get_param_value(__VERSION, &str_val); klogi(" - 17. VERSION(STR) : %s", str_val); get_param_value(__CMDLINE, &str_val); klogi(" - 18. CMDLINE(STR) : %s", str_val); get_param_value(__DELTA_LOCATION, &str_val); klogi(" - 19. DELTA_LOCATION(STR) : %s", str_val); get_param_value(__CMDLINE_MODE, &str_val); klogi(" - 20. CMDLINE_MODE(STR) : %s", str_val); get_param_value(__PARAM_STR_4, &str_val); klogi(" - 21. PARAM_STR_4(STR) : %s", str_val); klogi("-----------------------------------------------------"); }