static bool parse_vnic_interface(char* name, uint16_t* vmid, uint16_t* vnic_index, uint16_t* interface_index) {
if(strncmp(name, "v", 1))
return false;
char* next;
char* _vmid = strtok_r(name + 1, "eth", &next);
if(!_vmid)
return false;
if(!is_uint8(_vmid))
return false;
*vmid = parse_uint8(_vmid);
char* _interface_index;
char* _vnic_index = strtok_r(next, ":", &_interface_index);
if(!_vnic_index)
return false;
if(!is_uint8(_vnic_index))
return false;
*vnic_index = parse_uint8(_vnic_index);
if(_interface_index) {
if(!is_uint8(_interface_index))
return false;
*interface_index = parse_uint8(_interface_index) + 1;
} else
*interface_index = 0;
return true;
}
/* smbus_prologue is responsible for doing the common bits for both smbus read
* and write. It will parse the comand line arguments and open the appropriate
* i2c device. It returns 1 on success, 0 on failure. */
static int
smbus_prologue(const char *argv[], struct smbus_op_params *params,
const struct smbus_op *op)
{
if (parse_uint8(argv[1], ¶ms->i2c_bus)) {
fprintf(stderr, "invalid adapter value\n");
return -1;
}
if (parse_uint8(argv[2], ¶ms->address)) {
fprintf(stderr, "invalid address value\n");
return -1;
}
/* Only obtain the register if size designates that it is not a byte
* or quick operation. */
if (op->size != SMBUS_SIZE_BYTE && op->size != SMBUS_QUICK) {
if (parse_uint8(argv[3], ¶ms->reg)) {
fprintf(stderr, "invalid register value\n");
return -1;
}
}
params->fd = open_i2c_slave(params->i2c_bus, params->address);
if (params->fd < 0) {
fprintf(stderr, "can't open slave\n");
return -1;
}
return 0;
}
static void
do_service_request(struct packet_handler *c,
struct ssh_connection *connection,
struct lsh_string *packet)
{
CAST(service_handler, closure, c);
struct simple_buffer buffer;
unsigned msg_number;
int name;
simple_buffer_init(&buffer, packet->length, packet->data);
if (parse_uint8(&buffer, &msg_number)
&& (msg_number == SSH_MSG_SERVICE_REQUEST)
&& parse_atom(&buffer, &name)
&& parse_eod(&buffer))
{
if (name)
{
CAST_SUBTYPE(command, service, ALIST_GET(closure->services, name));
if (service)
{
/* Don't accept any further service requests */
connection->dispatch[SSH_MSG_SERVICE_REQUEST]
= &connection_fail_handler;
/* Start service */
#if DATAFELLOWS_WORKAROUNDS
if (connection->peer_flags & PEER_SERVICE_ACCEPT_KLUDGE)
C_WRITE(connection, format_service_accept_kludge());
else
#endif /* DATAFELLOWS_WORKAROUNDS */
C_WRITE(connection, format_service_accept(name));
COMMAND_CALL(service, connection,
closure->c, closure->e);
return;
}
}
EXCEPTION_RAISE(connection->e,
make_protocol_exception(SSH_DISCONNECT_SERVICE_NOT_AVAILABLE, NULL));
}
else
PROTOCOL_ERROR(connection->e, "Invalid SERVICE_REQUEST message");
}
static int
parse_io_width(const char *arg, struct smbus_op_params *params,
const struct smbus_op *op)
{
uint64_t ldata;
char *end;
switch (op->size) {
case SMBUS_QUICK:
ldata = strtoul(arg, &end, 0);
if (ismaxortrailingjunk(arg, end, ldata))
return -1;
if (ldata != 0 && ldata != 1) {
fprintf(stderr, "%s: isn't 0 or 1\n", arg);
return -1;
}
params->data.fixed.u8 = ldata;
break;
case SMBUS_SIZE_BYTE:
case SMBUS_SIZE_8:
ldata = strtoul(arg, &end, 0);
if (ismaxortrailingjunk(arg, end, ldata))
return -1;
params->data.fixed.u8 = ldata;
break;
case SMBUS_SIZE_16:
ldata = strtoul(arg, &end, 0);
if (ismaxortrailingjunk(arg, end, ldata))
return -1;
params->data.fixed.u16 = ldata;
break;
case SMBUS_SIZE_32:
ldata = strtoul(arg, &end, 0);
if (istrailingjunk(arg, end))
return -1;
params->data.fixed.u32 = ldata;
break;
case SMBUS_SIZE_64:
ldata = strtoull(arg, &end, 0);
if (istrailingjunk(arg, end))
return -1;
params->data.fixed.u64 = ldata;
break;
case SMBUS_SIZE_BLOCK:
{
int len;
int i;
char str_nibble[3];
len = strlen(arg);
if ( (len <= 0) || (len > 64) || (len % 2 != 0) ) {
fprintf(stderr, "%d: length is 0 or >64 or odd\n", len);
return -1;
}
/* NUL-terminate string. */
str_nibble[2] = '\0';
/* work right-to-left by bytes (nibble pairs) */
for (i = len - 2; i >= 0 ; i -= 2) {
str_nibble[0] = arg[i];
str_nibble[1] = arg[i+1];
assert(i/2 >= 0 && i/2 < sizeof params->data.array);
if (parse_uint8(str_nibble, ¶ms->data.array[i/2]))
/* parse_uint8 has complained */
return -1;
}
params->len = len / 2;
}
break;
default:
fprintf(stderr, "%s: unknown operand size\n", arg);
return -1;
}
return 0;
}
static void
magnet_handle_key(struct magnet_resource *res,
const char *name, const char *value)
{
char *to_free = NULL;
g_return_if_fail(res);
g_return_if_fail(name);
g_return_if_fail(value);
if (!utf8_is_valid_string(value)) {
const char *encoding;
char *result;
g_message("MAGNET URI key \"%s\" is not UTF-8 encoded", name);
if (MAGNET_KEY_DISPLAY_NAME != magnet_key_get(name))
return;
result = unknown_to_utf8(value, &encoding);
if (result != value) {
to_free = result;
}
value = result;
g_message("assuming MAGNET URI key \"%s\" is %s encoded",
name, encoding);
}
switch (magnet_key_get(name)) {
case MAGNET_KEY_DISPLAY_NAME:
if (!res->display_name) {
magnet_set_display_name(res, value);
}
break;
case MAGNET_KEY_ALTERNATE_SOURCE:
case MAGNET_KEY_EXACT_SOURCE:
{
struct magnet_source *ms;
const char *error;
ms = magnet_parse_exact_source(value, &error);
if (ms) {
if (!res->sha1 && ms->sha1) {
res->sha1 = atom_sha1_get(ms->sha1);
}
if (!ms->sha1 || sha1_eq(res->sha1, ms->sha1)) {
res->sources = g_slist_prepend(res->sources, ms);
} else {
magnet_source_free(&ms);
}
} else {
g_message("could not parse source \"%s\" in MAGNET URI: %s",
value, NULL_STRING(error));
}
}
break;
case MAGNET_KEY_EXACT_TOPIC:
if (!magnet_set_exact_topic(res, value)) {
g_message("MAGNET URI contained unsupported exact topic \"%s\"",
value);
}
break;
case MAGNET_KEY_KEYWORD_TOPIC:
magnet_add_search(res, value);
break;
case MAGNET_KEY_EXACT_LENGTH:
{
int error;
uint64 u;
u = parse_uint64(value, NULL, 10, &error);
if (!error) {
magnet_set_filesize(res, u);
}
}
break;
case MAGNET_KEY_PARQ_ID:
magnet_set_parq_id(res, value);
break;
case MAGNET_KEY_VENDOR:
magnet_set_vendor(res, value);
break;
case MAGNET_KEY_GUID:
magnet_set_guid(res, value);
break;
case MAGNET_KEY_DHT:
{
int error;
uint8 u;
u = parse_uint8(value, NULL, 10, &error);
if (!error) {
magnet_set_dht(res, u);
}
}
break;
case MAGNET_KEY_NONE:
g_message("unhandled parameter in MAGNET URI: \"%s\"", name);
break;
case NUM_MAGNET_KEYS:
g_assert_not_reached();
}
G_FREE_NULL(to_free);
}
static void
lshd_service_request_handler(struct transport_forward *self,
uint32_t length, const uint8_t *packet)
{
struct simple_buffer buffer;
unsigned msg_number;
const uint8_t *name;
uint32_t name_length;
simple_buffer_init(&buffer, length, packet);
if (parse_uint8(&buffer, &msg_number)
&& (msg_number == SSH_MSG_SERVICE_REQUEST)
&& parse_string(&buffer, &name_length, &name)
&& parse_eod(&buffer))
{
CAST(lshd_context, ctx, self->super.ctx);
const struct service_entry *service
= service_config_lookup(ctx->service_config,
name_length, name);
if (service)
{
int pipe[2];
pid_t child;
if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe) < 0)
{
werror("lshd_service_request_handler: socketpair failed: %e.\n",
errno);
transport_disconnect(&self->super,
SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
"Service could not be started");
return;
}
child = fork();
if (child < 0)
{
werror("lshd_service_request_handler: fork failed: %e.\n",
errno);
close(pipe[0]);
close(pipe[1]);
transport_disconnect(&self->super,
SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
"Service could not be started");
return;
}
if (child)
{
/* Parent process */
close(pipe[1]);
transport_send_packet(&self->super, TRANSPORT_WRITE_FLAG_PUSH,
format_service_accept(name_length, name));
/* Setup forwarding. Replaces event_handler and packet_handler. */
transport_forward_setup(self, pipe[0], pipe[0]);
}
else
{
/* Child process */
struct arglist args;
const char *program;
unsigned i;
close(pipe[0]);
dup2(pipe[1], STDIN_FILENO);
dup2(pipe[1], STDOUT_FILENO);
close(pipe[1]);
/* FIXME: Pass sufficient information so that
$SSH_CLIENT can be set properly. */
arglist_init (&args);
program = service->args.argv[0];
arglist_push (&args, program);
/* If not absolute, interpret it relative to
libexecdir. */
if (program[0] != '/')
program = lsh_get_cstring(ssh_format("%lz/%lz",
ctx->service_config->libexec_dir,
program));
for (i = 1; i < service->args.argc; i++)
{
const char *arg = service->args.argv[i];
if (arg[0] == '$')
{
if (!strcmp(arg+1, "(session_id)"))
arg = lsh_get_cstring(ssh_format("%lxS",
self->super.session_id));
}
arglist_push (&args, arg);
}
debug("exec of service %s, program %z. Argument list:\n",
name_length, name, program);
for (i = 0; i < args.argc; i++)
debug(" %z\n", args.argv[i]);
execv(program, (char **) args.argv);
werror("lshd_service_request_handler: exec of %z failed: %e.\n",
args.argv[0], errno);
_exit(EXIT_FAILURE);
}
}
else
transport_disconnect(&self->super,
SSH_DISCONNECT_SERVICE_NOT_AVAILABLE,
"Service not available");
}
else
transport_protocol_error(&self->super, "Invalid SERVICE_REQUEST");
}
/* Processes the current directive.
* If the encoder returns an error, a message including current file and
* line number together with the pt error string is printed on stderr.
*
* Returns 0 on success; a negative enum errcode otherwise.
* Returns -err_internal if @p or @e is the NULL pointer.
* Returns -err_parse_missing_directive if there was a pt directive marker,
* but no directive.
* Returns -stop_process if the .exp directive was encountered.
* Returns -err_pt_lib if the pt encoder returned an error.
* Returns -err_parse if a general parsing error was encountered.
* Returns -err_parse_unknown_directive if there was an unknown pt directive.
*/
static int p_process(struct parser *p, struct pt_encoder *e)
{
int bytes_written;
int errcode;
char *directive, *payload, *pt_label_name, *tmp;
struct pt_directive *pd;
struct pt_packet packet;
if (bug_on(!p))
return -err_internal;
if (bug_on(!e))
return -err_internal;
pd = p->pd;
if (!pd)
return -err_internal;
directive = pd->name;
payload = pd->payload;
pt_label_name = NULL;
bytes_written = 0;
errcode = 0;
/* find a label name. */
tmp = strchr(directive, ':');
if (tmp) {
uint64_t x;
pt_label_name = directive;
directive = tmp+1;
*tmp = '\0';
/* ignore whitespace between label and directive. */
while (isspace(*directive))
directive += 1;
/* if we can lookup a yasm label with the same name, the
* current pt directive label is invalid. */
errcode = yasm_lookup_label(p->y, &x, pt_label_name);
if (errcode == 0)
errcode = -err_label_not_unique;
if (errcode != -err_no_label)
return yasm_print_err(p->y, "label lookup",
errcode);
/* if we can lookup a pt directive label with the same
* name, the current pt directive label is invalid. */
errcode = l_lookup(p->pt_labels, &x, pt_label_name);
if (errcode == 0)
errcode = -err_label_not_unique;
if (errcode != -err_no_label)
return yasm_print_err(p->y, "label lookup",
-err_label_not_unique);
}
/* now try to match the directive string and call the
* corresponding function that parses the payload and emits an
* according packet.
*/
if (strcmp(directive, "") == 0)
return yasm_print_err(p->y, "invalid syntax",
-err_parse_missing_directive);
else if (strcmp(directive, ".exp") == 0) {
/* this is the end of processing pt directives, so we
* add a p_last label to the pt directive labels.
*/
errcode = l_append(p->pt_labels, "eos", p->pt_bytes_written);
if (errcode < 0)
return yasm_print_err(p->y, "append label", errcode);
return -stop_process;
}
if (strcmp(directive, "psb") == 0) {
errcode = parse_empty(payload);
if (errcode < 0) {
yasm_print_err(p->y, "psb: parsing failed", errcode);
goto error;
}
packet.type = ppt_psb;
} else if (strcmp(directive, "psbend") == 0) {
errcode = parse_empty(payload);
if (errcode < 0) {
yasm_print_err(p->y, "psbend: parsing failed", errcode);
goto error;
}
packet.type = ppt_psbend;
} else if (strcmp(directive, "pad") == 0) {
errcode = parse_empty(payload);
if (errcode < 0) {
yasm_print_err(p->y, "pad: parsing failed", errcode);
goto error;
}
packet.type = ppt_pad;
} else if (strcmp(directive, "ovf") == 0) {
errcode = parse_empty(payload);
if (errcode < 0) {
yasm_print_err(p->y, "ovf: parsing failed", errcode);
goto error;
}
packet.type = ppt_ovf;
} else if (strcmp(directive, "tnt") == 0) {
errcode = parse_tnt(&packet.payload.tnt.payload,
&packet.payload.tnt.bit_size, payload);
if (errcode < 0) {
yasm_print_err(p->y, "tnt: parsing failed", errcode);
goto error;
}
packet.type = ppt_tnt_8;
} else if (strcmp(directive, "tnt64") == 0) {
errcode = parse_tnt(&packet.payload.tnt.payload,
&packet.payload.tnt.bit_size, payload);
if (errcode < 0) {
yasm_print_err(p->y, "tnt64: parsing failed", errcode);
goto error;
}
packet.type = ppt_tnt_64;
} else if (strcmp(directive, "tip") == 0) {
errcode = parse_ip(p, &packet.payload.ip.ip,
&packet.payload.ip.ipc, payload);
if (errcode < 0) {
yasm_print_err(p->y, "tip: parsing failed", errcode);
goto error;
}
packet.type = ppt_tip;
} else if (strcmp(directive, "tip.pge") == 0) {
errcode = parse_ip(p, &packet.payload.ip.ip,
&packet.payload.ip.ipc, payload);
if (errcode < 0) {
yasm_print_err(p->y, "tip.pge: parsing failed",
errcode);
goto error;
}
packet.type = ppt_tip_pge;
} else if (strcmp(directive, "tip.pgd") == 0) {
errcode = parse_ip(p, &packet.payload.ip.ip,
&packet.payload.ip.ipc, payload);
if (errcode < 0) {
yasm_print_err(p->y, "tip.pgd: parsing failed",
errcode);
goto error;
}
packet.type = ppt_tip_pgd;
} else if (strcmp(directive, "fup") == 0) {
errcode = parse_ip(p, &packet.payload.ip.ip,
&packet.payload.ip.ipc, payload);
if (errcode < 0) {
yasm_print_err(p->y, "fup: parsing failed", errcode);
goto error;
}
packet.type = ppt_fup;
} else if (strcmp(directive, "mode.exec") == 0) {
if (strcmp(payload, "16bit") == 0) {
packet.payload.mode.bits.exec.csl = 0;
packet.payload.mode.bits.exec.csd = 0;
} else if (strcmp(payload, "64bit") == 0) {
packet.payload.mode.bits.exec.csl = 1;
packet.payload.mode.bits.exec.csd = 0;
} else if (strcmp(payload, "32bit") == 0) {
packet.payload.mode.bits.exec.csl = 0;
packet.payload.mode.bits.exec.csd = 1;
} else {
errcode = yasm_print_err(p->y,
"mode.exec: argument must be one of \"16bit\", \"64bit\" or \"32bit\"",
-err_parse);
goto error;
}
packet.payload.mode.leaf = pt_mol_exec;
packet.type = ppt_mode;
} else if (strcmp(directive, "mode.tsx") == 0) {
if (strcmp(payload, "begin") == 0) {
packet.payload.mode.bits.tsx.intx = 1;
packet.payload.mode.bits.tsx.abrt = 0;
} else if (strcmp(payload, "abort") == 0) {
packet.payload.mode.bits.tsx.intx = 0;
packet.payload.mode.bits.tsx.abrt = 1;
} else if (strcmp(payload, "commit") == 0) {
packet.payload.mode.bits.tsx.intx = 0;
packet.payload.mode.bits.tsx.abrt = 0;
} else {
errcode = yasm_print_err(p->y,
"mode.tsx: argument must be one of \"begin\", \"abort\" or \"commit\"",
-err_parse);
goto error;
}
packet.payload.mode.leaf = pt_mol_tsx;
packet.type = ppt_mode;
} else if (strcmp(directive, "pip") == 0) {
errcode = parse_uint64(&packet.payload.pip.cr3, payload);
if (errcode < 0) {
yasm_print_err(p->y, "pip: parsing failed", errcode);
goto error;
}
packet.type = ppt_pip;
} else if (strcmp(directive, "tsc") == 0) {
errcode = parse_uint64(&packet.payload.tsc.tsc, payload);
if (errcode < 0) {
yasm_print_err(p->y, "tsc: parsing failed", errcode);
goto error;
}
packet.type = ppt_tsc;
} else if (strcmp(directive, "cbr") == 0) {
errcode = parse_uint8(&packet.payload.cbr.ratio, payload);
if (errcode < 0) {
yasm_print_err(p->y, "cbr: parsing cbr failed",
errcode);
goto error;
}
packet.type = ppt_cbr;
} else {
errcode = yasm_print_err(p->y, "invalid syntax",
-err_parse_unknown_directive);
goto error;
}
bytes_written = pt_enc_next(e, &packet);
if (bytes_written < 0) {
const char *errstr, *format;
char *msg;
size_t n;
errstr = pt_errstr(pt_errcode(bytes_written));
format = "encoder error in directive %s (status %s)";
/* the length of format includes the "%s" (-2)
* characters, we add errstr (+-0) and then we need
* space for a terminating null-byte (+1).
*/
n = strlen(format)-4 + strlen(directive) + strlen(errstr) + 1;
msg = malloc(n);
if (!msg)
errcode = yasm_print_err(p->y,
"encoder error not enough memory to show error code",
-err_pt_lib);
else {
sprintf(msg, format, directive, errstr);
errcode = yasm_print_err(p->y, msg, -err_pt_lib);
free(msg);
}
} else {
if (pt_label_name) {
errcode = l_append(p->pt_labels, pt_label_name,
p->pt_bytes_written);
if (errcode < 0)
goto error;
}
p->pt_bytes_written += bytes_written;
}
error:
if (errcode < 0)
bytes_written = errcode;
return bytes_written;
}
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;
}
