GList *get_q2_skin_list (const char *dir) {
GList *list = NULL;
GList *dirs;
GList *tmp;
GList *skins;
GList *skin;
char *path;
char *skin_dir;
char *skin_str;
path = file_in_dir (dir, "baseq2/players");
dirs = dir_to_list (path, dir_alldirs_filter);
for (tmp = dirs; tmp; tmp = tmp->next) {
skin_dir = file_in_dir (path, (char *) tmp->data);
skins = dir_to_list (skin_dir, dir_q2_skin_filter);
g_free (skin_dir);
for (skin = skins; skin; skin = skin->next) {
skin_str = file_in_dir ((char *) tmp->data, (char *) skin->data);
list = g_list_prepend (list, skin_str);
}
}
g_free (path);
list = g_list_reverse (list);
return list;
}
guchar *get_qw_skin (char *skin, char *path) {
char *filename;
char *skinsdir;
guchar *pcx;
int skinlen;
if (!skin || skin[0] == '\0')
skin = "base.pcx";
skinsdir = file_in_dir (path, "qw/skins/");
skinlen = strlen (skin);
if (skinlen > 4 && g_ascii_strcasecmp (skin + skinlen - 4, ".pcx") == 0)
filename = file_in_dir (skinsdir, skin);
else
filename = skin_filename (skin, skinsdir, ".pcx");
pcx = read_skin_pcx (filename, FALSE);
#ifdef DEBUG
if (!pcx)
fprintf (stderr, "cannot load QW skin %s\n", filename);
#endif
g_free (filename);
g_free (skinsdir);
return pcx;
}
int rc_migrate_dir (void) {
int res;
struct stat st_buf;
const gchar* xdg_user_dir = NULL;
gchar* legacy_user_rcdir = NULL;
gchar* xdg_user_rcdir = NULL;
if (!g_get_user_name () || !g_get_home_dir () || !g_get_user_config_dir ()) {
fprintf(stderr, "Unable to get user name/home directory/XDG config directory\n");
return FALSE;
}
xdg_user_dir = g_get_user_config_dir ();
legacy_user_rcdir = file_in_dir (g_get_home_dir (), RC_DIR);
xdg_user_rcdir = file_in_dir (xdg_user_dir, XDG_RC_DIR);
/* if ~/.qf exists and ~/.config/xqf does not exists */
if (stat (legacy_user_rcdir, &st_buf) != -1 && stat (xdg_user_rcdir, &st_buf) == -1) {
/* if ~/.config does not exists, create it */
if (stat (xdg_user_dir, &st_buf) == -1) {
res = mkdir (xdg_user_dir, 0755);
if (res != 0) {
fprintf(stderr, "Can't create XDG user config directory %s\n", xdg_user_dir);
g_free(legacy_user_rcdir);
g_free(xdg_user_rcdir);
return res;
}
}
else {
/* move ~/.qf ~/.config/xqf */
fprintf(stdout, "Moving legacy config directory %s to XDG user config directory %s\n", legacy_user_rcdir, xdg_user_rcdir);
res = rename(legacy_user_rcdir, xdg_user_rcdir);
if (res == 0) {
fprintf(stdout, "Legacy config directory %s succesfully moved to XDG user config directory %s\n", legacy_user_rcdir, xdg_user_rcdir);
}
else {
fprintf(stderr, "Error when moving legacy config directory %s to XDG user config directory %s\n", legacy_user_rcdir, xdg_user_rcdir);
g_free(legacy_user_rcdir);
g_free(xdg_user_rcdir);
return res;
}
}
}
else if (stat (legacy_user_rcdir, &st_buf) != -1 && stat (xdg_user_rcdir, &st_buf) != -1) {
fprintf(stderr, "Warning, there is an old legacy config directory %s, but XDG user config directory %s will be used\n", legacy_user_rcdir, xdg_user_rcdir);
}
g_free(legacy_user_rcdir);
g_free(xdg_user_rcdir);
return TRUE;
}
static void player_filter_save_patterns (void) {
GSList *list;
struct player_pattern *pp;
FILE *f;
char *fn;
fn = file_in_dir (user_rcdir, PLAYERS_FILE);
if (!players) {
unlink (fn);
}
else {
f = fopen (fn, "w");
if (!f) {
g_free (fn);
return;
}
for (list = players; list; list = list->next) {
pp = (struct player_pattern *) list->data;
fprintf (f, "%s {\n ", mode_symbols[pp->mode]);
print_dq_string (f, pp->pattern);
fprintf (f, ",\n 0x%02X,\n ", pp->groups);
print_dq_string (f, pp->comment);
fprintf (f, "\n}\n\n");
}
fclose (f);
}
g_free (fn);
}
static void player_filter_load_patterns (void) {
char *fn;
int fd;
GScanner *scanner;
int retval;
int i;
fn = file_in_dir (user_rcdir, PLAYERS_FILE);
fd = open (fn, O_RDONLY);
if (fd < 0) {
g_free (fn);
return;
}
scanner = g_scanner_new (&patterns_scanner_config);
for (i = TOKEN_STRING; i <= TOKEN_REGEXP; i++) {
g_scanner_add_symbol (scanner, mode_symbols[i - TOKEN_STRING],
GINT_TO_POINTER(i));
}
g_scanner_input_file (scanner, fd);
do {
retval = player_pattern_parse_statement (scanner, fn);
} while (retval);
g_scanner_destroy (scanner);
g_free (fn);
close (fd);
if (filters[FILTER_PLAYER].changed != FILTER_NOT_CHANGED)
filters[FILTER_PLAYER].last_changed = filter_time_inc();
}
static char *new_temp_dir()
{
char *buf, *base = get_tempdir();
#ifdef HAVE_MKDTEMP
buf = file_in_dir(NULL, base, "mtpaintXXXXXX", PATHBUF);
if (!buf) return (NULL);
if (mkdtemp(buf))
{
chmod(buf, 0755);
return (buf);
}
#else
buf = tempnam(base, "mttmp");
if (!buf) return (NULL);
#ifdef WIN32 /* No mkdtemp() in MinGW */
/* tempnam() may use Unix path separator */
reseparate(buf);
if (!mkdir(buf)) return (buf);
#else
if (!mkdir(buf, 0755)) return (buf);
#endif
#endif
free(buf);
return (NULL);
}
int rc_save (void) {
char *fn;
fn = file_in_dir (user_rcdir, RC_FILE);
unlink (fn);
g_free (fn);
return 0;
}
GList *get_qw_skin_list (const char *dir) {
GList *list;
char *path;
path = file_in_dir (dir, "qw/skins");
list = dir_to_list (path, dir_qw_skin_filter);
g_free (path);
return list;
}
static void unlink_file (const char *filename) {
char *fn;
fn = file_in_dir (directories->data, filename);
#ifdef DEBUG
fprintf (stderr, "config.c: unlink_file (%s)\n", fn);
#endif
unlink (fn);
g_free (fn);
}
void host_cache_load (void) {
char *hostcache;
struct zstream z;
hostcache = file_in_dir (user_rcdir, HOSTCACHE_FILE);
zstream_open_r (&z, hostcache);
if (z.f) {
host_cache_clear ();
host_cache = host_cache_read_list (z.f);
zstream_close (&z);
}
g_free (hostcache);
}
static char *dir_alldirs_filter (const char *dir, const char *str) {
struct stat st_buf;
int res;
char *file;
if (!str || str[0] == '.')
return NULL;
file = file_in_dir (dir, str);
res = stat (file, &st_buf);
g_free (file);
if (res == 0 && S_ISDIR (st_buf.st_mode))
return g_strdup (str);
return NULL;
}
static void load_file (const char *filename) {
FILE *f = NULL;
char buf[BUF_SIZE];
char *fn;
struct state_s state = {0};
GSList* l;
gboolean (*parse_line)(char* buf, struct state_s* state);
struct config_file* file = NULL;
debug (4, "%s", filename);
for (l = directories; l && !f; l = g_slist_next(l)) {
fn = file_in_dir (l->data, filename);
f = fopen (fn, "r");
if (f) debug(4, "loaded %s", fn);
g_free (fn);
}
/* Create empty file record and thus cache lookups of non-existent files.
* Don't mark it 'dirty' -- nothing was changed really.
*/
find_key (filename, NULL, NULL, TRUE, &file, NULL, NULL);
if (!f)
return;
state.filename = filename;
// XXX:
if (!strncmp(filename, "scripts/", strlen("scripts/"))) {
parse_line = parse_line_script;
file->read_only = 1;
}
else
parse_line = parse_line_file;
while (fgets (buf, BUF_SIZE, f))
parse_line(buf, &state);
g_free(state.secname);
fclose (f);
}
static void dump_file (struct config_file *file) {
GList *sptr, *kptr;
struct config_section *section;
struct config_key *key;
FILE *f;
char *fn;
if (!file->dirty)
return;
if (file->read_only)
return;
if (!file->sections) {
unlink_file (file->filename);
return;
}
fn = file_in_dir (directories->data, file->filename);
f = fopen (fn, "w");
g_free (fn);
if (f) {
for (sptr = file->sections; sptr; sptr = sptr->next) {
section = (struct config_section *) sptr->data;
fprintf (f, "[%s]\n", section->name);
for (kptr = section->keys; kptr; kptr = kptr->next) {
key = (struct config_key *) kptr->data;
fprintf (f, "%s=%s\n", key->name, key->value);
}
fprintf (f, "\n");
}
fclose (f);
}
}
guchar *get_q2_skin (char *skin, char *path) {
char *skinsdir;
char *filename;
guchar *pcx;
// int skinlen;
if (!skin || skin[0] == '\0')
return NULL;
skinsdir = file_in_dir (path, "baseq2/players/");
// skinlen = strlen (skin);
filename = skin_filename (skin, skinsdir, "_i.pcx");
pcx = read_skin_pcx (filename, TRUE);
#ifdef DEBUG
if (!pcx)
fprintf (stderr, "cannot load Q2 skin %s\n", filename);
#endif
g_free (filename);
g_free (skinsdir);
return pcx;
}
void host_cache_save (void) {
GSList *hosts;
char *hostcache;
struct zstream z;
hosts = hosts_to_cache ();
host_cache_clear ();
host_cache = hosts;
hostcache = file_in_dir (user_rcdir, HOSTCACHE_FILE);
if (host_cache) {
zstream_open_w (&z, hostcache);
if (z.f) {
host_cache_save_list (z.f, host_cache);
zstream_close (&z);
}
}
else {
zstream_unlink (hostcache);
}
g_free (hostcache);
}
void props_load (void) {
FILE *f;
char *fn;
struct host *h;
struct server_props *p = NULL;
char *addr;
unsigned short port;
char buf[1024];
char *ptr;
props_free_all ();
fn = file_in_dir (user_rcdir, SERVERS_FILE);
f = fopen (fn, "r");
g_free (fn);
if (!f)
return;
while (!feof (f)) {
fgets (buf, 1024, f);
if (buf[0] == '\n') {
if (p)
p = NULL;
}
else if (buf[0] == '[') {
if (p)
continue;
ptr = strchr (&buf[1], ']');
if (!ptr)
continue;
*ptr = '\0';
if (!parse_address (&buf[1], &addr, &port))
continue;
if (port == 0) {
g_free (addr);
continue;
}
h = host_add (addr);
g_free (addr);
if (!h)
continue;
p = __properties (h, port);
if (!p)
p = properties_new (h, port);
}
else {
if (!p)
continue;
ptr = strchr (buf, ' ');
if (!ptr)
continue;
*ptr++ = '\0';
if (strcmp (buf, "custom_cfg") == 0) {
g_free (p->custom_cfg);
p->custom_cfg = strdup_strip (ptr);
}
else if (strcmp (buf, "password") == 0) {
g_free (p->server_password);
p->server_password = strdup_strip (ptr);
}
else if (strcmp (buf, "spectator_password") == 0) {
g_free (p->spectator_password);
p->spectator_password = strdup_strip (ptr);
}
else if (strcmp (buf, "rcon_password") == 0) {
g_free (p->rcon_password);
p->rcon_password = strdup_strip (ptr);
}
else if (strcmp (buf, "reserved_slots") == 0) {
p->reserved_slots= atoi(ptr);
}
else if (strcmp (buf, "sucks") == 0) {
p->sucks = atoi(ptr);
}
else if (strcmp (buf, "comment") == 0) {
unsigned di, si;
size_t slen = strlen(ptr);
int quote = 0;
g_free (p->comment);
p->comment = g_malloc0 (slen + 1);
for (si = 0, di = 0; si < slen; ++si) {
if (quote) {
quote = 0;
if (ptr[si] == 'n')
p->comment[di++] = '\n';
else if (ptr[si] == '\\')
p->comment[di++] = '\\';
else
xqf_warning("unknown control sequence \\%c", ptr[si]);
}
else if (ptr[si] == '\\') {
quote = 1;
}
else {
p->comment[di++] = ptr[si];
}
}
}
}
}
fclose (f);
}
int rc_parse (void) {
char *fn;
struct keyword *kw;
fn = file_in_dir (user_rcdir, RC_FILE);
rc_open (fn);
g_free (fn);
if(!rc)
return -1;
while ((token = rc_next_token ()) != TOKEN_EOF) {
switch (token) {
case TOKEN_KEYWORD:
for (kw = keywords; kw->name; kw++) {
if (strcmp (token_str, kw->name) == 0) {
switch (kw->required) {
case KEYWORD_INT:
if (rc_expect_token (TOKEN_INT))
config_set_int (kw->config, token_int);
break;
case KEYWORD_BOOL:
if (rc_expect_token (TOKEN_INT))
config_set_bool (kw->config, token_int);
break;
case KEYWORD_STRING:
if (rc_expect_token (TOKEN_STRING))
config_set_string (kw->config, token_str);
break;
}
break;
}
}
break;
case TOKEN_EOL:
case TOKEN_EOF:
break;
default:
syntax_error ();
rc_skip_to_eol ();
break;
} /* switch */
} /* while */
rc_close ();
/* Compatibility with old versions */
if (!games[Q1_SERVER].dir && games[QW_SERVER].dir) {
games[Q1_SERVER].dir = g_strdup (games[QW_SERVER].dir);
config_set_string ("/" CONFIG_FILE "/Game: QS/dir", games[Q1_SERVER].dir);
}
if (default_w_switch < 0) default_w_switch = 0;
if (default_b_switch < 0) default_b_switch = 0;
return 0;
}
void props_save (void) {
FILE *f;
char *fn;
GSList *list;
struct server_props *p;
fn = file_in_dir (user_rcdir, SERVERS_FILE);
if (props_list) {
f = fopen (fn, "w");
chmod (fn, S_IRUSR | S_IWUSR);
g_free (fn);
if (!f)
return;
}
else {
unlink (fn);
g_free (fn);
return;
}
for (list = props_list; list; list = list->next) {
p = (struct server_props *) list->data;
if (p->custom_cfg || p->server_password || p->spectator_password || p->rcon_password || p->reserved_slots
|| p->sucks || (p->comment && strlen(p->comment))) {
fprintf (f, "[%s:%d]\n", inet_ntoa (p->host->ip), p->port);
if (p->custom_cfg)
fprintf (f, "custom_cfg %s\n", p->custom_cfg);
if (p->server_password)
fprintf (f, "password %s\n", p->server_password);
if (p->spectator_password)
fprintf (f, "spectator_password %s\n", p->spectator_password);
if (p->rcon_password)
fprintf (f, "rcon_password %s\n", p->rcon_password);
if (p->reserved_slots)
fprintf (f, "reserved_slots %d\n", p->reserved_slots);
if (p->sucks)
fprintf (f, "sucks %d\n", p->sucks);
if (p->comment && strlen(p->comment)) {
char* s = p->comment;
// strip trailing \n, otherwise one is added each time the server is saved
while (s[strlen(s)-1] == '\n')
s[strlen(s)-1] = '\0';
fputs("comment ", f);
while (*s) {
switch(*s) {
case '\n':
fputs("\\n", f);
break;
case '\\':
fputs("\\\\", f);
break;
default:
fputc(*s, f);
break;
}
++s;
}
fputc('\n', f);
}
fprintf (f, "\n");
}
}
fclose (f);
}
