void show_textfile(const char *file_name)
{
char *buf;
unsigned int file_size;
unsigned int line_count;
unsigned int i;
const char **lines;
const char *start_line;
buf = read_file(file_name, &file_size);
if (!buf)
return;
line_count = 0;
for (i = 0; i < file_size; ++i)
line_count += buf[i] == '\n';
lines = ccalloc(line_count, sizeof *lines);
line_count = 0;
start_line = buf;
for (i = 0; i < file_size; ++i) {
if (buf[i] == '\n') {
lines[line_count++] = start_line;
buf[i] = '\0';
start_line = &buf[i + 1];
}
if (buf[i] == '\t')
buf[i] = ' ';
}
create_text_box(lines, line_count, file_name, attr_textbox);
free(lines);
free(buf);
}
struct board *create_buffer_board(int width, int height)
{
// Create a dummy board to be used as a buffer for undo block actions
struct board *src_board = ccalloc(1, sizeof(struct board));
int layer_size = width * height;
src_board->board_width = width;
src_board->board_height = height;
src_board->robot_list = ccalloc(1, sizeof(struct robot *));
src_board->scroll_list = ccalloc(1, sizeof(struct scroll *));
src_board->sensor_list = ccalloc(1, sizeof(struct sensor *));
src_board->level_id = ccalloc(1, layer_size);
src_board->level_color = ccalloc(1, layer_size);
src_board->level_param = ccalloc(1, layer_size);
src_board->level_under_id = ccalloc(1, layer_size);
src_board->level_under_color = ccalloc(1, layer_size);
src_board->level_under_param = ccalloc(1, layer_size);
return src_board;
}
static char *dup_current_name(void)
{
int rows, cols, max, i;
char *s;
if (form_driver(form, REQ_VALIDATION) == E_OK) {
dynamic_field_info(fields[1], &rows, &cols, &max);
s = ccalloc(1, cols + 1);
memcpy(s, field_buffer(fields[1], 0), cols);
for (i = strlen(s) - 1; i >= 0 && s[i] == ' '; --i)
s[i] = '\0';
return s;
} else {
return cstrdup("");
}
}
static void delete_hook(const char *file)
{
struct manifest_entry *new_entry;
struct SHA256_ctx ctx;
bool ret;
FILE *f;
new_entry = ccalloc(1, sizeof(struct manifest_entry));
if(!new_entry)
goto err_out;
if(delete_p)
{
delete_p->next = new_entry;
delete_p = delete_p->next;
}
else
delete_list = delete_p = new_entry;
delete_p->name = cmalloc(strlen(file) + 1);
if(!delete_p->name)
goto err_delete_p;
strcpy(delete_p->name, file);
f = fopen_unsafe(file, "rb");
if(!f)
goto err_delete_p_name;
delete_p->size = (unsigned long)ftell_and_rewind(f);
ret = manifest_compute_sha256(&ctx, f, delete_p->size);
fclose(f);
if(!ret)
goto err_delete_p_name;
memcpy(delete_p->sha256, ctx.H, sizeof(Uint32) * 8);
return;
err_delete_p_name:
free(delete_p->name);
err_delete_p:
free(delete_p);
delete_p = NULL;
err_out:
return;
}
static void create_text_box(const char *const *lines, unsigned int count,
const char *title_, int attrs)
{
unsigned int i;
text_lines = ccalloc(count, sizeof *text_lines);
for (i = 0; i < count; ++i)
text_lines[i] = cstrdup(lines[i]);
text_lines_count = count;
max_line_width = get_max_mbs_width(lines, count);
title = cstrdup(title_);
widget_attrs = attrs;
current_top = 0;
current_left = 0;
create();
}
struct host *host_accept(struct host *s)
{
struct sockaddr *addr;
struct host *c = NULL;
socklen_t addrlen;
int newfd;
switch(s->af)
{
#ifdef CONFIG_IPV6
case AF_INET6:
addrlen = sizeof(struct sockaddr_in6);
break;
#endif
default:
addrlen = sizeof(struct sockaddr_in);
break;
}
addr = cmalloc(addrlen);
newfd = platform_accept(s->fd, addr, &addrlen);
if(newfd >= 0)
{
assert(addr->sa_family == s->af);
platform_socket_blocking(newfd, true);
c = ccalloc(1, sizeof(struct host));
c->af = addr->sa_family;
c->proto = s->proto;
c->name = NULL;
c->fd = newfd;
}
else
{
if(platform_last_error_fatal())
platform_perror("accept");
}
free(addr);
return c;
}
int VariantFindFreePositionInFrame(DataStructure *dataStructure, VariantFrame *frame, int signalIndex,
int startPosition) {
int i, j, freeBytesInSequence, bestFoundOffset, last, currentFreeOffset;
if ((frame->node != dataStructure->signalNodeIDs[signalIndex]) && (frame->node != -1))
return -1;
char *messagePositions = (char *) ccalloc(dataStructure->slotLength, sizeof(char));
for (i = 0; i < (int) frame->signals.size(); i++) // For each signal in frame
{
for (j = dataStructure->signalInFrameOffsets[frame->signals[i]];
j < dataStructure->signalInFrameOffsets[frame->signals[i]] +
dataStructure->signalLengths[frame->signals[i]]; j++) {
messagePositions[j] = 1;
}
}
bestFoundOffset = -1;
freeBytesInSequence = 0;
last = 1;
currentFreeOffset = 0;
for (i = startPosition; i < dataStructure->slotLength; i++) {
if (messagePositions[i] == 1) {
if (freeBytesInSequence >= dataStructure->signalLengths[signalIndex]) {
bestFoundOffset = currentFreeOffset;
break;
}
freeBytesInSequence = 0;
last = 1;
}
else {
if (last == 1)
currentFreeOffset = i;
freeBytesInSequence++;
last = 0;
}
}
if (freeBytesInSequence >= dataStructure->signalLengths[signalIndex] && bestFoundOffset == -1) {
bestFoundOffset = currentFreeOffset;
}
ffree(messagePositions);
return bestFoundOffset;
}
static void create_blank_board(struct board *cur_board)
{
int size = 2000;
cur_board->overlay_mode = 0;
cur_board->board_width = 80;
cur_board->board_height = 25;
cur_board->level_id = ccalloc(1, size);
cur_board->level_color = ccalloc(1, size);
cur_board->level_param = ccalloc(1, size);
cur_board->level_under_id = ccalloc(1, size);
cur_board->level_under_color = ccalloc(1, size);
cur_board->level_under_param = ccalloc(1, size);
strcpy(cur_board->mod_playing, "");
cur_board->viewport_x = 0;
cur_board->viewport_y = 0;
cur_board->viewport_width = 80;
cur_board->viewport_height = 25;
cur_board->can_shoot = 0;
cur_board->can_bomb = 0;
cur_board->fire_burn_brown = 0;
cur_board->fire_burn_space = 0;
cur_board->fire_burn_fakes = 0;
cur_board->fire_burn_trees = 0;
cur_board->explosions_leave = 0;
cur_board->save_mode = 1;
cur_board->forest_becomes = 0;
cur_board->collect_bombs = 0;
cur_board->fire_burns = 0;
cur_board->board_dir[0] = 0;
cur_board->board_dir[1] = 0;
cur_board->board_dir[2] = 0;
cur_board->board_dir[3] = 0;
cur_board->restart_if_zapped = 0;
cur_board->time_limit = 0;
cur_board->last_key = 0;
cur_board->num_input = 0;
cur_board->input_size = 0;
strcpy(cur_board->input_string, "");
cur_board->player_last_dir = 0;
strcpy(cur_board->bottom_mesg, "");
cur_board->b_mesg_timer = 0;
cur_board->lazwall_start = 0;
cur_board->b_mesg_row = 24;
cur_board->b_mesg_col = -1;
cur_board->scroll_x = 0;
cur_board->scroll_y = 0;
cur_board->locked_x = 0;
cur_board->locked_y = 0;
cur_board->player_ns_locked = 0;
cur_board->player_ew_locked = 0;
cur_board->player_attack_locked = 0;
cur_board->volume = 0;
cur_board->volume_inc = 0;
cur_board->volume_target = 0;
cur_board->num_robots = 0;
cur_board->num_robots_active = 0;
cur_board->num_robots_allocated = 0;
cur_board->robot_list = ccalloc(1, sizeof(struct robot *));
cur_board->robot_list_name_sorted = ccalloc(1, sizeof(struct robot *));
cur_board->num_scrolls = 0;
cur_board->num_scrolls_allocated = 0;
cur_board->scroll_list = ccalloc(1, sizeof(struct scroll *));
cur_board->num_sensors = 0;
cur_board->num_sensors_allocated = 0;
cur_board->sensor_list = ccalloc(1, sizeof(struct sensor *));
}
__editor_maybe_static int load_board_direct(struct board *cur_board,
FILE *fp, int data_size, int savegame, int version)
{
int num_robots, num_scrolls, num_sensors, num_robots_active;
int overlay_mode, size, board_width, board_height, i;
int viewport_x, viewport_y, viewport_width, viewport_height;
int truncated = 0;
struct robot *cur_robot;
struct scroll *cur_scroll;
struct sensor *cur_sensor;
char *test_buffer;
int board_location = ftell(fp);
cur_board->num_robots = 0;
cur_board->num_robots_allocated = 0;
cur_board->num_robots_active = 0;
cur_board->num_scrolls = 0;
cur_board->num_scrolls_allocated = 0;
cur_board->num_sensors = 0;
cur_board->num_sensors_allocated = 0;
cur_board->robot_list = NULL;
cur_board->robot_list_name_sorted = NULL;
cur_board->sensor_list = NULL;
cur_board->scroll_list = NULL;
// Initialize some fields that may no longer be loaded
// from the board file itself..
cur_board->last_key = '?';
cur_board->num_input = 0;
cur_board->input_size = 0;
cur_board->input_string[0] = 0;
cur_board->player_last_dir = 0x10;
cur_board->bottom_mesg[0] = 0;
cur_board->b_mesg_timer = 0;
cur_board->lazwall_start = 7;
cur_board->b_mesg_row = 24;
cur_board->b_mesg_col = -1;
cur_board->scroll_x = 0;
cur_board->scroll_y = 0;
cur_board->locked_x = -1;
cur_board->locked_y = -1;
cur_board->volume = 255;
cur_board->volume_inc = 0;
cur_board->volume_target = 255;
// board_mode, unused
if(fgetc(fp) == EOF)
{
val_error(WORLD_BOARD_MISSING, board_location);
return VAL_MISSING;
}
overlay_mode = fgetc(fp);
if(!overlay_mode)
{
int overlay_width;
int overlay_height;
overlay_mode = fgetc(fp);
overlay_width = fgetw(fp);
overlay_height = fgetw(fp);
size = overlay_width * overlay_height;
if((size < 1) || (size > MAX_BOARD_SIZE))
goto err_invalid;
cur_board->overlay = cmalloc(size);
cur_board->overlay_color = cmalloc(size);
if(load_RLE2_plane(cur_board->overlay, fp, size))
goto err_freeoverlay;
test_buffer = cmalloc(1024);
free(test_buffer);
// Skip sizes
if(fseek(fp, 4, SEEK_CUR) ||
load_RLE2_plane(cur_board->overlay_color, fp, size))
goto err_freeoverlay;
test_buffer = cmalloc(1024);
free(test_buffer);
}
else
{
overlay_mode = 0;
// Undo that last get
fseek(fp, -1, SEEK_CUR);
}
cur_board->overlay_mode = overlay_mode;
board_width = fgetw(fp);
board_height = fgetw(fp);
cur_board->board_width = board_width;
cur_board->board_height = board_height;
size = board_width * board_height;
if((size < 1) || (size > MAX_BOARD_SIZE))
goto err_freeoverlay;
cur_board->level_id = cmalloc(size);
cur_board->level_color = cmalloc(size);
cur_board->level_param = cmalloc(size);
cur_board->level_under_id = cmalloc(size);
cur_board->level_under_color = cmalloc(size);
cur_board->level_under_param = cmalloc(size);
if(load_RLE2_plane(cur_board->level_id, fp, size))
goto err_freeboard;
if(fseek(fp, 4, SEEK_CUR) ||
load_RLE2_plane(cur_board->level_color, fp, size))
goto err_freeboard;
if(fseek(fp, 4, SEEK_CUR) ||
load_RLE2_plane(cur_board->level_param, fp, size))
goto err_freeboard;
if(fseek(fp, 4, SEEK_CUR) ||
load_RLE2_plane(cur_board->level_under_id, fp, size))
goto err_freeboard;
if(fseek(fp, 4, SEEK_CUR) ||
load_RLE2_plane(cur_board->level_under_color, fp, size))
goto err_freeboard;
if(fseek(fp, 4, SEEK_CUR) ||
load_RLE2_plane(cur_board->level_under_param, fp, size))
goto err_freeboard;
// Load board parameters
if(version < 0x0253)
{
fread(cur_board->mod_playing, LEGACY_MOD_FILENAME_MAX, 1, fp);
cur_board->mod_playing[LEGACY_MOD_FILENAME_MAX] = 0;
}
else
{
size_t len = fgetw(fp);
if(len >= MAX_PATH)
len = MAX_PATH - 1;
fread(cur_board->mod_playing, len, 1, fp);
cur_board->mod_playing[len] = 0;
}
viewport_x = fgetc(fp);
viewport_y = fgetc(fp);
viewport_width = fgetc(fp);
viewport_height = fgetc(fp);
if(
(viewport_x < 0) || (viewport_x > 79) ||
(viewport_y < 0) || (viewport_y > 24) ||
(viewport_width < 1) || (viewport_width > 80) ||
(viewport_height < 1) || (viewport_height > 25))
goto err_invalid;
cur_board->viewport_x = viewport_x;
cur_board->viewport_y = viewport_y;
cur_board->viewport_width = viewport_width;
cur_board->viewport_height = viewport_height;
cur_board->can_shoot = fgetc(fp);
cur_board->can_bomb = fgetc(fp);
cur_board->fire_burn_brown = fgetc(fp);
cur_board->fire_burn_space = fgetc(fp);
cur_board->fire_burn_fakes = fgetc(fp);
cur_board->fire_burn_trees = fgetc(fp);
cur_board->explosions_leave = fgetc(fp);
cur_board->save_mode = fgetc(fp);
cur_board->forest_becomes = fgetc(fp);
cur_board->collect_bombs = fgetc(fp);
cur_board->fire_burns = fgetc(fp);
for(i = 0; i < 4; i++)
{
cur_board->board_dir[i] = fgetc(fp);
}
cur_board->restart_if_zapped = fgetc(fp);
cur_board->time_limit = fgetw(fp);
if(version < 0x0253)
{
cur_board->last_key = fgetc(fp);
cur_board->num_input = fgetw(fp);
cur_board->input_size = fgetc(fp);
fread(cur_board->input_string, LEGACY_INPUT_STRING_MAX + 1, 1, fp);
cur_board->input_string[LEGACY_INPUT_STRING_MAX] = 0;
cur_board->player_last_dir = fgetc(fp);
fread(cur_board->bottom_mesg, LEGACY_BOTTOM_MESG_MAX + 1, 1, fp);
cur_board->bottom_mesg[LEGACY_BOTTOM_MESG_MAX] = 0;
cur_board->b_mesg_timer = fgetc(fp);
cur_board->lazwall_start = fgetc(fp);
cur_board->b_mesg_row = fgetc(fp);
cur_board->b_mesg_col = (signed char)fgetc(fp);
cur_board->scroll_x = (signed short)fgetw(fp);
cur_board->scroll_y = (signed short)fgetw(fp);
cur_board->locked_x = (signed short)fgetw(fp);
cur_board->locked_y = (signed short)fgetw(fp);
}
else if(savegame)
{
size_t len;
cur_board->last_key = fgetc(fp);
cur_board->num_input = fgetw(fp);
cur_board->input_size = fgetw(fp);
len = fgetw(fp);
if(len >= ROBOT_MAX_TR)
len = ROBOT_MAX_TR - 1;
fread(cur_board->input_string, len, 1, fp);
cur_board->input_string[len] = 0;
cur_board->player_last_dir = fgetc(fp);
len = fgetw(fp);
if(len >= ROBOT_MAX_TR)
len = ROBOT_MAX_TR - 1;
fread(cur_board->bottom_mesg, len, 1, fp);
cur_board->bottom_mesg[len] = 0;
cur_board->b_mesg_timer = fgetc(fp);
cur_board->lazwall_start = fgetc(fp);
cur_board->b_mesg_row = fgetc(fp);
cur_board->b_mesg_col = (signed char)fgetc(fp);
cur_board->scroll_x = (signed short)fgetw(fp);
cur_board->scroll_y = (signed short)fgetw(fp);
cur_board->locked_x = (signed short)fgetw(fp);
cur_board->locked_y = (signed short)fgetw(fp);
}
cur_board->player_ns_locked = fgetc(fp);
cur_board->player_ew_locked = fgetc(fp);
cur_board->player_attack_locked = fgetc(fp);
if(version < 0x0253 || savegame)
{
cur_board->volume = fgetc(fp);
cur_board->volume_inc = fgetc(fp);
cur_board->volume_target = fgetc(fp);
}
/***************/
/* Load robots */
/***************/
num_robots = fgetc(fp);
num_robots_active = 0;
if(num_robots == EOF)
truncated = 1;
// EOF/crazy value check
if((num_robots < 0) || (num_robots > 255) || (num_robots > size))
goto board_scan;
cur_board->robot_list = ccalloc(num_robots + 1, sizeof(struct robot *));
// Also allocate for name sorted list
cur_board->robot_list_name_sorted =
ccalloc(num_robots, sizeof(struct robot *));
// Any null objects being placed will later be optimized out
if(num_robots)
{
for(i = 1; i <= num_robots; i++)
{
// Make sure there's robots to load here
int length_check = fgetw(fp);
fseek(fp, -2, SEEK_CUR);
if(length_check < 0)
{
// Send off the error and then tell validation to shut up for now
val_error(WORLD_ROBOT_MISSING, ftell(fp));
set_validation_suppression(1);
truncated = 1;
}
cur_robot = load_robot_allocate(fp, savegame, version);
if(cur_robot->used)
{
cur_board->robot_list[i] = cur_robot;
cur_board->robot_list_name_sorted[num_robots_active] = cur_robot;
num_robots_active++;
}
else
{
// We don't need no null robot
clear_robot(cur_robot);
cur_board->robot_list[i] = NULL;
}
}
}
set_validation_suppression(-1);
if(num_robots_active > 0)
{
if(num_robots_active != num_robots)
{
cur_board->robot_list_name_sorted =
crealloc(cur_board->robot_list_name_sorted,
sizeof(struct robot *) * num_robots_active);
}
qsort(cur_board->robot_list_name_sorted, num_robots_active,
sizeof(struct robot *), cmp_robots);
}
else
{
free(cur_board->robot_list_name_sorted);
cur_board->robot_list_name_sorted = NULL;
}
cur_board->num_robots = num_robots;
cur_board->num_robots_allocated = num_robots;
cur_board->num_robots_active = num_robots_active;
/****************/
/* Load scrolls */
/****************/
num_scrolls = fgetc(fp);
if(num_scrolls == EOF)
truncated = 1;
if((num_scrolls < 0) || (num_scrolls > 255) || (num_robots + num_scrolls > size))
goto board_scan;
cur_board->scroll_list = ccalloc(num_scrolls + 1, sizeof(struct scroll *));
if(num_scrolls)
{
for(i = 1; i <= num_scrolls; i++)
{
cur_scroll = load_scroll_allocate(fp);
if(cur_scroll->used)
cur_board->scroll_list[i] = cur_scroll;
else
clear_scroll(cur_scroll);
}
}
cur_board->num_scrolls = num_scrolls;
cur_board->num_scrolls_allocated = num_scrolls;
/****************/
/* Load sensors */
/****************/
num_sensors = fgetc(fp);
if(num_sensors == EOF)
truncated = 1;
if((num_sensors < 0) || (num_sensors > 255) ||
(num_scrolls + num_sensors + num_robots > size))
goto board_scan;
cur_board->sensor_list = ccalloc(num_sensors + 1, sizeof(struct sensor *));
if(num_sensors)
{
for(i = 1; i <= num_sensors; i++)
{
cur_sensor = load_sensor_allocate(fp);
if(cur_sensor->used)
cur_board->sensor_list[i] = cur_sensor;
else
clear_sensor(cur_sensor);
}
}
cur_board->num_sensors = num_sensors;
cur_board->num_sensors_allocated = num_sensors;
board_scan:
// Now do a board scan to make sure there aren't more than the data told us.
{
int robot_count = 0, scroll_count = 0, sensor_count = 0;
char err_mesg[80] = { 0 };
for(i = 0; i < (board_width * board_height); i++)
{
if(cur_board->level_id[i] > 127)
cur_board->level_id[i] = CUSTOM_BLOCK;
if(cur_board->level_under_id[i] > 127)
cur_board->level_under_id[i] = CUSTOM_FLOOR;
switch(cur_board->level_id[i])
{
case ROBOT:
case ROBOT_PUSHABLE:
{
robot_count++;
if(robot_count > cur_board->num_robots)
{
cur_board->level_id[i] = CUSTOM_BLOCK;
cur_board->level_param[i] = 'R';
cur_board->level_color[i] = 0xCF;
}
break;
}
case SIGN:
case SCROLL:
{
scroll_count++;
if(scroll_count > cur_board->num_scrolls)
{
cur_board->level_id[i] = CUSTOM_BLOCK;
cur_board->level_param[i] = 'S';
cur_board->level_color[i] = 0xCF;
}
}
case SENSOR:
{
// Wait, I forgot. Nobody cares about sensors.
//sensor_count++;
if(sensor_count > cur_board->num_sensors)
{
cur_board->level_id[i] = CUSTOM_FLOOR;
cur_board->level_param[i] = 'S';
cur_board->level_color[i] = 0xDF;
}
}
}
}
if(robot_count > cur_board->num_robots)
{
snprintf(err_mesg, 80, "Board @ %Xh: found %i robots; expected %i",
board_location, robot_count, cur_board->num_robots);
error(err_mesg, 1, 8, 0);
}
if(scroll_count > cur_board->num_scrolls)
{
snprintf(err_mesg, 80, "Board @ %Xh: found %i scrolls/signs; expected %i",
board_location, scroll_count, cur_board->num_scrolls);
error(err_mesg, 1, 8, 0);
}
// This won't be reached but I'll leave it anyway.
if(sensor_count > cur_board->num_sensors)
{
snprintf(err_mesg, 80, "Board @ %Xh: found %i sensors; expected %i",
board_location, sensor_count, cur_board->num_sensors);
error(err_mesg, 1, 8, 0);
}
if(err_mesg[0])
error("Any extra robots/scrolls/signs were replaced", 1, 8, 0);
}
if(truncated == 1)
val_error(WORLD_BOARD_TRUNCATED_SAFE, board_location);
return VAL_SUCCESS;
err_freeboard:
free(cur_board->level_id);
free(cur_board->level_color);
free(cur_board->level_param);
free(cur_board->level_under_id);
free(cur_board->level_under_color);
free(cur_board->level_under_param);
err_freeoverlay:
if(overlay_mode)
{
free(cur_board->overlay);
free(cur_board->overlay_color);
}
err_invalid:
val_error(WORLD_BOARD_CORRUPT, board_location);
return VAL_INVALID;
}
struct host *host_create(enum host_type type, enum host_family fam)
{
struct linger linger = { 1, 30 };
const uint32_t on = 1;
int err, fd, af, proto;
struct host *h;
switch(fam)
{
#ifdef CONFIG_IPV6
case HOST_FAMILY_IPV6:
af = AF_INET6;
break;
#endif
default:
af = AF_INET;
break;
}
switch(type)
{
case HOST_TYPE_UDP:
fd = platform_socket(af, SOCK_DGRAM, IPPROTO_UDP);
proto = IPPROTO_UDP;
break;
default:
fd = platform_socket(af, SOCK_STREAM, IPPROTO_TCP);
proto = IPPROTO_TCP;
break;
}
if(fd < 0)
{
platform_perror("socket");
return NULL;
}
#if defined(CONFIG_IPV6) && defined(IPV6_V6ONLY)
if(af == AF_INET6)
{
const uint32_t off = 0;
err = platform_setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, (void *)&off, 4);
if(err < 0)
{
platform_perror("setsockopt(IPV6_V6ONLY)");
return NULL;
}
}
#endif
/* We need to turn off bind address checking, allowing
* port numbers to be reused; otherwise, TIME_WAIT will
* delay binding to these ports for 2 * MSL seconds.
*/
err = platform_setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, (void *)&on, 4);
if(err < 0)
{
platform_perror("setsockopt(SO_REUSEADDR)");
return NULL;
}
/* When connection is closed, we want to "linger" to
* make sure everything is transmitted. Enable this
* feature here. However, we can only do this on TCP
* sockets, as some platforms (winsock) don't like
* modifying linger on UDP sockets.
*/
if(proto == IPPROTO_TCP)
{
err = platform_setsockopt(fd, SOL_SOCKET, SO_LINGER,
(void *)&linger, sizeof(struct linger));
if(err < 0)
{
platform_perror("setsockopt(SO_LINGER)");
return NULL;
}
}
// Initially the socket is blocking
platform_socket_blocking(fd, true);
// Create our "host" abstraction (latterly augmented)
h = ccalloc(1, sizeof(struct host));
h->proto = proto;
h->af = af;
h->fd = fd;
h->timeout_ms = HOST_TIMEOUT_DEFAULT;
return h;
}
void init_event(void)
{
input.buffer = ccalloc(num_buffered_events, sizeof(struct buffered_status));
input.load_offset = num_buffered_events - 1;
input.store_offset = 0;
}
struct manifest_entry *manifest_list_create(FILE *f)
{
struct manifest_entry *head = NULL, *e = NULL, *next_e;
char buffer[LINE_BUF_LEN];
// Walk the manifest line by line
while(true)
{
char *m = buffer, *line;
size_t line_len;
// Grab a single line from the manifest
if(!fgets(buffer, LINE_BUF_LEN, f))
break;
next_e = ccalloc(1, sizeof(struct manifest_entry));
if(head)
{
e->next = next_e;
e = e->next;
}
else
head = e = next_e;
// Grab the sha256 token
line = strsep(&m, " ");
if(!line)
goto err_invalid_manifest;
/* Break the 64 character (8x8) hex string down into
* eight constituent 32bit SHA result registers (32*8=256).
*/
if(!manifest_parse_sha256(line, e->sha256))
goto err_invalid_manifest;
// Grab the size token
line = strsep(&m, " ");
if(!line)
goto err_invalid_manifest;
// Validate and parse it
if(!manifest_parse_size(line, &e->size))
goto err_invalid_manifest;
// Grab the filename token
line = strsep(&m, "\n");
if(!line)
goto err_invalid_manifest;
line_len = strlen(line);
e->name = cmalloc(line_len + 1);
strncpy(e->name, line, line_len);
e->name[line_len] = 0;
}
if(e)
e->next = NULL;
return head;
err_invalid_manifest:
warn("Malformed manifest file.\n");
manifest_list_free(&head);
return head;
}
__editor_maybe_static void load_board_direct(struct board *cur_board,
FILE *fp, int savegame, int version)
{
int num_robots, num_scrolls, num_sensors, num_robots_active;
int overlay_mode, size, board_width, board_height, i;
struct robot *cur_robot;
struct scroll *cur_scroll;
struct sensor *cur_sensor;
char *test_buffer;
// Initialize some fields that may no longer be loaded
// from the board file itself..
cur_board->last_key = '?';
cur_board->num_input = 0;
cur_board->input_size = 0;
cur_board->input_string[0] = 0;
cur_board->player_last_dir = 0x10;
cur_board->bottom_mesg[0] = 0;
cur_board->b_mesg_timer = 0;
cur_board->lazwall_start = 7;
cur_board->b_mesg_row = 24;
cur_board->b_mesg_col = -1;
cur_board->scroll_x = 0;
cur_board->scroll_y = 0;
cur_board->locked_x = -1;
cur_board->locked_y = -1;
cur_board->volume = 255;
cur_board->volume_inc = 0;
cur_board->volume_target = 255;
// board_mode, unused
fgetc(fp);
overlay_mode = fgetc(fp);
if(!overlay_mode)
{
int overlay_width;
int overlay_height;
overlay_mode = fgetc(fp);
overlay_width = fgetw(fp);
overlay_height = fgetw(fp);
size = overlay_width * overlay_height;
cur_board->overlay = cmalloc(size);
cur_board->overlay_color = cmalloc(size);
load_RLE2_plane(cur_board->overlay, fp, size);
test_buffer = cmalloc(1024);
free(test_buffer);
// Skip sizes
fseek(fp, 4, SEEK_CUR);
load_RLE2_plane(cur_board->overlay_color, fp, size);
test_buffer = cmalloc(1024);
free(test_buffer);
}
else
{
overlay_mode = 0;
// Undo that last get
fseek(fp, -1, SEEK_CUR);
}
cur_board->overlay_mode = overlay_mode;
board_width = fgetw(fp);
board_height = fgetw(fp);
cur_board->board_width = board_width;
cur_board->board_height = board_height;
size = board_width * board_height;
cur_board->level_id = cmalloc(size);
cur_board->level_color = cmalloc(size);
cur_board->level_param = cmalloc(size);
cur_board->level_under_id = cmalloc(size);
cur_board->level_under_color = cmalloc(size);
cur_board->level_under_param = cmalloc(size);
load_RLE2_plane(cur_board->level_id, fp, size);
fseek(fp, 4, SEEK_CUR);
load_RLE2_plane(cur_board->level_color, fp, size);
fseek(fp, 4, SEEK_CUR);
load_RLE2_plane(cur_board->level_param, fp, size);
fseek(fp, 4, SEEK_CUR);
load_RLE2_plane(cur_board->level_under_id, fp, size);
fseek(fp, 4, SEEK_CUR);
load_RLE2_plane(cur_board->level_under_color, fp, size);
fseek(fp, 4, SEEK_CUR);
load_RLE2_plane(cur_board->level_under_param, fp, size);
// Load board parameters
if(version < 0x0253)
{
fread(cur_board->mod_playing, LEGACY_MOD_FILENAME_MAX, 1, fp);
cur_board->mod_playing[LEGACY_MOD_FILENAME_MAX] = 0;
}
else
{
size_t len = fgetw(fp);
if(len >= MAX_PATH)
len = MAX_PATH - 1;
fread(cur_board->mod_playing, len, 1, fp);
cur_board->mod_playing[len] = 0;
}
cur_board->viewport_x = fgetc(fp);
cur_board->viewport_y = fgetc(fp);
cur_board->viewport_width = fgetc(fp);
cur_board->viewport_height = fgetc(fp);
cur_board->can_shoot = fgetc(fp);
cur_board->can_bomb = fgetc(fp);
cur_board->fire_burn_brown = fgetc(fp);
cur_board->fire_burn_space = fgetc(fp);
cur_board->fire_burn_fakes = fgetc(fp);
cur_board->fire_burn_trees = fgetc(fp);
cur_board->explosions_leave = fgetc(fp);
cur_board->save_mode = fgetc(fp);
cur_board->forest_becomes = fgetc(fp);
cur_board->collect_bombs = fgetc(fp);
cur_board->fire_burns = fgetc(fp);
for(i = 0; i < 4; i++)
{
cur_board->board_dir[i] = fgetc(fp);
}
cur_board->restart_if_zapped = fgetc(fp);
cur_board->time_limit = fgetw(fp);
if(version < 0x0253)
{
cur_board->last_key = fgetc(fp);
cur_board->num_input = fgetw(fp);
cur_board->input_size = fgetc(fp);
fread(cur_board->input_string, LEGACY_INPUT_STRING_MAX + 1, 1, fp);
cur_board->input_string[LEGACY_INPUT_STRING_MAX] = 0;
cur_board->player_last_dir = fgetc(fp);
fread(cur_board->bottom_mesg, LEGACY_BOTTOM_MESG_MAX + 1, 1, fp);
cur_board->bottom_mesg[LEGACY_BOTTOM_MESG_MAX] = 0;
cur_board->b_mesg_timer = fgetc(fp);
cur_board->lazwall_start = fgetc(fp);
cur_board->b_mesg_row = fgetc(fp);
cur_board->b_mesg_col = (signed char)fgetc(fp);
cur_board->scroll_x = (signed short)fgetw(fp);
cur_board->scroll_y = (signed short)fgetw(fp);
cur_board->locked_x = (signed short)fgetw(fp);
cur_board->locked_y = (signed short)fgetw(fp);
}
else if(savegame)
{
size_t len;
cur_board->last_key = fgetc(fp);
cur_board->num_input = fgetw(fp);
cur_board->input_size = fgetw(fp);
len = fgetw(fp);
if(len >= ROBOT_MAX_TR)
len = ROBOT_MAX_TR - 1;
fread(cur_board->input_string, len, 1, fp);
cur_board->input_string[len] = 0;
cur_board->player_last_dir = fgetc(fp);
len = fgetw(fp);
if(len >= ROBOT_MAX_TR)
len = ROBOT_MAX_TR - 1;
fread(cur_board->bottom_mesg, len, 1, fp);
cur_board->bottom_mesg[len] = 0;
cur_board->b_mesg_timer = fgetc(fp);
cur_board->lazwall_start = fgetc(fp);
cur_board->b_mesg_row = fgetc(fp);
cur_board->b_mesg_col = (signed char)fgetc(fp);
cur_board->scroll_x = (signed short)fgetw(fp);
cur_board->scroll_y = (signed short)fgetw(fp);
cur_board->locked_x = (signed short)fgetw(fp);
cur_board->locked_y = (signed short)fgetw(fp);
}
cur_board->player_ns_locked = fgetc(fp);
cur_board->player_ew_locked = fgetc(fp);
cur_board->player_attack_locked = fgetc(fp);
if(version < 0x0253 || savegame)
{
cur_board->volume = fgetc(fp);
cur_board->volume_inc = fgetc(fp);
cur_board->volume_target = fgetc(fp);
}
// Load robots
num_robots = fgetc(fp);
num_robots_active = 0;
cur_board->robot_list = ccalloc(num_robots + 1, sizeof(struct robot *));
// Also allocate for name sorted list
cur_board->robot_list_name_sorted =
ccalloc(num_robots, sizeof(struct robot *));
// Any null objects being placed will later be optimized out
if(num_robots)
{
for(i = 1; i <= num_robots; i++)
{
cur_robot = load_robot_allocate(fp, savegame, version);
if(cur_robot->used)
{
cur_board->robot_list[i] = cur_robot;
cur_board->robot_list_name_sorted[num_robots_active] = cur_robot;
num_robots_active++;
}
else
{
// We don't need no null robot
clear_robot(cur_robot);
cur_board->robot_list[i] = NULL;
}
}
}
if(num_robots_active)
{
if(num_robots_active != num_robots)
{
cur_board->robot_list_name_sorted =
crealloc(cur_board->robot_list_name_sorted,
sizeof(struct robot *) * num_robots_active);
}
qsort(cur_board->robot_list_name_sorted, num_robots_active,
sizeof(struct robot *), cmp_robots);
}
else
{
free(cur_board->robot_list_name_sorted);
cur_board->robot_list_name_sorted = NULL;
}
cur_board->num_robots = num_robots;
cur_board->num_robots_allocated = num_robots;
cur_board->num_robots_active = num_robots_active;
// Load scrolls
num_scrolls = fgetc(fp);
cur_board->scroll_list = ccalloc(num_scrolls + 1, sizeof(struct scroll *));
if(num_scrolls)
{
for(i = 1; i <= num_scrolls; i++)
{
cur_scroll = load_scroll_allocate(fp);
if(cur_scroll->used)
cur_board->scroll_list[i] = cur_scroll;
else
clear_scroll(cur_scroll);
}
}
cur_board->num_scrolls = num_scrolls;
cur_board->num_scrolls_allocated = num_scrolls;
// Load sensors
num_sensors = fgetc(fp);
cur_board->sensor_list = ccalloc(num_sensors + 1, sizeof(struct sensor *));
if(num_sensors)
{
for(i = 1; i <= num_sensors; i++)
{
cur_sensor = load_sensor_allocate(fp);
if(cur_sensor->used)
cur_board->sensor_list[i] = cur_sensor;
else
clear_sensor(cur_sensor);
}
}
cur_board->num_sensors = num_sensors;
cur_board->num_sensors_allocated = num_sensors;
}
