client/wrapper.c

Go to the documentation of this file.

/************************************************************************
*            Atrinik, a Multiplayer Online Role Playing Game            *
*                                                                       *
*    Copyright (C) 2009-2011 Alex Tokar and Atrinik Development Team    *
*                                                                       *
* Fork from Daimonin (Massive Multiplayer Online Role Playing Game)     *
* and Crossfire (Multiplayer game for X-windows).                       *
*                                                                       *
* This program is free software; you can redistribute it and/or modify  *
* it under the terms of the GNU General Public License as published by  *
* the Free Software Foundation; either version 2 of the License, or     *
* (at your option) any later version.                                   *
*                                                                       *
* This program is distributed in the hope that it will be useful,       *
* but WITHOUT ANY WARRANTY; without even the implied warranty of        *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
* GNU General Public License for more details.                          *
*                                                                       *
* You should have received a copy of the GNU General Public License     *
* along with this program; if not, write to the Free Software           *
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.             *
*                                                                       *
* The author can be reached at admin@atrinik.org                        *
************************************************************************/

#include <global.h>

static FILE *logstream = NULL;

static const char *const loglevel_names[] =
{
    "[Error] ",
    "[Bug]   ",
    "[Debug] ",
    "[Info]  "
};

void LOG(LogLevel logLevel, char *format, ...)
{
    va_list ap;
    char buf[HUGE_BUF * 4];

    if (!logstream)
    {
        logstream = fopen_wrapper(LOG_FILE, "w");
    }

    va_start(ap, format);
    vsnprintf(buf, sizeof(buf), format, ap);
    va_end(ap);

    fputs(loglevel_names[logLevel], stdout);
    fputs(buf, stdout);

    if (logstream)
    {
        fputs(loglevel_names[logLevel], logstream);
        fputs(buf, logstream);
        fflush(logstream);
    }

    if (logLevel == llevError)
    {
        LOG(llevInfo, "\nFatal error encountered. Exiting...\n");
        system_end();
        abort();
        exit(-1);
    }
}

void system_start()
{
    SDL_Surface *icon;

    icon = IMG_Load_wrapper(DIRECTORY_BITMAPS"/"CLIENT_ICON_NAME);

    if (icon)
    {
        SDL_WM_SetIcon(icon, 0);
        SDL_FreeSurface(icon);
    }

    SDL_WM_SetCaption(PACKAGE_NAME, PACKAGE_NAME);

    logstream = fopen_wrapper(LOG_FILE, "w");
}

void system_end()
{
    popup_destroy_visible();
    list_remove_all();
    script_killall();
    save_interface_file();
    kill_widgets();
    curl_deinit();
    socket_deinitialize();
    sound_deinit();
    free_bitmaps();
    text_deinit();
    free_help_files();
    effects_deinit();
    settings_deinit();
    keybind_deinit();
    SDL_Quit();
}

char *get_word_from_string(char *str, int *pos)
{
    static char buf[HUGE_BUF];
    int i = 0;

    buf[0] = '\0';

    while (*(str + (*pos)) != '\0' && (!isalnum(*(str + (*pos))) && !isalpha(*(str + (*pos)))))
    {
        (*pos)++;
    }

    /* Nothing left */
    if (*(str + (*pos)) == '\0')
    {
        return NULL;
    }

    /* Copy until end of string or whitespace */
    while (*(str + (*pos)) != '\0' && (isalnum(*(str + (*pos))) || isalpha(*(str + (*pos)))))
    {
        buf[i++] = *(str + (*pos)++);
    }

    buf[i] = '\0';

    return buf;
}

static int mkdir_recurse(const char *path)
{
    char *copy, *p;

    p = copy = strdup(path);

    do
    {
        p = strchr(p + 1, '/');

        if (p)
        {
            *p = '\0';
        }

        if (access(copy, F_OK) == -1)
        {
            if (mkdir(copy, 0755) == -1)
            {
                free(copy);
                return -1;
            }
        }

        if (p)
        {
            *p = '/';
        }
    }
    while (p);

    free(copy);

    return 0;
}

void copy_file(const char *filename, const char *filename_out)
{
    FILE *fp, *fp_out;
    char buf[HUGE_BUF], *stmp;

    fp = fopen(filename, "r");

    if (!fp)
    {
        LOG(llevBug, "copy_file(): Failed to open '%s' for reading.\n", filename);
        return;
    }

    stmp = strrchr(filename_out, '/');

    if (stmp)
    {
        char ctmp;

        ctmp = stmp[0];
        stmp[0] = '\0';
        mkdir_recurse(filename_out);
        stmp[0] = ctmp;
    }

    fp_out = fopen(filename_out, "w");

    if (!fp_out)
    {
        LOG(llevBug, "copy_file(): Failed to open '%s' for writing.\n", filename_out);
        fclose(fp);
        return;
    }

    while (fgets(buf, sizeof(buf), fp))
    {
        fputs(buf, fp_out);
    }

    fclose(fp);
    fclose(fp_out);
}

