static int
lscmd_ls(const lscmd_t *self, const char *path) {
if (isoutofhome(self->config->var_home_path, path)) {
err_error("\"%s\" is out of home", path);
return 1;
}
struct file_dir *dir = file_diropen(path);
if (!dir) {
err_error("failed to open directory \"%s\"", path);
return 2;
}
cstring_array_t *arr = lscmd_dir2arr(self, dir);
if (!arr) {
err_error("failed to read directory \"%s\"", path);
return 3;
}
cstrarr_sort(arr);
lscmd_arrdump(self, arr, stdout);
cstrarr_del(arr);
if (file_dirclose(dir) < 0) {
err_error("failed to close directory \"%s\"", path);
return 4;
}
return 0;
}
int
lscmd_run(lscmd_t *self) {
if (self->opts.ishelp) {
lscmd_usage(self);
return 0;
}
char cd[FILE_NPATH];
if (!file_readline(cd, sizeof cd, self->config->var_cd_path)) {
err_error("failed to read line from cd of variable");
return 1;
}
char home[FILE_NPATH];
if (!file_readline(home, sizeof home, self->config->var_home_path)) {
err_error("failed to read line from home of variable");
return 2;
}
if (optind - self->argc == 0) {
return lscmd_ls(self, cd);
} else {
char path[FILE_NPATH];
for (int i = optind; i < self->argc; ++i) {
const char *arg = self->argv[i];
const char *org = (arg[0] == '/' ? home : cd);
file_solvefmt(path, sizeof path, "%s/%s", org, arg);
lscmd_ls(self, path);
}
}
return 0;
}
/*
* net_socket_recv - wait and receive packet
* returns: error code
* sock(in): socket
* pack(in): packet to send
*/
int
net_socket_recv (NET_SOCKET *sock, unsigned char *buffer, int size, int *read) {
int ret_code = ERR_NONE;
int addr_size = 0;
/* check nulls */
if (sock == NULL || buffer == NULL || read == NULL) {
assert (false);
return err_error (ERR_BAD_POINTER, NULL, __HERE__);
}
/* receive */
*read = recv (*sock, buffer, size, MSG_WAITALL);
if (*read < 0) {
return err_errorf (ERR_SOCKET_RECV_FAIL, "winsock error code: %d", __HERE__,
WSAGetLastError ());
}
/* count'em */
net_socket_recv_bytes += size;
/* all ok */
return ERR_NONE;
}
/*
* net_socket_init_client - initialize a client socket
* returns: error code
* sock(out): the initialized socket
* addr(in): address to send to
* port(in): port number
*/
int
net_socket_init_client (NET_SOCKET *sock, NET_ADDRESS *addr) {
bool ndl = true;
/* nulls check */
if (sock == NULL || addr == NULL) {
return err_error (ERR_BAD_POINTER, NULL, __HERE__);
}
/* initialize */
*sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (*sock == INVALID_SOCKET) {
return err_errorf (ERR_SOCKET_CREATE_FAIL, "winsock error code: %d", __HERE__,
WSAGetLastError ());
}
/* disable nagle */
if (setsockopt (*sock, IPPROTO_TCP, TCP_NODELAY, (const char *) &ndl, sizeof (bool)) != 0) {
return err_errorf (ERR_SOCKET_CREATE_FAIL, "error setting nodelay (wec %d)", __HERE__,
WSAGetLastError ());
}
/* connect */
if (connect (*sock, (SOCKADDR *) addr, sizeof (NET_ADDRESS)) != 0) {
return err_errorf (ERR_SOCKET_CREATE_FAIL, "host %d:%d / winsock error code: %d", __HERE__,
addr->sin_addr.S_un.S_addr, ntohs (addr->sin_port), WSAGetLastError ());
}
/* all ok */
return ERR_NONE;
}
/*
* err_errorf - register an error with format string and varargs
* returns: the error code passed in the first parameter
* code(in): error code
* format(in): format string
* file_name(in): name of file where error appeared
* line(in): line number where error appeared
* args(in): arguments for format
*/
int
err_errorf (int code, const char *format, const char *file_name, int line, ...) {
char err_buffer[1025] = { 0 };
int len = 0;
/* write error to string */
va_list argp;
va_start (argp, line);
len = vsnprintf (err_buffer, 1024, format, argp);
va_end (argp);
/* write string end and call error handling routine */
if (len >= 0 && len <= 1024) {
err_buffer[len] = 0;
return err_error (code, err_buffer, file_name, line);
} else {
return err_error (code, format, file_name, line);
}
}
/*
* out_init - initialize output window
* returns: error code
*/
int
out_init () {
char window_title[100] = "\0";
/* initialzie state mutex */
mutex_init (&state_mutex);
/* initialize sdl video */
if (SDL_Init (SDL_INIT_VIDEO) < 0) {
return err_error (ERR_OUTPUT_SDL_INIT_ERROR, NULL, __HERE__);
}
/* initialize ttf */
if (TTF_Init () < 0) {
return err_error (ERR_OUTPUT_TTF_INIT_ERROR, NULL, __HERE__);
}
/* initialize surface */
out_surface = SDL_SetVideoMode(cfg_window_width, cfg_window_height, OUT_BITS_PER_PIXEL,
SDL_HWSURFACE | SDL_DOUBLEBUF);
if (out_surface == NULL) {
return err_error (ERR_OUTPUT_SURFACE_INIT_ERROR, NULL, __HERE__);
}
/* initialize UI font */
out_font = TTF_OpenFont (OUT_FONT_FILE_NAME, OUT_FONT_SIZE);
if (out_font == NULL) {
return err_errorf (ERR_OUTPUT_FONT_LOAD_ERROR, "file '%s', error was: %s", __HERE__,
OUT_FONT_FILE_NAME, SDL_GetError ());
}
/* set window caption */
snprintf (window_title, 99, "trace-tlk viewer (%d.%d.%d)", VER_MAJOR, VER_MINOR, VER_RELEASE);
SDL_WM_SetCaption (window_title, NULL);
/* initialize virtual camera */
out_reset_camera ();
/* all ok */
return ERR_NONE;
}
/*
* net_socket_init_server - initialize a listener socket
* returns: error code
* sock(out): the initialized and bound socket
* port(in): port to listen to
* maxcon(in): maximum number of connections
*/
int
net_socket_init_server (NET_SOCKET *sock, int port, int maxcon) {
int ret_code = ERR_NONE;
NET_ADDRESS addr;
bool ndl = true;
if (sock == NULL) {
return err_error (ERR_BAD_POINTER, NULL, __HERE__);
}
/* create socket */
*sock = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (*sock == INVALID_SOCKET) {
return err_errorf (ERR_SOCKET_CREATE_FAIL, "winsock error code: %d", __HERE__,
WSAGetLastError ());
}
/* disable nagle */
if (setsockopt (*sock, IPPROTO_TCP, TCP_NODELAY, (const char *) &ndl, sizeof (bool)) != 0) {
return err_errorf (ERR_SOCKET_CREATE_FAIL, "error setting nodelay (wec %d)", __HERE__,
WSAGetLastError ());
}
/* set up address */
addr.sin_addr.s_addr = htonl (INADDR_ANY);
addr.sin_family = AF_INET;
addr.sin_port = htons (port);
/* bind */
ret_code = bind (*sock, (SOCKADDR *) &addr, sizeof (addr));
if (ret_code != 0) {
return err_errorf (ERR_SOCKET_BIND_FAIL, "winsock error code: %d", __HERE__,
WSAGetLastError ());
}
/* accept */
ret_code = listen (*sock, SOMAXCONN);
if (ret_code != 0) {
return err_errorf (ERR_SOCKET_BIND_FAIL, "at LISTEN, winsock error code: %d", __HERE__,
WSAGetLastError ());
}
/* all ok */
return ERR_NONE;
}
/*
* net_socket_accept - accept incoming connection
* returns: error code
* sock(in): socket to listen to
* client(out): accepted client socket
* address(out): address of accepted client
*/
int
net_socket_accept (NET_SOCKET *sock, NET_SOCKET *client, NET_ADDRESS *addr) {
int len = sizeof (NET_ADDRESS);
if (sock == NULL || client == NULL || addr == NULL) {
return err_error (ERR_BAD_POINTER, NULL, __HERE__);
}
/* accept */
*client = accept (*sock, (SOCKADDR *) addr, &len);
if (*client == NULL_SOCKET) {
return err_errorf (ERR_SOCKET_ACCEPT_FAIL, "winsock error code: %d", __HERE__,
WSAGetLastError ());
}
return ERR_NONE;
}
static void read_header(header *hdr)
{
char *buffer = 0;
size_t buflen = 0;
if (getline(&buffer, &buflen, stdin) == -1)
err_error("Failed to read header line");
int offset = 0;
if (sscanf(buffer + offset, "%31s%n", hdr->r_name, &offset) != 1)
err_format("header row name", buffer);
for (int i = 0; i < MAX_VALUES; i++)
{
int extra;
if (sscanf(buffer + offset, "%31s%n", hdr->c_name[i], &extra) != 1)
err_format("header column name", buffer);
assert(extra > 0);
offset += extra;
}
free(buffer);
}
/*
* net_socket_send - send a packet trough a socket
* returns: error code
* sock(in): socket
* addr(in): address
* pack(in): packet to send
*/
int
net_socket_send (NET_SOCKET *sock, unsigned char *buffer, int size) {
int ret_code = ERR_NONE;
/* check nulls */
if (sock == NULL || buffer == NULL) {
assert (false);
return err_error (ERR_BAD_POINTER, NULL, __HERE__);
}
/* send data */
if (send (*sock, buffer, size, 0) < 0) {
return err_errorf (ERR_SOCKET_SEND_FAIL, "winsock error code: %d", __HERE__,
WSAGetLastError ());
}
/* count'em */
net_socket_sent_bytes += size;
/* all ok */
return ERR_NONE;
}
static char *stack_pop(Stack *stack)
{
if (stack->tos == 0)
err_error("Pop on empty stack\n");
return(stack->stack[--stack->tos]);
}
static size_t fixed_tests(char const *range, size_t *counter)
{
size_t fail = 0;
Colour seq_001[] = { WHITE, BLACK, RED };
Colour seq_002[] = { WHITE, WHITE, WHITE };
Colour seq_003[] = { RED, RED, RED };
Colour seq_004[] = { BLACK, BLACK, BLACK };
Colour seq_005[] = { RED, BLACK, WHITE };
Colour seq_006[] = { WHITE, WHITE, RED, RED, BLACK, BLACK, WHITE };
Colour seq_007[] =
{
BLACK, BLACK, WHITE, WHITE, RED, RED, BLACK, BLACK, WHITE,
BLACK, BLACK,
};
Colour seq_008[] = { WHITE, BLACK };
Colour seq_009[] = { BLACK, BLACK, RED, RED, WHITE, WHITE, RED };
Colour seq_010[] = { BLACK, BLACK, RED, WHITE, RED };
Colour seq_011[] =
{
RED, BLACK, RED, WHITE, RED, RED, BLACK, WHITE, RED, BLACK, RED,
BLACK, BLACK, RED, BLACK, WHITE, BLACK, WHITE, WHITE, WHITE,
WHITE, RED, RED, RED, RED, BLACK, WHITE
};
Colour seq_012[] =
{
WHITE, WHITE, RED, WHITE, RED, BLACK, RED, BLACK, WHITE, BLACK,
RED, RED, RED, WHITE, RED, RED, BLACK, BLACK, BLACK, RED, RED,
BLACK, BLACK, WHITE, WHITE, RED, WHITE, BLACK, RED, BLACK,
WHITE, RED, WHITE, WHITE, RED, WHITE, BLACK, RED, RED, RED,
WHITE,
};
Colour seq_013[] = { RED, WHITE, RED, };
Colour seq_014[] = { RED, WHITE, };
Colour seq_015[] = { RED, BLACK, };
Colour seq_016[] = { RED, RED, };
Colour seq_017[] = { BLACK, WHITE, };
Colour seq_018[] = { BLACK, BLACK, };
Colour seq_019[] = { BLACK, RED, };
Colour seq_020[] = { WHITE, WHITE, };
Colour seq_021[] = { WHITE, RED, };
Colour seq_022[] = { RED, WHITE, RED, WHITE, };
Colour seq_023[] =
{
RED, WHITE, RED, WHITE, RED, RED, WHITE, WHITE, WHITE,
};
Test tests[] =
{
{ seq_001, sizeof(seq_001)/sizeof(seq_001[0]) },
{ seq_002, sizeof(seq_002)/sizeof(seq_002[0]) },
{ seq_003, sizeof(seq_003)/sizeof(seq_003[0]) },
{ seq_004, sizeof(seq_004)/sizeof(seq_004[0]) },
{ seq_005, sizeof(seq_005)/sizeof(seq_005[0]) },
{ seq_006, sizeof(seq_006)/sizeof(seq_006[0]) },
{ seq_007, sizeof(seq_007)/sizeof(seq_007[0]) },
{ seq_008, sizeof(seq_008)/sizeof(seq_008[0]) },
{ seq_009, sizeof(seq_009)/sizeof(seq_009[0]) },
{ seq_010, sizeof(seq_010)/sizeof(seq_010[0]) },
{ seq_011, sizeof(seq_011)/sizeof(seq_011[0]) },
{ seq_012, sizeof(seq_012)/sizeof(seq_012[0]) },
{ seq_013, sizeof(seq_013)/sizeof(seq_013[0]) },
{ seq_014, sizeof(seq_014)/sizeof(seq_014[0]) },
{ seq_015, sizeof(seq_015)/sizeof(seq_015[0]) },
{ seq_016, sizeof(seq_016)/sizeof(seq_016[0]) },
{ seq_017, sizeof(seq_017)/sizeof(seq_017[0]) },
{ seq_018, sizeof(seq_018)/sizeof(seq_018[0]) },
{ seq_019, sizeof(seq_019)/sizeof(seq_019[0]) },
{ seq_020, sizeof(seq_020)/sizeof(seq_020[0]) },
{ seq_021, sizeof(seq_021)/sizeof(seq_021[0]) },
{ seq_022, sizeof(seq_022)/sizeof(seq_022[0]) },
{ seq_023, sizeof(seq_023)/sizeof(seq_023[0]) },
};
enum { NUM_TESTS = sizeof(tests) / sizeof(tests[0]) };
*counter = 0;
if (range != 0)
{
const char *ptr = range;
const char *nxt;
long lo;
long hi;
while ((nxt = parse_range(ptr, &lo, &hi)) != 0)
{
if (nxt == ptr)
err_error("invalid range string (%s)\n", range);
if (hi == 0)
hi = NUM_TESTS-1;
for (long i = lo; i <= hi; i++)
{
(*counter)++;
if (test_sequence(tests[i]) == false)
{
printf("Test %ld: Failed\n", i);
fail++;
}
}
ptr = nxt;
}
}
else
{
for (size_t i = 0; i < NUM_TESTS; i++)
{
(*counter)++;
if (test_sequence(tests[i]) == false)
{
printf("Test %ld: Failed\n", i);
fail++;
}
}
}
return fail;
}
static NORETURN void err_reporter(size_t size)
{
DB_TRACKING();
err_error("out of memory allocating %zu bytes\n", size);
}
