mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity
transmission/libtransmission/variant.c

1351 lines
32 KiB
C
Raw Blame History

/*
* This file Copyright (C) 2008-2014 Mnemosyne LLC
*
* It may be used under the GNU GPL versions 2 or 3
* or any future license endorsed by Mnemosyne LLC.
*
* $Id$
*/
#if defined (HAVE_USELOCALE) && (!defined (_XOPEN_SOURCE) || _XOPEN_SOURCE < 700)
#undef _XOPEN_SOURCE
#define _XOPEN_SOURCE 700
#endif
#if defined (HAVE_USELOCALE) && !defined (_GNU_SOURCE)
#define _GNU_SOURCE
#endif
#include <assert.h>
#include <errno.h>
#include <stdlib.h> /* strtod(), realloc(), qsort() */
#include <string.h>
#ifdef _WIN32
#include <share.h>
#endif
#include <locale.h> /* setlocale() */
#if defined (HAVE_USELOCALE) && defined (HAVE_XLOCALE_H)
#include <xlocale.h>
#endif
#include <event2/buffer.h>
#define __LIBTRANSMISSION_VARIANT_MODULE__
#include "transmission.h"
#include "ConvertUTF.h"
#include "error.h"
#include "file.h"
#include "log.h"
#include "utils.h" /* tr_new(), tr_free() */
#include "variant.h"
#include "variant-common.h"
/* don't use newlocale/uselocale on old versions of uClibc because they're buggy.
* https://trac.transmissionbt.com/ticket/6006 */
#if defined (__UCLIBC__) && !TR_UCLIBC_CHECK_VERSION (0, 9, 34)
#undef HAVE_USELOCALE
#endif
/**
***
**/
struct locale_context
{
#ifdef HAVE_USELOCALE
locale_t new_locale;
locale_t old_locale;
#else
#if defined (HAVE__CONFIGTHREADLOCALE) && defined (_ENABLE_PER_THREAD_LOCALE)
int old_thread_config;
#endif
int category;
char old_locale[128];
#endif
};
static void
use_numeric_locale (struct locale_context * context,
const char * locale_name)
{
#ifdef HAVE_USELOCALE
context->new_locale = newlocale (LC_NUMERIC_MASK, locale_name, NULL);
context->old_locale = uselocale (context->new_locale);
#else
#if defined (HAVE__CONFIGTHREADLOCALE) && defined (_ENABLE_PER_THREAD_LOCALE)
context->old_thread_config = _configthreadlocale (_ENABLE_PER_THREAD_LOCALE);
#endif
context->category = LC_NUMERIC;
tr_strlcpy (context->old_locale, setlocale (context->category, NULL), sizeof (context->old_locale));
setlocale (context->category, locale_name);
#endif
}
static void
restore_locale (struct locale_context * context)
{
#ifdef HAVE_USELOCALE
uselocale (context->old_locale);
freelocale (context->new_locale);
#else
setlocale (context->category, context->old_locale);
#if defined (HAVE__CONFIGTHREADLOCALE) && defined (_ENABLE_PER_THREAD_LOCALE)
_configthreadlocale (context->old_thread_config);
#endif
#endif
}
/***
****
***/
static bool
tr_variantIsContainer (const tr_variant * v)
{
return tr_variantIsList (v) || tr_variantIsDict (v);
}
static bool
tr_variantIsSomething (const tr_variant * v)
{
return tr_variantIsContainer (v)
|| tr_variantIsInt (v)
|| tr_variantIsString (v)
|| tr_variantIsReal (v)
|| tr_variantIsBool (v);
}
void
tr_variantInit (tr_variant * v, char type)
{
v->type = type;
memset (&v->val, 0, sizeof(v->val));
}
/***
****
***/
static const struct tr_variant_string STRING_INIT =
{
.type = TR_STRING_TYPE_QUARK,
.quark = TR_KEY_NONE,
.len = 0,
.str.str = ""
};
static void
tr_variant_string_clear (struct tr_variant_string * str)
{
if (str->type == TR_STRING_TYPE_HEAP)
tr_free ((char*)(str->str.str));
*str = STRING_INIT;
}
/* returns a const pointer to the variant's string */
static const char *
tr_variant_string_get_string (const struct tr_variant_string * str)
{
const char * ret;
switch (str->type)
{
case TR_STRING_TYPE_BUF: ret = str->str.buf; break;
case TR_STRING_TYPE_HEAP: ret = str->str.str; break;
case TR_STRING_TYPE_QUARK: ret = str->str.str; break;
default: ret = NULL;
}
return ret;
}
static void
tr_variant_string_set_quark (struct tr_variant_string * str,
const tr_quark quark)
{
tr_variant_string_clear (str);
str->type = TR_STRING_TYPE_QUARK;
str->quark = quark;
str->str.str = tr_quark_get_string (quark, &str->len);
}
static void
tr_variant_string_set_string (struct tr_variant_string * str,
const char * bytes,
int len)
{
tr_variant_string_clear (str);
if (bytes == NULL)
len = 0;
else if (len < 0)
len = strlen (bytes);
if ((size_t)len < sizeof(str->str.buf))
{
str->type = TR_STRING_TYPE_BUF;
memcpy (str->str.buf, bytes, len);
str->str.buf[len] = '\0';
str->len = len;
}
else
{
char * tmp = tr_new (char, len+1);
memcpy (tmp, bytes, len);
tmp[len] = '\0';
str->type = TR_STRING_TYPE_HEAP;
str->str.str = tmp;
str->len = len;
}
}
/***
****
***/
static inline const char *
getStr (const tr_variant * v)
{
assert (tr_variantIsString (v));
return tr_variant_string_get_string (&v->val.s);
}
static int
dictIndexOf (const tr_variant * dict, const tr_quark key)
{
if (tr_variantIsDict (dict))
{
const tr_variant * walk;
const tr_variant * const begin = dict->val.l.vals;
const tr_variant * const end = begin + dict->val.l.count;
for (walk=begin; walk!=end; ++walk)
if (walk->key == key)
return walk - begin;
}
return -1;
}
tr_variant *
tr_variantDictFind (tr_variant * dict, const tr_quark key)
{
const int i = dictIndexOf (dict, key);
return i < 0 ? NULL : dict->val.l.vals+i;
}
static bool
tr_variantDictFindType (tr_variant * dict,
const tr_quark key,
int type,
tr_variant ** setme)
{
return tr_variantIsType (*setme = tr_variantDictFind (dict, key), type);
}
size_t
tr_variantListSize (const tr_variant * list)
{
return tr_variantIsList (list) ? list->val.l.count : 0;
}
tr_variant*
tr_variantListChild (tr_variant * v,
size_t i)
{
tr_variant * ret = NULL;
if (tr_variantIsList (v) && (i < v->val.l.count))
ret = v->val.l.vals + i;
return ret;
}
bool
tr_variantListRemove (tr_variant * list, size_t i)
{
bool removed = false;
if (tr_variantIsList (list) && (i < list->val.l.count))
{
removed = true;
tr_variantFree (&list->val.l.vals[i]);
tr_removeElementFromArray (list->val.l.vals, i,
sizeof (tr_variant),
list->val.l.count--);
}
return removed;
}
bool
tr_variantGetInt (const tr_variant * v,
int64_t * setme)
{
bool success = false;
if (!success && ((success = tr_variantIsInt (v))))
if (setme)
*setme = v->val.i;
if (!success && ((success = tr_variantIsBool (v))))
if (setme)
*setme = v->val.b ? 1 : 0;
return success;
}
bool
tr_variantGetStr (const tr_variant * v,
const char ** setme,
size_t * len)
{
const bool success = tr_variantIsString (v);
if (success)
*setme = getStr (v);
if (len != NULL)
*len = success ? v->val.s.len : 0;
return success;
}
bool
tr_variantGetRaw (const tr_variant * v,
const uint8_t ** setme_raw,
size_t * setme_len)
{
const bool success = tr_variantIsString (v);
if (success)
{
*setme_raw = (uint8_t*) getStr (v);
*setme_len = v->val.s.len;
}
return success;
}
bool
tr_variantGetBool (const tr_variant * v, bool * setme)
{
const char * str;
bool success = false;
if ((success = tr_variantIsBool (v)))
*setme = v->val.b;
if (!success && tr_variantIsInt (v))
if ((success = (v->val.i==0 || v->val.i==1)))
*setme = v->val.i!=0;
if (!success && tr_variantGetStr (v, &str, NULL))
if ((success = (!strcmp (str,"true") || !strcmp (str,"false"))))
*setme = !strcmp (str,"true");
return success;
}
bool
tr_variantGetReal (const tr_variant * v, double * setme)
{
bool success = false;
if (!success && ((success = tr_variantIsReal (v))))
*setme = v->val.d;
if (!success && ((success = tr_variantIsInt (v))))
*setme = v->val.i;
if (!success && tr_variantIsString (v))
{
char * endptr;
struct locale_context locale_ctx;
double d;
/* the json spec requires a '.' decimal point regardless of locale */
use_numeric_locale (&locale_ctx, "C");
d = strtod (getStr (v), &endptr);
restore_locale (&locale_ctx);
if ((success = (getStr (v) != endptr) && !*endptr))
*setme = d;
}
return success;
}
bool
tr_variantDictFindInt (tr_variant * dict,
const tr_quark key,
int64_t * setme)
{
tr_variant * child = tr_variantDictFind (dict, key);
return tr_variantGetInt (child, setme);
}
bool
tr_variantDictFindBool (tr_variant * dict,
const tr_quark key,
bool * setme)
{
tr_variant * child = tr_variantDictFind (dict, key);
return tr_variantGetBool (child, setme);
}
bool
tr_variantDictFindReal (tr_variant * dict,
const tr_quark key,
double * setme)
{
tr_variant * child = tr_variantDictFind (dict, key);
return tr_variantGetReal (child, setme);
}
bool
tr_variantDictFindStr (tr_variant * dict,
const tr_quark key,
const char ** setme,
size_t * len)
{
tr_variant * child = tr_variantDictFind (dict, key);
return tr_variantGetStr (child, setme, len);
}
bool
tr_variantDictFindList (tr_variant * dict,
const tr_quark key,
tr_variant ** setme)
{
return tr_variantDictFindType (dict, key, TR_VARIANT_TYPE_LIST, setme);
}
bool
tr_variantDictFindDict (tr_variant * dict,
const tr_quark key,
tr_variant ** setme)
{
return tr_variantDictFindType (dict, key, TR_VARIANT_TYPE_DICT, setme);
}
bool
tr_variantDictFindRaw (tr_variant * dict,
const tr_quark key,
const uint8_t ** setme_raw,
size_t * setme_len)
{
tr_variant * child = tr_variantDictFind (dict, key);
return tr_variantGetRaw (child, setme_raw, setme_len);
}
/***
****
***/
void
tr_variantInitRaw (tr_variant * v, const void * src, size_t byteCount)
{
tr_variantInit (v, TR_VARIANT_TYPE_STR);
tr_variant_string_set_string (&v->val.s, src, byteCount);
}
void
tr_variantInitQuark (tr_variant * v, const tr_quark q)
{
tr_variantInit (v, TR_VARIANT_TYPE_STR);
tr_variant_string_set_quark (&v->val.s, q);
}
void
tr_variantInitStr (tr_variant * v, const void * str, int len)
{
tr_variantInit (v, TR_VARIANT_TYPE_STR);
tr_variant_string_set_string (&v->val.s, str, len);
}
void
tr_variantInitBool (tr_variant * v, bool value)
{
tr_variantInit (v, TR_VARIANT_TYPE_BOOL);
v->val.b = value != 0;
}
void
tr_variantInitReal (tr_variant * v, double value)
{
tr_variantInit (v, TR_VARIANT_TYPE_REAL);
v->val.d = value;
}
void
tr_variantInitInt (tr_variant * v, int64_t value)
{
tr_variantInit (v, TR_VARIANT_TYPE_INT);
v->val.i = value;
}
void
tr_variantInitList (tr_variant * v, size_t reserve_count)
{
tr_variantInit (v, TR_VARIANT_TYPE_LIST);
tr_variantListReserve (v, reserve_count);
}
static void
containerReserve (tr_variant * v, size_t count)
{
const size_t needed = v->val.l.count + count;
assert (tr_variantIsContainer (v));
if (needed > v->val.l.alloc)
{
/* scale the alloc size in powers-of-2 */
size_t n = v->val.l.alloc ? v->val.l.alloc : 8;
while (n < needed)
n *= 2u;
v->val.l.vals = tr_renew (tr_variant, v->val.l.vals, n);
v->val.l.alloc = n;
}
}
void
tr_variantListReserve (tr_variant * list, size_t count)
{
assert (tr_variantIsList (list));
containerReserve (list, count);
}
void
tr_variantInitDict (tr_variant * v, size_t reserve_count)
{
tr_variantInit (v, TR_VARIANT_TYPE_DICT);
tr_variantDictReserve (v, reserve_count);
}
void
tr_variantDictReserve (tr_variant * dict,
size_t reserve_count)
{
assert (tr_variantIsDict (dict));
containerReserve (dict, reserve_count);
}
tr_variant *
tr_variantListAdd (tr_variant * list)
{
tr_variant * child;
assert (tr_variantIsList (list));
containerReserve (list, 1);
child = &list->val.l.vals[list->val.l.count++];
child->key = 0;
tr_variantInit (child, TR_VARIANT_TYPE_INT);
return child;
}
tr_variant *
tr_variantListAddInt (tr_variant * list,
int64_t val)
{
tr_variant * child = tr_variantListAdd (list);
tr_variantInitInt (child, val);
return child;
}
tr_variant *
tr_variantListAddReal (tr_variant * list,
double val)
{
tr_variant * child = tr_variantListAdd (list);
tr_variantInitReal (child, val);
return child;
}
tr_variant *
tr_variantListAddBool (tr_variant * list,
bool val)
{
tr_variant * child = tr_variantListAdd (list);
tr_variantInitBool (child, val);
return child;
}
tr_variant *
tr_variantListAddStr (tr_variant * list,
const char * val)
{
tr_variant * child = tr_variantListAdd (list);
tr_variantInitStr (child, val, -1);
return child;
}
tr_variant *
tr_variantListAddQuark (tr_variant * list,
const tr_quark val)
{
tr_variant * child = tr_variantListAdd (list);
tr_variantInitQuark (child, val);
return child;
}
tr_variant *
tr_variantListAddRaw (tr_variant * list,
const void * val,
size_t len)
{
tr_variant * child = tr_variantListAdd (list);
tr_variantInitRaw (child, val, len);
return child;
}
tr_variant*
tr_variantListAddList (tr_variant * list,
size_t reserve_count)
{
tr_variant * child = tr_variantListAdd (list);
tr_variantInitList (child, reserve_count);
return child;
}
tr_variant*
tr_variantListAddDict (tr_variant * list,
size_t reserve_count)
{
tr_variant * child = tr_variantListAdd (list);
tr_variantInitDict (child, reserve_count);
return child;
}
tr_variant *
tr_variantDictAdd (tr_variant * dict,
const tr_quark key)
{
tr_variant * val;
assert (tr_variantIsDict (dict));
containerReserve (dict, 1);
val = dict->val.l.vals + dict->val.l.count++;
tr_variantInit (val, TR_VARIANT_TYPE_INT);
val->key = key;
return val;
}
static tr_variant*
dictFindOrAdd (tr_variant * dict, const tr_quark key, int type)
{
tr_variant * child;
/* see if it already exists, and if so, try to reuse it */
if ((child = tr_variantDictFind (dict, key)))
{
if (!tr_variantIsType (child, type))
{
tr_variantDictRemove (dict, key);
child = NULL;
}
else if (child->type == TR_VARIANT_TYPE_STR)
{
tr_variant_string_clear (&child->val.s);
}
}
/* if it doesn't exist, create it */
if (child == NULL)
child = tr_variantDictAdd (dict, key);
return child;
}
tr_variant*
tr_variantDictAddInt (tr_variant * dict,
const tr_quark key,
int64_t val)
{
tr_variant * child = dictFindOrAdd (dict, key, TR_VARIANT_TYPE_INT);
tr_variantInitInt (child, val);
return child;
}
tr_variant*
tr_variantDictAddBool (tr_variant * dict,
const tr_quark key,
bool val)
{
tr_variant * child = dictFindOrAdd (dict, key, TR_VARIANT_TYPE_BOOL);
tr_variantInitBool (child, val);
return child;
}
tr_variant*
tr_variantDictAddReal (tr_variant * dict,
const tr_quark key,
double val)
{
tr_variant * child = dictFindOrAdd (dict, key, TR_VARIANT_TYPE_REAL);
tr_variantInitReal (child, val);
return child;
}
tr_variant*
tr_variantDictAddQuark (tr_variant * dict,
const tr_quark key,
const tr_quark val)
{
tr_variant * child = dictFindOrAdd (dict, key, TR_VARIANT_TYPE_STR);
tr_variantInitQuark (child, val);
return child;
}
tr_variant*
tr_variantDictAddStr (tr_variant * dict,
const tr_quark key,
const char * val)
{
tr_variant * child = dictFindOrAdd (dict, key, TR_VARIANT_TYPE_STR);
tr_variantInitStr (child, val, -1);
return child;
}
tr_variant*
tr_variantDictAddRaw (tr_variant * dict,
const tr_quark key,
const void * src,
size_t len)
{
tr_variant * child = dictFindOrAdd (dict, key, TR_VARIANT_TYPE_STR);
tr_variantInitRaw (child, src, len);
return child;
}
tr_variant*
tr_variantDictAddList (tr_variant * dict,
const tr_quark key,
size_t reserve_count)
{
tr_variant * child = tr_variantDictAdd (dict, key);
tr_variantInitList (child, reserve_count);
return child;
}
tr_variant*
tr_variantDictAddDict (tr_variant * dict,
const tr_quark key,
size_t reserve_count)
{
tr_variant * child = tr_variantDictAdd (dict, key);
tr_variantInitDict (child, reserve_count);
return child;
}
tr_variant *
tr_variantDictSteal (tr_variant * dict,
const tr_quark key,
tr_variant * value)
{
tr_variant * child = tr_variantDictAdd (dict, key);
*child = *value;
child->key = key;
tr_variantInit (value, value->type);
return child;
}
bool
tr_variantDictRemove (tr_variant * dict,
const tr_quark key)
{
bool removed = false;
const int i = dictIndexOf (dict, key);
if (i >= 0)
{
const int last = dict->val.l.count - 1;
tr_variantFree (&dict->val.l.vals[i]);
if (i != last)
dict->val.l.vals[i] = dict->val.l.vals[last];
--dict->val.l.count;
removed = true;
}
return removed;
}
/***
**** BENC WALKING
***/
struct KeyIndex
{
const char * keystr;
tr_variant * val;
};
static int
compareKeyIndex (const void * va, const void * vb)
{
const struct KeyIndex * a = va;
const struct KeyIndex * b = vb;
return strcmp (a->keystr, b->keystr);
}
struct SaveNode
{
const tr_variant * v;
tr_variant sorted;
size_t childIndex;
bool isVisited;
};
static void
nodeConstruct (struct SaveNode * node,
const tr_variant * v,
bool sort_dicts)
{
node->isVisited = false;
node->childIndex = 0;
if (sort_dicts && tr_variantIsDict(v))
{
/* make node->sorted a sorted version of this dictionary */
size_t i;
const size_t n = v->val.l.count;
struct KeyIndex * tmp = tr_new (struct KeyIndex, n);
for (i=0; i<n; i++)
{
tmp[i].val = v->val.l.vals+i;
tmp[i].keystr = tr_quark_get_string (tmp[i].val->key, NULL);
}
qsort (tmp, n, sizeof (struct KeyIndex), compareKeyIndex);
tr_variantInitDict (&node->sorted, n);
for (i=0; i<n; ++i)
node->sorted.val.l.vals[i] = *tmp[i].val;
node->sorted.val.l.count = n;
tr_free (tmp);
node->v = &node->sorted;
}
else
{
node->v = v;
}
}
static void
nodeDestruct (struct SaveNode * node)
{
if (node->v == &node->sorted)
tr_free (node->sorted.val.l.vals);
}
/**
* This function's previous recursive implementation was
* easier to read, but was vulnerable to a smash-stacking
* attack via maliciously-crafted data. (#667)
*/
void
tr_variantWalk (const tr_variant * v,
const struct VariantWalkFuncs * walkFuncs,
void * user_data,
bool sort_dicts)
{
int stackSize = 0;
int stackAlloc = 64;
struct SaveNode * stack = tr_new (struct SaveNode, stackAlloc);
nodeConstruct (&stack[stackSize++], v, sort_dicts);
while (stackSize > 0)
{
struct SaveNode * node = &stack[stackSize-1];
const tr_variant * v;
if (!node->isVisited)
{
v = node->v;
node->isVisited = true;
}
else if (tr_variantIsContainer(node->v) && (node->childIndex < node->v->val.l.count))
{
const int index = node->childIndex++;
v = node->v->val.l.vals + index;
if (tr_variantIsDict (node->v))
{
tr_variant tmp;
tr_variantInitQuark (&tmp, v->key);
walkFuncs->stringFunc (&tmp, user_data);
}
}
else /* done with this node */
{
if (tr_variantIsContainer (node->v))
walkFuncs->containerEndFunc (node->v, user_data);
--stackSize;
nodeDestruct (node);
continue;
}
if (v) switch (v->type)
{
case TR_VARIANT_TYPE_INT:
walkFuncs->intFunc (v, user_data);
break;
case TR_VARIANT_TYPE_BOOL:
walkFuncs->boolFunc (v, user_data);
break;
case TR_VARIANT_TYPE_REAL:
walkFuncs->realFunc (v, user_data);
break;
case TR_VARIANT_TYPE_STR:
walkFuncs->stringFunc (v, user_data);
break;
case TR_VARIANT_TYPE_LIST:
if (v == node->v)
{
walkFuncs->listBeginFunc (v, user_data);
}
else
{
if (stackAlloc == stackSize)
{
stackAlloc *= 2;
stack = tr_renew (struct SaveNode, stack, stackAlloc);
}
nodeConstruct (&stack[stackSize++], v, sort_dicts);
}
break;
case TR_VARIANT_TYPE_DICT:
if (v == node->v)
{
walkFuncs->dictBeginFunc (v, user_data);
}
else
{
if (stackAlloc == stackSize)
{
stackAlloc *= 2;
stack = tr_renew (struct SaveNode, stack, stackAlloc);
}
nodeConstruct (&stack[stackSize++], v, sort_dicts);
}
break;
default:
/* did caller give us an uninitialized val? */
tr_logAddError ("%s", _("Invalid metadata"));
break;
}
}
tr_free (stack);
}
/****
*****
****/
static void
freeDummyFunc (const tr_variant * v UNUSED, void * buf UNUSED)
{}
static void
freeStringFunc (const tr_variant * v, void * unused UNUSED)
{
tr_variant_string_clear (&((tr_variant*)v)->val.s);
}
static void
freeContainerEndFunc (const tr_variant * v, void * unused UNUSED)
{
tr_free (v->val.l.vals);
}
static const struct VariantWalkFuncs freeWalkFuncs = { freeDummyFunc,
freeDummyFunc,
freeDummyFunc,
freeStringFunc,
freeDummyFunc,
freeDummyFunc,
freeContainerEndFunc };
void
tr_variantFree (tr_variant * v)
{
if (tr_variantIsSomething (v))
tr_variantWalk (v, &freeWalkFuncs, NULL, false);
}
/***
****
***/
static void
tr_variantListCopy (tr_variant * target, const tr_variant * src)
{
int i = 0;
const tr_variant * val;
while ((val = tr_variantListChild ((tr_variant*)src, i++)))
{
if (tr_variantIsBool (val))
{
bool boolVal = 0;
tr_variantGetBool (val, &boolVal);
tr_variantListAddBool (target, boolVal);
}
else if (tr_variantIsReal (val))
{
double realVal = 0;
tr_variantGetReal (val, &realVal);
tr_variantListAddReal (target, realVal);
}
else if (tr_variantIsInt (val))
{
int64_t intVal = 0;
tr_variantGetInt (val, &intVal);
tr_variantListAddInt (target, intVal);
}
else if (tr_variantIsString (val))
{
size_t len;
const char * str;
tr_variantGetStr (val, &str, &len);
tr_variantListAddRaw (target, str, len);
}
else if (tr_variantIsDict (val))
{
tr_variantMergeDicts (tr_variantListAddDict (target, 0), val);
}
else if (tr_variantIsList (val))
{
tr_variantListCopy (tr_variantListAddList (target, 0), val);
}
else
{
tr_logAddError ("tr_variantListCopy skipping item");
}
}
}
static size_t
tr_variantDictSize (const tr_variant * dict)
{
return tr_variantIsDict (dict) ? dict->val.l.count : 0;
}
bool
tr_variantDictChild (tr_variant * dict,
size_t n,
tr_quark * key,
tr_variant ** val)
{
bool success = 0;
assert (tr_variantIsDict (dict));
if (tr_variantIsDict (dict) && (n<dict->val.l.count))
{
*key = dict->val.l.vals[n].key;
*val = dict->val.l.vals+n;
success = true;
}
return success;
}
void
tr_variantMergeDicts (tr_variant * target, const tr_variant * source)
{
size_t i;
const size_t sourceCount = tr_variantDictSize (source);
assert (tr_variantIsDict (target));
assert (tr_variantIsDict (source));
tr_variantDictReserve (target, sourceCount + tr_variantDictSize(target));
for (i=0; i<sourceCount; ++i)
{
tr_quark key;
tr_variant * val;
tr_variant * t;
if (tr_variantDictChild ((tr_variant*)source, i, &key, &val))
{
if (tr_variantIsBool (val))
{
bool boolVal;
tr_variantGetBool (val, &boolVal);
tr_variantDictAddBool (target, key, boolVal);
}
else if (tr_variantIsReal (val))
{
double realVal = 0;
tr_variantGetReal (val, &realVal);
tr_variantDictAddReal (target, key, realVal);
}
else if (tr_variantIsInt (val))
{
int64_t intVal = 0;
tr_variantGetInt (val, &intVal);
tr_variantDictAddInt (target, key, intVal);
}
else if (tr_variantIsString (val))
{
size_t len;
const char * str;
tr_variantGetStr (val, &str, &len);
tr_variantDictAddRaw (target, key, str, len);
}
else if (tr_variantIsDict (val) && tr_variantDictFindDict (target, key, &t))
{
tr_variantMergeDicts (t, val);
}
else if (tr_variantIsList (val))
{
if (tr_variantDictFind (target, key) == NULL)
tr_variantListCopy (tr_variantDictAddList (target, key, tr_variantListSize (val)), val);
}
else if (tr_variantIsDict (val))
{
tr_variant * target_dict = tr_variantDictFind (target, key);
if (target_dict == NULL)
target_dict = tr_variantDictAddDict (target, key, tr_variantDictSize (val));
if (tr_variantIsDict (target_dict))
tr_variantMergeDicts (target_dict, val);
}
else
{
tr_logAddDebug ("tr_variantMergeDicts skipping \"%s\"", tr_quark_get_string(key,NULL));
}
}
}
}
/***
****
***/
struct evbuffer *
tr_variantToBuf (const tr_variant * v, tr_variant_fmt fmt)
{
struct locale_context locale_ctx;
struct evbuffer * buf = evbuffer_new();
/* parse with LC_NUMERIC="C" to ensure a "." decimal separator */
use_numeric_locale (&locale_ctx, "C");
evbuffer_expand (buf, 4096); /* alloc a little memory to start off with */
switch (fmt)
{
case TR_VARIANT_FMT_BENC:
tr_variantToBufBenc (v, buf);
break;
case TR_VARIANT_FMT_JSON:
tr_variantToBufJson (v, buf, false);
break;
case TR_VARIANT_FMT_JSON_LEAN:
tr_variantToBufJson (v, buf, true);
break;
}
/* restore the previous locale */
restore_locale (&locale_ctx);
return buf;
}
char*
tr_variantToStr (const tr_variant * v, tr_variant_fmt fmt, int * len)
{
struct evbuffer * buf = tr_variantToBuf (v, fmt);
const size_t n = evbuffer_get_length (buf);
char * ret = evbuffer_free_to_str (buf);
if (len != NULL)
*len = (int) n;
return ret;
}
int
tr_variantToFile (const tr_variant * v,
tr_variant_fmt fmt,
const char * filename)
{
char * tmp;
tr_sys_file_t fd;
int err = 0;
char * real_filename;
tr_error * error = NULL;
/* follow symlinks to find the "real" file, to make sure the temporary
* we build with tr_sys_file_open_temp() is created on the right partition */
if ((real_filename = tr_sys_path_resolve (filename, NULL)) != NULL)
filename = real_filename;
/* if the file already exists, try to move it out of the way & keep it as a backup */
tmp = tr_strdup_printf ("%s.tmp.XXXXXX", filename);
fd = tr_sys_file_open_temp (tmp, &error);
if (fd != TR_BAD_SYS_FILE)
{
uint64_t nleft;
/* save the variant to a temporary file */
{
struct evbuffer * buf = tr_variantToBuf (v, fmt);
const char * walk = (const char *) evbuffer_pullup (buf, -1);
nleft = evbuffer_get_length (buf);
while (nleft > 0)
{
uint64_t n;
if (!tr_sys_file_write (fd, walk, nleft, &n, &error))
{
err = error->code;
break;
}
nleft -= n;
walk += n;
}
evbuffer_free (buf);
}
tr_sys_file_close (fd, NULL);
if (nleft > 0)
{
tr_logAddError (_("Couldn't save temporary file \"%1$s\": %2$s"), tmp, error->message);
tr_sys_path_remove (tmp, NULL);
tr_error_free (error);
}
else
{
tr_error_clear (&error);
if (tr_sys_path_rename (tmp, filename, &error))
{
tr_logAddInfo (_("Saved \"%s\""), filename);
}
else
{
err = error->code;
tr_logAddError (_("Couldn't save file \"%1$s\": %2$s"), filename, error->message);
tr_sys_path_remove (tmp, NULL);
tr_error_free (error);
}
}
}
else
{
err = error->code;
tr_logAddError (_("Couldn't save temporary file \"%1$s\": %2$s"), tmp, error->message);
tr_error_free (error);
}
tr_free (tmp);
tr_free (real_filename);
return err;
}
/***
****
***/
bool
tr_variantFromFile (tr_variant * setme,
tr_variant_fmt fmt,
const char * filename,
tr_error ** error)
{
bool ret = false;
uint8_t * buf;
size_t buflen;
buf = tr_loadFile (filename, &buflen, error);
if (buf != NULL)
{
if (tr_variantFromBuf (setme, fmt, buf, buflen, filename, NULL) == 0)
ret = true;
else
tr_error_set_literal (error, 0, _("Unable to parse file content"));
tr_free (buf);
}
return ret;
}
int
tr_variantFromBuf (tr_variant * setme,
tr_variant_fmt fmt,
const void * buf,
size_t buflen,
const char * optional_source,
const char ** setme_end)
{
int err;
struct locale_context locale_ctx;
/* parse with LC_NUMERIC="C" to ensure a "." decimal separator */
use_numeric_locale (&locale_ctx, "C");
switch (fmt)
{
case TR_VARIANT_FMT_JSON:
case TR_VARIANT_FMT_JSON_LEAN:
err = tr_jsonParse (optional_source, buf, buflen, setme, setme_end);
break;
default /* TR_VARIANT_FMT_BENC */:
err = tr_variantParseBenc (buf, ((const char*)buf)+buflen, setme, setme_end);
break;
}
/* restore the previous locale */
restore_locale (&locale_ctx);
return err;
}
Reference in New Issue View Git Blame Copy Permalink