{ "files": { "adapter.h": "#ifndef ADAPTER_H\n#define ADAPTER_H\n#include \"stream.h\"\n#define ADAPTER_STEPS 64\n#define ADAPTER_CALLS 256\ntypedef struct adapter_call {\n int kind;\n size_t requested;\n int flags;\n ssize_t result;\n int error;\n unsigned char bytes[STREAM_CAPACITY];\n size_t count;\n} adapter_call;\ntypedef struct adapter {\n int sends[ADAPTER_STEPS];\n int receives[ADAPTER_STEPS];\n size_t send_count;\n size_t recv_count;\n size_t send_next;\n size_t recv_next;\n unsigned seed;\n uint64_t cursor;\n int shutdown_error;\n adapter_call calls[ADAPTER_CALLS];\n size_t call_count;\n} adapter;\nvoid adapter_init(adapter *port, unsigned seed);\nstream_port adapter_port(adapter *port);\nint adapter_load(adapter *port, int receive, const int *steps, size_t count);\nvoid adapter_observation_reset(adapter *port);\nvoid adapter_print(const adapter *port);\n#endif\n", "adapter.c": "#include \"adapter.h\"\n#include \n#include \n#include \nstatic int step_error(int value)\n{\n switch (value) {\n case -1: return EINTR;\n case -2: return EAGAIN;\n case -3: return EPIPE;\n default: return EIO;\n }\n}\nstatic adapter_call *new_call(adapter *port, int kind, size_t request, int flags)\n{\n adapter_call *call;\n if (port->call_count >= ADAPTER_CALLS) {\n return NULL;\n }\n call = &port->calls[port->call_count++];\n memset(call, 0, sizeof *call);\n call->kind = kind;\n call->requested = request;\n call->flags = flags;\n return call;\n}\nstatic ssize_t send_bytes(void *context, const unsigned char *bytes,\n size_t count, int flags)\n{\n adapter *port = context;\n adapter_call *call = new_call(port, 1, count, flags);\n int step = (int)count;\n size_t accepted;\n if (port->send_next < port->send_count) {\n step = port->sends[port->send_next++];\n }\n if (!call) {\n errno = EIO;\n return -1;\n }\n call->count = count;\n memcpy(call->bytes, bytes, count);\n if (step < 0) {\n call->result = -1;\n call->error = step_error(step);\n errno = call->error;\n return -1;\n }\n accepted = (size_t)step < count ? (size_t)step : count;\n call->result = (ssize_t)accepted;\n return call->result;\n}\nstatic ssize_t recv_bytes(void *context, unsigned char *bytes,\n size_t count, int flags)\n{\n adapter *port = context;\n adapter_call *call = new_call(port, 2, count, flags);\n int step = -2;\n size_t received;\n size_t index;\n if (port->recv_next < port->recv_count) {\n step = port->receives[port->recv_next++];\n }\n if (!call) {\n errno = EIO;\n return -1;\n }\n if (step < 0) {\n call->result = -1;\n call->error = step_error(step);\n errno = call->error;\n return -1;\n }\n received = (size_t)step < count ? (size_t)step : count;\n for (index = 0; index < received; ++index) {\n bytes[index] = (unsigned char)((port->seed + 17 * port->cursor) & 255);\n port->cursor += 1;\n }\n call->result = (ssize_t)received;\n call->count = received;\n memcpy(call->bytes, bytes, received);\n return call->result;\n}\nstatic int shutdown_write(void *context)\n{\n adapter *port = context;\n adapter_call *call = new_call(port, 3, 0, 0);\n if (!call) {\n errno = EIO;\n return -1;\n }\n if (port->shutdown_error != 0) {\n errno = port->shutdown_error;\n call->error = errno;\n call->result = -1;\n return -1;\n }\n return 0;\n}\nvoid adapter_init(adapter *port, unsigned seed)\n{\n memset(port, 0, sizeof *port);\n port->seed = seed;\n}\nstream_port adapter_port(adapter *port)\n{\n stream_port result;\n result.context = port;\n result.send_bytes = send_bytes;\n result.recv_bytes = recv_bytes;\n result.shutdown_write = shutdown_write;\n return result;\n}\nint adapter_load(adapter *port, int receive, const int *steps, size_t count)\n{\n size_t index;\n if (count > ADAPTER_STEPS) {\n return STREAM_INVALID;\n }\n for (index = 0; index < count; ++index) {\n if (steps[index] < -4 || steps[index] > STREAM_CAPACITY) {\n return STREAM_INVALID;\n }\n }\n if (receive) {\n memcpy(port->receives, steps, count * sizeof *steps);\n port->recv_count = count;\n port->recv_next = 0;\n } else {\n memcpy(port->sends, steps, count * sizeof *steps);\n port->send_count = count;\n port->send_next = 0;\n }\n return STREAM_OK;\n}\nvoid adapter_observation_reset(adapter *port)\n{\n port->call_count = 0;\n}\nstatic void print_hex(const unsigned char *bytes, size_t count)\n{\n size_t index;\n putchar('\"');\n for (index = 0; index < count; ++index) {\n printf(\"%02x\", bytes[index]);\n }\n putchar('\"');\n}\nvoid adapter_print(const adapter *port)\n{\n size_t index;\n printf(\"{\\\"next\\\":[%zu,%zu],\\\"cursor\\\":%llu,\\\"calls\\\":[\",\n port->send_next, port->recv_next, (unsigned long long)port->cursor);\n for (index = 0; index < port->call_count; ++index) {\n const adapter_call *call = &port->calls[index];\n if (index != 0) {\n putchar(',');\n }\n printf(\"[%d,%zu,%d,%zd,%d,\", call->kind, call->requested,\n call->flags, call->result, call->error);\n print_hex(call->bytes, call->count);\n putchar(']');\n }\n printf(\"]}\");\n}\n", "console.c": "#include \"stream.h\"\n#include \"adapter.h\"\n#include \n#include \n#include \n#include \n#define CHANNELS 3\n#define LINE_CAPACITY 8192\nstatic stream channels[CHANNELS];\nstatic adapter ports[CHANNELS];\nstatic int parse_number(const char *text, long *out)\n{\n unsigned long value = 0;\n unsigned long limit = 1000000;\n int negative = 0;\n if (*text == '-' || *text == '+') {\n negative = *text == '-';\n text += 1;\n }\n if (*text == '\\0') {\n return 0;\n }\n while (*text != '\\0') {\n unsigned digit;\n if (*text < '0' || *text > '9') {\n return 0;\n }\n digit = (unsigned)(*text - '0');\n if (value > (limit - digit) / 10) {\n return 0;\n }\n value = value * 10 + digit;\n text += 1;\n }\n *out = negative ? -(long)value : (long)value;\n return 1;\n}\nstatic int hex_digit(char c)\n{\n if (c >= '0' && c <= '9') return c - '0';\n if (c >= 'a' && c <= 'f') return c - 'a' + 10;\n if (c >= 'A' && c <= 'F') return c - 'A' + 10;\n return -1;\n}\nstatic int parse_bytes(const char *text, unsigned char *bytes, size_t *count)\n{\n size_t length;\n size_t index;\n *count = 0;\n if (strcmp(text, \"-\") == 0) {\n return 1;\n }\n length = strlen(text);\n if (length % 2 != 0 || length > 2 * (STREAM_CAPACITY + 1)) {\n return 0;\n }\n for (index = 0; index < length; index += 2) {\n int high = hex_digit(text[index]);\n int low = hex_digit(text[index + 1]);\n if (high < 0 || low < 0) {\n return 0;\n }\n bytes[(*count)++] = (unsigned char)(high * 16 + low);\n }\n return 1;\n}\nstatic void print_hex(const unsigned char *bytes, size_t count)\n{\n size_t index;\n putchar('\"');\n for (index = 0; index < count; ++index) {\n printf(\"%02x\", bytes[index]);\n }\n putchar('\"');\n}\nstatic void print_stream(const stream *value)\n{\n unsigned char bytes[STREAM_CAPACITY];\n size_t count;\n printf(\"{\\\"state\\\":[%u,%d,%d,%d,%d,%llu,%llu,%llu],\\\"tx\\\":\",\n value->generation, value->opened, value->read_end, value->write_end,\n value->last_error, (unsigned long long)value->accepted,\n (unsigned long long)value->received, (unsigned long long)value->delivered);\n count = ring_copy(&value->outgoing, bytes, STREAM_CAPACITY);\n print_hex(bytes, count);\n printf(\",\\\"rx\\\":\");\n count = ring_copy(&value->incoming, bytes, STREAM_CAPACITY);\n print_hex(bytes, count);\n putchar('}');\n}\nstatic int split(char *line, char **tokens, int capacity)\n{\n char *next = line;\n int count = 0;\n while (*next != '\\0') {\n while (*next == ' ' || *next == '\\t') next += 1;\n if (*next == '\\0') break;\n if (count == capacity) return -1;\n tokens[count++] = next;\n while (*next != '\\0' && *next != ' ' && *next != '\\t') next += 1;\n if (*next != '\\0') *next++ = '\\0';\n }\n return count;\n}\nstatic int dispatch(char **tokens, int count, unsigned char *out, size_t *progress)\n{\n long channel;\n long value;\n int operation;\n stream *selected;\n unsigned char bytes[STREAM_CAPACITY + 1];\n size_t size;\n if (count < 2 || strlen(tokens[0]) != 1 || !parse_number(tokens[1], &channel)) {\n return STREAM_INVALID;\n }\n if (channel < 0 || channel >= CHANNELS) return STREAM_INVALID;\n selected = &channels[channel];\n operation = tokens[0][0];\n if ((operation == 'O' || operation == 'C' || operation == 'F') && count == 2) {\n if (operation == 'O') return stream_open(selected);\n if (operation == 'C') return stream_close(selected);\n return stream_finish(selected);\n }\n if (operation == 'Q' && count == 3) {\n if (!parse_bytes(tokens[2], bytes, &size)) return STREAM_INVALID;\n return stream_queue(selected, bytes, size);\n }\n if ((operation == 'T' || operation == 'R' || operation == 'D' || operation == 'H') && count == 3) {\n if (!parse_number(tokens[2], &value) || value < 0) return STREAM_INVALID;\n if (operation == 'T' || operation == 'R' || operation == 'D') *progress = 777;\n if (operation == 'T') return stream_transmit(selected, (size_t)value, progress);\n if (operation == 'R') return stream_receive(selected, (size_t)value, progress);\n if (operation == 'D') return stream_take(selected, out, (size_t)value, progress);\n if (value != 0 && value != EIO && value != EAGAIN) return STREAM_INVALID;\n ports[channel].shutdown_error = (int)value;\n return STREAM_OK;\n }\n if ((operation == 'S' || operation == 'V') && count >= 2 && count <= ADAPTER_STEPS + 2) {\n int steps[ADAPTER_STEPS];\n int index;\n for (index = 2; index < count; ++index) {\n if (!parse_number(tokens[index], &value) || value < -4 || value > STREAM_CAPACITY) {\n return STREAM_INVALID;\n }\n steps[index - 2] = (int)value;\n }\n return adapter_load(&ports[channel], operation == 'V', steps, (size_t)(count - 2));\n }\n return STREAM_INVALID;\n}\nstatic int read_line(char *line, int *invalid)\n{\n size_t length = 0;\n int c;\n int seen = 0;\n *invalid = 0;\n while ((c = getchar()) != EOF && c != '\\n') {\n seen = 1;\n if (c == 0) *invalid = 1;\n if (length < LINE_CAPACITY) line[length++] = (char)c;\n else *invalid = 1;\n }\n line[length] = '\\0';\n return seen || c == '\\n';\n}\nint main(void)\n{\n char line[LINE_CAPACITY + 2];\n char *tokens[ADAPTER_STEPS + 4];\n int index;\n int invalid;\n for (index = 0; index < CHANNELS; ++index) {\n adapter_init(&ports[index], (unsigned)(31 + 71 * index));\n memset(&channels[index], 0xa5, sizeof channels[index]);\n stream_init(&channels[index], adapter_port(&ports[index]));\n }\n while (read_line(line, &invalid)) {\n size_t progress = 0;\n unsigned char out[STREAM_CAPACITY];\n int rc;\n int count;\n for (index = 0; index < CHANNELS; ++index) adapter_observation_reset(&ports[index]);\n count = split(line, tokens, ADAPTER_STEPS + 4);\n rc = invalid || count < 0 ? STREAM_INVALID : dispatch(tokens, count, out, &progress);\n printf(\"{\\\"rc\\\":%d,\\\"n\\\":%zu,\\\"out\\\":\", rc, progress);\n if (count > 0 && strcmp(tokens[0], \"D\") == 0) print_hex(out, progress);\n else print_hex(out, 0);\n printf(\",\\\"channels\\\":[\");\n for (index = 0; index < CHANNELS; ++index) {\n if (index != 0) putchar(',');\n print_stream(&channels[index]);\n }\n printf(\"],\\\"ports\\\":[\");\n for (index = 0; index < CHANNELS; ++index) {\n if (index != 0) putchar(',');\n adapter_print(&ports[index]);\n }\n printf(\"]}\\n\");\n }\n return ferror(stdin) ? 1 : 0;\n}\n", "Makefile": "CC = cc\nCFLAGS = -std=c11 -O2 -Wall -Wextra -Werror\nOBJECTS = console.o adapter.o state.o transmit.o receive.o\nall: socket-console\nsocket-console: $(OBJECTS)\n\t$(CC) $(CFLAGS) $(OBJECTS) -o $@\n$(OBJECTS): stream.h\nconsole.o adapter.o: adapter.h\nclean:\n\trm -f $(OBJECTS) socket-console\n.PHONY: all clean\n" }, "candidates": [ "stream.h", "state.c", "transmit.c", "receive.c" ] }