Freeciv-3.1: /fast/freeciv/nightly/S3_1/server/savegame/savemain.c Source File

Freeciv-3.1

Loading...
Searching...
No Matches
savemain.c
Go to the documentation of this file.
1/***********************************************************************
2 Freeciv - Copyright (C) 1996 - A Kjeldberg, L Gregersen, P Unold
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12***********************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18/* utility */
19#include "log.h"
20#include "mem.h"
21#include "registry.h"
22
23/* common */
24#include "ai.h"
25#include "capability.h"
26#include "game.h"
27
28/* server */
29#include "console.h"
30#include "notify.h"
31
32/* server/savegame */
33#include "savegame2.h"
34#include "savegame3.h"
35
36#include "savemain.h"
37
38 static fc_thread *save_thread = NULL;
39
40/************************************************************************/
43 void savegame_load(struct section_file *sfile)
44{
45 const char *savefile_options;
46
47 fc_assert_ret(sfile != NULL);
48
49#ifdef DEBUG_TIMERS
50 struct timer *loadtimer = timer_new(TIMER_CPU, TIMER_DEBUG);
51 timer_start(loadtimer);
52#endif
53
54 savefile_options = secfile_lookup_str(sfile, "savefile.options");
55
56 if (!savefile_options) {
57 log_error("Missing savefile options. Can not load the savegame.");
58 return;
59 }
60
61 if (has_capabilities("+version3", savefile_options)) {
62 /* load new format (freeciv 3.0.x and newer) */
63 log_verbose("loading savefile in 3.0+ format ...");
64 savegame3_load(sfile);
65 } else if (has_capabilities("+version2", savefile_options)) {
66 /* load old format (freeciv 2.3 - 2.6) */
67 log_verbose("loading savefile in 2.3 - 2.6 format ...");
68 savegame2_load(sfile);
69 } else {
70 log_error("Too old savegame format not supported any more.");
71 return;
72 }
73
74 players_iterate(pplayer) {
75 unit_list_iterate(pplayer->units, punit) {
76 CALL_FUNC_EACH_AI(unit_created, punit);
77 CALL_PLR_AI_FUNC(unit_got, pplayer, punit);
78 } unit_list_iterate_end;
79
80 city_list_iterate(pplayer->cities, pcity) {
81 CALL_FUNC_EACH_AI(city_created, pcity);
82 CALL_PLR_AI_FUNC(city_got, pplayer, pplayer, pcity);
83 } city_list_iterate_end;
84 } players_iterate_end;
85
86#ifdef DEBUG_TIMERS
87 timer_stop(loadtimer);
88 log_debug("Loading secfile in %.3f seconds.", timer_read_seconds(loadtimer));
89 timer_destroy(loadtimer);
90#endif /* DEBUG_TIMERS */
91}
92
93/************************************************************************/
96 void savegame_save(struct section_file *sfile, const char *save_reason,
97 bool scenario)
98{
99 savegame3_save(sfile, save_reason, scenario);
100}
101
102 struct save_thread_data
103{
104 struct section_file *sfile;
105 char filepath[600];
106 int save_compress_level;
107 enum fz_method save_compress_type;
108};
109
110/************************************************************************/
113 static void save_thread_data_free(struct save_thread_data *stdata)
114{
115 secfile_destroy(stdata->sfile);
116 free(stdata);
117}
118
119/************************************************************************/
122 static void save_thread_run(void *arg)
123{
124 struct save_thread_data *stdata = (struct save_thread_data *)arg;
125
126 if (!secfile_save(stdata->sfile, stdata->filepath, stdata->save_compress_level,
127 stdata->save_compress_type)) {
128 con_write(C_FAIL, _("Failed saving game as %s"), stdata->filepath);
129 log_error("Game saving failed: %s", secfile_error());
130 notify_conn(NULL, NULL, E_LOG_ERROR, ftc_warning, _("Failed saving game."));
131 } else {
132 con_write(C_OK, _("Game saved as %s"), stdata->filepath);
133 }
134
135 save_thread_data_free(stdata);
136}
137
138/************************************************************************/
142 void save_game(const char *orig_filename, const char *save_reason,
143 bool scenario)
144{
145 char *dot, *filename;
146 struct timer *timer_cpu, *timer_user;
147 struct save_thread_data *stdata;
148
149 stdata = fc_malloc(sizeof(*stdata));
150
151 stdata->save_compress_type = game.server.save_compress_type;
152 stdata->save_compress_level = game.server.save_compress_level;
153
154 if (!orig_filename) {
155 stdata->filepath[0] = '\0';
156 filename = stdata->filepath;
157 } else {
158 sz_strlcpy(stdata->filepath, orig_filename);
159 if ((filename = strrchr(stdata->filepath, '/'))) {
160 filename++;
161 } else {
162 filename = stdata->filepath;
163 }
164
165 /* Ignores the dot at the start of the filename. */
166 for (dot = filename; '.' == *dot; dot++) {
167 /* Nothing. */
168 }
169 if ('\0' == *dot) {
170 /* Only dots in this file name, consider it as empty. */
171 filename[0] = '\0';
172 } else {
173 char *end_dot;
174 char *strip_extensions[] = {
175 ".sav", ".gz", ".bz2", ".xz", ".zst", NULL };
176 bool stripped = TRUE;
177
178 while ((end_dot = strrchr(dot, '.')) && stripped) {
179 int i;
180
181 stripped = FALSE;
182
183 for (i = 0; strip_extensions[i] != NULL && !stripped; i++) {
184 if (!strcmp(end_dot, strip_extensions[i])) {
185 *end_dot = '\0';
186 stripped = TRUE;
187 }
188 }
189 }
190 }
191 }
192
193 /* If orig_filename is NULL or empty, use a generated default name. */
194 if (filename[0] == '\0') {
195 /* manual save */
196 generate_save_name(game.server.save_name, filename,
197 sizeof(stdata->filepath) + stdata->filepath - filename, "manual");
198 }
199
200 timer_cpu = timer_new(TIMER_CPU, TIMER_ACTIVE);
201 timer_start(timer_cpu);
202 timer_user = timer_new(TIMER_USER, TIMER_ACTIVE);
203 timer_start(timer_user);
204
205 /* Allowing duplicates shouldn't be allowed. However, it takes very too
206 * long time for huge game saving... */
207 stdata->sfile = secfile_new(TRUE);
208 savegame_save(stdata->sfile, save_reason, scenario);
209
210 /* We have consistent game state in stdata->sfile now, so
211 * we could pass it to the saving thread already. We want to
212 * handle below notify_conn() and directory creation in
213 * main thread, though. */
214
215 /* Append ".sav" to filename. */
216 sz_strlcat(stdata->filepath, ".sav");
217
218 if (stdata->save_compress_level > 0) {
219 switch (stdata->save_compress_type) {
220#ifdef FREECIV_HAVE_LIBZ
221 case FZ_ZLIB:
222 /* Append ".gz" to filename. */
223 sz_strlcat(stdata->filepath, ".gz");
224 break;
225#endif
226#ifdef FREECIV_HAVE_LIBBZ2
227 case FZ_BZIP2:
228 /* Append ".bz2" to filename. */
229 sz_strlcat(stdata->filepath, ".bz2");
230 break;
231#endif
232#ifdef FREECIV_HAVE_LIBLZMA
233 case FZ_XZ:
234 /* Append ".xz" to filename. */
235 sz_strlcat(stdata->filepath, ".xz");
236 break;
237#endif
238#ifdef FREECIV_HAVE_LIBZSTD
239 case FZ_ZSTD:
240 /* Append ".zstd" to filename. */
241 sz_strlcat(stdata->filepath, ".zst");
242 break;
243#endif /* FREECIV_HAVE_LIBZSTD */
244 case FZ_PLAIN:
245 break;
246 default:
247 log_error(_("Unsupported compression type %d."),
248 stdata->save_compress_type);
249 notify_conn(NULL, NULL, E_SETTING, ftc_warning,
250 _("Unsupported compression type %d."),
251 stdata->save_compress_type);
252 break;
253 }
254 }
255
256 if (!path_is_absolute(stdata->filepath)) {
257 char tmpname[600];
258
259 if (!scenario) {
260 /* Ensure the saves directory exists. */
261 if (srvarg.saves_pathname[0] != '\0'
262 && !make_dir(srvarg.saves_pathname)) {
263 log_error(_("Can't create saves directory %s!"),
264 srvarg.saves_pathname);
265 /* Don't tell server paths to clients */
266 notify_conn(NULL, NULL, E_SETTING, ftc_warning,
267 _("Can't create saves directory!"));
268
269 save_thread_data_free(stdata);
270 timer_destroy(timer_cpu);
271 timer_destroy(timer_user);
272
273 return;
274 }
275
276 sz_strlcpy(tmpname, srvarg.saves_pathname);
277 } else {
278 /* Make sure scenario directory exist */
279 if (srvarg.scenarios_pathname[0] != '\0'
280 && !make_dir(srvarg.scenarios_pathname)) {
281 log_error(_("Can't create scenario saves directory %s!"),
282 srvarg.scenarios_pathname);
283 /* Don't tell server paths to clients */
284 notify_conn(NULL, NULL, E_SETTING, ftc_warning,
285 _("Can't create scenario saves directory!"));
286
287 save_thread_data_free(stdata);
288 timer_destroy(timer_cpu);
289 timer_destroy(timer_user);
290
291 return;
292 }
293
294 sz_strlcpy(tmpname, srvarg.scenarios_pathname);
295 }
296
297 if (tmpname[0] != '\0') {
298 sz_strlcat(tmpname, "/");
299 }
300 sz_strlcat(tmpname, stdata->filepath);
301 sz_strlcpy(stdata->filepath, tmpname);
302 }
303
304 if (save_thread != NULL) {
305 /* Previously started thread */
306 fc_thread_wait(save_thread);
307 if (!game.server.threaded_save) {
308 /* Setting has changed since the last save */
309 free(save_thread);
310 save_thread = NULL;
311 }
312 } else if (game.server.threaded_save) {
313 save_thread = fc_malloc(sizeof(save_thread));
314 }
315
316 if (save_thread != NULL) {
317 fc_thread_start(save_thread, &save_thread_run, stdata);
318 } else {
319 save_thread_run(stdata);
320 }
321
322#ifdef LOG_TIMERS
323 log_verbose("Save time: %g seconds (%g apparent)",
324 timer_read_seconds(timer_cpu), timer_read_seconds(timer_user));
325#endif
326
327 timer_destroy(timer_cpu);
328 timer_destroy(timer_user);
329}
330
331/************************************************************************/
334 void save_system_close(void)
335{
336 if (save_thread != NULL) {
337 fc_thread_wait(save_thread);
338 free(save_thread);
339 save_thread = NULL;
340 }
341}
342
ai.h
CALL_FUNC_EACH_AI
#define CALL_FUNC_EACH_AI(_func,...)
Definition ai.h:384
CALL_PLR_AI_FUNC
#define CALL_PLR_AI_FUNC(_func, _player,...)
Definition ai.h:374
has_capabilities
bool has_capabilities(const char *us, const char *them)
Definition capability.c:86
capability.h
city_list_iterate
#define city_list_iterate(citylist, pcity)
Definition city.h:488
city_list_iterate_end
#define city_list_iterate_end
Definition city.h:490
con_write
void con_write(enum rfc_status rfc_status, const char *message,...)
Definition console.c:203
console.h
C_FAIL
@ C_FAIL
Definition console.h:45
C_OK
@ C_OK
Definition console.h:41
punit
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit * punit
Definition dialogs_g.h:73
_
#define _(String)
Definition fcintl.h:67
fc_thread_start
int fc_thread_start(fc_thread *thread, void(*function)(void *arg), void *arg)
fc_thread_wait
void fc_thread_wait(fc_thread *thread)
ftc_warning
const struct ft_color ftc_warning
Definition featured_text.c:75
game
struct civ_game game
Definition game.c:57
generate_save_name
int generate_save_name(const char *format, char *buf, int buflen, const char *reason)
Definition game.c:771
game.h
fz_method
fz_method
Definition ioz.h:36
FZ_PLAIN
@ FZ_PLAIN
Definition ioz.h:37
log.h
fc_assert_ret
#define fc_assert_ret(condition)
Definition log.h:191
log_verbose
#define log_verbose(message,...)
Definition log.h:109
log_debug
#define log_debug(message,...)
Definition log.h:115
log_error
#define log_error(message,...)
Definition log.h:103
mem.h
fc_malloc
#define fc_malloc(sz)
Definition mem.h:34
notify_conn
void notify_conn(struct conn_list *dest, const struct tile *ptile, enum event_type event, const struct ft_color color, const char *format,...)
Definition notify.c:239
notify.h
players_iterate_end
#define players_iterate_end
Definition player.h:535
players_iterate
#define players_iterate(_pplayer)
Definition player.h:530
registry.h
secfile_new
struct section_file * secfile_new(bool allow_duplicates)
Definition section_file.c:73
secfile_error
const char * secfile_error(void)
Definition section_file.c:36
secfile_destroy
void secfile_destroy(struct section_file *secfile)
Definition section_file.c:95
secfile_lookup_str
const char * secfile_lookup_str(const struct section_file *secfile, const char *path,...)
Definition registry_ini.c:2112
secfile_save
bool secfile_save(const struct section_file *secfile, const char *filename, int compression_level, enum fz_method compression_method)
Definition registry_ini.c:641
savegame2_load
void savegame2_load(struct section_file *file)
Definition savegame2.c:387
savegame2.h
savegame3_save
void savegame3_save(struct section_file *sfile, const char *save_reason, bool scenario)
Definition savegame3.c:417
savegame3_load
void savegame3_load(struct section_file *file)
Definition savegame3.c:444
savegame3.h
savegame_load
void savegame_load(struct section_file *sfile)
Definition savemain.c:43
savegame_save
void savegame_save(struct section_file *sfile, const char *save_reason, bool scenario)
Definition savemain.c:96
save_system_close
void save_system_close(void)
Definition savemain.c:334
save_thread_run
static void save_thread_run(void *arg)
Definition savemain.c:122
save_thread_data_free
static void save_thread_data_free(struct save_thread_data *stdata)
Definition savemain.c:113
save_game
void save_game(const char *orig_filename, const char *save_reason, bool scenario)
Definition savemain.c:142
save_thread
static fc_thread * save_thread
Definition savemain.c:38
savemain.h
make_dir
bool make_dir(const char *pathname)
Definition shared.c:1769
path_is_absolute
bool path_is_absolute(const char *filename)
Definition shared.c:1870
srvarg
struct server_arguments srvarg
Definition srv_main.c:173
civ_game::threaded_save
bool threaded_save
Definition game.h:179
civ_game::save_compress_level
int save_compress_level
Definition game.h:180
civ_game::server
struct civ_game::@30::@34 server
civ_game::save_name
char save_name[MAX_LEN_NAME]
Definition game.h:219
civ_game::save_compress_type
enum fz_method save_compress_type
Definition game.h:181
save_thread_data
Definition savemain.c:103
save_thread_data::save_compress_level
int save_compress_level
Definition savemain.c:106
save_thread_data::save_compress_type
enum fz_method save_compress_type
Definition savemain.c:107
save_thread_data::sfile
struct section_file * sfile
Definition savemain.c:104
save_thread_data::filepath
char filepath[600]
Definition savemain.c:105
section_file
Definition section_file.h:36
server_arguments::scenarios_pathname
char * scenarios_pathname
Definition srv_main.h:47
server_arguments::saves_pathname
char * saves_pathname
Definition srv_main.h:46
timer
Definition timing.c:81
sz_strlcpy
#define sz_strlcpy(dest, src)
Definition support.h:161
TRUE
#define TRUE
Definition support.h:46
FALSE
#define FALSE
Definition support.h:47
sz_strlcat
#define sz_strlcat(dest, src)
Definition support.h:162
timer_new
struct timer * timer_new(enum timer_timetype type, enum timer_use use)
Definition timing.c:157
timer_destroy
void timer_destroy(struct timer *t)
Definition timing.c:191
timer_start
void timer_start(struct timer *t)
Definition timing.c:224
timer_stop
void timer_stop(struct timer *t)
Definition timing.c:268
timer_read_seconds
double timer_read_seconds(struct timer *t)
Definition timing.c:344
TIMER_ACTIVE
@ TIMER_ACTIVE
Definition timing.h:45
TIMER_DEBUG
#define TIMER_DEBUG
Definition timing.h:59
TIMER_CPU
@ TIMER_CPU
Definition timing.h:40
TIMER_USER
@ TIMER_USER
Definition timing.h:41
unit_list_iterate
#define unit_list_iterate(unitlist, punit)
Definition unitlist.h:31
unit_list_iterate_end
#define unit_list_iterate_end
Definition unitlist.h:33