172 lines
4.7 KiB
C
172 lines
4.7 KiB
C
#include "lab.h"
|
|
|
|
void client_init(struct client *client, struct backend *backend)
|
|
{
|
|
memset(client, 0, sizeof(*client));
|
|
client->backend = backend;
|
|
for (size_t bank = 0; bank < BANKS; bank++) { client->value[bank][0] = -1; }
|
|
}
|
|
|
|
static int invoke(struct client *client, int operation, int a, int b,
|
|
unsigned char *bytes, size_t length)
|
|
{
|
|
int result;
|
|
for (;;) {
|
|
result = device_call(client->backend, operation, a, b, bytes, length);
|
|
if (result != -EINTR) {
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
static void status_encode(unsigned value, unsigned char *bytes, size_t width)
|
|
{
|
|
size_t index;
|
|
for (index = 0; index < width; index++) {
|
|
bytes[index] = (unsigned char)(value & 255u);
|
|
value >>= 8;
|
|
}
|
|
}
|
|
|
|
static int status_query(struct client *client, const struct command *command,
|
|
struct reply *reply)
|
|
{
|
|
const int *state = client->value[client->selected];
|
|
unsigned char bytes[32];
|
|
size_t index;
|
|
int start;
|
|
int count;
|
|
int width;
|
|
if (command->operation != 'Q' && command->operation != 'P') {
|
|
return 0;
|
|
}
|
|
if (!command_has(command, 2)) {
|
|
reply->result = -EINVAL;
|
|
return 1;
|
|
}
|
|
start = command->argument[0];
|
|
if (command->operation == 'Q') {
|
|
count = 1;
|
|
width = command->argument[1];
|
|
if (width != 1 && width != 2 && width != 4) {
|
|
reply->result = -EINVAL;
|
|
return 1;
|
|
}
|
|
} else {
|
|
count = command->argument[1];
|
|
width = 4;
|
|
}
|
|
if (start < 0 || count < 0 || start > 8 || count > 8 - start) {
|
|
reply->result = -EINVAL;
|
|
return 1;
|
|
}
|
|
memset(bytes, 0, sizeof(bytes));
|
|
for (index = 0; index < (size_t)count; index++) {
|
|
unsigned value = (unsigned)state[start + (int)index];
|
|
status_encode(value, bytes + index * (size_t)width, (size_t)width);
|
|
}
|
|
reply_copy(reply, bytes, (size_t)(count * width));
|
|
return 1;
|
|
}
|
|
|
|
|
|
static int store_value(struct client *client, const struct command *command)
|
|
{
|
|
int *state = client->value[client->selected];
|
|
unsigned char bytes[BYTE_LIMIT];
|
|
int parsed = 0;
|
|
int result;
|
|
int count;
|
|
if (command->count < 1) {
|
|
return -EINVAL;
|
|
}
|
|
count = command->argument[0];
|
|
if (count < 0 || count > 12 || !bytes_valid(command, 1, (size_t)count)) {
|
|
return -EINVAL;
|
|
}
|
|
bytes_from_command(bytes, command, 1, (size_t)count);
|
|
/* STRICT_STORE */
|
|
result = text_integer(bytes, (size_t)count, &parsed);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
result = invoke(client, 1, parsed, 0, NULL, 0);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
state[0] = parsed;
|
|
state[4]++;
|
|
return 0;
|
|
}
|
|
|
|
static int capture_value(struct client *client)
|
|
{
|
|
int *state = client->value[client->selected];
|
|
unsigned char bytes[4];
|
|
unsigned value;
|
|
int parsed;
|
|
int result;
|
|
result = invoke(client, 2, 0, 0, bytes, sizeof(bytes));
|
|
if (result) {
|
|
return result;
|
|
}
|
|
value = (unsigned)bytes[0] | ((unsigned)bytes[1] << 8) |
|
|
((unsigned)bytes[2] << 16) | ((unsigned)bytes[3] << 24);
|
|
parsed = value > INT_MAX ? -1 - (int)(UINT_MAX - value) : (int)value;
|
|
state[3] = parsed;
|
|
state[2] = 1;
|
|
return 0;
|
|
}
|
|
|
|
static int read_value(struct client *client, int capacity, struct reply *reply)
|
|
{
|
|
int *state = client->value[client->selected];
|
|
unsigned char bytes[24];
|
|
size_t length;
|
|
size_t available;
|
|
size_t count;
|
|
int result;
|
|
if (capacity < 1 || capacity > 16) {
|
|
return -EINVAL;
|
|
}
|
|
/* SNAPSHOT */
|
|
if (!state[2]) {
|
|
result = capture_value(client);
|
|
if (result) {
|
|
return result;
|
|
}
|
|
}
|
|
length = integer_text(state[3], bytes);
|
|
available = state[1] < (int)length ? length - (size_t)state[1] : 0;
|
|
count = available < (size_t)capacity ? available : (size_t)capacity;
|
|
reply_copy(reply, bytes + state[1], count);
|
|
state[1] += (int)count;
|
|
state[5]++;
|
|
state[6] += (int)count;
|
|
return 0;
|
|
}
|
|
|
|
static int seek_start(struct client *client)
|
|
{
|
|
int *state = client->value[client->selected];
|
|
state[1] = 0;
|
|
state[2] = 0;
|
|
state[3] = 0;
|
|
state[7]++;
|
|
return 0;
|
|
}
|
|
|
|
void client_apply(struct client *client, const struct command *command,
|
|
struct reply *reply)
|
|
{
|
|
if (status_query(client, command, reply)) { return; }
|
|
if (command->operation == 'W') {
|
|
reply->result = store_value(client, command);
|
|
} else if (command->operation == 'R' && command_has(command, 1)) {
|
|
reply->result = read_value(client, command->argument[0], reply);
|
|
} else if (command->operation == 'S' && command_has(command, 0)) {
|
|
reply->result = seek_start(client);
|
|
} else {
|
|
reply->result = -EINVAL;
|
|
}
|
|
}
|