void copy_if_exists(const char *from, const char *to, const char *src, const char *dst)
{
    char src_path[HUGE_BUF], dst_path[HUGE_BUF];

    snprintf(src_path, sizeof(src_path), "%s/%s", from, src);
    snprintf(dst_path, sizeof(dst_path), "%s/%s", to, dst);

    if (access(src_path, R_OK) == 0)
    {
        copy_rec(src_path, dst_path);
    }
}

void rmrf(const char *path)
{
    DIR *dir;
    struct dirent *currentfile;
    char buf[HUGE_BUF];
    struct stat st;

    dir = opendir(path);

    if (!dir)
    {
        return;
    }

    while ((currentfile = readdir(dir)))
    {
        if (!strcmp(currentfile->d_name, ".") || !strcmp(currentfile->d_name, ".."))
        {
            continue;
        }

        snprintf(buf, sizeof(buf), "%s/%s", path, currentfile->d_name);

        if (stat(buf, &st) != 0)
        {
            continue;
        }

        if (S_ISDIR(st.st_mode))
        {
            rmrf(buf);
        }
        else if (S_ISREG(st.st_mode))
        {
            unlink(buf);
        }
    }

    closedir(dir);
    rmdir(path);
}

void copy_rec(const char *src, const char *dst)
{
    struct stat st;

    /* Does it exist? */
    if (stat(src, &st) != 0)
    {
        return;
    }

    /* Copy directory contents. */
    if (S_ISDIR(st.st_mode))
    {
        DIR *dir;
        struct dirent *currentfile;
        char dir_src[HUGE_BUF], dir_dst[HUGE_BUF];

        dir = opendir(src);

        if (!dir)
        {
            return;
        }

        /* Try to make the new directory. */
        if (access(dst, R_OK) != 0)
        {
            mkdir(dst, 0755);
        }

        while ((currentfile = readdir(dir)))
        {
            if (currentfile->d_name[0] == '.')
            {
                continue;
            }

            snprintf(dir_src, sizeof(dir_src), "%s/%s", src, currentfile->d_name);
            snprintf(dir_dst, sizeof(dir_dst), "%s/%s", dst, currentfile->d_name);
            copy_rec(dir_src, dir_dst);
        }

        closedir(dir);
    }
    /* Copy file. */
    else
    {
        copy_file(src, dst);
    }
}

const char *get_config_dir()
{
    const char *desc;

#ifdef LINUX
    desc = getenv("HOME");
#else
    desc = getenv("APPDATA");
#endif

    /* Failed to find an usable destination, so store it in the
     * current directory. */
    if (!desc || !*desc)
    {
        desc = ".";
    }

    return desc;
}

void get_data_dir_file(char *buf, size_t len, const char *fname)
{
    /* Try the current directory first. */
    snprintf(buf, len, "./%s", fname);

#ifdef INSTALL_SUBDIR_SHARE
    /* Not found, try the share directory since it was defined... */
    if (access(buf, R_OK))
    {
        char *prefix;

        /* Get the prefix. */
        prefix = br_find_prefix("./");
        /* Construct the path. */
        snprintf(buf, len, "%s/"INSTALL_SUBDIR_SHARE"/%s", prefix, fname);
        free(prefix);
    }
#endif
}

char *file_path(const char *fname, const char *mode)
{
    static char tmp[HUGE_BUF];
    char *stmp, ctmp, version[MAX_BUF];

    snprintf(tmp, sizeof(tmp), "%s/.atrinik/%s/%s", get_config_dir(), package_get_version_partial(version, sizeof(version)), fname);

    if (strchr(mode, 'w'))
    {
        if ((stmp = strrchr(tmp, '/')))
        {
            ctmp = stmp[0];
            stmp[0] = '\0';
            mkdir_recurse(tmp);
            stmp[0] = ctmp;
        }
    }
    else if (strchr(mode, '+') || strchr(mode, 'a'))
    {
        if (access(tmp, W_OK))
        {
            char otmp[HUGE_BUF];

            get_data_dir_file(otmp, sizeof(otmp), fname);

            if ((stmp = strrchr(tmp, '/')))
            {
                ctmp = stmp[0];
                stmp[0] = '\0';
                mkdir_recurse(tmp);
                stmp[0] = ctmp;
            }

            copy_file(otmp, tmp);
        }
    }
    else
    {
        if (access(tmp, R_OK))
        {
            get_data_dir_file(tmp, sizeof(tmp), fname);
        }
    }

    return tmp;
}

FILE *fopen_wrapper(const char *fname, const char *mode)
{
    return fopen(file_path(fname, mode), mode);
}

SDL_Surface *IMG_Load_wrapper(const char *file)
{
    return IMG_Load(file_path(file, "r"));
}

TTF_Font *TTF_OpenFont_wrapper(const char *file, int ptsize)
{
    return TTF_OpenFont(file_path(file, "r"), ptsize);
}