Freeciv

/* Both of these are stored in the local encoding. The grouping_sep must

* be converted to the internal encoding when it's used. */

/* As well as base64 functions, this string is used for checking for

* 'safe' filenames, so should not contain / \ . */

static const char base64url[] =

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";

static struct astring realfile = ASTRING_INIT;

seplen = strlen(sep);

#if 0 /* Not needed while the values are unsigned. */

#endif

if (mantissa == 0) {

if (ptr <= buf + seplen) {

/* Avoid a buffer overflow. */

return ptr;

}

}

ptr -= seplen;

memcpy(ptr, sep, seplen);

if (*(grp + 1) != 0) {

{

int i = 0;

return FALSE;

}

for (; '\0' != name[i]; i++) {

return FALSE;

}

}

const char illegal_chars[] = {'|', '%', '"', ',', '*', '<', '>', '\0'};

int i, j;

return FALSE;

}

{

size_t i = 0;

return FALSE;

}

for (; '\0' != s[i]; i++) {

return FALSE;

}

}

return TRUE;

}

{

size_t i = 0;

return;

}

****************************************************************************/

char *skip_leading_spaces(char *s)

{

while (*s != '\0' && fc_isspace(*s)) {

s++;

{

char *t;

t = skip_leading_spaces(s);

if (t != s) {

while (*t != '\0') {

char *t;

size_t len;

len = strlen(s);

if (len > 0) {

t = s + len -1;

{

char *t;

t = s + strlen(s) -1;

while (t>=s && (*t) == trailing) {

int len = strlen(str);

*nleft -= len;

return str + len;

}

}

/************************************************************************//**

then it will only test 'str' only contains an integer number.

****************************************************************************/

bool str_to_int(const char *str, int *pint)

{

const char *start;

while (fc_isspace(*str)) {

/* Skip leading spaces. */

str++;

}

}

/************************************************************************//**

Convert 'str' to its unsigned int representation if possible.

an unsigned integer number.

****************************************************************************/

bool str_to_uint(const char *str, unsigned int *pint)

{

const char *start;

while (fc_isspace(*str)) {

/* Skip leading spaces. */

str++;

}

}

/************************************************************************//**

****************************************************************************/

bool str_to_float(const char *str, float *pfloat)

{

bool dot;

const char *start;

while (fc_isspace(*str)) {

/* Skip leading spaces. */

}

return ('\0' == *str && dot

}

/************************************************************************//**

Returns string which gives users home dir, as specified by $HOME.

Gets value once, and then caches result.

Note the caller should not mess with the returned string.

****************************************************************************/

char *user_home_dir(void)

#define HOMEVAR "HOME"

#endif

char *env = getenv(HOMEVAR);

if (env) {

log_verbose(HOMEVAR " is %s", home_dir_user);

} else {

log_error("Could not find home directory (" HOMEVAR " is not set).");

}

}

****************************************************************************/

void free_user_home_dir(void)

{

free(home_dir_user);

}

}

****************************************************************************/

char *freeciv_storage_dir(void)

{

storage_dir_freeciv = fc_malloc(strlen(FREECIV_STORAGE_DIR) + 1);

strcpy(storage_dir_freeciv, FREECIV_STORAGE_DIR);

****************************************************************************/

void free_freeciv_storage_dir(void)

{

free(storage_dir_freeciv);

}

}

* is readable etc? Don't currently. */

if (i == -1 && ok_to_free) {

free(tok);

}

}

do {

char *dir = expand_dir(tok, FALSE);

strvec_append(dirs, dir);

if (dir != tok) {

free(dir);

}

}

} while (tok);

free(path);

****************************************************************************/

void free_data_dir_names(void)

{

strvec_destroy(data_dir_names);

}

strvec_destroy(save_dir_names);

}

strvec_destroy(scenario_dir_names);

}

}

/* The first time this function is called it will search and

* allocate the directory listing. Subsequently we will already

* know the list and can just return it. */

const char *path;

#ifdef FREECIV_APPIMAGE

log_error(_("\"%s\" is set but empty; using default \"%s\" "

"data directories instead."),

FREECIV_DATA_PATH, default_data_path);

}

strvec_remove_duplicate(data_dir_names, strcmp); /* Don't set a path both. */

