--- 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
--- /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 <stdbool.h>
+#include <stdio.h>
+#include <string.h>
+
+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;
+ }
+}
--- /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_ */
--- 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 <SDL.h>
#include <SDL_net.h>
@@ -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;*/
}
--- /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 <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <limits.h>
+#include <errno.h>
+#include <stdarg.h>
+
+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(val<INT_MIN || val>INT_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;
+}
--- /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 <stdbool.h>
+
+/**
+ * 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_ */
--- /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
--- /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
--- /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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/** 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<len ; i++) {
+ hash += (unsigned)key[i] ;
+ hash += (hash<<10);
+ hash ^= (hash>>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 (size<DICTMINSZ) size=DICTMINSZ ;
+
+ if (!(d = (dictionary *)calloc(1, sizeof(dictionary)))) {
+ return NULL;
+ }
+ d->size = 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 ; i<d->size ; 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 ; i<d->size ; 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 ; i<d->size ; 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 ; i<d->size ; 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 ; i<d->size ; 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 ; i<NVALS ; i++) {
+ sprintf(cval, "%04d", i);
+ dictionary_set(d, cval, "salut");
+ }
+ printf("getting %d values...\n", NVALS);
+ for (i=0 ; i<NVALS ; i++) {
+ sprintf(cval, "%04d", i);
+ val = dictionary_get(d, cval, DICT_INVALID_KEY);
+ if (val==DICT_INVALID_KEY) {
+ printf("cannot get value for key [%s]\n", cval);
+ }
+ }
+ printf("unsetting %d values...\n", NVALS);
+ for (i=0 ; i<NVALS ; i++) {
+ sprintf(cval, "%04d", i);
+ dictionary_unset(d, cval);
+ }
+ if (d->n != 0) {
+ printf("error deleting values\n");
+ }
+ printf("deallocating...\n");
+ dictionary_del(d);
+ return 0 ;
+}
+#endif
+/* vim: set ts=4 et sw=4 tw=75 */
--- /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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/*---------------------------------------------------------------------------
+ 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
--- /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 <ctype.h>
+#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<ASCIILINESZ) {
+ l[i] = (char)tolower((int)s[i]);
+ i++ ;
+ }
+ l[ASCIILINESZ]=(char)0;
+ return l ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+ @brief Remove blanks at the beginning and the end of a string.
+ @param s String to parse.
+ @return ptr to statically allocated string.
+
+ This function returns a pointer to a statically allocated string,
+ which is identical to the input string, except that all blank
+ characters at the end and the beg. of the string have been removed.
+ 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 * strstrip(const char * s)
+{
+ static char l[ASCIILINESZ+1];
+ char * last ;
+
+ if (s==NULL) return NULL ;
+
+ while (isspace((int)*s) && *s) s++;
+ memset(l, 0, ASCIILINESZ+1);
+ strcpy(l, s);
+ last = l + strlen(l);
+ while (last > 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 ; i<d->size ; 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 ; i<d->size ; 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 ; i<d->size ; 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 ; i<d->size ; i++) {
+ if (d->key[i]==NULL)
+ continue ;
+ fprintf(f, "%s = %s\n", d->key[i], d->val[i]);
+ }
+ return ;
+ }
+ for (i=0 ; i<nsec ; i++) {
+ secname = iniparser_getsecname(d, i) ;
+ iniparser_dumpsection_ini(d, secname, f) ;
+ }
+ fprintf(f, "\n");
+ return ;
+}
+
+/*-------------------------------------------------------------------------*/
+/**
+ @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)
+{
+ int j ;
+ char keym[ASCIILINESZ+1];
+ int seclen ;
+
+ if (d==NULL || f==NULL) return ;
+ if (! iniparser_find_entry(d, s)) return ;
+
+ seclen = (int)strlen(s);
+ fprintf(f, "\n[%s]\n", s);
+ sprintf(keym, "%s:", s);
+ for (j=0 ; j<d->size ; 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 ; j<d->size ; 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 ; j<d->size ; 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 */
--- /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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/*
+ * The following #include is necessary on many Unixes but not Linux.
+ * It is not needed for Windows platforms.
+ * Uncomment it if needed.
+ */
+/* #include <unistd.h> */
+
+#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
--- 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);
- }
-}
--- 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);
--- 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 <string.h>
#include <stdbool.h>
#include <stdlib.h>
#include <stdio.h>
+/*
+ * 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);
-}
--- 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 <stddef.h>
#include <stdbool.h>
+#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_ */
--- /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 <stdio.h>
+
+static void freeCfgMeta(flib_cfg_meta *cfg) {
+ if(cfg) {
+ if(cfg->settings) {
+ for(int i=0; i<cfg->settingCount; 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; i<cfg->modCount; 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; i<result->settingCount; 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; i<result->modCount; 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; i<meta->settingCount; 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; i<meta->settingCount; 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; i<meta->modCount; 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; i<config->settingCount; i++) {
+ error |= inihelper_setint(dict, "BasicSettings", meta->settings[i].iniName, config->settings[i]);
+ }
+ for(int i=0; i<config->modCount; 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);
+ }
+}
--- /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 <stdbool.h>
+
+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_ */
--- 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);
}
--- 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_