home · contact · privacy
e3047234311aa19f4aaa5a154fc240b6e55525af
[plomrogue] / src / client / io.c
1 /* src/client/io.c */
2
3 #define _POSIX_C_SOURCE 1 /* PIPE_BUF */
4 #include "io.h"
5 #include <limits.h> /* PIPE_BUF */
6 #include <ncurses.h> /* halfdelay(), getch() */
7 #include <stddef.h> /* NULL */
8 #include <stdint.h> /* uint8_t, uint16_t, uint32_t */
9 #include <stdio.h> /* FILE, sprintf(), fseek(), fflush() */
10 #include <string.h> /* strcmp(), strlen(), memcpy() */
11 #include <stdlib.h> /* free(), atoi() */
12 #include <sys/stat.h> /* stat() */
13 #include <sys/types.h> /* time_t */
14 #include <time.h> /* time() */
15 #include <unistd.h> /* access() */
16 #include "../common/try_malloc.h" /* try_malloc() */
17 #include "../common/rexit.h" /* exit_trouble(), exit_err() */
18 #include "../common/readwrite.h" /* try_fopen(), try_fclose(), try_fgets(),
19                                   * try_fgetc(), textfile_width(), try_fputc()
20                                   */
21 #include "control.h" /* try_key() */
22 #include "map.h" /* map_center() */
23 #include "windows.h" /* reset_windows_on_winch(), draw_all_wins() */
24 #include "world.h" /* world global */
25
26
27
28 /* Read next lines of "file" up to (and excluding) a line "%\n" into the
29  * world.player_inventory string.
30  */
31 static void read_inventory(char * read_buf, uint32_t linemax, FILE * file);
32
33 /* Read the next characters in "file" into world.map.cells. In detail: Read
34  * world.map.length times world.map.length characters, followed by one ignored
35  * character (that we assume is a newline).
36  */
37 static void read_map_cells(FILE * file);
38
39 /* Repeatedly use try_fgets() with given arguments to read the remaining lines
40  * of "file" into the world.log string.
41  */
42 static void read_log(char * read_buf, uint32_t linemax, FILE * file);
43
44 /* Return value seen by atoi() in next line of "file" when passed to try_fgets()
45  * with the given arguments.
46  */
47 static uint16_t read_value_from_line(char * read_buf, uint32_t linemax,
48                                      FILE * file);
49
50 /* If the server's worldstate file has changed since the last read_world(),
51  * return a pointer to its file descriptor; else, return NULL.
52  *
53  * Two tests are performed to check for a file change. The file's last data
54  * modification time in seconds via stat() is compared against world.last_update
55  * (and if it is changed, world.last_update is re-set to it). If this does not
56  * verify a change, the first bytes of the file are read to compare the game
57  * turn number described therein to the last read turn number in world.turn.
58  *
59  * The stat() check is mostly useless, for it only detects file updates once a
60  * second. But the turn check fails if a new world is generated from turn 1 on:
61  * the new world also starts in turn 1, not signifying any world change to the
62  * turn check. The stat() check detects this change with at most 1 second delay.
63  */
64 static FILE * changed_worldstate_file(char * path);
65
66 /* Attempt to read the server's worldstate file as representation of the game
67  * world in a hard-coded serialization format. Returns 1 on success and 0 if the
68  * out file wasn't read for supposedly not having changed since a last
69  * read_world() call.
70  *
71  * map_center() is triggered by the first successful read_world() or on turn 1,
72  * so the client focuses the map window on the player on client and world start.
73  */
74 static uint8_t read_world();
75
76 /* If "last_server_answer_time" is too old, send a PING to the server; or, if a
77  * previous PING has not sparked any answer after a while, abort the client.
78  */
79 static void test_ping_pong(time_t last_server_answer_time);
80
81 /* Update "last_server_answer_time" if new stuff has been written to the
82  * server's out file.
83  */
84 static void test_server_activity(time_t * last_server_answer_time);
85
86
87
88 static void read_inventory(char * read_buf, uint32_t linemax, FILE * file)
89 {
90     char * f_name = "read_inventory()";
91     char * delimiter = "%\n";
92     free(world.player_inventory);
93     world.player_inventory = NULL;          /* Avoids illegal strlen() below. */
94     while (1)
95     {
96         try_fgets(read_buf, linemax + 1, file, f_name);
97         if (!(strcmp(read_buf, delimiter)))
98         {
99             break;
100         }
101         int old_size = 0;
102         if (NULL != world.player_inventory)
103         {
104             old_size = strlen(world.player_inventory);
105         }
106         int new_size = strlen(read_buf);
107         char * new_inventory = try_malloc(old_size + new_size + 1, f_name);
108         memcpy(new_inventory, world.player_inventory, old_size);
109         sprintf(new_inventory + old_size, "%s", read_buf);
110         free(world.player_inventory);
111         world.player_inventory = new_inventory;
112     }
113     world.player_inventory[strlen(world.player_inventory) - 1] = '\0';
114     world.player_inventory_select = 0;
115 }
116
117
118
119 static void read_map_cells(FILE * file)
120 {
121     char * f_name = "read_map_cells()";
122     free(world.map.cells);
123     world.map.cells = try_malloc(world.map.length * world.map.length, f_name);
124     uint16_t y, x;
125     for (y = 0; y < world.map.length; y++)
126     {
127         for (x = 0; x < world.map.length; x++)
128         {
129             char c = try_fgetc(file, f_name);
130             world.map.cells[(y * world.map.length) + x] = c;
131         }
132         try_fgetc(file, f_name);
133     }
134 }
135
136
137
138 static void read_log(char * read_buf, uint32_t linemax, FILE * file)
139 {
140     char * f_name = "read_log()";
141     free(world.log);
142     world.log = NULL;
143     while (try_fgets(read_buf, linemax + 1, file, f_name))
144     {
145         int old_size = 0;
146         if (NULL != world.log)
147         {
148             old_size = strlen(world.log);
149         }
150         int new_size = strlen(read_buf);
151         char * new_log = try_malloc(old_size + new_size + 1, f_name);
152         memcpy(new_log, world.log, old_size);
153         sprintf(new_log + old_size, "%s", read_buf);
154         free(world.log);
155         world.log = new_log;
156     }
157 }
158
159
160
161 static uint16_t read_value_from_line(char * read_buf, uint32_t linemax,
162                                      FILE * file)
163 {
164     char * f_name = "read_value_from_line()";
165     try_fgets(read_buf, linemax + 1, file, f_name);
166     return atoi(read_buf);
167 }
168
169
170
171 static FILE * changed_worldstate_file(char * path)
172 {
173     char * f_name = "changed_worldstate_file()";
174     struct stat stat_buf;
175     exit_trouble(stat(path, &stat_buf), f_name, "stat()");
176     if (stat_buf.st_mtime != world.last_update)
177     {
178         world.last_update = stat_buf.st_mtime;
179         return try_fopen(path, "r", f_name);
180     }
181     FILE * file = try_fopen(path, "r", f_name);
182     char turn_string[6];
183     try_fgets(turn_string, 6, file, f_name);
184     if (world.turn == atoi(turn_string))
185     {
186         try_fclose(file, f_name);
187         return NULL;
188     }
189     exit_trouble(fseek(file, 0, SEEK_SET), f_name, "fseek()");
190     return file;
191 }
192
193
194
195 static uint8_t read_world()
196 {
197     char * f_name = "read_world()";
198     char * path = "server/worldstate";
199     char * quit_msg = "No worldstate file found to read. Server may be down.";
200     static uint8_t first_read = 1;
201     exit_err(access(path, F_OK), quit_msg);
202     FILE * file = changed_worldstate_file(path);
203     if (!file)
204     {
205         return 0;
206     }
207     uint32_t linemax = textfile_width(file);
208     char * read_buf = try_malloc(linemax + 1, f_name);
209     world.turn = read_value_from_line(read_buf, linemax, file);
210     world.player_lifepoints = read_value_from_line(read_buf, linemax, file);
211     read_inventory(read_buf, linemax, file);
212     world.player_pos.y = read_value_from_line(read_buf, linemax, file);
213     world.player_pos.x = read_value_from_line(read_buf, linemax, file);
214     if (1 == world.turn || first_read)
215     {
216         map_center();
217         first_read = 0;
218     }
219     world.map.length = read_value_from_line(read_buf, linemax, file);
220     read_map_cells(file);
221     read_log(read_buf, linemax, file);
222     free(read_buf);
223     try_fclose(file, f_name);
224     return 1;
225 }
226
227
228
229 static void test_ping_pong(time_t last_server_answer_time)
230 {
231     static uint8_t ping_sent = 0;
232     time_t now = time(0);
233     if (ping_sent && last_server_answer_time > now - 3)
234     {
235         ping_sent = 0;
236     }
237     if (!ping_sent && last_server_answer_time < now - 3)
238     {
239         send("PING");
240         ping_sent = 1;
241         return;
242     }
243     exit_err(last_server_answer_time < now - 6, "Server not answering.");
244 }
245
246
247
248 static void test_server_activity(time_t * last_server_answer_time)
249 {
250     char * f_name = "test_server_activity()";
251     int test = try_fgetc(world.file_server_out, f_name);
252     if (EOF == test)
253     {
254         return;
255     }
256     do
257     {
258         ;
259     }
260     while (EOF != (test = try_fgetc(world.file_server_out, f_name)));
261     * last_server_answer_time = time(0);
262 }
263
264
265
266 extern void send(char * msg)
267 {
268     char * f_name = "send()";
269     uint32_t msg_size = strlen(msg) + 1;
270     char * err = "send() tries to send message larger than PIPE_BUF bytes.";
271     exit_err(msg_size > PIPE_BUF, err);
272     try_fwrite(msg, strlen(msg), 1, world.file_server_in, f_name);
273     try_fputc('\n', world.file_server_in, f_name);
274     fflush(world.file_server_in);
275 }
276
277
278
279 extern char * io_loop()
280 {
281     world.halfdelay = 1;            /* Ensures read_world() is only called 10 */
282     halfdelay(world.halfdelay);     /* times a second during user inactivity. */
283     uint8_t change_in_client = 0;
284     time_t last_server_answer_time = time(0);
285     while (1)
286     {
287         test_server_activity(&last_server_answer_time);
288         test_ping_pong(last_server_answer_time);
289         if (world.winch)
290         {
291             reset_windows_on_winch();
292             world.winch = 0;
293             change_in_client++;
294         }
295         if (read_world() || change_in_client)
296         {
297             draw_all_wins();
298         }
299         change_in_client = 0;
300         int key = getch();
301         if (ERR != key)
302         {
303             change_in_client = try_key((uint16_t) key);
304             if (2 == change_in_client)
305             {
306                 break;
307             }
308         }
309     }
310     send("QUIT");
311     return "Sent QUIT to server.";
312 }