# HG changeset patch # User Medo # Date 1339029918 -7200 # Node ID 038e3415100a824624febeb87e97e3f62d1ab974 # Parent 7c2eb284f9f1c1bae504b95250e1f66d53b7a298 Added ini reading/writing for game schemes to the frontend lib diff -r 7c2eb284f9f1 -r 038e3415100a project_files/Android-build/SDL-android-project/res/raw/basicsettings.ini --- a/project_files/Android-build/SDL-android-project/res/raw/basicsettings.ini Mon Jun 04 21:12:20 2012 +0200 +++ b/project_files/Android-build/SDL-android-project/res/raw/basicsettings.ini Thu Jun 07 02:45:18 2012 +0200 @@ -19,6 +19,7 @@ title=Turn Time [InitialHealth] +checkOverMax=false times1000=false command=inithealth default=200 diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/demo.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/demo.c Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,67 @@ +#include "demo.h" +#include "logging.h" + +#include +#include +#include + +static int demo_record(flib_vector demoBuffer, const void *data, size_t len) { + if(flib_vector_append(demoBuffer, data, len) < len) { + flib_log_e("Error recording demo: Out of memory."); + return -1; + } else { + return 0; + } +} + +int flib_demo_record_from_engine(flib_vector demoBuffer, const uint8_t *message, const char *playerName) { + if(!demoBuffer || !message || !playerName) { + flib_log_e("Call to flib_demo_record_from_engine with demoBuffer==null or message==null or playerName==null"); + return -1; + } + + if(strchr("?CEiQqHb", message[1])) { + return 0; // Those message types are not recorded in a demo. + } + + if(message[1] == 's') { + if(message[0] >= 3) { + // Chat messages are reformatted to make them look as if they were received, not sent. + // Get the actual chat message as C string + char chatMsg[256]; + memcpy(chatMsg, message+2, message[0]-3); + chatMsg[message[0]-3] = 0; + + // If the message starts with /me, it will be displayed differently. + char converted[257]; + bool memessage = message[0] >= 7 && !memcmp(message+2, "/me ", 4); + const char *template = memessage ? "s\x02* %s %s " : "s\x01%s: %s "; + int size = snprintf(converted+1, 256, template, playerName, chatMsg); + converted[0] = size>255 ? 255 : size; + return demo_record(demoBuffer, converted, converted[0]+1); + } else { + return 0; // Malformed chat message is no reason to abort... + } + } else { + return demo_record(demoBuffer, message, message[0]+1); + } +} + +int flib_demo_record_to_engine(flib_vector demoBuffer, const uint8_t *message, size_t len) { + if(!demoBuffer || (len>0 && !message)) { + flib_log_e("Call to flib_demo_record_to_engine with demoBuffer==null or message==null"); + return -1; + } + return demo_record(demoBuffer, message, len); +} + +void flib_demo_replace_gamemode(flib_buffer buf, char gamemode) { + size_t msgStart = 0; + char *data = (char*)buf.data; + while(msgStart+2 < buf.size) { + if(!memcmp(data+msgStart, "\x02T", 2)) { + data[msgStart+2] = gamemode; + } + msgStart += (uint8_t)data[msgStart]+1; + } +} diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/demo.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/demo.h Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,30 @@ +/** + * Demo recording functions. Only used by the ipc game code. + */ + +#ifndef DEMO_H_ +#define DEMO_H_ + +#include "buffer.h" + +/** + * Record a message sent from the engine to the frontend. + * Returns 0 for OK, a negative value on error. + * Don't pass NULL. + */ +int flib_demo_record_from_engine(flib_vector demoBuffer, const uint8_t *message, const char *playerName); + +/** + * Record a message sent from the frontend to the engine. + * Returns 0 for OK, a negative value on error. + * Don't pass NULL. + */ +int flib_demo_record_to_engine(flib_vector demoBuffer, const uint8_t *message, size_t len); + +/** + * Replace game mode messages ("TL", "TD", "TS", "TN") in the recording to mirror + * the intended use. Pass 'S' for savegames, 'D' for demos. + */ +void flib_demo_replace_gamemode(flib_buffer buf, char gamemode); + +#endif /* DEMO_H_ */ diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/frontlib.c --- a/project_files/frontlib/frontlib.c Mon Jun 04 21:12:20 2012 +0200 +++ b/project_files/frontlib/frontlib.c Thu Jun 07 02:45:18 2012 +0200 @@ -2,6 +2,7 @@ #include "logging.h" #include "socket.h" #include "ipc.h" +#include "model/cfg.h" #include #include @@ -76,6 +77,15 @@ int main(int argc, char *argv[]) { flib_init(0); + flib_cfg_meta *meta = flib_cfg_meta_from_ini("basicsettings.ini", "gamemods.ini"); + flib_cfg *cfg = flib_cfg_create(meta, "DefaultScheme"); + flib_cfg_to_ini(meta, "defaulttest.ini", cfg); + + flib_cfg_meta_destroy(meta); + + flib_quit(); + return 0; +/* flib_ipc ipc = flib_ipc_create(true, "Medo42"); assert(ipc); flib_ipc_onConfigQuery(ipc, &onConfigQuery, ipc); @@ -87,5 +97,5 @@ } flib_log_i("Shutting down..."); flib_quit(); - return 0; + return 0;*/ } diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/ini/inihelper.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/ini/inihelper.c Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,183 @@ +#include "inihelper.h" +#include "../logging.h" + +#include +#include +#include +#include +#include +#include + +static char *flib_asprintf(const char *fmt, ...) { + va_list argp; + va_start(argp, fmt); + size_t requiredSize = vsnprintf(NULL, 0, fmt, argp)+1; + char *buf = malloc(requiredSize); + if(buf) { + vsnprintf(buf, requiredSize, fmt, argp); + } + va_end(argp); + return buf; +} + +char *inihelper_strdupnull(const char *str) { + if(!str) { + return NULL; + } + return flib_asprintf("%s", str); +} + +static bool keychar_needs_urlencoding(char c) { + return !isalnum(c); +} + +char *inihelper_urlencode(const char *inbuf) { + if(!inbuf) { + return NULL; + } + size_t insize = strlen(inbuf); + if(insize > SIZE_MAX/4) { + return NULL; + } + + char *outbuf = malloc(insize*3+1); + if(!outbuf) { + return NULL; + } + + size_t inpos = 0, outpos = 0; + while(inbuf[inpos]) { + if(!keychar_needs_urlencoding(inbuf[inpos])) { + outbuf[outpos++] = inbuf[inpos++]; + } else { + sprintf(outbuf+outpos, "%%%02X", inbuf[inpos]); + inpos++; + outpos += 3; + } + } + outbuf[outpos] = 0; + return outbuf; +} + +char *inihelper_urldecode(const char *inbuf) { + char *outbuf = malloc(strlen(inbuf)+1); + if(!outbuf) { + return NULL; + } + + size_t inpos = 0, outpos = 0; + while(inbuf[inpos]) { + if(inbuf[inpos] == '%' && isxdigit(inbuf[inpos+1]) && isxdigit(inbuf[inpos+2])) { + char temp[3] = {inbuf[inpos+1],inbuf[inpos+2],0}; + outbuf[outpos++] = strtol(temp, NULL, 16); + inpos += 3; + } else { + outbuf[outpos++] = inbuf[inpos++]; + } + } + outbuf[outpos] = 0; + return outbuf; +} + +char *inihelper_createDictKey(const char *sectionName, const char *keyName) { + if(!sectionName || !keyName) { + return NULL; + } + return flib_asprintf("%s:%s", sectionName, keyName); +} + +char *inihelper_getstring(dictionary *inifile, bool *error, const char *sectionName, const char *keyName) { + if(!inifile || !sectionName || !keyName) { + *error = true; + return NULL; + } + char *extendedkey = inihelper_createDictKey(sectionName, keyName); + if(!extendedkey) { + *error = true; + return NULL; + } + char *result = iniparser_getstring(inifile, extendedkey, NULL); + free(extendedkey); + if(!result) { + flib_log_i("Missing ini setting: %s/%s", sectionName, keyName); + *error = true; + } + return result; +} + +char *inihelper_getstringdup(dictionary *inifile, bool *error, const char *sectionName, const char *keyName) { + return inihelper_strdupnull(inihelper_getstring(inifile, error, sectionName, keyName)); +} + +int inihelper_getint(dictionary *inifile, bool *error, const char *sectionName, const char *keyName) { + char *value = inihelper_getstring(inifile, error, sectionName, keyName); + if(!value) { + return 0; + } else { + errno = 0; + long val = strtol(value, NULL, 10); + if(errno!=0) { + *error = true; + return 0; + } + if(valINT_MAX) { + *error = true; + return 0; + } + return (int)val; + } +} + +bool inihelper_getbool(dictionary *inifile, bool *error, const char *sectionName, const char *keyName) { + char *value = inihelper_getstring(inifile, error, sectionName, keyName); + if(!value) { + return false; + } else { + bool trueval = strchr("1tTyY", value[0]); + bool falseval = strchr("0fFnN", value[0]); + if(!trueval && !falseval) { + *error = true; + return false; + } else { + return trueval; + } + } +} + +int inihelper_setstr(dictionary *dict, const char *sectionName, const char *keyName, const char *value) { + int result = -1; + if(!dict || !sectionName || !keyName || !value) { + flib_log_e("inihelper_setstr called with bad parameters"); + } else { + char *extendedkey = inihelper_createDictKey(sectionName, keyName); + if(extendedkey) { + result = iniparser_set(dict, extendedkey, value); + free(extendedkey); + } + } + return result; +} + +int inihelper_setint(dictionary *dict, const char *sectionName, const char *keyName, int value) { + int result = -1; + if(!dict || !sectionName || !keyName) { + flib_log_e("inihelper_setint called with bad parameters"); + } else { + char *strvalue = flib_asprintf("%i", value); + if(strvalue) { + result = inihelper_setstr(dict, sectionName, keyName, strvalue); + free(strvalue); + } + } + return result; +} + +int inihelper_setbool(dictionary *dict, const char *sectionName, const char *keyName, bool value) { + int result = -1; + if(!dict || !sectionName || !keyName) { + flib_log_e("inihelper_setint called with bad parameters"); + } else { + result = inihelper_setstr(dict, sectionName, keyName, value ? "true" : "false"); + } + return result; +} diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/ini/inihelper.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/ini/inihelper.h Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,58 @@ +/** + * Some helper functions for working with the iniparser functions - in particular, + * for interoperability with the ini format used by the QtSettings class. + */ + +#ifndef INIHELPER_H_ +#define INIHELPER_H_ + +#include "../iniparser/iniparser.h" +#include + +/** + * Returned buffer must be free()d + */ +char *inihelper_strdupnull(const char *str); + +/** + * Returned buffer must be free()d + */ +char *inihelper_urlencode(const char *inbuf); + +/** + * Returned buffer must be free()d + */ +char *inihelper_urldecode(const char *inbuf); + +/** + * Create a key in the format "sectionName:keyName" + * Returned buffer must be free()d + */ +char *inihelper_createDictKey(const char *sectionName, const char *keyName); + +/** + * Returns an internal buffer, don't modify or free + * Sets error to true if something goes wrong, leaves it unchanged otherwise. + */ +char *inihelper_getstring(dictionary *inifile, bool *error, const char *sectionName, const char *keyName); + +/** + * Returned buffer must be free()d + * Sets error to true if something goes wrong, leaves it unchanged otherwise. + */ +char *inihelper_getstringdup(dictionary *inifile, bool *error, const char *sectionName, const char *keyName); + +/** + * Sets error to true if something goes wrong, leaves it unchanged otherwise. + */ +int inihelper_getint(dictionary *inifile, bool *error, const char *sectionName, const char *keyName); + +/** + * Sets error to true if something goes wrong, leaves it unchanged otherwise. + */ +bool inihelper_getbool(dictionary *inifile, bool *error, const char *sectionName, const char *keyName); + +int inihelper_setstr(dictionary *dict, const char *sectionName, const char *keyName, const char *value); +int inihelper_setint(dictionary *dict, const char *sectionName, const char *keyName, int value); +int inihelper_setbool(dictionary *dict, const char *sectionName, const char *keyName, bool value); +#endif /* INIHELPER_H_ */ diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/iniparser/LICENSE --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/iniparser/LICENSE Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,23 @@ +Copyright (c) 2000-2012 by Nicolas Devillard. +MIT License + +Permission is hereby granted, free of charge, to any person +obtaining a copy of this software and associated documentation +files (the "Software"), to deal in the Software without +restriction, including without limitation the rights to use, +copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES +OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT +HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. \ No newline at end of file diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/iniparser/VERSION --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/iniparser/VERSION Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,2 @@ +This is version 3.1 of the iniparser library developed by N. Devillard. +See http://ndevilla.free.fr/iniparser/ for details and new versions. \ No newline at end of file diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/iniparser/dictionary.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/iniparser/dictionary.c Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,398 @@ +/*-------------------------------------------------------------------------*/ +/** + @file dictionary.c + @author N. Devillard + @brief Implements a dictionary for string variables. + + This module implements a simple dictionary object, i.e. a list + of string/string associations. This object is useful to store e.g. + informations retrieved from a configuration file (ini files). +*/ +/*--------------------------------------------------------------------------*/ + +/*--------------------------------------------------------------------------- + Includes + ---------------------------------------------------------------------------*/ +#include "dictionary.h" + +#include +#include +#include +#include + +/** Maximum value size for integers and doubles. */ +#define MAXVALSZ 1024 + +/** Minimal allocated number of entries in a dictionary */ +#define DICTMINSZ 128 + +/** Invalid key token */ +#define DICT_INVALID_KEY ((char*)-1) + +/*--------------------------------------------------------------------------- + Private functions + ---------------------------------------------------------------------------*/ + +/* Doubles the allocated size associated to a pointer */ +/* 'size' is the current allocated size. */ +static void * mem_double(void * ptr, int size) +{ + void * newptr ; + + newptr = calloc(2*size, 1); + if (newptr==NULL) { + return NULL ; + } + memcpy(newptr, ptr, size); + free(ptr); + return newptr ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Duplicate a string + @param s String to duplicate + @return Pointer to a newly allocated string, to be freed with free() + + This is a replacement for strdup(). This implementation is provided + for systems that do not have it. + */ +/*--------------------------------------------------------------------------*/ +static char * xstrdup(const char * s) +{ + char * t ; + if (!s) + return NULL ; + t = (char*)malloc(strlen(s)+1) ; + if (t) { + strcpy(t,s); + } + return t ; +} + +/*--------------------------------------------------------------------------- + Function codes + ---------------------------------------------------------------------------*/ +/*-------------------------------------------------------------------------*/ +/** + @brief Compute the hash key for a string. + @param key Character string to use for key. + @return 1 unsigned int on at least 32 bits. + + This hash function has been taken from an Article in Dr Dobbs Journal. + This is normally a collision-free function, distributing keys evenly. + The key is stored anyway in the struct so that collision can be avoided + by comparing the key itself in last resort. + */ +/*--------------------------------------------------------------------------*/ +unsigned dictionary_hash(const char * key) +{ + int len ; + unsigned hash ; + int i ; + + len = strlen(key); + for (hash=0, i=0 ; i>6) ; + } + hash += (hash <<3); + hash ^= (hash >>11); + hash += (hash <<15); + return hash ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Create a new dictionary object. + @param size Optional initial size of the dictionary. + @return 1 newly allocated dictionary objet. + + This function allocates a new dictionary object of given size and returns + it. If you do not know in advance (roughly) the number of entries in the + dictionary, give size=0. + */ +/*--------------------------------------------------------------------------*/ +dictionary * dictionary_new(int size) +{ + dictionary * d ; + + /* If no size was specified, allocate space for DICTMINSZ */ + if (sizesize = size ; + d->val = (char **)calloc(size, sizeof(char*)); + d->key = (char **)calloc(size, sizeof(char*)); + d->hash = (unsigned int *)calloc(size, sizeof(unsigned)); + return d ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Delete a dictionary object + @param d dictionary object to deallocate. + @return void + + Deallocate a dictionary object and all memory associated to it. + */ +/*--------------------------------------------------------------------------*/ +void dictionary_del(dictionary * d) +{ + int i ; + + if (d==NULL) return ; + for (i=0 ; isize ; i++) { + if (d->key[i]!=NULL) + free(d->key[i]); + if (d->val[i]!=NULL) + free(d->val[i]); + } + free(d->val); + free(d->key); + free(d->hash); + free(d); + return ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Get a value from a dictionary. + @param d dictionary object to search. + @param key Key to look for in the dictionary. + @param def Default value to return if key not found. + @return 1 pointer to internally allocated character string. + + This function locates a key in a dictionary and returns a pointer to its + value, or the passed 'def' pointer if no such key can be found in + dictionary. The returned character pointer points to data internal to the + dictionary object, you should not try to free it or modify it. + */ +/*--------------------------------------------------------------------------*/ +char * dictionary_get(dictionary * d, const char * key, char * def) +{ + unsigned hash ; + int i ; + + hash = dictionary_hash(key); + for (i=0 ; isize ; i++) { + if (d->key[i]==NULL) + continue ; + /* Compare hash */ + if (hash==d->hash[i]) { + /* Compare string, to avoid hash collisions */ + if (!strcmp(key, d->key[i])) { + return d->val[i] ; + } + } + } + return def ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Set a value in a dictionary. + @param d dictionary object to modify. + @param key Key to modify or add. + @param val Value to add. + @return int 0 if Ok, anything else otherwise + + If the given key is found in the dictionary, the associated value is + replaced by the provided one. If the key cannot be found in the + dictionary, it is added to it. + + It is Ok to provide a NULL value for val, but NULL values for the dictionary + or the key are considered as errors: the function will return immediately + in such a case. + + Notice that if you dictionary_set a variable to NULL, a call to + dictionary_get will return a NULL value: the variable will be found, and + its value (NULL) is returned. In other words, setting the variable + content to NULL is equivalent to deleting the variable from the + dictionary. It is not possible (in this implementation) to have a key in + the dictionary without value. + + This function returns non-zero in case of failure. + */ +/*--------------------------------------------------------------------------*/ +int dictionary_set(dictionary * d, const char * key, const char * val) +{ + int i ; + unsigned hash ; + + if (d==NULL || key==NULL) return -1 ; + + /* Compute hash for this key */ + hash = dictionary_hash(key) ; + /* Find if value is already in dictionary */ + if (d->n>0) { + for (i=0 ; isize ; i++) { + if (d->key[i]==NULL) + continue ; + if (hash==d->hash[i]) { /* Same hash value */ + if (!strcmp(key, d->key[i])) { /* Same key */ + /* Found a value: modify and return */ + if (d->val[i]!=NULL) + free(d->val[i]); + d->val[i] = val ? xstrdup(val) : NULL ; + /* Value has been modified: return */ + return 0 ; + } + } + } + } + /* Add a new value */ + /* See if dictionary needs to grow */ + if (d->n==d->size) { + + /* Reached maximum size: reallocate dictionary */ + d->val = (char **)mem_double(d->val, d->size * sizeof(char*)) ; + d->key = (char **)mem_double(d->key, d->size * sizeof(char*)) ; + d->hash = (unsigned int *)mem_double(d->hash, d->size * sizeof(unsigned)) ; + if ((d->val==NULL) || (d->key==NULL) || (d->hash==NULL)) { + /* Cannot grow dictionary */ + return -1 ; + } + /* Double size */ + d->size *= 2 ; + } + + /* Insert key in the first empty slot. Start at d->n and wrap at + d->size. Because d->n < d->size this will necessarily + terminate. */ + for (i=d->n ; d->key[i] ; ) { + if(++i == d->size) i = 0; + } + /* Copy key */ + d->key[i] = xstrdup(key); + d->val[i] = val ? xstrdup(val) : NULL ; + d->hash[i] = hash; + d->n ++ ; + return 0 ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Delete a key in a dictionary + @param d dictionary object to modify. + @param key Key to remove. + @return void + + This function deletes a key in a dictionary. Nothing is done if the + key cannot be found. + */ +/*--------------------------------------------------------------------------*/ +void dictionary_unset(dictionary * d, const char * key) +{ + unsigned hash ; + int i ; + + if (key == NULL) { + return; + } + + hash = dictionary_hash(key); + for (i=0 ; isize ; i++) { + if (d->key[i]==NULL) + continue ; + /* Compare hash */ + if (hash==d->hash[i]) { + /* Compare string, to avoid hash collisions */ + if (!strcmp(key, d->key[i])) { + /* Found key */ + break ; + } + } + } + if (i>=d->size) + /* Key not found */ + return ; + + free(d->key[i]); + d->key[i] = NULL ; + if (d->val[i]!=NULL) { + free(d->val[i]); + d->val[i] = NULL ; + } + d->hash[i] = 0 ; + d->n -- ; + return ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Dump a dictionary to an opened file pointer. + @param d Dictionary to dump + @param f Opened file pointer. + @return void + + Dumps a dictionary onto an opened file pointer. Key pairs are printed out + as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as + output file pointers. + */ +/*--------------------------------------------------------------------------*/ +void dictionary_dump(dictionary * d, FILE * out) +{ + int i ; + + if (d==NULL || out==NULL) return ; + if (d->n<1) { + fprintf(out, "empty dictionary\n"); + return ; + } + for (i=0 ; isize ; i++) { + if (d->key[i]) { + fprintf(out, "%20s\t[%s]\n", + d->key[i], + d->val[i] ? d->val[i] : "UNDEF"); + } + } + return ; +} + + +/* Test code */ +#ifdef TESTDIC +#define NVALS 20000 +int main(int argc, char *argv[]) +{ + dictionary * d ; + char * val ; + int i ; + char cval[90] ; + + /* Allocate dictionary */ + printf("allocating...\n"); + d = dictionary_new(0); + + /* Set values in dictionary */ + printf("setting %d values...\n", NVALS); + for (i=0 ; in != 0) { + printf("error deleting values\n"); + } + printf("deallocating...\n"); + dictionary_del(d); + return 0 ; +} +#endif +/* vim: set ts=4 et sw=4 tw=75 */ diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/iniparser/dictionary.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/iniparser/dictionary.h Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,165 @@ + +/*-------------------------------------------------------------------------*/ +/** + @file dictionary.h + @author N. Devillard + @brief Implements a dictionary for string variables. + + This module implements a simple dictionary object, i.e. a list + of string/string associations. This object is useful to store e.g. + informations retrieved from a configuration file (ini files). +*/ +/*--------------------------------------------------------------------------*/ + +#ifndef _DICTIONARY_H_ +#define _DICTIONARY_H_ + +/*--------------------------------------------------------------------------- + Includes + ---------------------------------------------------------------------------*/ + +#include +#include +#include +#include + +/*--------------------------------------------------------------------------- + New types + ---------------------------------------------------------------------------*/ + + +/*-------------------------------------------------------------------------*/ +/** + @brief Dictionary object + + This object contains a list of string/string associations. Each + association is identified by a unique string key. Looking up values + in the dictionary is speeded up by the use of a (hopefully collision-free) + hash function. + */ +/*-------------------------------------------------------------------------*/ +typedef struct _dictionary_ { + int n ; /** Number of entries in dictionary */ + int size ; /** Storage size */ + char ** val ; /** List of string values */ + char ** key ; /** List of string keys */ + unsigned * hash ; /** List of hash values for keys */ +} dictionary ; + + +/*--------------------------------------------------------------------------- + Function prototypes + ---------------------------------------------------------------------------*/ + +/*-------------------------------------------------------------------------*/ +/** + @brief Compute the hash key for a string. + @param key Character string to use for key. + @return 1 unsigned int on at least 32 bits. + + This hash function has been taken from an Article in Dr Dobbs Journal. + This is normally a collision-free function, distributing keys evenly. + The key is stored anyway in the struct so that collision can be avoided + by comparing the key itself in last resort. + */ +/*--------------------------------------------------------------------------*/ +unsigned dictionary_hash(const char * key); + +/*-------------------------------------------------------------------------*/ +/** + @brief Create a new dictionary object. + @param size Optional initial size of the dictionary. + @return 1 newly allocated dictionary objet. + + This function allocates a new dictionary object of given size and returns + it. If you do not know in advance (roughly) the number of entries in the + dictionary, give size=0. + */ +/*--------------------------------------------------------------------------*/ +dictionary * dictionary_new(int size); + +/*-------------------------------------------------------------------------*/ +/** + @brief Delete a dictionary object + @param d dictionary object to deallocate. + @return void + + Deallocate a dictionary object and all memory associated to it. + */ +/*--------------------------------------------------------------------------*/ +void dictionary_del(dictionary * vd); + +/*-------------------------------------------------------------------------*/ +/** + @brief Get a value from a dictionary. + @param d dictionary object to search. + @param key Key to look for in the dictionary. + @param def Default value to return if key not found. + @return 1 pointer to internally allocated character string. + + This function locates a key in a dictionary and returns a pointer to its + value, or the passed 'def' pointer if no such key can be found in + dictionary. The returned character pointer points to data internal to the + dictionary object, you should not try to free it or modify it. + */ +/*--------------------------------------------------------------------------*/ +char * dictionary_get(dictionary * d, const char * key, char * def); + + +/*-------------------------------------------------------------------------*/ +/** + @brief Set a value in a dictionary. + @param d dictionary object to modify. + @param key Key to modify or add. + @param val Value to add. + @return int 0 if Ok, anything else otherwise + + If the given key is found in the dictionary, the associated value is + replaced by the provided one. If the key cannot be found in the + dictionary, it is added to it. + + It is Ok to provide a NULL value for val, but NULL values for the dictionary + or the key are considered as errors: the function will return immediately + in such a case. + + Notice that if you dictionary_set a variable to NULL, a call to + dictionary_get will return a NULL value: the variable will be found, and + its value (NULL) is returned. In other words, setting the variable + content to NULL is equivalent to deleting the variable from the + dictionary. It is not possible (in this implementation) to have a key in + the dictionary without value. + + This function returns non-zero in case of failure. + */ +/*--------------------------------------------------------------------------*/ +int dictionary_set(dictionary * vd, const char * key, const char * val); + +/*-------------------------------------------------------------------------*/ +/** + @brief Delete a key in a dictionary + @param d dictionary object to modify. + @param key Key to remove. + @return void + + This function deletes a key in a dictionary. Nothing is done if the + key cannot be found. + */ +/*--------------------------------------------------------------------------*/ +void dictionary_unset(dictionary * d, const char * key); + + +/*-------------------------------------------------------------------------*/ +/** + @brief Dump a dictionary to an opened file pointer. + @param d Dictionary to dump + @param f Opened file pointer. + @return void + + Dumps a dictionary onto an opened file pointer. Key pairs are printed out + as @c [Key]=[Value], one per line. It is Ok to provide stdout or stderr as + output file pointers. + */ +/*--------------------------------------------------------------------------*/ +void dictionary_dump(dictionary * d, FILE * out); + +#endif diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/iniparser/iniparser.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/iniparser/iniparser.c Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,748 @@ + +/*-------------------------------------------------------------------------*/ +/** + @file iniparser.c + @author N. Devillard + @brief Parser for ini files. +*/ +/*--------------------------------------------------------------------------*/ +/*---------------------------- Includes ------------------------------------*/ +#include +#include "iniparser.h" + +/*---------------------------- Defines -------------------------------------*/ +#define ASCIILINESZ (1024) +#define INI_INVALID_KEY ((char*)-1) + +/*--------------------------------------------------------------------------- + Private to this module + ---------------------------------------------------------------------------*/ +/** + * This enum stores the status for each parsed line (internal use only). + */ +typedef enum _line_status_ { + LINE_UNPROCESSED, + LINE_ERROR, + LINE_EMPTY, + LINE_COMMENT, + LINE_SECTION, + LINE_VALUE +} line_status ; + +/*-------------------------------------------------------------------------*/ +/** + @brief Convert a string to lowercase. + @param s String to convert. + @return ptr to statically allocated string. + + This function returns a pointer to a statically allocated string + containing a lowercased version of the input string. Do not free + or modify the returned string! Since the returned string is statically + allocated, it will be modified at each function call (not re-entrant). + */ +/*--------------------------------------------------------------------------*/ +static char * strlwc(const char * s) +{ + static char l[ASCIILINESZ+1]; + int i ; + + if (s==NULL) return NULL ; + memset(l, 0, ASCIILINESZ+1); + i=0 ; + while (s[i] && i l) { + if (!isspace((int)*(last-1))) + break ; + last -- ; + } + *last = (char)0; + return (char*)l ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Get number of sections in a dictionary + @param d Dictionary to examine + @return int Number of sections found in dictionary + + This function returns the number of sections found in a dictionary. + The test to recognize sections is done on the string stored in the + dictionary: a section name is given as "section" whereas a key is + stored as "section:key", thus the test looks for entries that do not + contain a colon. + + This clearly fails in the case a section name contains a colon, but + this should simply be avoided. + + This function returns -1 in case of error. + */ +/*--------------------------------------------------------------------------*/ +int iniparser_getnsec(dictionary * d) +{ + int i ; + int nsec ; + + if (d==NULL) return -1 ; + nsec=0 ; + for (i=0 ; isize ; i++) { + if (d->key[i]==NULL) + continue ; + if (strchr(d->key[i], ':')==NULL) { + nsec ++ ; + } + } + return nsec ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Get name for section n in a dictionary. + @param d Dictionary to examine + @param n Section number (from 0 to nsec-1). + @return Pointer to char string + + This function locates the n-th section in a dictionary and returns + its name as a pointer to a string statically allocated inside the + dictionary. Do not free or modify the returned string! + + This function returns NULL in case of error. + */ +/*--------------------------------------------------------------------------*/ +char * iniparser_getsecname(dictionary * d, int n) +{ + int i ; + int foundsec ; + + if (d==NULL || n<0) return NULL ; + foundsec=0 ; + for (i=0 ; isize ; i++) { + if (d->key[i]==NULL) + continue ; + if (strchr(d->key[i], ':')==NULL) { + foundsec++ ; + if (foundsec>n) + break ; + } + } + if (foundsec<=n) { + return NULL ; + } + return d->key[i] ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Dump a dictionary to an opened file pointer. + @param d Dictionary to dump. + @param f Opened file pointer to dump to. + @return void + + This function prints out the contents of a dictionary, one element by + line, onto the provided file pointer. It is OK to specify @c stderr + or @c stdout as output files. This function is meant for debugging + purposes mostly. + */ +/*--------------------------------------------------------------------------*/ +void iniparser_dump(dictionary * d, FILE * f) +{ + int i ; + + if (d==NULL || f==NULL) return ; + for (i=0 ; isize ; i++) { + if (d->key[i]==NULL) + continue ; + if (d->val[i]!=NULL) { + fprintf(f, "[%s]=[%s]\n", d->key[i], d->val[i]); + } else { + fprintf(f, "[%s]=UNDEF\n", d->key[i]); + } + } + return ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Save a dictionary to a loadable ini file + @param d Dictionary to dump + @param f Opened file pointer to dump to + @return void + + This function dumps a given dictionary into a loadable ini file. + It is Ok to specify @c stderr or @c stdout as output files. + */ +/*--------------------------------------------------------------------------*/ +void iniparser_dump_ini(dictionary * d, FILE * f) +{ + int i ; + int nsec ; + char * secname ; + + if (d==NULL || f==NULL) return ; + + nsec = iniparser_getnsec(d); + if (nsec<1) { + /* No section in file: dump all keys as they are */ + for (i=0 ; isize ; i++) { + if (d->key[i]==NULL) + continue ; + fprintf(f, "%s = %s\n", d->key[i], d->val[i]); + } + return ; + } + for (i=0 ; isize ; j++) { + if (d->key[j]==NULL) + continue ; + if (!strncmp(d->key[j], keym, seclen+1)) { + fprintf(f, + "%-30s = %s\n", + d->key[j]+seclen+1, + d->val[j] ? d->val[j] : ""); + } + } + fprintf(f, "\n"); + return ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the number of keys in a section of a dictionary. + @param d Dictionary to examine + @param s Section name of dictionary to examine + @return Number of keys in section + */ +/*--------------------------------------------------------------------------*/ +int iniparser_getsecnkeys(dictionary * d, char * s) +{ + int seclen, nkeys ; + char keym[ASCIILINESZ+1]; + int j ; + + nkeys = 0; + + if (d==NULL) return nkeys; + if (! iniparser_find_entry(d, s)) return nkeys; + + seclen = (int)strlen(s); + sprintf(keym, "%s:", s); + + for (j=0 ; jsize ; j++) { + if (d->key[j]==NULL) + continue ; + if (!strncmp(d->key[j], keym, seclen+1)) + nkeys++; + } + + return nkeys; + +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the number of keys in a section of a dictionary. + @param d Dictionary to examine + @param s Section name of dictionary to examine + @return pointer to statically allocated character strings + + This function queries a dictionary and finds all keys in a given section. + Each pointer in the returned char pointer-to-pointer is pointing to + a string allocated in the dictionary; do not free or modify them. + + This function returns NULL in case of error. + */ +/*--------------------------------------------------------------------------*/ +char ** iniparser_getseckeys(dictionary * d, char * s) +{ + + char **keys; + + int i, j ; + char keym[ASCIILINESZ+1]; + int seclen, nkeys ; + + keys = NULL; + + if (d==NULL) return keys; + if (! iniparser_find_entry(d, s)) return keys; + + nkeys = iniparser_getsecnkeys(d, s); + + keys = (char**) malloc(nkeys*sizeof(char*)); + + seclen = (int)strlen(s); + sprintf(keym, "%s:", s); + + i = 0; + + for (j=0 ; jsize ; j++) { + if (d->key[j]==NULL) + continue ; + if (!strncmp(d->key[j], keym, seclen+1)) { + keys[i] = d->key[j]; + i++; + } + } + + return keys; + +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the string associated to a key + @param d Dictionary to search + @param key Key string to look for + @param def Default value to return if key not found. + @return pointer to statically allocated character string + + This function queries a dictionary for a key. A key as read from an + ini file is given as "section:key". If the key cannot be found, + the pointer passed as 'def' is returned. + The returned char pointer is pointing to a string allocated in + the dictionary, do not free or modify it. + */ +/*--------------------------------------------------------------------------*/ +char * iniparser_getstring(dictionary * d, const char * key, char * def) +{ + char * lc_key ; + char * sval ; + + if (d==NULL || key==NULL) + return def ; + + lc_key = strlwc(key); + sval = dictionary_get(d, lc_key, def); + return sval ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the string associated to a key, convert to an int + @param d Dictionary to search + @param key Key string to look for + @param notfound Value to return in case of error + @return integer + + This function queries a dictionary for a key. A key as read from an + ini file is given as "section:key". If the key cannot be found, + the notfound value is returned. + + Supported values for integers include the usual C notation + so decimal, octal (starting with 0) and hexadecimal (starting with 0x) + are supported. Examples: + + "42" -> 42 + "042" -> 34 (octal -> decimal) + "0x42" -> 66 (hexa -> decimal) + + Warning: the conversion may overflow in various ways. Conversion is + totally outsourced to strtol(), see the associated man page for overflow + handling. + + Credits: Thanks to A. Becker for suggesting strtol() + */ +/*--------------------------------------------------------------------------*/ +int iniparser_getint(dictionary * d, const char * key, int notfound) +{ + char * str ; + + str = iniparser_getstring(d, key, INI_INVALID_KEY); + if (str==INI_INVALID_KEY) return notfound ; + return (int)strtol(str, NULL, 0); +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the string associated to a key, convert to a double + @param d Dictionary to search + @param key Key string to look for + @param notfound Value to return in case of error + @return double + + This function queries a dictionary for a key. A key as read from an + ini file is given as "section:key". If the key cannot be found, + the notfound value is returned. + */ +/*--------------------------------------------------------------------------*/ +double iniparser_getdouble(dictionary * d, const char * key, double notfound) +{ + char * str ; + + str = iniparser_getstring(d, key, INI_INVALID_KEY); + if (str==INI_INVALID_KEY) return notfound ; + return atof(str); +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the string associated to a key, convert to a boolean + @param d Dictionary to search + @param key Key string to look for + @param notfound Value to return in case of error + @return integer + + This function queries a dictionary for a key. A key as read from an + ini file is given as "section:key". If the key cannot be found, + the notfound value is returned. + + A true boolean is found if one of the following is matched: + + - A string starting with 'y' + - A string starting with 'Y' + - A string starting with 't' + - A string starting with 'T' + - A string starting with '1' + + A false boolean is found if one of the following is matched: + + - A string starting with 'n' + - A string starting with 'N' + - A string starting with 'f' + - A string starting with 'F' + - A string starting with '0' + + The notfound value returned if no boolean is identified, does not + necessarily have to be 0 or 1. + */ +/*--------------------------------------------------------------------------*/ +int iniparser_getboolean(dictionary * d, const char * key, int notfound) +{ + char * c ; + int ret ; + + c = iniparser_getstring(d, key, INI_INVALID_KEY); + if (c==INI_INVALID_KEY) return notfound ; + if (c[0]=='y' || c[0]=='Y' || c[0]=='1' || c[0]=='t' || c[0]=='T') { + ret = 1 ; + } else if (c[0]=='n' || c[0]=='N' || c[0]=='0' || c[0]=='f' || c[0]=='F') { + ret = 0 ; + } else { + ret = notfound ; + } + return ret; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Finds out if a given entry exists in a dictionary + @param ini Dictionary to search + @param entry Name of the entry to look for + @return integer 1 if entry exists, 0 otherwise + + Finds out if a given entry exists in the dictionary. Since sections + are stored as keys with NULL associated values, this is the only way + of querying for the presence of sections in a dictionary. + */ +/*--------------------------------------------------------------------------*/ +int iniparser_find_entry( + dictionary * ini, + const char * entry +) +{ + int found=0 ; + if (iniparser_getstring(ini, entry, INI_INVALID_KEY)!=INI_INVALID_KEY) { + found = 1 ; + } + return found ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Set an entry in a dictionary. + @param ini Dictionary to modify. + @param entry Entry to modify (entry name) + @param val New value to associate to the entry. + @return int 0 if Ok, -1 otherwise. + + If the given entry can be found in the dictionary, it is modified to + contain the provided value. If it cannot be found, -1 is returned. + It is Ok to set val to NULL. + */ +/*--------------------------------------------------------------------------*/ +int iniparser_set(dictionary * ini, const char * entry, const char * val) +{ + return dictionary_set(ini, strlwc(entry), val) ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Delete an entry in a dictionary + @param ini Dictionary to modify + @param entry Entry to delete (entry name) + @return void + + If the given entry can be found, it is deleted from the dictionary. + */ +/*--------------------------------------------------------------------------*/ +void iniparser_unset(dictionary * ini, const char * entry) +{ + dictionary_unset(ini, strlwc(entry)); +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Load a single line from an INI file + @param input_line Input line, may be concatenated multi-line input + @param section Output space to store section + @param key Output space to store key + @param value Output space to store value + @return line_status value + */ +/*--------------------------------------------------------------------------*/ +static line_status iniparser_line( + const char * input_line, + char * section, + char * key, + char * value) +{ + line_status sta ; + char line[ASCIILINESZ+1]; + int len ; + + strcpy(line, strstrip(input_line)); + len = (int)strlen(line); + + sta = LINE_UNPROCESSED ; + if (len<1) { + /* Empty line */ + sta = LINE_EMPTY ; + } else if (line[0]=='#' || line[0]==';') { + /* Comment line */ + sta = LINE_COMMENT ; + } else if (line[0]=='[' && line[len-1]==']') { + /* Section name */ + sscanf(line, "[%[^]]", section); + strcpy(section, strstrip(section)); + strcpy(section, strlwc(section)); + sta = LINE_SECTION ; + } else if (sscanf (line, "%[^=] = \"%[^\"]\"", key, value) == 2 + || sscanf (line, "%[^=] = '%[^\']'", key, value) == 2 + || sscanf (line, "%[^=] = %[^;#]", key, value) == 2) { + /* Usual key=value, with or without comments */ + strcpy(key, strstrip(key)); + strcpy(key, strlwc(key)); + strcpy(value, strstrip(value)); + /* + * sscanf cannot handle '' or "" as empty values + * this is done here + */ + if (!strcmp(value, "\"\"") || (!strcmp(value, "''"))) { + value[0]=0 ; + } + sta = LINE_VALUE ; + } else if (sscanf(line, "%[^=] = %[;#]", key, value)==2 + || sscanf(line, "%[^=] %[=]", key, value) == 2) { + /* + * Special cases: + * key= + * key=; + * key=# + */ + strcpy(key, strstrip(key)); + strcpy(key, strlwc(key)); + value[0]=0 ; + sta = LINE_VALUE ; + } else { + /* Generate syntax error */ + sta = LINE_ERROR ; + } + return sta ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Parse an ini file and return an allocated dictionary object + @param ininame Name of the ini file to read. + @return Pointer to newly allocated dictionary + + This is the parser for ini files. This function is called, providing + the name of the file to be read. It returns a dictionary object that + should not be accessed directly, but through accessor functions + instead. + + The returned dictionary must be freed using iniparser_freedict(). + */ +/*--------------------------------------------------------------------------*/ +dictionary * iniparser_load(const char * ininame) +{ + FILE * in ; + + char line [ASCIILINESZ+1] ; + char section [ASCIILINESZ+1] ; + char key [ASCIILINESZ+1] ; + char tmp [ASCIILINESZ+1] ; + char val [ASCIILINESZ+1] ; + + int last=0 ; + int len ; + int lineno=0 ; + int errs=0; + + dictionary * dict ; + + if ((in=fopen(ininame, "r"))==NULL) { + fprintf(stderr, "iniparser: cannot open %s\n", ininame); + return NULL ; + } + + dict = dictionary_new(0) ; + if (!dict) { + fclose(in); + return NULL ; + } + + memset(line, 0, ASCIILINESZ); + memset(section, 0, ASCIILINESZ); + memset(key, 0, ASCIILINESZ); + memset(val, 0, ASCIILINESZ); + last=0 ; + + while (fgets(line+last, ASCIILINESZ-last, in)!=NULL) { + lineno++ ; + len = (int)strlen(line)-1; + if (len==0) + continue; + /* Safety check against buffer overflows */ + if (line[len]!='\n') { + fprintf(stderr, + "iniparser: input line too long in %s (%d)\n", + ininame, + lineno); + dictionary_del(dict); + fclose(in); + return NULL ; + } + /* Get rid of \n and spaces at end of line */ + while ((len>=0) && + ((line[len]=='\n') || (isspace(line[len])))) { + line[len]=0 ; + len-- ; + } + /* Detect multi-line */ + if (line[len]=='\\') { + /* Multi-line value */ + last=len ; + continue ; + } else { + last=0 ; + } + switch (iniparser_line(line, section, key, val)) { + case LINE_EMPTY: + case LINE_COMMENT: + break ; + + case LINE_SECTION: + errs = dictionary_set(dict, section, NULL); + break ; + + case LINE_VALUE: + sprintf(tmp, "%s:%s", section, key); + errs = dictionary_set(dict, tmp, val) ; + break ; + + case LINE_ERROR: + fprintf(stderr, "iniparser: syntax error in %s (%d):\n", + ininame, + lineno); + fprintf(stderr, "-> %s\n", line); + errs++ ; + break; + + default: + break ; + } + memset(line, 0, ASCIILINESZ); + last=0; + if (errs<0) { + fprintf(stderr, "iniparser: memory allocation failure\n"); + break ; + } + } + if (errs) { + dictionary_del(dict); + dict = NULL ; + } + fclose(in); + return dict ; +} + +/*-------------------------------------------------------------------------*/ +/** + @brief Free all memory associated to an ini dictionary + @param d Dictionary to free + @return void + + Free all memory associated to an ini dictionary. + It is mandatory to call this function before the dictionary object + gets out of the current context. + */ +/*--------------------------------------------------------------------------*/ +void iniparser_freedict(dictionary * d) +{ + dictionary_del(d); +} + +/* vim: set ts=4 et sw=4 tw=75 */ diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/iniparser/iniparser.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/iniparser/iniparser.h Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,307 @@ + +/*-------------------------------------------------------------------------*/ +/** + @file iniparser.h + @author N. Devillard + @brief Parser for ini files. +*/ +/*--------------------------------------------------------------------------*/ + +#ifndef _INIPARSER_H_ +#define _INIPARSER_H_ + +/*--------------------------------------------------------------------------- + Includes + ---------------------------------------------------------------------------*/ + +#include +#include +#include + +/* + * The following #include is necessary on many Unixes but not Linux. + * It is not needed for Windows platforms. + * Uncomment it if needed. + */ +/* #include */ + +#include "dictionary.h" + +/*-------------------------------------------------------------------------*/ +/** + @brief Get number of sections in a dictionary + @param d Dictionary to examine + @return int Number of sections found in dictionary + + This function returns the number of sections found in a dictionary. + The test to recognize sections is done on the string stored in the + dictionary: a section name is given as "section" whereas a key is + stored as "section:key", thus the test looks for entries that do not + contain a colon. + + This clearly fails in the case a section name contains a colon, but + this should simply be avoided. + + This function returns -1 in case of error. + */ +/*--------------------------------------------------------------------------*/ + +int iniparser_getnsec(dictionary * d); + + +/*-------------------------------------------------------------------------*/ +/** + @brief Get name for section n in a dictionary. + @param d Dictionary to examine + @param n Section number (from 0 to nsec-1). + @return Pointer to char string + + This function locates the n-th section in a dictionary and returns + its name as a pointer to a string statically allocated inside the + dictionary. Do not free or modify the returned string! + + This function returns NULL in case of error. + */ +/*--------------------------------------------------------------------------*/ + +char * iniparser_getsecname(dictionary * d, int n); + + +/*-------------------------------------------------------------------------*/ +/** + @brief Save a dictionary to a loadable ini file + @param d Dictionary to dump + @param f Opened file pointer to dump to + @return void + + This function dumps a given dictionary into a loadable ini file. + It is Ok to specify @c stderr or @c stdout as output files. + */ +/*--------------------------------------------------------------------------*/ + +void iniparser_dump_ini(dictionary * d, FILE * f); + +/*-------------------------------------------------------------------------*/ +/** + @brief Save a dictionary section to a loadable ini file + @param d Dictionary to dump + @param s Section name of dictionary to dump + @param f Opened file pointer to dump to + @return void + + This function dumps a given section of a given dictionary into a loadable ini + file. It is Ok to specify @c stderr or @c stdout as output files. + */ +/*--------------------------------------------------------------------------*/ + +void iniparser_dumpsection_ini(dictionary * d, char * s, FILE * f); + +/*-------------------------------------------------------------------------*/ +/** + @brief Dump a dictionary to an opened file pointer. + @param d Dictionary to dump. + @param f Opened file pointer to dump to. + @return void + + This function prints out the contents of a dictionary, one element by + line, onto the provided file pointer. It is OK to specify @c stderr + or @c stdout as output files. This function is meant for debugging + purposes mostly. + */ +/*--------------------------------------------------------------------------*/ +void iniparser_dump(dictionary * d, FILE * f); + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the number of keys in a section of a dictionary. + @param d Dictionary to examine + @param s Section name of dictionary to examine + @return Number of keys in section + */ +/*--------------------------------------------------------------------------*/ +int iniparser_getsecnkeys(dictionary * d, char * s); + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the number of keys in a section of a dictionary. + @param d Dictionary to examine + @param s Section name of dictionary to examine + @return pointer to statically allocated character strings + + This function queries a dictionary and finds all keys in a given section. + Each pointer in the returned char pointer-to-pointer is pointing to + a string allocated in the dictionary; do not free or modify them. + + This function returns NULL in case of error. + */ +/*--------------------------------------------------------------------------*/ +char ** iniparser_getseckeys(dictionary * d, char * s); + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the string associated to a key + @param d Dictionary to search + @param key Key string to look for + @param def Default value to return if key not found. + @return pointer to statically allocated character string + + This function queries a dictionary for a key. A key as read from an + ini file is given as "section:key". If the key cannot be found, + the pointer passed as 'def' is returned. + The returned char pointer is pointing to a string allocated in + the dictionary, do not free or modify it. + */ +/*--------------------------------------------------------------------------*/ +char * iniparser_getstring(dictionary * d, const char * key, char * def); + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the string associated to a key, convert to an int + @param d Dictionary to search + @param key Key string to look for + @param notfound Value to return in case of error + @return integer + + This function queries a dictionary for a key. A key as read from an + ini file is given as "section:key". If the key cannot be found, + the notfound value is returned. + + Supported values for integers include the usual C notation + so decimal, octal (starting with 0) and hexadecimal (starting with 0x) + are supported. Examples: + + - "42" -> 42 + - "042" -> 34 (octal -> decimal) + - "0x42" -> 66 (hexa -> decimal) + + Warning: the conversion may overflow in various ways. Conversion is + totally outsourced to strtol(), see the associated man page for overflow + handling. + + Credits: Thanks to A. Becker for suggesting strtol() + */ +/*--------------------------------------------------------------------------*/ +int iniparser_getint(dictionary * d, const char * key, int notfound); + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the string associated to a key, convert to a double + @param d Dictionary to search + @param key Key string to look for + @param notfound Value to return in case of error + @return double + + This function queries a dictionary for a key. A key as read from an + ini file is given as "section:key". If the key cannot be found, + the notfound value is returned. + */ +/*--------------------------------------------------------------------------*/ +double iniparser_getdouble(dictionary * d, const char * key, double notfound); + +/*-------------------------------------------------------------------------*/ +/** + @brief Get the string associated to a key, convert to a boolean + @param d Dictionary to search + @param key Key string to look for + @param notfound Value to return in case of error + @return integer + + This function queries a dictionary for a key. A key as read from an + ini file is given as "section:key". If the key cannot be found, + the notfound value is returned. + + A true boolean is found if one of the following is matched: + + - A string starting with 'y' + - A string starting with 'Y' + - A string starting with 't' + - A string starting with 'T' + - A string starting with '1' + + A false boolean is found if one of the following is matched: + + - A string starting with 'n' + - A string starting with 'N' + - A string starting with 'f' + - A string starting with 'F' + - A string starting with '0' + + The notfound value returned if no boolean is identified, does not + necessarily have to be 0 or 1. + */ +/*--------------------------------------------------------------------------*/ +int iniparser_getboolean(dictionary * d, const char * key, int notfound); + + +/*-------------------------------------------------------------------------*/ +/** + @brief Set an entry in a dictionary. + @param ini Dictionary to modify. + @param entry Entry to modify (entry name) + @param val New value to associate to the entry. + @return int 0 if Ok, -1 otherwise. + + If the given entry can be found in the dictionary, it is modified to + contain the provided value. If it cannot be found, -1 is returned. + It is Ok to set val to NULL. + */ +/*--------------------------------------------------------------------------*/ +int iniparser_set(dictionary * ini, const char * entry, const char * val); + + +/*-------------------------------------------------------------------------*/ +/** + @brief Delete an entry in a dictionary + @param ini Dictionary to modify + @param entry Entry to delete (entry name) + @return void + + If the given entry can be found, it is deleted from the dictionary. + */ +/*--------------------------------------------------------------------------*/ +void iniparser_unset(dictionary * ini, const char * entry); + +/*-------------------------------------------------------------------------*/ +/** + @brief Finds out if a given entry exists in a dictionary + @param ini Dictionary to search + @param entry Name of the entry to look for + @return integer 1 if entry exists, 0 otherwise + + Finds out if a given entry exists in the dictionary. Since sections + are stored as keys with NULL associated values, this is the only way + of querying for the presence of sections in a dictionary. + */ +/*--------------------------------------------------------------------------*/ +int iniparser_find_entry(dictionary * ini, const char * entry) ; + +/*-------------------------------------------------------------------------*/ +/** + @brief Parse an ini file and return an allocated dictionary object + @param ininame Name of the ini file to read. + @return Pointer to newly allocated dictionary + + This is the parser for ini files. This function is called, providing + the name of the file to be read. It returns a dictionary object that + should not be accessed directly, but through accessor functions + instead. + + The returned dictionary must be freed using iniparser_freedict(). + */ +/*--------------------------------------------------------------------------*/ +dictionary * iniparser_load(const char * ininame); + +/*-------------------------------------------------------------------------*/ +/** + @brief Free all memory associated to an ini dictionary + @param d Dictionary to free + @return void + + Free all memory associated to an ini dictionary. + It is mandatory to call this function before the dictionary object + gets out of the current context. + */ +/*--------------------------------------------------------------------------*/ +void iniparser_freedict(dictionary * d); + +#endif diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/ipc.c --- a/project_files/frontlib/ipc.c Mon Jun 04 21:12:20 2012 +0200 +++ b/project_files/frontlib/ipc.c Thu Jun 07 02:45:18 2012 +0200 @@ -155,11 +155,12 @@ return; } - flib_ipcconn_tick(ipc->connection); - IpcConnState newstate = flib_ipcconn_state(ipc->connection); - if(ipc->oldConnState == IPC_LISTENING && newstate == IPC_CONNECTED) { - ipc->oldConnState = newstate; - ipc->onConnectCb(ipc->onConnectCtx); + if(ipc->oldConnState == IPC_LISTENING) { + flib_ipcconn_accept(ipc->connection); + if(flib_ipcconn_state(ipc->connection) == IPC_CONNECTED) { + ipc->oldConnState = IPC_CONNECTED; + ipc->onConnectCb(ipc->onConnectCtx); + } } if(ipc->oldConnState == IPC_CONNECTED) { @@ -216,13 +217,31 @@ } } - newstate = flib_ipcconn_state(ipc->connection); - if(newstate == IPC_NOT_CONNECTED) { - ipc->oldConnState = newstate; + if(flib_ipcconn_state(ipc->connection) == IPC_NOT_CONNECTED) { + ipc->oldConnState = IPC_NOT_CONNECTED; ipc->onDisconnectCb(ipc->onDisconnectCtx); } } +void flib_ipc_tick(flib_ipc ipc) { + if(!ipc) { + flib_log_w("Call to flib_ipc_tick with ipc==null"); + return; + } + if(ipc->running) { + flib_log_w("Call to flib_ipc_tick from a callback"); + return; + } + + ipc->running = true; + flib_ipc_wrappedtick(ipc); + ipc->running = false; + + if(ipc->destroyRequested) { + flib_ipc_destroy(&ipc); + } +} + int flib_ipc_send_raw(flib_ipc ipc, void *data, size_t len) { if(!ipc) { flib_log_w("Call to flib_ipc_send_raw with ipc==null"); @@ -261,24 +280,5 @@ flib_constbuffer result = {NULL, 0}; return result; } - return flib_ipcconn_getdemo(ipc->connection); + return flib_ipcconn_getrecord(ipc->connection, false); } - -void flib_ipc_tick(flib_ipc ipc) { - if(!ipc) { - flib_log_w("Call to flib_ipc_tick with ipc==null"); - return; - } - if(ipc->running) { - flib_log_w("Call to flib_ipc_tick from a callback"); - return; - } - - ipc->running = true; - flib_ipc_wrappedtick(ipc); - ipc->running = false; - - if(ipc->destroyRequested) { - flib_ipc_destroy(&ipc); - } -} diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/ipc.h --- a/project_files/frontlib/ipc.h Mon Jun 04 21:12:20 2012 +0200 +++ b/project_files/frontlib/ipc.h Thu Jun 07 02:45:18 2012 +0200 @@ -31,6 +31,23 @@ int flib_ipc_send_message(flib_ipc ipc, void *data, size_t len); int flib_ipc_send_messagestr(flib_ipc ipc, char *data); +// Configuration +int flib_ipc_send_seed(flib_ipc ipc, const char *seed); +int flib_ipc_send_script(flib_ipc ipc, const char *scriptpath); +int flib_ipc_send_map_regular(flib_ipc ipc, const char *theme, int templateFilter); +int flib_ipc_send_map_maze(flib_ipc ipc, const char *theme, int mazeType); +int flib_ipc_send_map_drawn(flib_ipc ipc, const char *theme, void *drawnMapData, size_t drawnMapDataLen); +int flib_ipc_send_map_named(flib_ipc ipc, const char *mappath); +int flib_ipc_send_gamemods(flib_ipc ipc, uint32_t modflags); +int flib_ipc_send_gamesetting(flib_ipc ipc, const char *settingname, int modflags); +int flib_ipc_send_weapon_loadout(flib_ipc ipc, const char *weapsettings); +int flib_ipc_send_weapon_delay(flib_ipc ipc, const char *weapsettings); +int flib_ipc_send_weapon_cratechance(flib_ipc ipc, const char *weapsettings); +int flib_ipc_send_weapon_crateammo(flib_ipc ipc, const char *weapsettings); + +int flib_ipc_send_conf_end(flib_ipc ipc); + + uint16_t flib_ipc_port(flib_ipc ipc); flib_constbuffer flib_ipc_getdemo(flib_ipc ipc); diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/ipcconn.c --- a/project_files/frontlib/ipcconn.c Mon Jun 04 21:12:20 2012 +0200 +++ b/project_files/frontlib/ipcconn.c Thu Jun 07 02:45:18 2012 +0200 @@ -1,16 +1,24 @@ #include "ipcconn.h" #include "logging.h" #include "socket.h" +#include "demo.h" #include #include #include #include +/* + * The receive buffer has to be able to hold any message that might be received. Normally + * the messages are at most 256 bytes, but the map preview contains 4097 bytes (4096 for a + * bitmap, 1 for the number of hogs which fit on the map). + * + * We don't need to worry about wasting a few kb though, and I like powers of two... + */ typedef struct _flib_ipcconn { + uint8_t readBuffer[8192]; char playerName[256]; - uint8_t readBuffer[256]; int readBufferSize; flib_acceptor acceptor; @@ -25,6 +33,7 @@ flib_acceptor acceptor = flib_acceptor_create(0); if(!result || !acceptor) { + flib_log_e("Can't create ipcconn."); free(result); flib_acceptor_close(&acceptor); return NULL; @@ -50,73 +59,44 @@ } uint16_t flib_ipcconn_port(flib_ipcconn ipc) { + if(!ipc) { + flib_log_e("Call to flib_ipcconn_port with ipc==null"); + return 0; + } return ipc->port; } void flib_ipcconn_destroy(flib_ipcconn *ipcptr) { - if(!ipcptr || !*ipcptr) { - return; + if(!ipcptr) { + flib_log_e("Call to flib_ipcconn_destroy with ipcptr==null"); + } else if(*ipcptr) { + flib_ipcconn ipc = *ipcptr; + flib_acceptor_close(&ipc->acceptor); + flib_socket_close(&ipc->sock); + flib_vector_destroy(&ipc->demoBuffer); + free(ipc); + *ipcptr = NULL; } - flib_ipcconn ipc = *ipcptr; - flib_acceptor_close(&ipc->acceptor); - flib_socket_close(&ipc->sock); - flib_vector_destroy(&ipc->demoBuffer); - free(ipc); - *ipcptr = NULL; } IpcConnState flib_ipcconn_state(flib_ipcconn ipc) { - if(ipc && ipc->sock) { + if(!ipc) { + flib_log_e("Call to flib_ipcconn_state with ipc==null"); + return IPC_NOT_CONNECTED; + } else if(ipc->sock) { return IPC_CONNECTED; - } else if(ipc && ipc->acceptor) { + } else if(ipc->acceptor) { return IPC_LISTENING; } else { return IPC_NOT_CONNECTED; } } -static void demo_record(flib_ipcconn ipc, const void *data, size_t len) { - if(ipc->demoBuffer) { - if(flib_vector_append(ipc->demoBuffer, data, len) < len) { - // Out of memory, fail demo recording - flib_vector_destroy(&ipc->demoBuffer); - } - } +static bool isMessageReady(flib_ipcconn ipc) { + return ipc->readBufferSize >= ipc->readBuffer[0]+1; } -static void demo_record_from_engine(flib_ipcconn ipc, const uint8_t *message) { - if(!ipc->demoBuffer || message[0]==0) { - return; - } - if(strchr("?CEiQqHb", message[1])) { - // Those message types are not recorded in a demo. - return; - } - - if(message[1] == 's') { - if(message[0] >= 3) { - // Chat messages get a special once-over to make them look as if they were received, not sent. - // Get the actual chat message as c string - char chatMsg[256]; - memcpy(chatMsg, message+2, message[0]-3); - chatMsg[message[0]-3] = 0; - - // If the message starts with /me, it will be displayed differently. - char converted[257]; - bool memessage = message[0] >= 7 && !memcmp(message+2, "/me ", 4); - const char *template = memessage ? "s\x02* %s %s " : "s\x01%s: %s "; - int size = snprintf(converted+1, 256, template, ipc->playerName, chatMsg); - converted[0] = size>255 ? 255 : size; - demo_record(ipc, converted, converted[0]+1); - } - } else { - demo_record(ipc, message, message[0]+1); - } -} - -int flib_ipcconn_recv_message(flib_ipcconn ipc, void *data) { - flib_ipcconn_tick(ipc); - +static void receiveToBuffer(flib_ipcconn ipc) { if(ipc->sock) { int size = flib_socket_nbrecv(ipc->sock, ipc->readBuffer+ipc->readBufferSize, sizeof(ipc->readBuffer)-ipc->readBufferSize); if(size>=0) { @@ -125,16 +105,32 @@ flib_socket_close(&ipc->sock); } } +} - int msgsize = ipc->readBuffer[0]+1; - if(ipc->readBufferSize >= msgsize) { - demo_record_from_engine(ipc, ipc->readBuffer); +int flib_ipcconn_recv_message(flib_ipcconn ipc, void *data) { + if(!ipc || !data) { + flib_log_e("Call to flib_ipcconn_recv_message with ipc==null or data==null"); + return -1; + } + + if(!isMessageReady(ipc)) { + receiveToBuffer(ipc); + } + + if(isMessageReady(ipc)) { + if(ipc->demoBuffer) { + if(flib_demo_record_from_engine(ipc->demoBuffer, ipc->readBuffer, ipc->playerName) < 0) { + flib_log_w("Stopping demo recording due to an error."); + flib_vector_destroy(&ipc->demoBuffer); + } + } + int msgsize = ipc->readBuffer[0]+1; memcpy(data, ipc->readBuffer, msgsize); memmove(ipc->readBuffer, ipc->readBuffer+msgsize, ipc->readBufferSize-msgsize); ipc->readBufferSize -= msgsize; return msgsize; } else if(!ipc->sock && ipc->readBufferSize>0) { - flib_log_w("Last message from engine data stream is incomplete (received %u of %u bytes)", ipc->readBufferSize, msgsize); + flib_log_w("Last message from engine data stream is incomplete (received %u of %u bytes)", ipc->readBufferSize, ipc->readBuffer[0]+1); ipc->readBufferSize = 0; return -1; } else { @@ -142,16 +138,40 @@ } } -int flib_ipcconn_send_raw(flib_ipcconn ipc, void *data, size_t len) { - flib_ipcconn_tick(ipc); +int flib_ipcconn_recv_map(flib_ipcconn ipc, void *data) { + if(!ipc || !data) { + flib_log_e("Call to flib_ipcconn_recv_map with ipc==null or data==null"); + return -1; + } + + receiveToBuffer(ipc); + if(ipc->readBufferSize >= IPCCONN_MAPMSG_BYTES) { + memcpy(data, ipc->readBuffer, IPCCONN_MAPMSG_BYTES); + memmove(ipc->readBuffer, ipc->readBuffer+IPCCONN_MAPMSG_BYTES, ipc->readBufferSize-IPCCONN_MAPMSG_BYTES); + return IPCCONN_MAPMSG_BYTES; + } else { + return -1; + } +} + +int flib_ipcconn_send_raw(flib_ipcconn ipc, void *data, size_t len) { + if(!ipc || (!data && len>0)) { + flib_log_e("Call to flib_ipcconn_send_raw with ipc==null or data==null"); + return -1; + } if(!ipc->sock) { - flib_log_w("flib_ipcconn_send_message: Not connected."); + flib_log_w("flib_ipcconn_send_raw: Not connected."); return -1; } if(flib_socket_send(ipc->sock, data, len) == len) { - demo_record(ipc, data, len); + if(ipc->demoBuffer) { + if(flib_demo_record_to_engine(ipc->demoBuffer, data, len) < 0) { + flib_log_w("Stopping demo recording due to an error."); + flib_vector_destroy(&ipc->demoBuffer); + } + } return 0; } else { flib_log_w("Failed or incomplete ICP write: engine connection lost."); @@ -161,8 +181,8 @@ } int flib_ipcconn_send_message(flib_ipcconn ipc, void *data, size_t len) { - if(len>255) { - flib_log_e("Attempt to send too much data to the engine in a single message."); + if(!ipc || (!data && len>0) || len>255) { + flib_log_e("Call to flib_ipcconn_send_message with ipc==null or data==null or len>255"); return -1; } @@ -177,8 +197,10 @@ return flib_ipcconn_send_message(ipc, data, strlen(data)); } -void flib_ipcconn_tick(flib_ipcconn ipc) { - if(!ipc->sock && ipc->acceptor) { +void flib_ipcconn_accept(flib_ipcconn ipc) { + if(!ipc) { + flib_log_e("Call to flib_ipcconn_accept with ipc==null"); + } else if(!ipc->sock && ipc->acceptor) { ipc->sock = flib_socket_accept(ipc->acceptor, true); if(ipc->sock) { flib_acceptor_close(&ipc->acceptor); @@ -186,31 +208,14 @@ } } -static void replace_gamemode(flib_buffer buf, char gamemode) { - size_t msgStart = 0; - char *data = (char*)buf.data; - while(msgStart+2 < buf.size) { - if(!memcmp(data+msgStart, "\x02T", 2)) { - data[msgStart+2] = gamemode; - } - msgStart += (uint8_t)data[msgStart]+1; +flib_constbuffer flib_ipcconn_getrecord(flib_ipcconn ipc, bool save) { + if(!ipc) { + flib_log_e("Call to flib_ipcconn_getrecord with ipc==null"); } -} - -flib_constbuffer flib_ipcconn_getdemo(flib_ipcconn ipc) { - if(!ipc->demoBuffer) { + if(!ipc || !ipc->demoBuffer) { flib_constbuffer result = {NULL, 0}; return result; } - replace_gamemode(flib_vector_as_buffer(ipc->demoBuffer), 'D'); + flib_demo_replace_gamemode(flib_vector_as_buffer(ipc->demoBuffer), save ? 'S' : 'D'); return flib_vector_as_constbuffer(ipc->demoBuffer); } - -flib_constbuffer flib_ipcconn_getsave(flib_ipcconn ipc) { - if(!ipc->demoBuffer) { - flib_constbuffer result = {NULL, 0}; - return result; - } - replace_gamemode(flib_vector_as_buffer(ipc->demoBuffer), 'S'); - return flib_vector_as_constbuffer(ipc->demoBuffer); -} diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/ipcconn.h --- a/project_files/frontlib/ipcconn.h Mon Jun 04 21:12:20 2012 +0200 +++ b/project_files/frontlib/ipcconn.h Thu Jun 07 02:45:18 2012 +0200 @@ -10,6 +10,8 @@ #include #include +#define IPCCONN_MAPMSG_BYTES 4097 + typedef enum {IPC_NOT_CONNECTED, IPC_LISTENING, IPC_CONNECTED} IpcConnState; struct _flib_ipcconn; @@ -56,6 +58,14 @@ */ int flib_ipcconn_recv_message(flib_ipcconn ipc, void *data); +/** + * Try to receive 4097 bytes. This is the size of the reply the engine sends + * when successfully queried for map data. The first 4096 bytes are a bit-packed + * twocolor image of the map (256x128), the last byte is the number of hogs that + * fit on the map. + */ +int flib_ipcconn_recv_map(flib_ipcconn ipc, void *data); + int flib_ipcconn_send_raw(flib_ipcconn ipc, void *data, size_t len); /** @@ -75,33 +85,22 @@ /** * Call regularly to allow background work to proceed */ -void flib_ipcconn_tick(flib_ipcconn ipc); +void flib_ipcconn_accept(flib_ipcconn ipc); /** - * Get a demo record of the connection. This should be called after + * Get a record of the connection. This should be called after * the connection is closed and all messages have been received. * * If demo recording was not enabled, or if the recording failed for some reason, * the buffer will be empty. * - * The buffer is only valid until a call to flib_ipcconn_getsave(), since save - * and demo records have some minor differences, and those are performed directly - * on the buffer before returning it). + * If save=true is passed, the result will be a savegame, otherwise it will be a + * demo. + * + * The buffer is only valid until flib_ipcconn_getsave is called again or the ipcconn + * is destroyed. */ -flib_constbuffer flib_ipcconn_getdemo(flib_ipcconn ipc); - -/** - * Get a savegame record of the connection. This should be called after - * the connection is closed and all messages have been received. - * - * If demo recording was not enabled, or if the recording failed for some reason, - * the buffer will be empty. - * - * The buffer is only valid until a call to flib_ipcconn_getdemo(), since save - * and demo records have some minor differences, and those are performed directly - * on the buffer before returning it). - */ -flib_constbuffer flib_ipcconn_getsave(flib_ipcconn ipc); +flib_constbuffer flib_ipcconn_getrecord(flib_ipcconn ipc, bool save); #endif /* IPCCONN_H_ */ diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/model/cfg.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/model/cfg.c Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,210 @@ +#include "cfg.h" + +#include "../iniparser/iniparser.h" +#include "../iniparser/dictionary.h" +#include "../ini/inihelper.h" +#include "../logging.h" + +#include + +static void freeCfgMeta(flib_cfg_meta *cfg) { + if(cfg) { + if(cfg->settings) { + for(int i=0; isettingCount; i++) { + free(cfg->settings[i].iniName); + free(cfg->settings[i].title); + free(cfg->settings[i].engineCommand); + free(cfg->settings[i].image); + } + free(cfg->settings); + } + if(cfg->mods) { + for(int i=0; imodCount; i++) { + free(cfg->mods[i].iniName); + } + free(cfg->mods); + } + free(cfg); + } +} + +flib_cfg_meta *flib_cfg_meta_from_ini(const char *settingpath, const char *modpath) { + if(!settingpath || !modpath) { + return NULL; + } + flib_cfg_meta *result = calloc(1, sizeof(flib_cfg_meta)); + dictionary *settingfile = iniparser_load(settingpath); + dictionary *modfile = iniparser_load(modpath); + + if(!result || !settingfile || !modfile) { + goto handleError; + } + + result->settingCount = iniparser_getnsec(settingfile); + result->modCount = iniparser_getnsec(modfile); + result->settings = calloc(result->settingCount, sizeof(flib_cfg_setting_meta)); + result->mods = calloc(result->modCount, sizeof(flib_cfg_mod_meta)); + + if(!result->settings || !result->mods) { + goto handleError; + } + + for(int i=0; isettingCount; i++) { + char *sectionName = iniparser_getsecname(settingfile, i); + if(!sectionName) { + goto handleError; + } + + bool error = false; + result->settings[i].iniName = inihelper_strdupnull(sectionName); + result->settings[i].title = inihelper_getstringdup(settingfile, &error, sectionName, "title"); + result->settings[i].engineCommand = inihelper_getstringdup(settingfile, &error, sectionName, "command"); + result->settings[i].image = inihelper_getstringdup(settingfile, &error, sectionName, "image"); + result->settings[i].checkOverMax = inihelper_getbool(settingfile, &error, sectionName, "checkOverMax"); + result->settings[i].times1000 = inihelper_getbool(settingfile, &error, sectionName, "times1000"); + result->settings[i].min = inihelper_getint(settingfile, &error, sectionName, "min"); + result->settings[i].max = inihelper_getint(settingfile, &error, sectionName, "max"); + result->settings[i].def = inihelper_getint(settingfile, &error, sectionName, "default"); + if(error) { + flib_log_e("Missing or malformed ini parameter in file %s, section %s", settingpath, sectionName); + goto handleError; + } + } + + for(int i=0; imodCount; i++) { + char *sectionName = iniparser_getsecname(modfile, i); + if(!sectionName) { + goto handleError; + } + + bool error = false; + result->mods[i].iniName = inihelper_strdupnull(sectionName); + result->mods[i].bitmaskIndex = inihelper_getint(modfile, &error, sectionName, "bitmaskIndex"); + if(error) { + flib_log_e("Missing or malformed ini parameter in file %s, section %s", modpath, sectionName); + goto handleError; + } + } + + iniparser_freedict(settingfile); + iniparser_freedict(modfile); + return result; + + handleError: + freeCfgMeta(result); + iniparser_freedict(settingfile); + iniparser_freedict(modfile); + return NULL; +} + +void flib_cfg_meta_destroy(flib_cfg_meta *metainfo) { + freeCfgMeta(metainfo); +} + +flib_cfg *flib_cfg_create(const flib_cfg_meta *meta, const char *schemeName) { + flib_cfg *result = calloc(1, sizeof(flib_cfg)); + if(!meta || !result || !schemeName) { + return NULL; + } + + result->modCount = meta->modCount; + result->settingCount = meta->settingCount; + result->schemeName = inihelper_strdupnull(schemeName); + result->mods = calloc(meta->modCount, sizeof(*result->mods)); + result->settings = calloc(meta->settingCount, sizeof(*result->settings)); + + if(!result->mods || !result->settings || !result->schemeName) { + flib_cfg_destroy(result); + return NULL; + } + + for(int i=0; isettingCount; i++) { + result->settings[i] = meta->settings[i].def; + } + return result; +} + +flib_cfg *flib_cfg_from_ini_handleError(flib_cfg *result, dictionary *settingfile) { + iniparser_freedict(settingfile); + flib_cfg_destroy(result); + return NULL; +} + +flib_cfg *flib_cfg_from_ini(const flib_cfg_meta *meta, const char *filename) { + if(!meta || !filename) { + return NULL; + } + dictionary *settingfile = iniparser_load(filename); + if(!settingfile) { + return NULL; + } + + bool error = false; + char *schemename = inihelper_getstring(settingfile, &error, "Scheme", "name"); + if(!schemename) { + return flib_cfg_from_ini_handleError(NULL, settingfile); + } + + flib_cfg *result = flib_cfg_create(meta, schemename); + + for(int i=0; isettingCount; i++) { + char *key = inihelper_createDictKey("BasicSettings", meta->settings[i].iniName); + if(!key) { + return flib_cfg_from_ini_handleError(result, settingfile); + } + result->settings[i] = iniparser_getint(settingfile, key, meta->settings[i].def); + free(key); + } + for(int i=0; imodCount; i++) { + char *key = inihelper_createDictKey("GameMods", meta->mods[i].iniName); + if(!key) { + return flib_cfg_from_ini_handleError(result, settingfile); + } + result->mods[i] = iniparser_getboolean(settingfile, key, false); + free(key); + } + iniparser_freedict(settingfile); + return result; +} + +int flib_cfg_to_ini(const flib_cfg_meta *meta, const char *filename, const flib_cfg *config) { + int result = -1; + if(meta && filename && config && config->modCount==meta->modCount && config->settingCount==meta->settingCount) { + dictionary *dict = dictionary_new(0); + if(dict) { + bool error = false; + // Add the sections + error |= iniparser_set(dict, "Scheme", NULL); + error |= iniparser_set(dict, "BasicSettings", NULL); + error |= iniparser_set(dict, "GameMods", NULL); + + // Add the values + error |= inihelper_setstr(dict, "Scheme", "name", config->schemeName); + for(int i=0; isettingCount; i++) { + error |= inihelper_setint(dict, "BasicSettings", meta->settings[i].iniName, config->settings[i]); + } + for(int i=0; imodCount; i++) { + error |= inihelper_setbool(dict, "GameMods", meta->mods[i].iniName, config->mods[i]); + } + if(!error) { + FILE *inifile = fopen(filename, "wb"); + if(inifile) { + iniparser_dump_ini(dict, inifile); + fclose(inifile); + result = 0; + } + } + dictionary_del(dict); + } + } + return result; +} + +void flib_cfg_destroy(flib_cfg* cfg) { + if(cfg) { + free(cfg->mods); + free(cfg->settings); + free(cfg->schemeName); + free(cfg); + } +} diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/model/cfg.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/project_files/frontlib/model/cfg.h Thu Jun 07 02:45:18 2012 +0200 @@ -0,0 +1,55 @@ +/** + * Data structures for game scheme information. + * + * Important conventions: + * - All data structures own what they point to. + * - Strings are never null pointers. + */ + +#ifndef CFG_H_ +#define CFG_H_ + +#include + +typedef struct { + char *iniName; + char *title; + char *engineCommand; + char *image; + int netplayIndex; + bool checkOverMax; + bool times1000; + int def; + int min; + int max; +} flib_cfg_setting_meta; + +typedef struct { + char *iniName; + int bitmaskIndex; +} flib_cfg_mod_meta; + +typedef struct { + int settingCount; + int modCount; + flib_cfg_setting_meta *settings; + flib_cfg_mod_meta *mods; +} flib_cfg_meta; + +typedef struct { + int settingCount; + int modCount; + char *schemeName; + int *settings; + bool *mods; +} flib_cfg; + +flib_cfg_meta *flib_cfg_meta_from_ini(const char *settingpath, const char *modpath); +void flib_cfg_meta_destroy(flib_cfg_meta *metainfo); + +flib_cfg *flib_cfg_create(const flib_cfg_meta *meta, const char *schemeName); +flib_cfg *flib_cfg_from_ini(const flib_cfg_meta *meta, const char *filename); +int flib_cfg_to_ini(const flib_cfg_meta *meta, const char *filename, const flib_cfg *config); +void flib_cfg_destroy(flib_cfg* cfg); + +#endif /* CFG_H_ */ diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/socket.c --- a/project_files/frontlib/socket.c Mon Jun 04 21:12:20 2012 +0200 +++ b/project_files/frontlib/socket.c Thu Jun 07 02:45:18 2012 +0200 @@ -23,10 +23,30 @@ return get_peer_ip(sock) == (uint32_t)((127UL<<24)+1); // 127.0.0.1 } +static flib_tcpsocket flib_socket_create(TCPsocket sdlsock) { + flib_tcpsocket result = malloc(sizeof(_flib_tcpsocket)); + if(!result) { + flib_log_e("Can't allocate socket: Out of memory!"); + return NULL; + } + result->sock = sdlsock; + result->sockset = SDLNet_AllocSocketSet(1); + + if(!result->sockset) { + flib_log_e("Can't allocate socket: Out of memory!"); + SDLNet_FreeSocketSet(result->sockset); + free(result); + return NULL; + } + + SDLNet_AddSocket(result->sockset, (SDLNet_GenericSocket)result->sock); + return result; +} + flib_acceptor flib_acceptor_create(uint16_t port) { flib_acceptor result = malloc(sizeof(_flib_acceptor)); if(!result) { - flib_log_e("Out of memory!"); + flib_log_e("Can't allocate acceptor: Out of memory!"); return NULL; } @@ -47,7 +67,6 @@ } else { /* SDL_net does not seem to have a way to listen on a random unused port and find out which port that is, so let's try to find one ourselves. */ - // TODO: Is socket binding fail-fast on all platforms? srand(time(NULL)); rand(); for(int i=0; i<1000; i++) { @@ -58,7 +77,7 @@ if(result->sock) { return result; } else { - flib_log_i("Unable to listen on port %u: %s", result->port, SDLNet_GetError()); + flib_log_w("Unable to listen on port %u: %s", result->port, SDLNet_GetError()); } } flib_log_e("Unable to listen on a random unused port."); @@ -68,68 +87,60 @@ } uint16_t flib_acceptor_listenport(flib_acceptor acceptor) { + if(!acceptor) { + flib_log_e("Call to flib_acceptor_listenport with acceptor==null"); + return 0; + } return acceptor->port; } void flib_acceptor_close(flib_acceptor *acceptorptr) { - if(acceptorptr == NULL || *acceptorptr == NULL) { - return; + if(!acceptorptr) { + flib_log_e("Call to flib_acceptor_close with acceptorptr==null"); + } else if(*acceptorptr) { + SDLNet_TCP_Close((*acceptorptr)->sock); + free(*acceptorptr); + *acceptorptr = NULL; } - SDLNet_TCP_Close((*acceptorptr)->sock); - free(*acceptorptr); - *acceptorptr = NULL; } flib_tcpsocket flib_socket_accept(flib_acceptor acceptor, bool localOnly) { - flib_tcpsocket result = NULL; if(!acceptor) { + flib_log_e("Call to flib_socket_accept with acceptor==null"); return NULL; } - while(result==NULL) { - TCPsocket sock = SDLNet_TCP_Accept(acceptor->sock); - if(!sock) { - // No incoming connections - return NULL; - } + flib_tcpsocket result = NULL; + TCPsocket sock = NULL; + while(!result && (sock = SDLNet_TCP_Accept(acceptor->sock))) { if(localOnly && !connection_is_local(sock)) { flib_log_i("Rejected nonlocal connection attempt from %s", flib_format_ip(get_peer_ip(sock))); SDLNet_TCP_Close(sock); } else { - result = malloc(sizeof(_flib_tcpsocket)); - if(result==NULL) { - flib_log_e("Out of memory!"); + result = flib_socket_create(sock); + if(!result) { SDLNet_TCP_Close(sock); - return NULL; } - result->sock = sock; - result->sockset = SDLNet_AllocSocketSet(1); - if(result->sockset==NULL) { - flib_log_e("Out of memory!"); - SDLNet_TCP_Close(sock); - free(result); - return NULL; - } - SDLNet_AddSocket(result->sockset, (SDLNet_GenericSocket)result->sock); } } return result; } void flib_socket_close(flib_tcpsocket *sockptr) { - if(sockptr==NULL || *sockptr == NULL) { - return; + if(!sockptr) { + flib_log_e("Call to flib_socket_close with sockptr==null"); + } else if(*sockptr) { + flib_tcpsocket sock = *sockptr; + SDLNet_DelSocket(sock->sockset, (SDLNet_GenericSocket)sock->sock); + SDLNet_TCP_Close(sock->sock); + SDLNet_FreeSocketSet(sock->sockset); + free(sock); + *sockptr = NULL; } - flib_tcpsocket sock = *sockptr; - SDLNet_DelSocket(sock->sockset, (SDLNet_GenericSocket)sock->sock); - SDLNet_TCP_Close(sock->sock); - SDLNet_FreeSocketSet(sock->sockset); - free(sock); - *sockptr = NULL; } int flib_socket_nbrecv(flib_tcpsocket sock, void *data, int maxlen) { - if(!sock) { - flib_log_e("Attempt to receive on a NULL socket."); + if(!sock || (maxlen>0 && !data)) { + flib_log_e("Call to flib_socket_nbrecv with sock==null or data==null"); return -1; } int readySockets = SDLNet_CheckSockets(sock->sockset, 0); @@ -145,5 +156,9 @@ } int flib_socket_send(flib_tcpsocket sock, void *data, int len) { + if(!sock || (len>0 && !data)) { + flib_log_e("Call to flib_socket_send with sock==null or data==null"); + return -1; + } return SDLNet_TCP_Send(sock->sock, data, len); } diff -r 7c2eb284f9f1 -r 038e3415100a project_files/frontlib/socket.h --- a/project_files/frontlib/socket.h Mon Jun 04 21:12:20 2012 +0200 +++ b/project_files/frontlib/socket.h Thu Jun 07 02:45:18 2012 +0200 @@ -6,12 +6,7 @@ * on a random unused port, if one can be found. To support this feature, you can also * query the local port that an acceptor is listening on. * - * Further, we support nonblocking reads and writes here. The writes are buffered (TODO), - * so that all data will be accepted, and you can configure a maximum buffer size - * where the connection will be terminated. - * - * In order to ensure buffered data is actually sent out, you should regularly call - * the tick function on your sockets. + * Further, we support nonblocking reads here. */ #ifndef SOCKET_H_