/** * Parse "port:IP" string to retrieve the host address and port. * * @param str the string to parse * @param endptr if not NULL, it will point the first character after * the parsed elements. * @param port_ptr where the parsed port is written * @param addr_ptr where the parsed address is written * * @return TRUE if we parsed the string correctly, FALSE if it did not * look like a valid "port:IP" string. */ bool string_to_port_host_addr(const char *str, const char **endptr, uint16 *port_ptr, host_addr_t *addr_ptr) { const char *ep; host_addr_t addr; bool ret; uint16 port; int error; port = parse_uint16(str, &ep, 10, &error); if (!error && ':' == *ep) { ret = string_to_host_or_addr(ep, &ep, &addr); ret = ret && is_host_addr(addr); } else { addr = zero_host_addr; ret = FALSE; } if (addr_ptr) *addr_ptr = addr; if (port_ptr) *port_ptr = port; if (endptr) *endptr = ep; return ret; }
static int cmd_manager(int argc, char** argv, void(*callback)(char* result, int exit_status)) { for(int i = 1; i < argc; i++) { if(!strcmp("open", argv[i])) { NEXT_ARGUMENTS(); if(!is_uint16(argv[i])) return -i; if(manager_core) { printf("manager is already opened\n"); return -1; } uint16_t port = parse_uint16(argv[i]); manager_core = manager_core_server_open(port); if(!manager_core) { printf("open: failed\n"); return -2; } return 0; } else if(!strcmp("close", argv[i])) { if(!manager_core) { printf("close: failed. no manager opened\n"); return -2; } manager_core_server_close(manager_core); manager_core = NULL; return 0; } } return 0; }
/** * Parse "IP:port" string to retrieve the host address and port. * * @param str the string to parse * @param endptr if not NULL, it will point the first character after * the parsed elements. * @param addr_ptr where the parsed address is written * @param port_ptr where the parsed port is written * * @return TRUE if we parsed the string correctly, FALSE if it did not * look like a valid "IP:port" string. */ bool string_to_host_addr_port(const char *str, const char **endptr, host_addr_t *addr_ptr, uint16 *port_ptr) { const char *ep; host_addr_t addr; bool ret; uint16 port; ret = string_to_host_or_addr(str, &ep, &addr); if (ret && ':' == *ep && is_host_addr(addr)) { int error; ep++; port = parse_uint16(ep, &ep, 10, &error); ret = 0 == error && 0 != port; } else { ret = FALSE; port = 0; } if (addr_ptr) *addr_ptr = addr; if (port_ptr) *port_ptr = port; if (endptr) *endptr = ep; return ret; }
record_t parse_record(in_t::ptr_t &ptr) { record_t res; in_t::ptr_t p = ptr; if(!p.match<ident_t>(1)) { log_error("Illegal fcgi record version"); throw http::exception_t(http::code_502, "Bad Gateway"); } res.type = (type_t)*(p++); res.id = parse_uint16(p); uint16_t size = parse_uint16(p); uint8_t pad_size = *(p++); ++p; // skip reserved; res.data = in_segment_t(p, size); p += (size + pad_size); ptr = p; log_debug("fcgi recv id: %u, type: %u, len %u", res.id, res.type, size); return res; }
static const char * magnet_parse_host_port(const char *hostport, host_addr_t *addr, uint16 *port, const char **host, const char **host_end, const char **error_str) { const char *p; const char *endptr; clear_error_str(&error_str); g_return_val_if_fail(hostport, NULL); p = hostport; if (!string_to_host_or_addr(p, &endptr, addr)) { *error_str = "Expected host part"; return NULL; } if (is_host_addr(*addr)) { if (host) *host = NULL; if (host_end) *host_end = NULL; } else { if (host) *host = p; if (host_end) *host_end = endptr; } p += endptr - p; if (':' == *p) { const char *ep2; int error; uint16 u; p++; u = parse_uint16(p, &ep2, 10, &error); if (error) { *error_str = "TCP port is out of range"; /* Skip this parameter */ return NULL; } *port = u; p += ep2 - p; } else { *port = 80; } return p; }
int parse_string16(struct simple_buffer *buffer, uint32_t *length, const uint8_t **start) { uint32_t l; if (!parse_uint16(buffer, &l)) return 0; if (LEFT < l) return 0; *length = l; *start = HERE; ADVANCE(l); return 1; }
/** * Parse argument from specified name/value table into an unsigned 16-bit int. * * @param nvt the name/value table holding arguments * @param name the argument name whose value we need to parse * @param valp where to put the parsed value * * @return TRUE if OK with the value filled in, FALSE on failure. */ static gboolean upnp_ctrl_get_uint16(nv_table_t *nvt, const char *name, guint16 *valp) { const char *value; guint16 val; int error; value = nv_table_lookup_str(nvt, name); if (NULL == value) return FALSE; val = parse_uint16(value, NULL, 10, &error); if (error) return FALSE; *valp = val; return TRUE; }
static void var_set_listen_port(DCVariable *var, int argc, char **argv) { uint16_t port; if (argc > 2) { warn(_("too many arguments\n")); return; } if (argv[1][0] == '\0') { port = 0; } else { if (!parse_uint16(argv[1], &port)) { screen_putf(_("Invalid value `%s' for port number.\n"), quotearg(argv[1])); return; } } if (!set_active(is_active, port)) screen_putf(_("Active setting not changed.\n")); }
bool parse_ip_and_port(char *source, struct sockaddr_in *addr, uint16_t defport) { char *port; port = strrchr(source, ':'); if (port == NULL) { if (defport == 0) return false; addr->sin_port = htons(defport); } else { *port = '\0'; port++; if (!parse_uint16(port, &addr->sin_port)) return false; addr->sin_port = htons(addr->sin_port); } if (!inet_aton(source, &addr->sin_addr)) return false; addr->sin_family = AF_INET; return true; }
static int parse_args( int argc, char **argv, struct server_ctx *ctx ) { int c, option_index; #ifdef DEBUG uint16_t debug_level = DEBUG_DEFAULT_LEVEL; #endif /* DEBUG */ uint16_t streams; struct option long_options[] = { { "port", 1, 0, 'p' }, { "help", 0,0, 'H' }, { "buf", 1,0,'b' }, { "seq", 0,0,'s' }, { "echo",0,0,'e' }, { "verbose", 0,0,'v'}, { "instreams", 1,0, 'I' }, { "outstreams", 1,0,'O' }, { "xdump", 0,0,'x' }, #ifdef DEBUG { "debug",1,0,'D'}, #endif /* DEBUG */ { 0,0,0,0 } }; while (1) { c = getopt_long( argc, argv, "p:b:HsxevI:O:D:", long_options, &option_index ); if ( c == -1 ) break; switch (c) { case 'p' : if ( parse_uint16( optarg, &(ctx->port)) < 0 ) { fprintf(stderr, "Malformed port given\n" ); return -1; } break; case 'b' : if ( parse_uint16( optarg, &(ctx->recvbuf_size)) < 0 ) { fprintf(stderr, "Illegal recv buffer size given\n"); return -1; } break; case 's' : ctx->options = set_flag( ctx->options, SEQ_FLAG ); break; case 'e' : ctx->options = set_flag( ctx->options, ECHO_FLAG ); break; case 'v' : ctx->options = set_flag( ctx->options, VERBOSE_FLAG ); break; case 'x' : ctx->options = set_flag(ctx->options, XDUMP_FLAG); break; case 'I' : if (parse_uint16(optarg, &streams) < 0 ) { fprintf(stderr, "Invalid input stream count given\n"); return -1; } if (ctx->initmsg == NULL ) ctx->initmsg = mem_zalloc( sizeof(struct sctp_initmsg)); ctx->initmsg->sinit_max_instreams = streams; break; case 'O' : if (parse_uint16(optarg, &streams) < 0 ) { fprintf(stderr,"Invalid output stream count given\n"); return -1; } if (ctx->initmsg == NULL) ctx->initmsg = mem_zalloc(sizeof(*ctx->initmsg)); ctx->initmsg->sinit_num_ostreams = streams; break; #ifdef DEBUG case 'D' : if (parse_uint16(optarg, &debug_level) < 0) { fprintf(stderr,"Malformed Debug level number given\n"); return -1; } if (debug_level > DBG_L_ERR) { fprintf(stderr, "Invalid debug level (expected 0-3)\n"); return -1; } DBG_LEVEL(debug_level); break; #endif /* DEBUG */ case 'H' : default : print_usage(); return 0; break; } } return 1; }
static int key_value_parse_line_with_key(struct key_value_specification *k, char *line, void *base_address[]) { char *valuestr; int rc, len, klen; klen = strlen(k->key); len = strlen(line); if (len < klen + 1) return 1; if (strncmp(line, k->key, klen) != 0) return 1; if (line[klen] != ':') return 1; /* Skip leading spaces */ klen = klen + 1; while (line[klen] == ' ') klen++; /* At this point, we have a match on the key */ valuestr = &line[klen]; switch (k->type) { case KVS_STRING: rc = parse_string(valuestr, k, base_address); break; case KVS_INT64: rc = parse_int64(valuestr, k, base_address); break; case KVS_INT32: rc = parse_int32(valuestr, k, base_address); break; case KVS_INT16: rc = parse_int16(valuestr, k, base_address); break; case KVS_INT8: rc = parse_int8(valuestr, k, base_address); break; case KVS_UINT64: rc = parse_uint64(valuestr, k, base_address); break; case KVS_UINT32: rc = parse_uint32(valuestr, k, base_address); break; case KVS_UINT16: rc = parse_uint16(valuestr, k, base_address); break; case KVS_UINT8: rc = parse_uint8(valuestr, k, base_address); break; case KVS_DOUBLE: rc = parse_double(valuestr, k, base_address); break; case KVS_FLOAT: rc = parse_float(valuestr, k, base_address); break; default: fprintf(stderr, "%s:%d: unknown key type '%c' for key '%s'\n", __func__, __LINE__, k->type, k->key); rc = -1; break; } return rc; }
/* * scontrol_update_job - update the slurm job configuration per the supplied * arguments * IN argc - count of arguments * IN argv - list of arguments * RET 0 if no slurm error, errno otherwise. parsing error prints * error message and returns 0 */ extern int scontrol_update_job(int argc, char **argv) { bool update_size = false; int i, update_cnt = 0, rc = SLURM_SUCCESS, rc2; char *tag, *val; int taglen, vallen; job_desc_msg_t job_msg; job_array_resp_msg_t *resp = NULL; uint32_t job_uid = NO_VAL; slurm_init_job_desc_msg (&job_msg); for (i = 0; i < argc; i++) { char *add_info = NULL; tag = argv[i]; val = strchr(argv[i], '='); if (val) { taglen = val - argv[i]; if ((taglen > 0) && ((val[-1] == '+') || (val[-1] == '-'))) { add_info = val - 1; taglen--; } val++; vallen = strlen(val); } else if (xstrncasecmp(tag, "Nice", MAX(strlen(tag), 2)) == 0){ /* "Nice" is the only tag that might not have an equal sign, so it is handled specially. */ job_msg.nice = NICE_OFFSET + 100; update_cnt++; continue; } else if (!val && argv[i + 1]) { tag = argv[i]; taglen = strlen(tag); val = argv[++i]; vallen = strlen(val); } else { exit_code = 1; fprintf (stderr, "Invalid input: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); return -1; } if (xstrncasecmp(tag, "JobId", MAX(taglen, 3)) == 0) { job_msg.job_id_str = val; } else if (xstrncasecmp(tag, "AdminComment", MAX(taglen, 3)) == 0) { if (add_info) { if (add_info[0] == '-') { error("Invalid syntax, AdminComment can not be subtracted from."); exit_code = 1; return 0; } job_msg.admin_comment = add_info; /* * Mark as unset so we know we handled this * correctly as there is a check later to make * sure we know we got a +-. */ add_info = NULL; } else job_msg.admin_comment = val; update_cnt++; } else if (xstrncasecmp(tag, "ArrayTaskThrottle", MAX(taglen, 10)) == 0) { int throttle; throttle = strtoll(val, (char **) NULL, 10); if (throttle < 0) { error("Invalid ArrayTaskThrottle value"); exit_code = 1; return 0; } job_msg.array_inx = val; update_cnt++; } else if (xstrncasecmp(tag, "Comment", MAX(taglen, 3)) == 0) { job_msg.comment = val; update_cnt++; } else if (xstrncasecmp(tag, "Clusters", MAX(taglen, 8)) == 0) { job_msg.clusters = val; update_cnt++; } else if (xstrncasecmp(tag, "ClusterFeatures", MAX(taglen, 8)) == 0) { job_msg.cluster_features = val; update_cnt++; } else if (xstrncasecmp(tag, "DelayBoot", MAX(taglen, 5)) == 0) { int time_sec = time_str2secs(val); if (time_sec == NO_VAL) { error("Invalid DelayBoot value"); exit_code = 1; return 0; } job_msg.delay_boot = time_sec; update_cnt++; } else if (xstrncasecmp(tag, "TimeLimit", MAX(taglen, 5)) == 0) { uint32_t job_current_time, time_limit; if (val && ((val[0] == '+') || (val[0] == '-'))) { if (add_info) { error("Invalid syntax, variations of +=- are not accepted."); exit_code = 1; return 0; } add_info = val; val++; } time_limit = time_str2mins(val); if (time_limit == NO_VAL) { error("Invalid TimeLimit value"); exit_code = 1; return 0; } if (add_info) { if (!job_msg.job_id_str) { error("JobId must precede TimeLimit " "increment or decrement"); exit_code = 1; return 0; } job_current_time = _get_job_time(job_msg. job_id_str); if (job_current_time == NO_VAL) { exit_code = 1; return 0; } if (add_info[0] == '+') { time_limit += job_current_time; } else if (time_limit > job_current_time) { error("TimeLimit decrement larger than" " current time limit (%u > %u)", time_limit, job_current_time); exit_code = 1; return 0; } else { time_limit = job_current_time - time_limit; } /* * Mark as unset so we know we handled this * correctly as there is a check later to make * sure we know we got a +-. */ add_info = NULL; } job_msg.time_limit = time_limit; update_cnt++; } else if (xstrncasecmp(tag, "TimeMin", MAX(taglen, 5)) == 0) { int time_min = time_str2mins(val); if ((time_min < 0) && (time_min != INFINITE)) { error("Invalid TimeMin value"); exit_code = 1; return 0; } job_msg.time_min = time_min; update_cnt++; } else if (xstrncasecmp(tag, "Priority", MAX(taglen, 2)) == 0) { if (parse_uint32(val, &job_msg.priority)) { error ("Invalid Priority value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "Nice", MAX(taglen, 2)) == 0) { long long tmp_nice; tmp_nice = strtoll(val, (char **)NULL, 10); if (llabs(tmp_nice) > (NICE_OFFSET - 3)) { error("Nice value out of range (+/- %u). Value " "ignored", NICE_OFFSET - 3); exit_code = 1; return 0; } job_msg.nice = NICE_OFFSET + tmp_nice; update_cnt++; } else if (!xstrncasecmp(tag, "CPUsPerTask", MAX(taglen, 9))) { if (parse_uint16(val, &job_msg.cpus_per_task)) { error("Invalid CPUsPerTask value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (!xstrncasecmp(tag, "CpusPerTres", MAX(taglen, 9))) { job_msg.cpus_per_tres = val; update_cnt++; } else if (xstrncasecmp(tag, "NumCPUs", MAX(taglen, 6)) == 0) { int min_cpus, max_cpus=0; if (!get_resource_arg_range(val, "NumCPUs", &min_cpus, &max_cpus, false) || (min_cpus <= 0) || (max_cpus && (max_cpus < min_cpus))) { error ("Invalid NumCPUs value: %s", val); exit_code = 1; return 0; } job_msg.min_cpus = min_cpus; if (max_cpus) job_msg.max_cpus = max_cpus; update_cnt++; } /* ReqProcs was removed in Slurm version 2.1 */ else if ((xstrncasecmp(tag, "NumTasks", MAX(taglen, 8)) == 0) || (xstrncasecmp(tag, "ReqProcs", MAX(taglen, 8)) == 0)) { if (parse_uint32(val, &job_msg.num_tasks)) { error ("Invalid NumTasks value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "Requeue", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.requeue)) { error ("Invalid Requeue value: %s", val); exit_code = 1; return 0; } update_cnt++; } /* ReqNodes was replaced by NumNodes in Slurm version 2.1 */ else if ((xstrncasecmp(tag, "ReqNodes", MAX(taglen, 8)) == 0) || (xstrncasecmp(tag, "NumNodes", MAX(taglen, 8)) == 0)) { int min_nodes, max_nodes, rc; if (xstrcmp(val, "0") == 0) { job_msg.min_nodes = 0; } else if (xstrcasecmp(val, "ALL") == 0) { job_msg.min_nodes = INFINITE; } else { min_nodes = (int) job_msg.min_nodes; max_nodes = (int) job_msg.max_nodes; rc = get_resource_arg_range( val, "requested node count", &min_nodes, &max_nodes, false); if (!rc) return rc; job_msg.min_nodes = (uint32_t) min_nodes; job_msg.max_nodes = (uint32_t) max_nodes; } update_size = true; update_cnt++; } else if (xstrncasecmp(tag, "ReqSockets", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.sockets_per_node)) { error ("Invalid ReqSockets value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "ReqCores", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.cores_per_socket)) { error ("Invalid ReqCores value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "TasksPerNode", MAX(taglen, 2))==0) { if (parse_uint16(val, &job_msg.ntasks_per_node)) { error ("Invalid TasksPerNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "ReqThreads", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.threads_per_core)) { error ("Invalid ReqThreads value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "MinCPUsNode", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.pn_min_cpus)) { error ("Invalid MinCPUsNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "MinMemoryNode", MAX(taglen, 10)) == 0) { if (parse_uint64(val, &job_msg.pn_min_memory)) { error ("Invalid MinMemoryNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "MinMemoryCPU", MAX(taglen, 10)) == 0) { if (parse_uint64(val, &job_msg.pn_min_memory)) { error ("Invalid MinMemoryCPU value: %s", val); exit_code = 1; return 0; } job_msg.pn_min_memory |= MEM_PER_CPU; update_cnt++; } else if (xstrncasecmp(tag, "MinTmpDiskNode", MAX(taglen, 5)) == 0) { if (parse_uint32(val, &job_msg.pn_min_tmp_disk)) { error ("Invalid MinTmpDiskNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "Partition", MAX(taglen, 2)) == 0) { job_msg.partition = val; update_cnt++; } else if (xstrncasecmp(tag, "QOS", MAX(taglen, 2)) == 0) { job_msg.qos = val; update_cnt++; } else if (xstrncasecmp(tag, "ReservationName", MAX(taglen, 3)) == 0) { job_msg.reservation = val; update_cnt++; } else if (!xstrncasecmp(tag, "Name", MAX(taglen, 2)) || !xstrncasecmp(tag, "JobName", MAX(taglen, 4))) { job_msg.name = val; update_cnt++; } else if (xstrncasecmp(tag, "WCKey", MAX(taglen, 1)) == 0) { job_msg.wckey = val; update_cnt++; } else if (xstrncasecmp(tag, "StdOut", MAX(taglen, 6)) == 0) { job_msg.std_out = val; update_cnt++; } else if (xstrncasecmp(tag, "Switches", MAX(taglen, 5)) == 0) { char *sep_char; job_msg.req_switch = (uint32_t) strtol(val, &sep_char, 10); update_cnt++; if (sep_char && sep_char[0] == '@') { job_msg.wait4switch = time_str2mins(sep_char+1) * 60; } } else if (xstrncasecmp(tag, "wait-for-switch", MAX(taglen, 5)) == 0) { if (parse_uint32(val, &job_msg.wait4switch)) { error ("Invalid wait-for-switch value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (!xstrncasecmp(tag, "OverSubscribe", MAX(taglen, 2)) || !xstrncasecmp(tag, "Shared", MAX(taglen, 2))) { if (xstrncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.shared = 1; else if (xstrncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.shared = 0; else if (parse_uint16(val, &job_msg.shared)) { error("Invalid OverSubscribe value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "Contiguous", MAX(taglen, 3)) == 0) { if (xstrncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.contiguous = 1; else if (xstrncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.contiguous = 0; else if (parse_uint16(val, &job_msg.contiguous)) { error ("Invalid Contiguous value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (xstrncasecmp(tag, "CoreSpec", MAX(taglen, 4)) == 0) { if (!xstrcmp(val, "-1") || !xstrcmp(val, "*")) job_msg.core_spec = INFINITE16; else if (parse_uint16(val, &job_msg.core_spec)) { error ("Invalid CoreSpec value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (!xstrncasecmp(tag, "MemPerTres", MAX(taglen, 5))) { job_msg.mem_per_tres = val; update_cnt++; } else if (xstrncasecmp(tag, "ThreadSpec", MAX(taglen, 4)) == 0) { if (!xstrcmp(val, "-1") || !xstrcmp(val, "*")) job_msg.core_spec = INFINITE16; else if (parse_uint16(val, &job_msg.core_spec)) { error ("Invalid ThreadSpec value: %s", val); exit_code = 1; return 0; } else job_msg.core_spec |= CORE_SPEC_THREAD; update_cnt++; } else if (!xstrncasecmp(tag, "TresBind", MAX(taglen, 5))) { job_msg.tres_bind = val; update_cnt++; } else if (!xstrncasecmp(tag, "TresFreq", MAX(taglen, 5))) { job_msg.tres_freq = val; update_cnt++; } else if (!xstrncasecmp(tag, "TresPerJob", MAX(taglen, 8))) { job_msg.tres_per_job = val; update_cnt++; } else if (!xstrncasecmp(tag, "TresPerNode", MAX(taglen, 8))) { /* "gres" replaced by "tres_per_node" in v18.08 */ if (job_msg.tres_per_node) xstrfmtcat(job_msg.tres_per_node, ",%s", val); else job_msg.tres_per_node = xstrdup(val); update_cnt++; } else if (!xstrncasecmp(tag, "TresPerSocket", MAX(taglen, 8))) { job_msg.tres_per_socket = val; update_cnt++; } else if (!xstrncasecmp(tag, "TresPerTask", MAX(taglen, 8))) { job_msg.tres_per_task = val; update_cnt++; } else if (xstrncasecmp(tag, "ExcNodeList", MAX(taglen, 3)) == 0){ job_msg.exc_nodes = val; update_cnt++; } else if (!xstrncasecmp(tag, "NodeList", MAX(taglen, 8)) || !xstrncasecmp(tag, "ReqNodeList", MAX(taglen, 8))) { job_msg.req_nodes = val; update_size = true; update_cnt++; } else if (xstrncasecmp(tag, "Features", MAX(taglen, 1)) == 0) { job_msg.features = val; update_cnt++; } else if (xstrncasecmp(tag, "Gres", MAX(taglen, 2)) == 0) { /* "gres" replaced by "tres_per_node" in v18.08 */ if (!xstrcasecmp(val, "help") || !xstrcasecmp(val, "list")) { print_gres_help(); } else if (job_msg.tres_per_node) { xstrfmtcat(job_msg.tres_per_node, ",%s", val); } else { job_msg.tres_per_node = xstrdup(val); update_cnt++; } } else if (xstrncasecmp(tag, "Account", MAX(taglen, 1)) == 0) { job_msg.account = val; update_cnt++; } else if (xstrncasecmp(tag, "BurstBuffer", MAX(taglen, 1)) == 0) { job_msg.burst_buffer = val; update_cnt++; } else if (xstrncasecmp(tag, "Dependency", MAX(taglen, 1)) == 0) { job_msg.dependency = val; update_cnt++; } else if (xstrncasecmp(tag, "Licenses", MAX(taglen, 1)) == 0) { job_msg.licenses = val; update_cnt++; } else if (!xstrncasecmp(tag, "EligibleTime", MAX(taglen, 2)) || !xstrncasecmp(tag, "StartTime", MAX(taglen, 2))) { if ((job_msg.begin_time = parse_time(val, 0))) { if (job_msg.begin_time < time(NULL)) job_msg.begin_time = time(NULL); update_cnt++; } } else if (!xstrncasecmp(tag, "EndTime", MAX(taglen, 2))) { job_msg.end_time = parse_time(val, 0); update_cnt++; } else if (!xstrncasecmp(tag, "Reboot", MAX(taglen, 3))) { if (xstrncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.reboot = 1; else if (xstrncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.reboot = 0; else if (parse_uint16(val, &job_msg.reboot)) { error ("Invalid reboot value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (!xstrncasecmp(tag, "UserID", MAX(taglen, 3))) { uid_t user_id = 0; if (uid_from_string(val, &user_id) < 0) { exit_code = 1; fprintf (stderr, "Invalid UserID: %s\n", val); fprintf (stderr, "Request aborted\n"); return 0; } job_uid = (uint32_t) user_id; } else if (!xstrncasecmp(tag, "Deadline", MAX(taglen, 3))) { if ((job_msg.deadline = parse_time(val, 0))) { update_cnt++; } } else { exit_code = 1; fprintf (stderr, "Update of this parameter is not " "supported: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); return 0; } if (add_info) { error("Option %s does not accept [+|-]= syntax", tag); exit_code = 1; return 0; } } if (update_cnt == 0) { exit_code = 1; fprintf (stderr, "No changes specified\n"); return 0; } /* If specified, override uid with effective uid provided by * -u <uid> or --uid=<uid> */ if (euid != NO_VAL) job_msg.user_id = euid; if (!job_msg.job_id_str && job_msg.name) { /* Translate name to job ID string */ job_msg.job_id_str = _job_name2id(job_msg.name, job_uid); if (!job_msg.job_id_str) { exit_code = 1; return 0; } } if (!job_msg.job_id_str) { error("No job ID specified"); exit_code = 1; return 0; } if (update_size && !_is_single_job(job_msg.job_id_str)) { exit_code = 1; return 0; } if (_is_job_id(job_msg.job_id_str)) { job_msg.job_id_str = _next_job_id(); while (job_msg.job_id_str) { rc2 = slurm_update_job2(&job_msg, &resp); if (update_size && (rc2 == SLURM_SUCCESS)) { /* See check above for one job ID */ job_msg.job_id = slurm_atoul(job_msg.job_id_str); _update_job_size(job_msg.job_id); } if (rc2 != SLURM_SUCCESS) { rc2 = slurm_get_errno(); rc = MAX(rc, rc2); exit_code = 1; if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(slurm_get_errno()), job_msg.job_id_str); } } else if (resp) { for (i = 0; i < resp->job_array_count; i++) { if ((resp->error_code[i] == SLURM_SUCCESS) && (resp->job_array_count == 1)) continue; exit_code = 1; if (quiet_flag == 1) continue; fprintf(stderr, "%s: %s\n", resp->job_array_id[i], slurm_strerror(resp-> error_code[i])); } slurm_free_job_array_resp(resp); resp = NULL; } job_msg.job_id_str = _next_job_id(); } } else if (job_msg.job_id_str) { exit_code = 1; rc = ESLURM_INVALID_JOB_ID; slurm_seterrno(rc); if (quiet_flag != 1) { fprintf(stderr, "%s for job %s\n", slurm_strerror(rc), job_msg.job_id_str); } } return rc; }
/* main Initiate communication with the XBee module, then accept AT commands from STDIO, pass them to the XBee module and print the result. */ int main( int argc, char *argv[]) { char cmdstr[80]; int status; xbee_serial_t XBEE_SERPORT; uint16_t params[3]; parse_serial_arguments( argc, argv, &XBEE_SERPORT); // initialize the serial and device layer for this XBee device if (xbee_dev_init( &my_xbee, &XBEE_SERPORT, NULL, NULL)) { printf( "Failed to initialize device.\n"); return 0; } // Initialize the WPAN layer of the XBee device driver. This layer enables // endpoints and clusters, and is required for all ZigBee layers. xbee_wpan_init( &my_xbee, sample_endpoints); // Initialize the AT Command layer for this XBee device and have the // driver query it for basic information (hardware version, firmware version, // serial number, IEEE address, etc.) xbee_cmd_init_device( &my_xbee); printf( "Waiting for driver to query the XBee device...\n"); do { xbee_dev_tick( &my_xbee); status = xbee_cmd_query_status( &my_xbee); } while (status == -EBUSY); if (status) { printf( "Error %d waiting for query to complete.\n", status); } // report on the settings xbee_dev_dump_settings( &my_xbee, XBEE_DEV_DUMP_FLAG_DEFAULT); xbee_gpm_envelope_local( &envelope_self, &my_xbee.wpan_dev); if (envelope_self.ieee_address.u[0] == 0x0000) { // We're connected to a Wi-Fi XBee and need to use an IP address // (localhost, 127.0.0.1) as the target. envelope_self.ieee_address.l[0] = 0; envelope_self.ieee_address.l[1] = htobe32( 0x7F000001); } // get flash info, for use by later commands xbee_gpm_get_flash_info( &envelope_self); while (1) { while (xbee_readline( cmdstr, sizeof cmdstr) == -EAGAIN) { xbee_dev_tick( &my_xbee); } if (! strcmpi( cmdstr, "help") || ! strcmp( cmdstr, "?")) { print_menu(); } else if (! strcmpi( cmdstr, "quit")) { return 0; } else if (! strcmpi( cmdstr, "info")) { printf( "Sending platform info request (result %d)\n", xbee_gpm_get_flash_info( &envelope_self)); } else if (! strcmpi( cmdstr, "erase all")) { printf( "Erasing entire GPM (result %d)\n", xbee_gpm_erase_flash( &envelope_self)); } else if (! strncmpi( cmdstr, "erase ", 6)) { if (blocksize == 0) { puts( "Need to get 'info' response to learn blocksize before" "erasing a page."); } else if (parse_uint16( params, &cmdstr[6], 1) == 1) { printf( "Erasing block %u (result %d)\n", params[0], xbee_gpm_erase_block( &envelope_self, params[0], blocksize)); } else { printf( "Couldn't parse block number from [%s]\n", &cmdstr[6]); } } else if (! strncmpi( cmdstr, "read", 4)) { if (parse_uint16( params, &cmdstr[5], 3) == 3) { printf( "Read %u bytes from offset %u of block %u (result %d)\n", params[2], params[1], params[0], xbee_gpm_read( &envelope_self, params[0], params[1], params[2])); } else { printf( "Couldn't parse three values from [%s]\n", &cmdstr[5]); } } else if (! strcmpi( cmdstr, "pagesize")) { printf( "upload page size is %u\n", upload_pagesize); } else if (! strncmpi( cmdstr, "pagesize ", 9)) { if (parse_uint16( params, &cmdstr[9], 1) == 1) { if (params[0] > xbee_gpm_max_write( &my_xbee.wpan_dev)) { printf( "page size of %u exceeds maximum of %u\n", params[0], xbee_gpm_max_write( &my_xbee.wpan_dev)); } else { upload_pagesize = params[0]; printf( "upload page size is now %u\n", upload_pagesize); } } else { printf( "Couldn't parse page size from [%s]\n", &cmdstr[9]); } } else if (! strncmpi( cmdstr, "upload ", 7)) { start_upload( &cmdstr[7]); } else if (! strcmpi( cmdstr, "verify")) { printf( "Verify firmware in GPM (result %d)\n", xbee_gpm_firmware_verify( &envelope_self)); } else if (! strcmpi( cmdstr, "install")) { printf( "Install firmware in GPM (result %d)\n", xbee_gpm_firmware_install( &envelope_self)); } else if (! strncmpi( cmdstr, "AT", 2)) { process_command( &my_xbee, &cmdstr[2]); } else { printf( "unknown command: '%s'\n", cmdstr); } } }
/** * Try to connect to the list of nodes given by in following form: * * list = <node> | <node>, 1*<node> * port = 1..65535 * hostname = 1*[a-zA-Z0-9.-] * node = hostname [":" <port>] * | <IPv4 address>[":" <port>] * | <IPv6 address> * | "[" <IPv6 address> "]:" <port> * peer = ["tls:"]["g2:"]<node> * * If the port is omitted, the default port (GTA_PORT: 6346) is used. * The case-insensitive prefix "tls:" requests a TLS (encrypted) connection. */ void nodes_gui_common_connect_by_name(const gchar *line) { const gchar *q; g_assert(line); q = line; while ('\0' != *q) { const gchar *endptr, *hostname; size_t hostname_len; host_addr_t addr; guint32 flags; guint16 port; bool g2; q = skip_ascii_spaces(q); if (',' == *q) { q++; continue; } addr = zero_host_addr; port = GTA_PORT; flags = SOCK_F_FORCE; endptr = NULL; hostname = NULL; hostname_len = 0; endptr = is_strcaseprefix(q, "tls:"); if (endptr) { flags |= SOCK_F_TLS; q = endptr; } endptr = is_strcaseprefix(q, "g2:"); if (endptr) { g2 = TRUE; q = endptr; } else { g2 = FALSE; } if (!string_to_host_or_addr(q, &endptr, &addr)) { g_message("expected hostname or IP address"); break; } if (!is_host_addr(addr)) { hostname = q; hostname_len = endptr - q; } q = endptr; if (':' == *q) { gint error; port = parse_uint16(&q[1], &endptr, 10, &error); if (error || 0 == port) { g_message("cannot parse port"); break; } q = skip_ascii_spaces(endptr); } else { q = skip_ascii_spaces(endptr); if ('\0' != *q && ',' != *q) { g_message("expected \",\" or \":\""); break; } } if (!hostname) { if (g2) { guc_node_g2_add(addr, port, flags); } else { guc_node_add(addr, port, flags); } } else { struct add_node_context *ctx; gchar *p; if ('\0' == hostname[hostname_len]) { p = NULL; } else { size_t n = 1 + hostname_len; g_assert(n > hostname_len); p = halloc(n); g_strlcpy(p, hostname, n); hostname = p; } WALLOC(ctx); ctx->port = port; ctx->flags = flags; ctx->g2 = g2; guc_adns_resolve(hostname, add_node_helper, ctx); HFREE_NULL(p); } } }
extern int scontrol_parse_part_options (int argc, char *argv[], int *update_cnt_ptr, update_part_msg_t *part_msg_ptr) { int i, min, max; char *tag, *val; int taglen, vallen; if (!update_cnt_ptr) { error("scontrol_parse_part_options internal error, " "update_cnt_ptr == NULL"); exit_code = 1; return -1; } if (!part_msg_ptr) { error("scontrol_parse_part_options internal error, " "part_msg_ptr == NULL"); exit_code = 1; return -1; } for (i=0; i<argc; i++) { tag = argv[i]; val = strchr(argv[i], '='); if (val) { taglen = val - argv[i]; val++; vallen = strlen(val); } else { exit_code = 1; error("Invalid input: %s Request aborted", argv[i]); return -1; } if (strncasecmp(tag, "PartitionName", MAX(taglen, 2)) == 0) { part_msg_ptr->name = val; (*update_cnt_ptr)++; } else if (strncasecmp(tag, "MaxTime", MAX(taglen, 4)) == 0) { int max_time = time_str2mins(val); if ((max_time < 0) && (max_time != INFINITE)) { exit_code = 1; error("Invalid input %s", argv[i]); return -1; } part_msg_ptr->max_time = max_time; (*update_cnt_ptr)++; } else if (strncasecmp(tag, "DefaultTime", MAX(taglen, 8)) == 0){ int default_time = time_str2mins(val); if ((default_time < 0) && (default_time != INFINITE)) { exit_code = 1; error("Invalid input %s", argv[i]); return -1; } part_msg_ptr->default_time = default_time; (*update_cnt_ptr)++; } else if (strncasecmp(tag, "MaxCPUsPerNode", MAX(taglen, 4)) == 0) { if ((xstrcasecmp(val,"UNLIMITED") == 0) || (xstrcasecmp(val,"INFINITE") == 0)) { part_msg_ptr->max_cpus_per_node = (uint32_t) INFINITE; } else if (parse_uint32(val, &part_msg_ptr-> max_cpus_per_node)) { error("Invalid MaxCPUsPerNode value: %s", val); return -1; } (*update_cnt_ptr)++; } else if (strncasecmp(tag, "MaxNodes", MAX(taglen, 4)) == 0) { if ((xstrcasecmp(val,"UNLIMITED") == 0) || (xstrcasecmp(val,"INFINITE") == 0)) part_msg_ptr->max_nodes = (uint32_t) INFINITE; else { min = 1; get_resource_arg_range(val, "MaxNodes", &min, &max, true); part_msg_ptr->max_nodes = min; } (*update_cnt_ptr)++; } else if (strncasecmp(tag, "MinNodes", MAX(taglen, 2)) == 0) { min = 1; verify_node_count(val, &min, &max); part_msg_ptr->min_nodes = min; (*update_cnt_ptr)++; } else if (strncasecmp(tag, "Default", MAX(taglen, 7)) == 0) { if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_DEFAULT_CLR; else if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_DEFAULT; else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Acceptable Default values " "are YES and NO"); return -1; } (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "DisableRootJobs", MAX(taglen, 1))) { if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_NO_ROOT_CLR; else if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_NO_ROOT; else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Acceptable DisableRootJobs values " "are YES and NO"); return -1; } (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "ExclusiveUser", MAX(taglen, 1))) { if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_EXC_USER_CLR; else if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_EXCLUSIVE_USER; else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Acceptable ExclusiveUser values " "are YES and NO"); return -1; } (*update_cnt_ptr)++; } else if (strncasecmp(tag, "Hidden", MAX(taglen, 1)) == 0) { if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_HIDDEN_CLR; else if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_HIDDEN; else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Acceptable Hidden values " "are YES and NO"); return -1; } (*update_cnt_ptr)++; } else if (strncasecmp(tag, "LLN", MAX(taglen, 1)) == 0) { if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_LLN_CLR; else if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_LLN; else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Acceptable LLN values " "are YES and NO"); return -1; } (*update_cnt_ptr)++; } else if (strncasecmp(tag, "RootOnly", MAX(taglen, 3)) == 0) { if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_ROOT_ONLY_CLR; else if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_ROOT_ONLY; else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Acceptable RootOnly values " "are YES and NO"); return -1; } (*update_cnt_ptr)++; } else if (strncasecmp(tag, "ReqResv", MAX(taglen, 3)) == 0) { if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_REQ_RESV_CLR; else if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) part_msg_ptr->flags |= PART_FLAG_REQ_RESV; else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Acceptable ReqResv values " "are YES and NO"); return -1; } (*update_cnt_ptr)++; } else if (strncasecmp(tag, "Shared", MAX(taglen, 2)) == 0) { char *colon_pos = strchr(val, ':'); if (colon_pos) { *colon_pos = '\0'; vallen = strlen(val); } if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) { part_msg_ptr->max_share = 1; } else if (strncasecmp(val, "EXCLUSIVE", MAX(vallen, 1)) == 0) { part_msg_ptr->max_share = 0; } else if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) { if (colon_pos) { part_msg_ptr->max_share = (uint16_t) strtol(colon_pos+1, (char **) NULL, 10); } else { part_msg_ptr->max_share = (uint16_t) 4; } } else if (strncasecmp(val, "FORCE", MAX(vallen, 1)) == 0) { if (colon_pos) { part_msg_ptr->max_share = (uint16_t) strtol(colon_pos+1, (char **) NULL, 10) | SHARED_FORCE; } else { part_msg_ptr->max_share = (uint16_t) 4 |SHARED_FORCE; } } else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Acceptable Shared values are " "NO, EXCLUSIVE, YES:#, and FORCE:#"); return -1; } (*update_cnt_ptr)++; } else if (strncasecmp(tag, "PreemptMode", MAX(taglen, 3)) == 0) { uint16_t new_mode = preempt_mode_num(val); if (new_mode != (uint16_t) NO_VAL) part_msg_ptr->preempt_mode = new_mode; else { error("Invalid input: %s", argv[i]); return -1; } (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "Priority", MAX(taglen, 3))) { if (parse_uint16(val, &part_msg_ptr->priority_tier)) { error("Invalid Priority value: %s", val); return -1; } part_msg_ptr->priority_job_factor = part_msg_ptr->priority_tier; (*update_cnt_ptr)++; } else if (!strncasecmp(tag,"PriorityJobFactor",MAX(taglen, 3))) { if (parse_uint16(val, &part_msg_ptr->priority_job_factor)) { error("Invalid PriorityJobFactor value: %s", val); return -1; } (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "PriorityTier", MAX(taglen, 3))) { if (parse_uint16(val, &part_msg_ptr->priority_tier)) { error("Invalid PriorityTier value: %s", val); return -1; } (*update_cnt_ptr)++; } else if (strncasecmp(tag, "State", MAX(taglen, 2)) == 0) { if (strncasecmp(val, "INACTIVE", MAX(vallen, 1)) == 0) part_msg_ptr->state_up = PARTITION_INACTIVE; else if (strncasecmp(val, "DOWN", MAX(vallen, 1)) == 0) part_msg_ptr->state_up = PARTITION_DOWN; else if (strncasecmp(val, "UP", MAX(vallen, 1)) == 0) part_msg_ptr->state_up = PARTITION_UP; else if (strncasecmp(val, "DRAIN", MAX(vallen, 1)) == 0) part_msg_ptr->state_up = PARTITION_DRAIN; else { exit_code = 1; error("Invalid input: %s", argv[i]); error("Acceptable State values " "are UP, DOWN, DRAIN and INACTIVE"); return -1; } (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "Nodes", MAX(taglen, 1))) { part_msg_ptr->nodes = val; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "AllowGroups", MAX(taglen, 6))) { part_msg_ptr->allow_groups = val; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "AllowAccounts", MAX(taglen, 6))) { part_msg_ptr->allow_accounts = val; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "AllowQos", MAX(taglen, 6))) { part_msg_ptr->allow_qos = val; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "DenyAccounts", MAX(taglen, 5))) { part_msg_ptr->deny_accounts = val; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "DenyQos", MAX(taglen, 5))) { part_msg_ptr->deny_qos = val; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "AllocNodes", MAX(taglen, 6))) { part_msg_ptr->allow_alloc_nodes = val; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "Alternate", MAX(taglen, 3))) { part_msg_ptr->alternate = val; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "GraceTime", MAX(taglen, 5))) { if (parse_uint32(val, &part_msg_ptr->grace_time)) { error ("Invalid GraceTime value: %s", val); return -1; } (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "DefMemPerCPU", MAX(taglen, 10))) { if (parse_uint32(val, &part_msg_ptr->def_mem_per_cpu)) { error ("Invalid DefMemPerCPU value: %s", val); return -1; } part_msg_ptr->def_mem_per_cpu |= MEM_PER_CPU; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "DefMemPerNode", MAX(taglen, 10))) { if (parse_uint32(val, &part_msg_ptr->def_mem_per_cpu)) { error ("Invalid DefMemPerNode value: %s", val); return -1; } (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "MaxMemPerCPU", MAX(taglen, 10))) { if (parse_uint32(val, &part_msg_ptr->max_mem_per_cpu)) { error ("Invalid MaxMemPerCPU value: %s", val); return -1; } part_msg_ptr->max_mem_per_cpu |= MEM_PER_CPU; (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "MaxMemPerNode", MAX(taglen, 10))) { if (parse_uint32(val, &part_msg_ptr->max_mem_per_cpu)) { error ("Invalid MaxMemPerNode value: %s", val); return -1; } (*update_cnt_ptr)++; } else if (!strncasecmp(tag, "QoS", MAX(taglen, 3))) { part_msg_ptr->qos_char = val; (*update_cnt_ptr)++; } else { exit_code = 1; error("Update of this parameter is not " "supported: %s\n", argv[i]); error("Request aborted"); return -1; } } return 0; }
static char * thex_download_handle_xml(struct thex_download *ctx, const char *data, size_t size) { xnode_t *hashtree = NULL, *node; char *hashtree_id = NULL; bool success = FALSE; vxml_parser_t *vp; vxml_error_t e; if (size <= 0) { if (GNET_PROPERTY(tigertree_debug)) { g_debug("TTH XML record has no data"); } goto finish; } /* * Parse the XML record. */ vp = vxml_parser_make("THEX record", VXML_O_STRIP_BLANKS); vxml_parser_add_data(vp, data, size); e = vxml_parse_tree(vp, &hashtree); vxml_parser_free(vp); if (VXML_E_OK != e) { if (GNET_PROPERTY(tigertree_debug)) { g_warning("TTH cannot parse XML record: %s", vxml_strerror(e)); dump_hex(stderr, "XML record", data, size); } goto finish; } if (0 != strcmp("hashtree", xnode_element_name(hashtree))) { if (GNET_PROPERTY(tigertree_debug)) { g_debug("TTH couldn't find root hashtree element"); } goto finish; } node = find_element_by_name(hashtree, "file"); if (node) { if (!verify_element(node, "size", filesize_to_string(ctx->filesize))) goto finish; if (!verify_element(node, "segmentsize", THEX_SEGMENT_SIZE)) goto finish; } else { if (GNET_PROPERTY(tigertree_debug)) { g_debug("TTH couldn't find hashtree/file element"); } goto finish; } node = find_element_by_name(hashtree, "digest"); if (node) { if (!verify_element(node, "algorithm", THEX_HASH_ALGO)) goto finish; if (!verify_element(node, "outputsize", THEX_HASH_SIZE)) goto finish; } else { if (GNET_PROPERTY(tigertree_debug)) { g_debug("TTH couldn't find hashtree/digest element"); } goto finish; } node = find_element_by_name(hashtree, "serializedtree"); if (node) { const char *value; int error; if (!verify_element(node, "type", THEX_TREE_TYPE)) goto finish; value = xnode_prop_get(node, "uri"); if (NULL == value) { if (GNET_PROPERTY(tigertree_debug)) { g_debug("TTH couldn't find property \"uri\" of node \"%s\"", xnode_element_name(node)); } goto finish; } hashtree_id = h_strdup(value); value = xnode_prop_get(node, "depth"); if (NULL == value) { if (GNET_PROPERTY(tigertree_debug)) { g_debug("TTH couldn't find property \"depth\" of node \"%s\"", xnode_element_name(node)); } goto finish; } ctx->depth = parse_uint16(value, NULL, 10, &error); error |= ctx->depth > tt_full_depth(ctx->filesize); if (error) { ctx->depth = 0; g_warning("TTH bad value for \"depth\" of node \"%s\": \"%s\"", xnode_element_name(node), value); } if (error) goto finish; } else { if (GNET_PROPERTY(tigertree_debug)) g_debug("TTH couldn't find hashtree/serializedtree element"); goto finish; } success = TRUE; finish: if (!success) HFREE_NULL(hashtree_id); xnode_tree_free_null(&hashtree); return hashtree_id; }
static bool process_diff(InputStream *is, struct File *file, FILE *fp, const char **error) { uint8_t data[BS]; uint32_t S; uint16_t C, A; char digest1_str[2*DS + 1]; char digest2_str[2*DS + 1]; uint32_t TC = 0, TA = 0; for (;;) { if (is->read(is, data, 8) != 8) { *error = "read failed -- file truncated?"; return false; } S = parse_uint32(data + 0); C = parse_uint16(data + 4); A = parse_uint16(data + 6); if (S == 0xffffffffu && C == 0xffffu && A == 0xffffu) break; if (C > 0x7fff || A > 0x7fff || (S < 0xffffffffu) != (C > 0)) { *error = "invalid diff data"; return false; } TC += C; TA += A; while (A > 0) { if (is->read(is, data, BS) != BS) { *error = "read failed -- file truncated?"; return false; } A -= 1; } } if (is->read(is, file->diff.digest2, DS) != DS) { *error = "read failed -- file truncated?"; return false; } hexstring(digest2_str, file->diff.digest2, DS); if (is->read(is, file->diff.digest1, DS) == DS) { /* Version 1.1 file */ hexstring(digest1_str, file->diff.digest1, DS); } else { /* Version 1.0 file; no input file digest present */ memset(file->diff.digest1, 0, DS); strcpy(digest1_str, "?"); } file->type = FILE_DIFF; file->diff.copied = TC; file->diff.added = TA; if (fp != NULL) { fprintf(fp, "%s -> %s (%d blocks, %6.3f%% new)\n", digest1_str, digest2_str, TC + TA, 100.0*TA/(TC + TA) ); } return true; }
/* * scontrol_update_job - update the slurm job configuration per the supplied * arguments * IN argc - count of arguments * IN argv - list of arguments * RET 0 if no slurm error, errno otherwise. parsing error prints * error message and returns 0 */ extern int scontrol_update_job (int argc, char *argv[]) { bool update_size = false; int i, update_cnt = 0; char *tag, *val; int taglen, vallen; job_desc_msg_t job_msg; slurm_init_job_desc_msg (&job_msg); /* set current user, needed e.g., for AllowGroups checks */ job_msg.user_id = getuid(); for (i=0; i<argc; i++) { tag = argv[i]; val = strchr(argv[i], '='); if (val) { taglen = val - argv[i]; val++; vallen = strlen(val); } else if (strncasecmp(tag, "Nice", MAX(strlen(tag), 2)) == 0){ /* "Nice" is the only tag that might not have an equal sign, so it is handled specially. */ job_msg.nice = NICE_OFFSET + 100; update_cnt++; continue; } else { exit_code = 1; fprintf (stderr, "Invalid input: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); return -1; } if (strncasecmp(tag, "JobId", MAX(taglen, 3)) == 0) { job_msg.job_id = slurm_xlate_job_id(val); if (job_msg.job_id == 0) { error ("Invalid JobId value: %s", val); exit_code = 1; return 0; } } else if (strncasecmp(tag, "Comment", MAX(taglen, 3)) == 0) { job_msg.comment = val; update_cnt++; } else if (strncasecmp(tag, "TimeLimit", MAX(taglen, 5)) == 0) { bool incr, decr; uint32_t job_current_time, time_limit; incr = (val[0] == '+'); decr = (val[0] == '-'); if (incr || decr) val++; time_limit = time_str2mins(val); if ((time_limit < 0) && (time_limit != INFINITE)) { error("Invalid TimeLimit value"); exit_code = 1; return 0; } if (incr || decr) { job_current_time = _get_job_time(job_msg. job_id); if (job_current_time == NO_VAL) { exit_code = 1; return 0; } if (incr) { time_limit += job_current_time; } else if (time_limit > job_current_time) { error("TimeLimit decrement larger than" " current time limit (%u > %u)", time_limit, job_current_time); exit_code = 1; return 0; } else { time_limit = job_current_time - time_limit; } } job_msg.time_limit = time_limit; update_cnt++; } else if (strncasecmp(tag, "TimeMin", MAX(taglen, 5)) == 0) { int time_min = time_str2mins(val); if ((time_min < 0) && (time_min != INFINITE)) { error("Invalid TimeMin value"); exit_code = 1; return 0; } job_msg.time_min = time_min; update_cnt++; } else if (strncasecmp(tag, "Priority", MAX(taglen, 2)) == 0) { if (parse_uint32(val, &job_msg.priority)) { error ("Invalid Priority value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "Nice", MAX(taglen, 2)) == 0) { int nice; nice = strtoll(val, (char **) NULL, 10); if (abs(nice) > NICE_OFFSET) { error("Invalid nice value, must be between " "-%d and %d", NICE_OFFSET, NICE_OFFSET); exit_code = 1; return 0; } job_msg.nice = NICE_OFFSET + nice; update_cnt++; } else if (strncasecmp(tag, "NumCPUs", MAX(taglen, 6)) == 0) { int min_cpus, max_cpus=0; if (!get_resource_arg_range(val, "NumCPUs", &min_cpus, &max_cpus, false) || (min_cpus <= 0) || (max_cpus && (max_cpus < min_cpus))) { error ("Invalid NumCPUs value: %s", val); exit_code = 1; return 0; } job_msg.min_cpus = min_cpus; if (max_cpus) job_msg.max_cpus = max_cpus; update_cnt++; } /* ReqProcs was removed in SLURM version 2.1 */ else if (strncasecmp(tag, "ReqProcs", MAX(taglen, 8)) == 0) { if (parse_uint32(val, &job_msg.num_tasks)) { error ("Invalid ReqProcs value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "Requeue", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.requeue)) { error ("Invalid Requeue value: %s", val); exit_code = 1; return 0; } update_cnt++; } /* ReqNodes was replaced by NumNodes in SLURM version 2.1 */ else if ((strncasecmp(tag, "ReqNodes", MAX(taglen, 8)) == 0) || (strncasecmp(tag, "NumNodes", MAX(taglen, 8)) == 0)) { int min_nodes, max_nodes, rc; if (strcmp(val, "0") == 0) { job_msg.min_nodes = 0; } else if (strcasecmp(val, "ALL") == 0) { job_msg.min_nodes = INFINITE; } else { min_nodes = (int) job_msg.min_nodes; max_nodes = (int) job_msg.max_nodes; rc = get_resource_arg_range( val, "requested node count", &min_nodes, &max_nodes, false); if (!rc) return rc; job_msg.min_nodes = (uint32_t) min_nodes; job_msg.max_nodes = (uint32_t) max_nodes; } update_size = true; update_cnt++; } else if (strncasecmp(tag, "ReqSockets", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.sockets_per_node)) { error ("Invalid ReqSockets value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "ReqCores", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.cores_per_socket)) { error ("Invalid ReqCores value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "TasksPerNode", MAX(taglen, 2))==0) { if (parse_uint16(val, &job_msg.ntasks_per_node)) { error ("Invalid TasksPerNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "ReqThreads", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.threads_per_core)) { error ("Invalid ReqThreads value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "MinCPUsNode", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.pn_min_cpus)) { error ("Invalid MinCPUsNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "MinMemoryNode", MAX(taglen, 10)) == 0) { if (parse_uint32(val, &job_msg.pn_min_memory)) { error ("Invalid MinMemoryNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "MinMemoryCPU", MAX(taglen, 10)) == 0) { if (parse_uint32(val, &job_msg.pn_min_memory)) { error ("Invalid MinMemoryCPU value: %s", val); exit_code = 1; return 0; } job_msg.pn_min_memory |= MEM_PER_CPU; update_cnt++; } else if (strncasecmp(tag, "MinTmpDiskNode", MAX(taglen, 5)) == 0) { if (parse_uint32(val, &job_msg.pn_min_tmp_disk)) { error ("Invalid MinTmpDiskNode value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "Partition", MAX(taglen, 2)) == 0) { job_msg.partition = val; update_cnt++; } else if (strncasecmp(tag, "QOS", MAX(taglen, 2)) == 0) { job_msg.qos = val; update_cnt++; } else if (strncasecmp(tag, "ReservationName", MAX(taglen, 3)) == 0) { job_msg.reservation = val; update_cnt++; } else if (strncasecmp(tag, "Name", MAX(taglen, 2)) == 0) { job_msg.name = val; update_cnt++; } else if (strncasecmp(tag, "WCKey", MAX(taglen, 1)) == 0) { job_msg.wckey = val; update_cnt++; } else if (strncasecmp(tag, "StdOut", MAX(taglen, 6)) == 0) { job_msg.std_out = val; update_cnt++; } else if (strncasecmp(tag, "Switches", MAX(taglen, 5)) == 0) { char *sep_char; job_msg.req_switch = (uint32_t) strtol(val, &sep_char, 10); update_cnt++; if (sep_char && sep_char[0] == '@') { job_msg.wait4switch = time_str2mins(sep_char+1) * 60; } } else if (strncasecmp(tag, "wait-for-switch", MAX(taglen, 5)) == 0) { if (parse_uint32(val, &job_msg.wait4switch)) { error ("Invalid wait-for-switch value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "Shared", MAX(taglen, 2)) == 0) { if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.shared = 1; else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.shared = 0; else if (parse_uint16(val, &job_msg.shared)) { error ("Invalid wait-for-switch value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "Contiguous", MAX(taglen, 3)) == 0) { if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.contiguous = 1; else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.contiguous = 0; else if (parse_uint16(val, &job_msg.contiguous)) { error ("Invalid Contiguous value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "CoreSpec", MAX(taglen, 4)) == 0) { if (parse_uint16(val, &job_msg.core_spec)) { error ("Invalid CoreSpec value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "ExcNodeList", MAX(taglen, 3)) == 0){ job_msg.exc_nodes = val; update_cnt++; } else if (!strncasecmp(tag, "NodeList", MAX(taglen, 8)) || !strncasecmp(tag, "ReqNodeList", MAX(taglen, 8))) { job_msg.req_nodes = val; update_size = true; update_cnt++; } else if (strncasecmp(tag, "Features", MAX(taglen, 1)) == 0) { job_msg.features = val; update_cnt++; } else if (strncasecmp(tag, "Gres", MAX(taglen, 2)) == 0) { if (!strcasecmp(val, "help") || !strcasecmp(val, "list")) { print_gres_help(); } else { job_msg.gres = val; update_cnt++; } } else if (strncasecmp(tag, "Account", MAX(taglen, 1)) == 0) { job_msg.account = val; update_cnt++; } else if (strncasecmp(tag, "Dependency", MAX(taglen, 1)) == 0) { job_msg.dependency = val; update_cnt++; } else if (strncasecmp(tag, "Geometry", MAX(taglen, 2)) == 0) { char* token, *delimiter = ",x", *next_ptr; int j, rc = 0; int dims = slurmdb_setup_cluster_dims(); uint16_t geo[dims]; char* geometry_tmp = xstrdup(val); char* original_ptr = geometry_tmp; token = strtok_r(geometry_tmp, delimiter, &next_ptr); for (j=0; j<dims; j++) { if (token == NULL) { error("insufficient dimensions in " "Geometry"); rc = -1; break; } geo[j] = (uint16_t) atoi(token); if (geo[j] <= 0) { error("invalid --geometry argument"); rc = -1; break; } geometry_tmp = next_ptr; token = strtok_r(geometry_tmp, delimiter, &next_ptr); } if (token != NULL) { error("too many dimensions in Geometry"); rc = -1; } if (original_ptr) xfree(original_ptr); if (rc != 0) exit_code = 1; else { for (j=0; j<dims; j++) job_msg.geometry[j] = geo[j]; update_cnt++; } } else if (strncasecmp(tag, "Rotate", MAX(taglen, 2)) == 0) { if (strncasecmp(val, "YES", MAX(vallen, 1)) == 0) job_msg.rotate = 1; else if (strncasecmp(val, "NO", MAX(vallen, 1)) == 0) job_msg.rotate = 0; else if (parse_uint16(val, &job_msg.rotate)) { error ("Invalid wait-for-switch value: %s", val); exit_code = 1; return 0; } update_cnt++; } else if (strncasecmp(tag, "Conn-Type", MAX(taglen, 2)) == 0) { verify_conn_type(val, job_msg.conn_type); if (job_msg.conn_type[0] != (uint16_t)NO_VAL) update_cnt++; } else if (strncasecmp(tag, "Licenses", MAX(taglen, 1)) == 0) { job_msg.licenses = val; update_cnt++; } else if (!strncasecmp(tag, "EligibleTime", MAX(taglen, 2)) || !strncasecmp(tag, "StartTime", MAX(taglen, 2))) { if ((job_msg.begin_time = parse_time(val, 0))) { if (job_msg.begin_time < time(NULL)) job_msg.begin_time = time(NULL); update_cnt++; } } else if (!strncasecmp(tag, "EndTime", MAX(taglen, 2))) { job_msg.end_time = parse_time(val, 0); update_cnt++; } else { exit_code = 1; fprintf (stderr, "Update of this parameter is not " "supported: %s\n", argv[i]); fprintf (stderr, "Request aborted\n"); return 0; } } if (update_cnt == 0) { exit_code = 1; fprintf (stderr, "No changes specified\n"); return 0; } if (slurm_update_job(&job_msg)) return slurm_get_errno (); if (update_size) _update_job_size(job_msg.job_id); return SLURM_SUCCESS; }
/** * Parse common command line arguments. * @param c The command line short argument * @param oparg Argument for the parameter, if any * @param ctx Pointer to the common context which is filled according * to command line parameters. * @return 0 if argument is parsed, -1 if error occurred, -2 if * command line parameter was unknown. */ int common_parse_args(int c, char *arg, struct common_context *ctx) { auth_ret_t auth_ret; uint16_t streams; #ifdef DEBUG uint16_t debug_level = DEBUG_DEFAULT_LEVEL; #endif /* DEBUG */ if (c == -1) return 0; switch(c) { case 'S' : ctx->options = set_flag( ctx->options, SEQ_FLAG ); break; case 'e' : ctx->options = set_flag( ctx->options, ECHO_FLAG ); break; case 'v' : ctx->options = set_flag( ctx->options, VERBOSE_FLAG); break; case 'x' : ctx->options = set_flag(ctx->options, XDUMP_FLAG); break; case 'I' : if (parse_uint16(arg, &streams) < 0 ) { fprintf(stderr, "Invalid input stream count given\n"); return -1; } if (ctx->initmsg == NULL ) ctx->initmsg = mem_zalloc(sizeof(struct sctp_initmsg)); ctx->initmsg->sinit_max_instreams = streams; break; case 'O' : if (parse_uint16(arg, &streams) < 0 ) { fprintf(stderr, "Invalid output stream count given\n"); return -1; } if (ctx->initmsg == NULL) ctx->initmsg = mem_zalloc(sizeof(*ctx->initmsg)); ctx->initmsg->sinit_num_ostreams = streams; break; #ifdef DEBUG case 'D' : if (parse_uint16(arg, &debug_level) < 0) { fprintf(stderr,"Malformed Debug level number given\n"); return -1; } if (debug_level > DBG_L_ERR) { fprintf(stderr, "Invalid debug level (expected 0-3)\n"); return -1; } DBG_LEVEL(debug_level); break; #endif /* DEBUG */ case 'A' : if (ctx->actx == NULL) { ctx->actx = auth_create_context(); ctx->options = set_flag(ctx->options, AUTH_FLAG); } auth_ret = auth_parse_key(ctx->actx, arg); if (auth_ret == AUTHERR_INVALID_PARAM) { fprintf(stderr,"Invalid key given\n"); return -1; } break; case 'C' : if (ctx->actx == NULL) { ctx->actx = auth_create_context(); ctx->options = set_flag(ctx->options, AUTH_FLAG); } auth_ret = auth_parse_chunk(ctx->actx, arg); if (auth_ret == AUTHERR_INVALID_PARAM) { fprintf(stderr,"Invalid chunk type given\n"); return -1; } else if (auth_ret == AUTHERR_UNSUPPORTED_PARAM) { fprintf(stderr,"Given chunk type not supported for authentication\n"); return -1; } break; case 'M' : if (ctx->actx == NULL) { ctx->actx = auth_create_context(); ctx->options = set_flag(ctx->options, AUTH_FLAG); } auth_ret = auth_parse_hmac(ctx->actx, arg); if (auth_ret == AUTHERR_INVALID_PARAM) { fprintf(stderr,"Invalid hmac type given\n"); return -1; } else if (auth_ret == AUTHERR_UNSUPPORTED_PARAM) { fprintf(stderr, "HMAC %s is not supported\n", arg); return -1; } break; default : return -2; } return 0; }