static void
display_cache_file(struct display *dp, const char *filename)
/* Does the initial cache of the file. */
{
FILE *fp;
int ret;
dp->filename = filename;
if (filename != NULL)
{
fp = fopen(filename, "rb");
if (fp == NULL)
display_log(dp, USER_ERROR, "open failed: %s", strerror(errno));
}
else
fp = stdin;
ret = buffer_from_file(&dp->original_file, fp);
fclose(fp);
if (ret != 0)
display_log(dp, APP_ERROR, "read failed: %s", strerror(ret));
}
static void
read_png(struct display *dp, struct buffer *bp, const char *operation,
int transforms)
{
png_structp pp;
png_infop ip;
/* This cleans out any previous read and sets operation and transforms to
* empty.
*/
display_clean_read(dp);
if (operation != NULL) /* else this is a verify and do not overwrite info */
{
dp->operation = operation;
dp->transforms = transforms;
}
dp->read_pp = pp = png_create_read_struct(PNG_LIBPNG_VER_STRING, dp,
display_error, display_warning);
if (pp == NULL)
display_log(dp, LIBPNG_ERROR, "failed to create read struct");
/* The png_read_png API requires us to make the info struct, but it does the
* call to png_read_info.
*/
dp->read_ip = ip = png_create_info_struct(pp);
if (ip == NULL)
display_log(dp, LIBPNG_ERROR, "failed to create info struct");
# ifdef PNG_SET_USER_LIMITS_SUPPORTED
/* Remove the user limits, if any */
png_set_user_limits(pp, 0x7fffffff, 0x7fffffff);
# endif
/* Set the IO handling */
buffer_start_read(bp);
png_set_read_fn(pp, bp, read_function);
png_read_png(pp, ip, transforms, NULL/*params*/);
#if 0 /* crazy debugging */
{
png_bytep pr = png_get_rows(pp, ip)[0];
size_t rb = png_get_rowbytes(pp, ip);
size_t cb;
char c = ' ';
fprintf(stderr, "%.4x %2d (%3lu bytes):", transforms, png_get_bit_depth(pp,ip), (unsigned long)rb);
for (cb=0; cb<rb; ++cb)
fputc(c, stderr), fprintf(stderr, "%.2x", pr[cb]), c='.';
fputc('\n', stderr);
}
#endif
}
static void
buffer_read(struct display *dp, struct buffer *bp, png_bytep data,
png_size_t size)
{
struct buffer_list *last = bp->current;
size_t read_count = bp->read_count;
while (size > 0)
{
size_t avail;
if (last == NULL ||
(last == bp->last && read_count >= bp->end_count))
{
display_log(dp, USER_ERROR, "file truncated (%lu bytes)",
(unsigned long)size);
/*NOTREACHED*/
break;
}
else if (read_count >= sizeof last->buffer)
{
/* Move to the next buffer: */
last = last->next;
read_count = 0;
bp->current = last; /* Avoid update outside the loop */
/* And do a sanity check (the EOF case is caught above) */
if (last == NULL)
{
display_log(dp, INTERNAL_ERROR, "damaged buffer list");
/*NOTREACHED*/
break;
}
}
avail = (sizeof last->buffer) - read_count;
if (avail > size)
avail = size;
memcpy(data, last->buffer + read_count, avail);
read_count += avail;
size -= avail;
data += avail;
}
bp->read_count = read_count;
}
static void PNGCBAPI
display_error(png_structp pp, png_const_charp error)
{
struct display *dp = get_dp(pp);
display_log(dp, LIBPNG_ERROR, "%s", error);
}
int mlx_shaders_pixel(glsl_info_t *glsl)
{
char *source;
int length;
GLint action_ok;
glsl->pixel_vshader = glCreateShader(GL_VERTEX_SHADER);
/*
source = strdup("#version 110 \n"
"attribute vec2 position;"
"uniform vec2 winhalfsize;"
"varying vec2 texcoord;"
"void main()"
"{"
" vec2 pos = position - winhalfsize;"
" pos = pos / winhalfsize;"
" gl_Position = vec4( pos, 0.0, 1.0);"
" texcoord = position / (2.0*winhalfsize);"
"}");
*/
source = strdup("#version 110 \n"
"attribute vec2 position;"
//"uniform vec2 winhalfsize;"
"varying vec2 texcoord;"
"void main()"
"{"
//" vec2 pos = position - winhalfsize;"
//" pos = pos / winhalfsize;"
" gl_Position = vec4( position, 0.0, 1.0);"
" texcoord = (position + vec2(1.0, 1.0)) / 2.0;"
"}");
length = strlen(source);
glShaderSource(glsl->pixel_vshader, 1, (const GLchar**)&source, &length);
glCompileShader(glsl->pixel_vshader);
glGetShaderiv(glsl->pixel_vshader, GL_COMPILE_STATUS, &action_ok);
if (!action_ok) {
fprintf(stderr, "Failed to compile pixel vshader :\n");
display_log(glsl->pixel_vshader, glGetShaderiv, glGetShaderInfoLog);
return (1);
}
glsl->pixel_fshader = glCreateShader(GL_FRAGMENT_SHADER);
source = strdup("#version 110 \n"
"uniform sampler2D texture;"
"varying vec2 texcoord;"
"void main()"
"{"
// " gl_FragColor = vec4(0.0, 1.0, 0.0, 0.0);"
" gl_FragColor = texture2D(texture, texcoord);"
"}");
length = strlen(source);
glShaderSource(glsl->pixel_fshader, 1, (const GLchar**)&source, &length);
glCompileShader(glsl->pixel_fshader);
glGetShaderiv(glsl->pixel_fshader, GL_COMPILE_STATUS, &action_ok);
if (!action_ok) {
fprintf(stderr, "Failed to compile pixel fshader :\n");
display_log(glsl->pixel_fshader, glGetShaderiv, glGetShaderInfoLog);
return (1);
}
glsl->pixel_program = glCreateProgram();
glAttachShader(glsl->pixel_program, glsl->pixel_vshader);
glAttachShader(glsl->pixel_program, glsl->pixel_fshader);
glLinkProgram(glsl->pixel_program);
glGetProgramiv(glsl->pixel_program, GL_LINK_STATUS, &action_ok);
if (!action_ok) {
fprintf(stderr, "Failed to link pixel shader program:\n");
display_log(glsl->pixel_program, glGetProgramiv, glGetProgramInfoLog);
return (1);
}
glFlush();
return (0);
}
/**
* Main function of the server application. It does a infinite loop unless a user exits the program.
* @param[in] listener_socket File descriptor of the socket listening incoming connections.
* @param[in] fifo File descriptor of a temporary FIFO file.
*/
void
doServer(int listener_socket, int fifo) {
int i, fdmax, newfd;
players_list_s *players_list = NULL;
games_list_s *games_list = NULL;
threads_list_s *threads_list = NULL;
pthread_mutex_t players_list_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t games_list_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_t threads_list_mutex = PTHREAD_MUTEX_INITIALIZER;
fd_set base_rdfs, rdfs;
sigset_t mask, oldmask;
FD_ZERO(&base_rdfs);
FD_SET(listener_socket, &base_rdfs);
fdmax = max(listener_socket, fifo);
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigprocmask(SIG_BLOCK, &mask, &oldmask);
initialize_structures(&players_list, &games_list, &threads_list);
printf("Four-in-a-line server started\n");
while (work) {
rdfs = base_rdfs;
if (pselect(fdmax + 1, &rdfs, NULL, NULL, NULL, &oldmask) > 0) {
for (i = 0; i <= fdmax; i++) {
newfd = -1;
if (FD_ISSET(i, &rdfs)) {
if (i == listener_socket) {
/* request from newly connected client */
newfd = add_new_client(listener_socket);
if (newfd > 0) {
FD_SET(newfd, &base_rdfs);
if (newfd > fdmax) {
fdmax = newfd;
}
display_log(newfd);
communicate(newfd, &base_rdfs, &players_list,
&games_list, &threads_list,
&players_list_mutex, &games_list_mutex,
&threads_list_mutex);
} else if (i == fifo) {
/* trick to update base_rdfs set */
char temp[1];
bulk_read(fifo, temp, 1);
}
} else {
/* request from already connected client */
communicate(i, &base_rdfs, &players_list, &games_list,
&threads_list, &players_list_mutex,
&games_list_mutex, &threads_list_mutex);
}
}
}
} else {
if (EINTR == errno)
continue;
ERR("pselect");
}
}
pthread_mutex_destroy(&players_list_mutex);
pthread_mutex_destroy(&games_list_mutex);
pthread_mutex_destroy(&threads_list_mutex);
destroy_players(players_list);
destroy_games(games_list);
destroy_threads(threads_list);
sigprocmask(SIG_UNBLOCK, &mask, NULL);
}
int main(void) {
int result = OK;
char temp_buffer[MAX_INPUT_BUFFER];
/* get the CGI variables passed in the URL */
process_cgivars();
/* reset internal variables */
reset_cgi_vars();
/* read the CGI configuration file */
result = read_cgi_config_file(get_cgi_config_location());
if(result == ERROR) {
document_header(FALSE);
cgi_config_file_error(get_cgi_config_location());
document_footer();
return ERROR;
}
/* read the main configuration file */
result = read_main_config_file(main_config_file);
if(result == ERROR) {
document_header(FALSE);
main_config_file_error(main_config_file);
document_footer();
return ERROR;
}
/* read all object configuration data */
result = read_all_object_configuration_data(main_config_file, READ_ALL_OBJECT_DATA);
if(result == ERROR) {
document_header(FALSE);
object_data_error();
document_footer();
return ERROR;
}
document_header(TRUE);
/* get authentication information */
get_authentication_information(¤t_authdata);
/* determine what log file we should be using */
get_log_archive_to_use(log_archive, log_file_to_use, (int)sizeof(log_file_to_use));
if(display_header == TRUE) {
/* begin top table */
printf("<table border=0 width=100%% cellpadding=0 cellspacing=0>\n");
printf("<tr>\n");
/* left column of top table - info box */
printf("<td align=left valign=top width=33%%>\n");
display_info_table((log_rotation_method == LOG_ROTATION_NONE || log_archive == 0) ? "Current Event Log" : "Archived Event Log", FALSE, ¤t_authdata);
printf("</td>\n");
/* middle column of top table - log file navigation options */
printf("<td align=center valign=top width=33%%>\n");
snprintf(temp_buffer, sizeof(temp_buffer) - 1, "%s?%s", SHOWLOG_CGI, (use_lifo == FALSE) ? "oldestfirst&" : "");
temp_buffer[sizeof(temp_buffer) - 1] = '\x0';
display_nav_table(temp_buffer, log_archive);
printf("</td>\n");
/* right hand column of top row */
printf("<td align=right valign=top width=33%%>\n");
printf("<form method='GET' action='%s'>\n", SHOWLOG_CGI);
printf("<input type='hidden' name='archive' value='%d'>\n", log_archive);
printf("<table border=0 cellspacing=0 cellpadding=0 CLASS='optBox'>\n");
printf("<tr>");
printf("<td align=left valign=bottom CLASS='optBoxItem'><input type='checkbox' name='oldestfirst' %s> Older Entries First:</td>", (use_lifo == FALSE) ? "checked" : "");
printf("</tr>\n");
printf("<tr>");
printf("<td align=left valign=bottom CLASS='optBoxItem'><input type='submit' value='Update'></td>\n");
printf("</tr>\n");
/* display context-sensitive help */
printf("<tr>\n");
printf("<td align=right>\n");
display_context_help(CONTEXTHELP_LOG);
printf("</td>\n");
printf("</tr>\n");
printf("</table>\n");
printf("</form>\n");
printf("</td>\n");
/* end of top table */
printf("</tr>\n");
printf("</table>\n");
printf("</p>\n");
}
/* display the contents of the log file */
display_log();
document_footer();
/* free allocated memory */
free_memory();
return OK;
}
static int
compare_read(struct display *dp, int applied_transforms)
{
/* Compare the png_info from read_ip with original_info */
size_t rowbytes;
png_uint_32 width, height;
int bit_depth, color_type;
int interlace_method, compression_method, filter_method;
const char *e = NULL;
png_get_IHDR(dp->read_pp, dp->read_ip, &width, &height, &bit_depth,
&color_type, &interlace_method, &compression_method, &filter_method);
# define C(item) if (item != dp->item) \
display_log(dp, APP_WARNING, "IHDR " #item "(%lu) changed to %lu",\
(unsigned long)dp->item, (unsigned long)item), e = #item
/* The IHDR should be identical: */
C(width);
C(height);
C(bit_depth);
C(color_type);
C(interlace_method);
C(compression_method);
C(filter_method);
/* 'e' remains set to the name of the last thing changed: */
if (e)
display_log(dp, APP_ERROR, "IHDR changed (%s)", e);
/* All the chunks from the original PNG should be preserved in the output PNG
* because the PNG format has not been changed.
*/
{
unsigned long chunks =
png_get_valid(dp->read_pp, dp->read_ip, 0xffffffff);
if (chunks != dp->chunks)
display_log(dp, APP_FAIL, "PNG chunks changed from 0x%lx to 0x%lx",
(unsigned long)dp->chunks, chunks);
}
/* rowbytes should be the same */
rowbytes = png_get_rowbytes(dp->read_pp, dp->read_ip);
/* NOTE: on 64-bit systems this may trash the top bits of rowbytes,
* which could lead to weird error messages.
*/
if (rowbytes != dp->original_rowbytes)
display_log(dp, APP_ERROR, "PNG rowbytes changed from %lu to %lu",
(unsigned long)dp->original_rowbytes, (unsigned long)rowbytes);
/* The rows should be the same too, unless the applied transforms includes
* the shift transform, in which case low bits may have been lost.
*/
{
png_bytepp rows = png_get_rows(dp->read_pp, dp->read_ip);
unsigned int mask; /* mask (if not zero) for the final byte */
if (bit_depth < 8)
{
/* Need the stray bits at the end, this depends only on the low bits
* of the image width; overflow does not matter. If the width is an
* exact multiple of 8 bits this gives a mask of 0, not 0xff.
*/
mask = 0xff & (0xff00 >> ((bit_depth * width) & 7));
}
else
static void
update_display(struct display *dp)
/* called once after the first read to update all the info, original_pp and
* original_ip must have been filled in.
*/
{
png_structp pp;
png_infop ip;
/* Now perform the initial read with a 0 tranform. */
read_png(dp, &dp->original_file, "original read", 0/*no transform*/);
/* Move the result to the 'original' fields */
dp->original_pp = pp = dp->read_pp, dp->read_pp = NULL;
dp->original_ip = ip = dp->read_ip, dp->read_ip = NULL;
dp->original_rowbytes = png_get_rowbytes(pp, ip);
if (dp->original_rowbytes == 0)
display_log(dp, LIBPNG_BUG, "png_get_rowbytes returned 0");
dp->chunks = png_get_valid(pp, ip, 0xffffffff);
if ((dp->chunks & PNG_INFO_IDAT) == 0) /* set by png_read_png */
display_log(dp, LIBPNG_BUG, "png_read_png did not set IDAT flag");
dp->original_rows = png_get_rows(pp, ip);
if (dp->original_rows == NULL)
display_log(dp, LIBPNG_BUG, "png_read_png did not create row buffers");
if (!png_get_IHDR(pp, ip,
&dp->width, &dp->height, &dp->bit_depth, &dp->color_type,
&dp->interlace_method, &dp->compression_method, &dp->filter_method))
display_log(dp, LIBPNG_BUG, "png_get_IHDR failed");
/* 'active' transforms are discovered based on the original image format;
* running one active transform can activate others. At present the code
* does not attempt to determine the closure.
*/
{
png_uint_32 chunks = dp->chunks;
int active = 0, inactive = 0;
int ct = dp->color_type;
int bd = dp->bit_depth;
unsigned int i;
for (i=0; i<TTABLE_SIZE; ++i)
{
int transform = transform_info[i].transform;
if ((transform_info[i].valid_chunks == 0 ||
(transform_info[i].valid_chunks & chunks) != 0) &&
(transform_info[i].color_mask_required & ct) ==
transform_info[i].color_mask_required &&
(transform_info[i].color_mask_absent & ct) == 0 &&
(transform_info[i].bit_depths & bd) != 0 &&
(transform_info[i].when & TRANSFORM_R) != 0)
active |= transform;
else if ((transform_info[i].when & TRANSFORM_R) != 0)
inactive |= transform;
}
/* Some transforms appear multiple times in the table; the 'active' status
* is the logical OR of these and the inactive status must be adjusted to
* take this into account.
*/
inactive &= ~active;
dp->active_transforms = active;
dp->ignored_transforms = inactive; /* excluding write-only transforms */
if (active == 0)
display_log(dp, INTERNAL_ERROR, "bad transform table");
}
}
/* error handler callbacks for libpng */
static void PNGCBAPI
display_warning(png_structp pp, png_const_charp warning)
{
display_log(get_dp(pp), LIBPNG_WARNING, "%s", warning);
}
void display_sysmenu(void)
{
#ifdef USING_SYSMENU
// al_set_target_bitmap(sysmstate.bmp);
// al_set_target_bitmap(al_get_backbuffer(display));
al_set_clipping_rectangle(editor.panel_x, editor.panel_y, editor.panel_w, editor.panel_h);
al_clear_to_color(colours.base [COL_BLUE] [SHADE_MIN]);
reset_i_buttons();
al_draw_textf(font[FONT_SQUARE_BOLD].fnt, colours.base [COL_GREY] [SHADE_MAX], 5, 2, ALLEGRO_ALIGN_LEFT, "System Menu");
int i;
#define BUTTON_TEXT_LENGTH 30
char button_text [BUTTON_TEXT_LENGTH] = "";
int button_colour;
int button_base_shade; // is increased by 1 if button highlighted, so don't set this to SHADE_MAX
int button_selectable; // note that setting this to 0 just means the button doesn't look selectable
int hide_button; // button completely hidden
// sysmenu buttons are a bit complicated because their appearance depends on various game state things
for (i = 0; i < SYSMENU_BUTTONS; i ++)
{
button_colour = COL_BLUE;
button_base_shade = SHADE_LOW;
button_selectable = 1;
hide_button = 0;
switch(i)
{
/* case SYSMENU_NEXT_TURN:
switch(game.phase)
{
case GAME_PHASE_TURN:
if (game.current_turn == 0)
strcpy(button_text, "Start execution!");
else
strcpy(button_text, "Next turn");
button_colour = COL_GREEN;
break;
case GAME_PHASE_OVER:
strcpy(button_text, "Game over");
// button_colour = COL_GREEN;
button_base_shade = SHADE_MIN;
button_selectable = 0;
break;
default:
strcpy(button_text, "Executing...");
if (game.pause_soft)
strcpy(button_text, "Partial execution");
if (game.pause_hard)
strcpy(button_text, "Halted");
button_base_shade = SHADE_MIN;
button_selectable = 0;
break;
}
break;*/
case SYSMENU_PAUSE:
if (game.pause_soft == 0)
strcpy(button_text, "Pause");
else
{
strcpy(button_text, "Unpause");
button_colour = COL_GREEN;
}
break;
case SYSMENU_HALT:
if (game.pause_hard == 0)
strcpy(button_text, "Halt execution");
else
{
strcpy(button_text, "Restart execution");
button_colour = COL_GREEN;
}
break;
/* case SYSMENU_FF:
if (game.fast_forward == FAST_FORWARD_OFF)
strcpy(button_text, "Fast forward");
else
{
strcpy(button_text, "Stop fast forward");
button_colour = COL_GREEN;
}
break;*/
case SYSMENU_SAVE:
strcpy(button_text, "Save game");
break;
// case SYSMENU_LOAD:
// strcpy(button_text, "Load game");
// break;
case SYSMENU_QUIT:
if (game.phase == GAME_PHASE_OVER)
{
strcpy(button_text, "Return to main menu");
button_colour = COL_GREEN;
}
else
strcpy(button_text, "Quit game");
break;
case SYSMENU_QUIT_CONFIRM:
if (sysmstate.quit_confirm == 1)
{
strcpy(button_text, "Really quit?");
button_colour = COL_RED;
}
else
{
button_selectable = 0;
hide_button = 1;
}
break;
}
if (hide_button == 1)
continue;
if (sysmstate.button_highlight == i
&& button_selectable == 1)
// al_draw_filled_rectangle(editor.panel_x + sysmenu_button[i].x1, editor.panel_y + sysmenu_button[i].y1, editor.panel_x + sysmenu_button[i].x2, editor.panel_y + sysmenu_button[i].y2, colours.base [button_colour] [button_base_shade + 1]);
add_menu_button(editor.panel_x + sysmenu_button[i].x1, editor.panel_y + sysmenu_button[i].y1, editor.panel_x + sysmenu_button[i].x2, editor.panel_y + sysmenu_button[i].y2, colours.base [button_colour] [button_base_shade + 1], MBUTTON_TYPE_MENU);
else
add_menu_button(editor.panel_x + sysmenu_button[i].x1, editor.panel_y + sysmenu_button[i].y1, editor.panel_x + sysmenu_button[i].x2, editor.panel_y + sysmenu_button[i].y2, colours.base [button_colour] [button_base_shade], MBUTTON_TYPE_MENU);
// al_draw_filled_rectangle(editor.panel_x + sysmenu_button[i].x1, editor.panel_y + sysmenu_button[i].y1, editor.panel_x + sysmenu_button[i].x2, editor.panel_y + sysmenu_button[i].y2, colours.base [button_colour] [button_base_shade]);
add_menu_string(editor.panel_x + sysmenu_button[i].x1 + 15, editor.panel_y + sysmenu_button[i].y1 + 20, &colours.base [COL_GREY] [SHADE_HIGH], 0, FONT_SQUARE_BOLD, button_text);
// al_draw_textf(font[FONT_SQUARE_BOLD].fnt, colours.base [COL_GREY] [SHADE_HIGH], editor.panel_x + sysmenu_button[i].x1 + 15, editor.panel_y + sysmenu_button[i].y1 + 20, 0, "%s", button_text);
}
draw_menu_buttons();
// mode buttons should be drawn in i_display.c
display_log(editor.panel_x + EDIT_WINDOW_X, editor.panel_y + editor.mlog_window_y);
// al_set_target_bitmap(sysmstate.bmp);
al_set_clipping_rectangle(editor.panel_x, editor.panel_y, editor.panel_w, editor.panel_h);
draw_scrollbar(&mlog.scrollbar_v, 0, 0);
if (ex_control.panel_drag_ready == 1
|| ex_control.mouse_dragging_panel == 1)
draw_panel_drag_ready_line();
// al_set_target_bitmap(al_get_backbuffer(display));
// al_draw_bitmap(sysmstate.bmp, sysmstate.panel_x, sysmstate.panel_y, 0); // TO DO!!!!: need to treat the sysmenu bitmap as a subbitmap of the display backbuffer, which would let us save this drawing operation
#endif
}