strvec_iterate(data_dir_names, dirname) {

log_verbose("Data path component: %s", dirname);

/* The first time this function is called it will search and

* allocate the directory listing. Subsequently we will already

* know the list and can just return it. */

const char *path;

if ((path = getenv(FREECIV_SAVE_PATH)) && '\0' == path[0]) {

log_error(_("\"%s\" is set but empty; using default \"%s\" "

"save directories instead."),

FREECIV_SAVE_PATH, DEFAULT_SAVE_PATH);

}

strvec_remove_duplicate(save_dir_names, strcmp); /* Don't set a path both. */

strvec_iterate(save_dir_names, dirname) {

log_verbose("Save path component: %s", dirname);

/* The first time this function is called it will search and

* allocate the directory listing. Subsequently we will already

* know the list and can just return it. */

const char *path;

#ifdef FREECIV_APPIMAGE

log_error( _("\"%s\" is set but empty; using default \"%s\" "

"scenario directories instead."),

FREECIV_SCENARIO_PATH, default_scenario_path);

}

strvec_remove_duplicate(scenario_dir_names, strcmp); /* Don't set a path both. */

strvec_iterate(scenario_dir_names, dirname) {

log_verbose("Scenario path component: %s", dirname);

struct strvec *files = strvec_new();

size_t suffix_len = strlen(suffix);

return files;

}

Returns a filename to access the specified file from a

directory by searching all specified directories for the file.

the effective path. (But this should probably only be used for

debug output.)

data directories. (A file is considered "found" if it can be

read-opened.) The returned pointer points to static memory, so this

function can only supply one filename at a time. Don't free that

const char *fileinfoname(const struct strvec *dirs, const char *filename)

{

#ifndef DIR_SEPARATOR_IS_DEFAULT

int i;

#else /* DIR_SEPARATOR_IS_DEFAULT */

const char *fnbuf = filename;

#endif /* DIR_SEPARATOR_IS_DEFAULT */

}

if (!filename) {

log_verbose("Could not find readable file \"%s\" in data path.", filename);

}

/************************************************************************//**

{

struct fileinfo_list *res;

}

res = fileinfo_list_new_full(fileinfo_destroy);

****************************************************************************/

const char *setup_langname(void)

{

#ifdef ENABLE_NLS

langname = getenv("LANG");

break;

}

static char envstr[40];

fc_snprintf(envstr, sizeof(envstr), "LANG=%s", langname);

****************************************************************************/

static void autocap_update(void)

{

int i;

bool ac_enabled = FALSE;

char *lang = getenv("LANG");

if (lang[0] == autocap_opt_in[i][0]

&& lang[1] == autocap_opt_in[i][1]) {

ac_enabled = TRUE;

#ifdef HAVE_SETENV

setenv("LANG", lang, TRUE);

#else /* HAVE_SETENV */

static char envstr[40];

fc_snprintf(envstr, sizeof(envstr), "LANG=%s", lang);

This would result in the "C" locale being used, with grouping ""

and thousands_sep "", where we really want "\3" and ",". */

struct lconv *lc = localeconv();

if (lc->grouping[0] == '\0') {

void free_nls(void)

{

free(grouping);

free(grouping_sep);

}

/************************************************************************//**

If we have root privileges, die with an error.

(Eg, for security reasons.)

Param argv0 should be argv[0] or similar; fallback is

But don't die on systems where the user is always root...

(a general test for this would be better).

Doesn't use log_*() because gets called before logging is setup.

N_("non-match")

};

return descriptions[result];

}

int *ind_result)

{

return match_prefix_full(accessor_fn, n_names, max_len_name, cmp_fn,

}

/************************************************************************//**

Returns type of match or fail, and for return <= M_PRE_AMBIGUOUS

sets *ind_result with matching index (or for ambiguous, first match).

If max_len_name == 0, treat as no maximum.

matching names indices will be inserted into it. If 'pnum_matches' is

****************************************************************************/

enum m_pre_result match_prefix_full(m_pre_accessor_fn_t accessor_fn,

size_t n_names,

{

int i, len, nmatches;

len = strlen(prefix);

} else {

len = len_fn(prefix);

if (nmatches == 0) {

*ind_result = i; /* First match */

}

matches[nmatches] = i;

}

nmatches++;

if (nmatches == 1) {

return M_PRE_ONLY;

} else if (nmatches > 1) {

*pnum_matches = MIN(max_matches, nmatches);

}

return M_PRE_AMBIGUOUS;

static char *default_multicast_group_ipv6 = "FF31::8000:15B4";

#endif /* IPv6 support */

char *env = getenv("FREECIV_MULTICAST_GROUP");

if (env) {

****************************************************************************/

void free_multicast_group(void)

{

free(mc_group);

}

}

{

int j;

for (j = strlen(filepath); j >= 0; j--) {

if (filepath[j] == DIR_SEPARATOR_CHAR) {

bool make_dir(const char *pathname, int mode)

{

char *dir;

if (pathname[0] == '\0') {

return FALSE;

/************************************************************************//**

Scan in a word or set of words from start to but not including

any of the given delimiters. The buf pointer will point past delimiter,

space.

This function should be safe, and dest will contain "\0" and

Due to the way the scanning is performed, looking for a space

will give you the first word even if it comes before multiple

Returns delimiter found.

nothing is found, dest will contain the whole string, minus leading and

trailing whitespace. You can scan for "" to conveniently grab the

remainder of a string.

{

char *ptr, found = '?';

if (dest) {

dest[0] = '\0';

}

return '\0';

}

/* Just skip ahead. */

ptr = strpbrk(*buf, delimiters);

}

found = *ptr;

if (dest) {

*ptr = '\0';

remove_leading_trailing_spaces(dest);

}

*buf = strpbrk(*buf, delimiters);

(*buf)++; /* Skip delimiter */

} else {

}

} else {

}

return found;

****************************************************************************/

void array_shuffle(int *array, int n)

{

int i, j, t;

for (i = 0; i < n - 1; i++) {

if ('\0' != jump_to) {

/* Jump to next matching charather. */

test = strchr(test, jump_to);

/* No match. */

return FALSE;

}

/* Find the end of the pattern. */

while (TRUE) {

*pattern = strchr(*pattern, ']');

/* Wildcard format error. */

return FALSE;

} else if (*(*pattern - 1) != '\\') {

memset(escapes, 0, max_escapes);

format = strchr(format, '%');

format++;

if ('%' == *format) {

/* Double, not a sequence. */

}

while ('\0' != *format

format++;

}

escapes[idx] = *format;

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))

#define ADD_TO_POINTER(p, n) ((void *)((char *)(p)+(n)))

#define FC_MEMBER_OFFSETOF(type, member) ((size_t) &FC_MEMBER(type, member))

#define FC_MEMBER_SIZEOF(type, member) sizeof(FC_MEMBER(type, member))

#define FC_MEMBER_ARRAY_SIZE(type, member) \