plomlompom.com Git - plomrogue/blob - src/client/io.c

   1 /* src/client/io.c
   2  *
   3  * This file is part of PlomRogue. PlomRogue is licensed under the GPL version 3
   4  * or any later version. For details on its copyright, license, and warranties,
   5  * see the file NOTICE in the root directory of the PlomRogue source package.
   6  */
   7
   8 #define _POSIX_C_SOURCE 1 /* PIPE_BUF */
   9 #include "io.h"
  10 #include <limits.h> /* PIPE_BUF */
  11 #include <ncurses.h> /* halfdelay(), getch() */
  12 #include <stddef.h> /* NULL */
  13 #include <stdint.h> /* uint8_t, uint16_t, uint32_t, UINT32_MAX */
  14 #include <stdio.h> /* FILE, sprintf(), fseek(), fflush() */
  15 #include <string.h> /* strcmp(), strlen(), memcpy() */
  16 #include <stdlib.h> /* free(), atoi() */
  17 #include <sys/stat.h> /* stat() */
  18 #include <sys/types.h> /* time_t */
  19 #include <time.h> /* time() */
  20 #include <unistd.h> /* access() */
  21 #include "../common/try_malloc.h" /* try_malloc() */
  22 #include "../common/rexit.h" /* exit_trouble(), exit_err() */
  23 #include "../common/readwrite.h" /* try_fopen(), try_fclose(), try_fgets(),
  24                                   * try_fgetc(), textfile_width(), try_fputc(),
  25                                   * read_file_into_queue(),
  26                                   * get_message_from_queue(),
  27                                   */
  28 #include "control.h" /* try_key() */
  29 #include "map.h" /* map_center() */
  30 #include "windows.h" /* reset_windows_on_winch(), draw_all_wins() */
  31 #include "world.h" /* world global */
  32
  33
  34
  35 /* Read next lines of "file" up to (and excluding) a line "%\n" into the
  36  * world.player_inventory string.
  37  */
  38 static void read_inventory(char * read_buf, uint32_t linemax, FILE * file);
  39
  40 /* Read the next characters in "file" into "map". In detail: Read
  41  * world.map.length times world.map.length characters, followed by one ignored
  42  * character (that we assume is a newline).
  43  */
  44 static void read_map_cells(FILE * file, char ** map);
  45
  46 /* Return value seen by atoi() in next line of "file" when passed to try_fgets()
  47  * with the given arguments.
  48  */
  49 static uint16_t read_value_from_line(char * read_buf, uint32_t linemax,
  50                                      FILE * file);
  51
  52 /* If the server's worldstate file has changed since the last read_worldstate(),
  53  * return a pointer to its file descriptor; else, return NULL.
  54  *
  55  * Two tests are performed to check for a file change. The file's last data
  56  * modification time in seconds via stat() is compared against world.last_update
  57  * (and if it is changed, world.last_update is re-set to it). If this does not
  58  * verify a change, the first bytes of the file are read to compare the game
  59  * turn number described therein to the last read turn number in world.turn.
  60  *
  61  * The stat() check is mostly useless, for it only detects file updates once a
  62  * second. But the turn check fails if a new world is generated from turn 1 on:
  63  * the new world also starts in turn 1, not signifying any world change to the
  64  * turn check. The stat() check detects this change with at most 1 second delay.
  65  */
  66 static FILE * changed_worldstate_file(char * path);
  67
  68 /* Attempt to read the server's worldstate file as representation of the game
  69  * world in a hard-coded serialization format. Returns 1 on success, or 0 if the
  70  * out file wasn't read for supposedly not having changed since a last
  71  * read_worldstate() call.
  72  *
  73  * map_center() is triggered by either, the first successful read_worldstate()
  74  * (thus on client start), or on turn 1 (thus on world start).
  75  */
  76 static uint8_t read_worldstate();
  77
  78 /* Poll server for queue input. If no new input, send ping, or, if ping already
  79  * sent but unanswered for some time, abort.
  80  */
  81 static void test_and_poll_server();
  82
  83 /* If "string", append \n-prefixed "append", else write "append" as "string". */
  84 static void nl_append_string(char * append, char ** string);
  85
  86 /* Read messages from queue, act on them. */
  87 static uint8_t read_queue();
  88
  89
  90
  91 static void read_inventory(char * read_buf, uint32_t linemax, FILE * file)
  92 {
  93     char * delimiter = "%\n";
  94     free(world.player_inventory);
  95     world.player_inventory = NULL;          /* Avoids illegal strlen() below. */
  96     while (1)
  97     {
  98         try_fgets(read_buf, linemax + 1, file, __func__);
  99         if (!(strcmp(read_buf, delimiter)))
 100         {
 101             break;
 102         }
 103         int old_size = 0;
 104         if (world.player_inventory)
 105         {
 106             old_size = strlen(world.player_inventory);
 107         }
 108         int new_size = strlen(read_buf);
 109         char * new_inventory = try_malloc(old_size + new_size + 1, __func__);
 110         memcpy(new_inventory, world.player_inventory, old_size);
 111         int test = sprintf(new_inventory + old_size, "%s", read_buf);
 112         exit_trouble(test < 0, __func__, "sprintf");
 113         free(world.player_inventory);
 114         world.player_inventory = new_inventory;
 115     }
 116     world.player_inventory[strlen(world.player_inventory) - 1] = '\0';
 117     world.player_inventory_select = 0;
 118 }
 119
 120
 121
 122 static void read_map_cells(FILE * file, char ** map)
 123 {
 124     if (*map)
 125     {
 126         free(*map);
 127         *map = NULL;
 128     }
 129     *map = try_malloc(world.map.length * world.map.length, __func__);
 130     char * map_cells = *map;
 131     uint16_t y, x;
 132     for (y = 0; y < world.map.length; y++)
 133     {
 134         for (x = 0; x < world.map.length; x++)
 135         {
 136             char c = try_fgetc(file, __func__);
 137             map_cells[y * world.map.length + x] = c;
 138         }
 139         try_fgetc(file, __func__);
 140     }
 141 }
 142
 143
 144
 145 static uint16_t read_value_from_line(char * read_buf, uint32_t linemax,
 146                                      FILE * file)
 147 {
 148     try_fgets(read_buf, linemax + 1, file, __func__);
 149     return atoi(read_buf);
 150 }
 151
 152
 153
 154 static FILE * changed_worldstate_file(char * path)
 155 {
 156     struct stat stat_buf;
 157     exit_trouble(stat(path, &stat_buf), __func__, "stat");
 158     if (stat_buf.st_mtime != world.last_update)
 159     {
 160         world.last_update = stat_buf.st_mtime;
 161         return try_fopen(path, "r", __func__);
 162     }
 163     FILE * file = try_fopen(path, "r", __func__);
 164     char turn_string[6];
 165     try_fgets(turn_string, 6, file, __func__);
 166     if (world.turn == atoi(turn_string))
 167     {
 168         try_fclose(file, __func__);
 169         return NULL;
 170     }
 171     exit_trouble(fseek(file, 0, SEEK_SET), __func__, "fseek");
 172     return file;
 173 }
 174
 175
 176
 177 static uint8_t read_worldstate()
 178 {
 179     char * path = "server/worldstate";
 180     char * quit_msg = "No worldstate file found to read. Server may be down.";
 181     static uint8_t first_read = 1;
 182     exit_err(access(path, F_OK), quit_msg);
 183     FILE * file = changed_worldstate_file(path);
 184     if (!file)
 185     {
 186         return 0;
 187     }
 188     uint32_t linemax = textfile_width(file);
 189     char * read_buf = try_malloc(linemax + 1, __func__);
 190     world.turn = read_value_from_line(read_buf, linemax, file);
 191     world.player_lifepoints = read_value_from_line(read_buf, linemax, file);
 192     read_inventory(read_buf, linemax, file);
 193     world.player_pos.y = read_value_from_line(read_buf, linemax, file);
 194     world.player_pos.x = read_value_from_line(read_buf, linemax, file);
 195     if (1 == world.turn || first_read)
 196     {
 197         map_center();
 198         first_read = 0;
 199     }
 200     world.map.length = read_value_from_line(read_buf, linemax, file);
 201     read_map_cells(file, &world.map.cells);
 202     read_map_cells(file, &world.mem_map);
 203     free(read_buf);
 204     try_fclose(file, __func__);
 205     return 1;
 206 }
 207
 208
 209
 210 static void test_and_poll_server()
 211 {
 212     static time_t last_server_answer_time = 0;
 213     static uint8_t ping_sent = 0;
 214     if (read_file_into_queue(world.file_server_out, &world.queue))
 215     {
 216         last_server_answer_time = time(0);
 217         return;
 218     }
 219     time_t now = time(0);
 220     if (ping_sent && last_server_answer_time > now - 3)  /* Re-set if last    */
 221     {                                                    /* ping was answered */
 222         ping_sent = 0;                                   /* with server       */
 223         return;                                          /* activity.         */
 224     }
 225     if (!ping_sent && last_server_answer_time < now - 3)
 226     {
 227         send("PING");
 228         ping_sent = 1;
 229         return;
 230     }
 231     exit_err(last_server_answer_time < now - 6, "Server not answering.");
 232 }
 233
 234
 235
 236 static void nl_append_string(char * append, char ** string)
 237 {
 238     char * err = "too large sizes";
 239     exit_trouble(UINT32_MAX < strlen(append), __func__, err);
 240     uint32_t new_size = strlen(append);
 241     uint32_t old_size = 0;
 242     uint8_t add_nl = 0;
 243     if (*string)
 244     {
 245         exit_trouble(UINT32_MAX < new_size + strlen(*string), __func__, err);
 246         old_size = strlen(*string);
 247         add_nl = 1;
 248     }
 249     char * new_string = try_malloc(old_size + add_nl + new_size + 1, __func__);
 250     memcpy(new_string, *string, old_size);
 251     char * pattern = add_nl ? "\n%s" : "%s";
 252     int test = sprintf(new_string + old_size, pattern, append);
 253     exit_trouble(test < 0, __func__, "sprintf");
 254     free(*string);
 255     *string = new_string;
 256 }
 257
 258
 259
 260 static uint8_t read_queue()
 261 {
 262     static uint8_t things_here_parsing = 0;
 263     uint8_t ret = 0;
 264     char * msg;
 265     while (NULL != (msg = get_message_from_queue(&world.queue)))
 266     {
 267         char * log_prefix = "LOG ";
 268         if      (!strcmp(msg, "THINGS_HERE START"))
 269         {
 270             ret = 1;
 271             things_here_parsing = 1;
 272             free(world.things_here);
 273             world.things_here = NULL;
 274         }
 275         else if (!strcmp(msg, "THINGS_HERE END"))
 276         {
 277             things_here_parsing = 0;
 278             if (!world.things_here)
 279             {
 280                 nl_append_string("(none known)", &world.things_here);
 281             }
 282         }
 283         else if (things_here_parsing)
 284         {
 285             ret = 1;
 286             nl_append_string(msg, &world.things_here);
 287         }
 288         else if (!strncmp(msg, log_prefix, strlen(log_prefix)))
 289         {
 290             ret = 1;
 291             nl_append_string(msg + strlen(log_prefix), &world.log);
 292         }
 293         else if (!strcmp(msg, "NEW_WORLD"))
 294         {
 295             ret = 1;
 296             free(world.log);
 297             world.log = NULL;
 298         }
 299         else if (!strcmp(msg, "WORLD_UPDATED"))
 300         {
 301             query_mapcell();
 302         }
 303         free(msg);
 304     }
 305     return ret;
 306 }
 307
 308
 309
 310 extern void send(char * msg)
 311 {
 312     uint32_t msg_size = strlen(msg) + 1;
 313     char * err = "send() tried to send message larger than PIPE_BUF bytes.";
 314     exit_err(msg_size > PIPE_BUF, err);
 315     try_fwrite(msg, strlen(msg), 1, world.file_server_in, __func__);
 316     try_fputc('\n', world.file_server_in, __func__);
 317     fflush(world.file_server_in);
 318 }
 319
 320
 321
 322 extern char * io_loop()
 323 {
 324     world.halfdelay = 1;             /* Ensure server is polled only 10 times */
 325     halfdelay(world.halfdelay);      /* a second during user inactivity.      */
 326     uint8_t change_in_client = 0;
 327     uint16_t last_focused_turn = world.turn;
 328     while (1)
 329     {
 330         test_and_poll_server();
 331         if (world.winch)
 332         {
 333             reset_windows_on_winch();
 334             world.winch = 0;
 335             change_in_client++;
 336         }
 337         if (change_in_client || read_worldstate() || read_queue())
 338         {
 339             if (world.turn != last_focused_turn && world.autofocus)
 340             {
 341                 last_focused_turn = world.turn;
 342                 map_center();
 343             }
 344             draw_all_wins();
 345         }
 346         change_in_client = 0;
 347         int key = getch();
 348         if (ERR != key)
 349         {
 350             change_in_client = try_key((uint16_t) key);
 351             if (2 == change_in_client)
 352             {
 353                 break;
 354             }
 355         }
 356     }
 357     send("QUIT");
 358     return "Sent QUIT to server.";
 359 }