/**
* 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;
}
