Changeset 13667


Ignore:
Timestamp:
Dec 14, 2012, 4:34:42 AM (8 years ago)
Author:
jordan
Message:

refactor libtransmission's tr_benc class as tr_variant.

Location:
trunk
Files:
3 added
2 deleted
64 edited
3 moved

Legend:

Unmodified
Added
Removed
  • trunk/cli/cli.c

    r13625 r13667  
    2929
    3030#include <libtransmission/transmission.h>
    31 #include <libtransmission/bencode.h>
    3231#include <libtransmission/tr-getopt.h>
    3332#include <libtransmission/utils.h> /* tr_wait_msec */
     33#include <libtransmission/variant.h>
    3434#include <libtransmission/version.h>
    3535#include <libtransmission/web.h> /* tr_webRun */
     
    105105}
    106106
    107 static int parseCommandLine (tr_benc*, int argc, const char ** argv);
     107static int parseCommandLine (tr_variant*, int argc, const char ** argv);
    108108
    109109static void sigHandler (int signal);
     
    227227  tr_ctor     * ctor;
    228228  tr_torrent  * tor = NULL;
    229   tr_benc       settings;
     229  tr_variant       settings;
    230230  const char  * configDir;
    231231  uint8_t     * fileContents;
     
    248248
    249249  /* load the defaults from config file + libtransmission defaults */
    250   tr_bencInitDict (&settings, 0);
     250  tr_variantInitDict (&settings, 0);
    251251  configDir = getConfigDir (argc, (const char**)argv);
    252252  tr_sessionLoadSettings (&settings, configDir, MY_CONFIG_NAME);
     
    266266    }
    267267
    268   if (tr_bencDictFindStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str))
     268  if (tr_variantDictFindStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str, NULL))
    269269    {
    270270      str = tr_realpath (str, buf);
     
    272272      if (str != NULL)
    273273        {
    274           tr_bencDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, str);
     274          tr_variantDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, str);
    275275        }
    276276      else
     
    379379
    380380  printf ("\n");
    381   tr_bencFree (&settings);
     381  tr_variantFree (&settings);
    382382  tr_sessionClose (h);
    383383  return EXIT_SUCCESS;
     
    390390
    391391static int
    392 parseCommandLine (tr_benc * d, int argc, const char ** argv)
     392parseCommandLine (tr_variant * d, int argc, const char ** argv)
    393393{
    394394  int c;
     
    400400        {
    401401          case 'b':
    402             tr_bencDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED, true);
    403             break;
    404 
    405           case 'B': tr_bencDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED, false);
     402            tr_variantDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED, true);
     403            break;
     404
     405          case 'B': tr_variantDictAddBool (d, TR_PREFS_KEY_BLOCKLIST_ENABLED, false);
    406406            break;
    407407
    408408          case 'd':
    409             tr_bencDictAddInt (d, TR_PREFS_KEY_DSPEED_KBps, atoi (optarg));
    410             tr_bencDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED, true);
    411             break;
    412 
    413           case 'D': tr_bencDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED, false);
     409            tr_variantDictAddInt (d, TR_PREFS_KEY_DSPEED_KBps, atoi (optarg));
     410            tr_variantDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED, true);
     411            break;
     412
     413          case 'D': tr_variantDictAddBool (d, TR_PREFS_KEY_DSPEED_ENABLED, false);
    414414            break;
    415415
    416416          case 'f':
    417             tr_bencDictAddStr (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg);
    418             tr_bencDictAddBool (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true);
     417            tr_variantDictAddStr (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg);
     418            tr_variantDictAddBool (d, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true);
    419419            break;
    420420
     
    423423
    424424          case 'm':
    425             tr_bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, true);
     425            tr_variantDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, true);
    426426            break;
    427427
    428428          case 'M':
    429             tr_bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, false);
     429            tr_variantDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, false);
    430430            break;
    431431
    432432          case 'p':
    433             tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT, atoi (optarg));
     433            tr_variantDictAddInt (d, TR_PREFS_KEY_PEER_PORT, atoi (optarg));
    434434            break;
    435435
    436436          case 't':
    437             tr_bencDictAddInt (d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi (optarg));
     437            tr_variantDictAddInt (d, TR_PREFS_KEY_PEER_SOCKET_TOS, atoi (optarg));
    438438            break;
    439439
    440440          case 'u':
    441             tr_bencDictAddInt (d, TR_PREFS_KEY_USPEED_KBps, atoi (optarg));
    442             tr_bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, true);
     441            tr_variantDictAddInt (d, TR_PREFS_KEY_USPEED_KBps, atoi (optarg));
     442            tr_variantDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, true);
    443443            break;
    444444
    445445          case 'U':
    446             tr_bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, false);
     446            tr_variantDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, false);
    447447            break;
    448448
     
    456456
    457457          case 'w':
    458             tr_bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, optarg);
     458            tr_variantDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, optarg);
    459459            break;
    460460
    461461          case 910:
    462             tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED);
     462            tr_variantDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED);
    463463            break;
    464464
    465465          case 911:
    466             tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED);
     466            tr_variantDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED);
    467467            break;
    468468
    469469          case 912:
    470             tr_bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED);
     470            tr_variantDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED);
    471471            break;
    472472
  • trunk/daemon/daemon.c

    r13625 r13667  
    2525
    2626#include <libtransmission/transmission.h>
    27 #include <libtransmission/bencode.h>
    2827#include <libtransmission/tr-getopt.h>
    2928#include <libtransmission/utils.h>
     29#include <libtransmission/variant.h>
    3030#include <libtransmission/version.h>
    3131
     
    154154            else
    155155            {
    156                 tr_benc settings;
     156                tr_variant settings;
    157157                const char * configDir;
    158158
     
    166166                configDir = tr_sessionGetConfigDir (mySession);
    167167                tr_inf ("Reloading settings from \"%s\"", configDir);
    168                 tr_bencInitDict (&settings, 0);
    169                 tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_ENABLED, true);
     168                tr_variantInitDict (&settings, 0);
     169                tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_ENABLED, true);
    170170                tr_sessionLoadSettings (&settings, configDir, MY_NAME);
    171171                tr_sessionSet (mySession, &settings);
    172                 tr_bencFree (&settings);
     172                tr_variantFree (&settings);
    173173                tr_sessionReloadBlocklists (mySession);
    174174            }
     
    359359    int c;
    360360    const char * optarg;
    361     tr_benc settings;
     361    tr_variant settings;
    362362    bool boolVal;
    363363    bool loaded;
     
    377377
    378378    /* load settings from defaults + config file */
    379     tr_bencInitDict (&settings, 0);
    380     tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_ENABLED, true);
     379    tr_variantInitDict (&settings, 0);
     380    tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_ENABLED, true);
    381381    configDir = getConfigDir (argc, (const char**)argv);
    382382    loaded = tr_sessionLoadSettings (&settings, configDir, MY_NAME);
     
    386386    while ((c = tr_getopt (getUsage (), argc, (const char**)argv, options, &optarg))) {
    387387        switch (c) {
    388             case 'a': tr_bencDictAddStr (&settings, TR_PREFS_KEY_RPC_WHITELIST, optarg);
    389                       tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, true);
    390                       break;
    391             case 'b': tr_bencDictAddBool (&settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, true);
    392                       break;
    393             case 'B': tr_bencDictAddBool (&settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, false);
    394                       break;
    395             case 'c': tr_bencDictAddStr (&settings, PREF_KEY_DIR_WATCH, optarg);
    396                       tr_bencDictAddBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, true);
    397                       break;
    398             case 'C': tr_bencDictAddBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, false);
    399                       break;
    400             case 941: tr_bencDictAddStr (&settings, TR_PREFS_KEY_INCOMPLETE_DIR, optarg);
    401                       tr_bencDictAddBool (&settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true);
    402                       break;
    403             case 942: tr_bencDictAddBool (&settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false);
     388            case 'a': tr_variantDictAddStr (&settings, TR_PREFS_KEY_RPC_WHITELIST, optarg);
     389                      tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_WHITELIST_ENABLED, true);
     390                      break;
     391            case 'b': tr_variantDictAddBool (&settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, true);
     392                      break;
     393            case 'B': tr_variantDictAddBool (&settings, TR_PREFS_KEY_BLOCKLIST_ENABLED, false);
     394                      break;
     395            case 'c': tr_variantDictAddStr (&settings, PREF_KEY_DIR_WATCH, optarg);
     396                      tr_variantDictAddBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, true);
     397                      break;
     398            case 'C': tr_variantDictAddBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, false);
     399                      break;
     400            case 941: tr_variantDictAddStr (&settings, TR_PREFS_KEY_INCOMPLETE_DIR, optarg);
     401                      tr_variantDictAddBool (&settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true);
     402                      break;
     403            case 942: tr_variantDictAddBool (&settings, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false);
    404404                      break;
    405405            case 'd': dumpSettings = true;
     
    418418                      fprintf (stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING);
    419419                      exit (0);
    420             case 'o': tr_bencDictAddBool (&settings, TR_PREFS_KEY_DHT_ENABLED, true);
    421                       break;
    422             case 'O': tr_bencDictAddBool (&settings, TR_PREFS_KEY_DHT_ENABLED, false);
    423                       break;
    424             case 'p': tr_bencDictAddInt (&settings, TR_PREFS_KEY_RPC_PORT, atoi (optarg));
    425                       break;
    426             case 't': tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, true);
    427                       break;
    428             case 'T': tr_bencDictAddBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, false);
    429                       break;
    430             case 'u': tr_bencDictAddStr (&settings, TR_PREFS_KEY_RPC_USERNAME, optarg);
    431                       break;
    432             case 'v': tr_bencDictAddStr (&settings, TR_PREFS_KEY_RPC_PASSWORD, optarg);
    433                       break;
    434             case 'w': tr_bencDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, optarg);
    435                       break;
    436             case 'P': tr_bencDictAddInt (&settings, TR_PREFS_KEY_PEER_PORT, atoi (optarg));
    437                       break;
    438             case 'm': tr_bencDictAddBool (&settings, TR_PREFS_KEY_PORT_FORWARDING, true);
    439                       break;
    440             case 'M': tr_bencDictAddBool (&settings, TR_PREFS_KEY_PORT_FORWARDING, false);
    441                       break;
    442             case 'L': tr_bencDictAddInt (&settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi (optarg));
    443                       break;
    444             case 'l': tr_bencDictAddInt (&settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi (optarg));
     420            case 'o': tr_variantDictAddBool (&settings, TR_PREFS_KEY_DHT_ENABLED, true);
     421                      break;
     422            case 'O': tr_variantDictAddBool (&settings, TR_PREFS_KEY_DHT_ENABLED, false);
     423                      break;
     424            case 'p': tr_variantDictAddInt (&settings, TR_PREFS_KEY_RPC_PORT, atoi (optarg));
     425                      break;
     426            case 't': tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, true);
     427                      break;
     428            case 'T': tr_variantDictAddBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, false);
     429                      break;
     430            case 'u': tr_variantDictAddStr (&settings, TR_PREFS_KEY_RPC_USERNAME, optarg);
     431                      break;
     432            case 'v': tr_variantDictAddStr (&settings, TR_PREFS_KEY_RPC_PASSWORD, optarg);
     433                      break;
     434            case 'w': tr_variantDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, optarg);
     435                      break;
     436            case 'P': tr_variantDictAddInt (&settings, TR_PREFS_KEY_PEER_PORT, atoi (optarg));
     437                      break;
     438            case 'm': tr_variantDictAddBool (&settings, TR_PREFS_KEY_PORT_FORWARDING, true);
     439                      break;
     440            case 'M': tr_variantDictAddBool (&settings, TR_PREFS_KEY_PORT_FORWARDING, false);
     441                      break;
     442            case 'L': tr_variantDictAddInt (&settings, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi (optarg));
     443                      break;
     444            case 'l': tr_variantDictAddInt (&settings, TR_PREFS_KEY_PEER_LIMIT_TORRENT, atoi (optarg));
    445445                      break;
    446446            case 800: paused = true;
    447447                      break;
    448             case 910: tr_bencDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED);
    449                       break;
    450             case 911: tr_bencDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED);
    451                       break;
    452             case 912: tr_bencDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED);
    453                       break;
    454             case 'i': tr_bencDictAddStr (&settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, optarg);
    455                       break;
    456             case 'I': tr_bencDictAddStr (&settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, optarg);
    457                       break;
    458             case 'r': tr_bencDictAddStr (&settings, TR_PREFS_KEY_RPC_BIND_ADDRESS, optarg);
    459                       break;
    460             case 953: tr_bencDictAddReal (&settings, TR_PREFS_KEY_RATIO, atof (optarg));
    461                       tr_bencDictAddBool (&settings, TR_PREFS_KEY_RATIO_ENABLED, true);
    462                       break;
    463             case 954: tr_bencDictAddBool (&settings, TR_PREFS_KEY_RATIO_ENABLED, false);
    464                       break;
    465             case 'x': tr_bencDictAddStr (&settings, PREF_KEY_PIDFILE, optarg);
    466                       break;
    467             case 'y': tr_bencDictAddBool (&settings, TR_PREFS_KEY_LPD_ENABLED, true);
    468                       break;
    469             case 'Y': tr_bencDictAddBool (&settings, TR_PREFS_KEY_LPD_ENABLED, false);
    470                       break;
    471             case 810: tr_bencDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_ERR);
    472                       break;
    473             case 811: tr_bencDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_INF);
    474                       break;
    475             case 812: tr_bencDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_DBG);
    476                       break;
    477             case 830: tr_bencDictAddBool (&settings, TR_PREFS_KEY_UTP_ENABLED, true);
    478                       break;
    479             case 831: tr_bencDictAddBool (&settings, TR_PREFS_KEY_UTP_ENABLED, false);
     448            case 910: tr_variantDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED);
     449                      break;
     450            case 911: tr_variantDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED);
     451                      break;
     452            case 912: tr_variantDictAddInt (&settings, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED);
     453                      break;
     454            case 'i': tr_variantDictAddStr (&settings, TR_PREFS_KEY_BIND_ADDRESS_IPV4, optarg);
     455                      break;
     456            case 'I': tr_variantDictAddStr (&settings, TR_PREFS_KEY_BIND_ADDRESS_IPV6, optarg);
     457                      break;
     458            case 'r': tr_variantDictAddStr (&settings, TR_PREFS_KEY_RPC_BIND_ADDRESS, optarg);
     459                      break;
     460            case 953: tr_variantDictAddReal (&settings, TR_PREFS_KEY_RATIO, atof (optarg));
     461                      tr_variantDictAddBool (&settings, TR_PREFS_KEY_RATIO_ENABLED, true);
     462                      break;
     463            case 954: tr_variantDictAddBool (&settings, TR_PREFS_KEY_RATIO_ENABLED, false);
     464                      break;
     465            case 'x': tr_variantDictAddStr (&settings, PREF_KEY_PIDFILE, optarg);
     466                      break;
     467            case 'y': tr_variantDictAddBool (&settings, TR_PREFS_KEY_LPD_ENABLED, true);
     468                      break;
     469            case 'Y': tr_variantDictAddBool (&settings, TR_PREFS_KEY_LPD_ENABLED, false);
     470                      break;
     471            case 810: tr_variantDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_ERR);
     472                      break;
     473            case 811: tr_variantDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_INF);
     474                      break;
     475            case 812: tr_variantDictAddInt (&settings,  TR_PREFS_KEY_MSGLEVEL, TR_MSG_DBG);
     476                      break;
     477            case 830: tr_variantDictAddBool (&settings, TR_PREFS_KEY_UTP_ENABLED, true);
     478                      break;
     479            case 831: tr_variantDictAddBool (&settings, TR_PREFS_KEY_UTP_ENABLED, false);
    480480                      break;
    481481            default:  showUsage ();
     
    495495    if (dumpSettings)
    496496    {
    497         char * str = tr_bencToStr (&settings, TR_FMT_JSON, NULL);
     497        char * str = tr_variantToStr (&settings, TR_VARIANT_FMT_JSON, NULL);
    498498        fprintf (stderr, "%s", str);
    499499        tr_free (str);
     
    519519
    520520    pid_filename = NULL;
    521     tr_bencDictFindStr (&settings, PREF_KEY_PIDFILE, &pid_filename);
     521    tr_variantDictFindStr (&settings, PREF_KEY_PIDFILE, &pid_filename, NULL);
    522522    if (pid_filename && *pid_filename)
    523523    {
     
    534534    }
    535535
    536     if (tr_bencDictFindBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal) && boolVal)
     536    if (tr_variantDictFindBool (&settings, TR_PREFS_KEY_RPC_AUTH_REQUIRED, &boolVal) && boolVal)
    537537        tr_ninf (MY_NAME, "requiring authentication");
    538538
     
    547547        const char * dir;
    548548
    549         if (tr_bencDictFindBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal)
     549        if (tr_variantDictFindBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal)
    550550            && boolVal
    551             && tr_bencDictFindStr (&settings, PREF_KEY_DIR_WATCH, &dir)
     551            && tr_variantDictFindStr (&settings, PREF_KEY_DIR_WATCH, &dir, NULL)
    552552            && dir
    553553            && *dir)
     
    599599    if (pidfile_created)
    600600        remove (pid_filename);
    601     tr_bencFree (&settings);
     601    tr_variantFree (&settings);
    602602    return 0;
    603603}
  • trunk/daemon/my-valgrind.sh

    r6347 r13667  
    33export G_DEBUG=gc-friendly
    44export GLIBCXX_FORCE_NEW=1
    5 valgrind --tool=memcheck --leak-check=full --leak-resolution=high --num-callers=64 --log-file=x-valgrind --show-reachable=yes ./transmission-daemon -f
     5#valgrind --tool=memcheck --leak-check=full --leak-resolution=high --num-callers=64 --log-file=x-valgrind --show-reachable=yes ./transmission-daemon -f
     6valgrind --tool=cachegrind ./transmission-daemon -f -g /home/charles/.config/transmission
  • trunk/daemon/remote.c

    r13625 r13667  
    3131
    3232#include <libtransmission/transmission.h>
    33 #include <libtransmission/bencode.h>
    3433#include <libtransmission/rpcimpl.h>
    35 #include <libtransmission/json.h>
    3634#include <libtransmission/tr-getopt.h>
    3735#include <libtransmission/utils.h>
     36#include <libtransmission/variant.h>
    3837#include <libtransmission/version.h>
    3938
     
    547546
    548547static void
    549 addIdArg (tr_benc * args, const char * id)
     548addIdArg (tr_variant * args, const char * id)
    550549{
    551550    if (!*id)
     
    565564                isNum = false;
    566565        if (isNum || isList)
    567             tr_rpc_parse_list_str (tr_bencDictAdd (args, "ids"), id, strlen (id));
     566            tr_rpc_parse_list_str (tr_variantDictAdd (args, "ids"), id, strlen (id));
    568567        else
    569             tr_bencDictAddStr (args, "ids", id); /* it's a torrent sha hash */
     568            tr_variantDictAddStr (args, "ids", id); /* it's a torrent sha hash */
    570569    }
    571570}
    572571
    573572static void
    574 addTime (tr_benc * args, const char * key, const char * arg)
     573addTime (tr_variant * args, const char * key, const char * arg)
    575574{
    576575    int time;
     
    592591
    593592    if (success)
    594         tr_bencDictAddInt (args, key, time);
     593        tr_variantDictAddInt (args, key, time);
    595594    else
    596595        fprintf (stderr, "Please specify the time of day in 'hhmm' format.\n");
     
    598597
    599598static void
    600 addDays (tr_benc * args, const char * key, const char * arg)
     599addDays (tr_variant * args, const char * key, const char * arg)
    601600{
    602601    int days = 0;
     
    618617
    619618    if (days)
    620         tr_bencDictAddInt (args, key, days);
     619        tr_variantDictAddInt (args, key, days);
    621620    else
    622621        fprintf (stderr, "Please specify the days of the week in '1-3,4,7' format.\n");
     
    624623
    625624static void
    626 addFiles (tr_benc *    args,
     625addFiles (tr_variant *    args,
    627626          const char * key,
    628627          const char * arg)
    629628{
    630     tr_benc * files = tr_bencDictAddList (args, key, 100);
     629    tr_variant * files = tr_variantDictAddList (args, key, 100);
    631630
    632631    if (!*arg)
     
    641640        int * values = tr_parseNumberRange (arg, -1, &valueCount);
    642641        for (i=0; i<valueCount; ++i)
    643             tr_bencListAddInt (files, values[i]);
     642            tr_variantListAddInt (files, values[i]);
    644643        tr_free (values);
    645644    }
     
    763762
    764763static char*
    765 getStatusString (tr_benc * t, char * buf, size_t buflen)
     764getStatusString (tr_variant * t, char * buf, size_t buflen)
    766765{
    767766    int64_t status;
    768767    bool boolVal;
    769768
    770     if (!tr_bencDictFindInt (t, "status", &status))
     769    if (!tr_variantDictFindInt (t, "status", &status))
    771770    {
    772771        *buf = '\0';
     
    780779
    781780        case TR_STATUS_STOPPED:
    782             if (tr_bencDictFindBool (t, "isFinished", &boolVal) && boolVal)
     781            if (tr_variantDictFindBool (t, "isFinished", &boolVal) && boolVal)
    783782                tr_strlcpy (buf, "Finished", buflen);
    784783            else
     
    792791                             : "Verifying";
    793792            double percent;
    794             if (tr_bencDictFindReal (t, "recheckProgress", &percent))
     793            if (tr_variantDictFindReal (t, "recheckProgress", &percent))
    795794                tr_snprintf (buf, buflen, "%s (%.0f%%)", str, floor (percent*100.0));
    796795            else
     
    804803            int64_t fromUs = 0;
    805804            int64_t toUs = 0;
    806             tr_bencDictFindInt (t, "peersGettingFromUs", &fromUs);
    807             tr_bencDictFindInt (t, "peersSendingToUs", &toUs);
     805            tr_variantDictFindInt (t, "peersGettingFromUs", &fromUs);
     806            tr_variantDictFindInt (t, "peersSendingToUs", &toUs);
    808807            if (fromUs && toUs)
    809808                tr_strlcpy (buf, "Up & Down", buflen);
     
    812811            else if (fromUs) {
    813812                int64_t leftUntilDone = 0;
    814                 tr_bencDictFindInt (t, "leftUntilDone", &leftUntilDone);
     813                tr_variantDictFindInt (t, "leftUntilDone", &leftUntilDone);
    815814                if (leftUntilDone > 0)
    816815                    tr_strlcpy (buf, "Uploading", buflen);
     
    835834
    836835static void
    837 printDetails (tr_benc * top)
    838 {
    839     tr_benc *args, *torrents;
    840 
    841     if ((tr_bencDictFindDict (top, "arguments", &args))
    842       && (tr_bencDictFindList (args, "torrents", &torrents)))
     836printDetails (tr_variant * top)
     837{
     838    tr_variant *args, *torrents;
     839
     840    if ((tr_variantDictFindDict (top, "arguments", &args))
     841      && (tr_variantDictFindList (args, "torrents", &torrents)))
    843842    {
    844843        int ti, tCount;
    845         for (ti = 0, tCount = tr_bencListSize (torrents); ti < tCount;
     844        for (ti = 0, tCount = tr_variantListSize (torrents); ti < tCount;
    846845             ++ti)
    847846        {
    848             tr_benc *    t = tr_bencListChild (torrents, ti);
    849             tr_benc *    l;
     847            tr_variant *    t = tr_variantListChild (torrents, ti);
     848            tr_variant *    l;
    850849            const char * str;
    851850            char         buf[512];
     
    856855
    857856            printf ("NAME\n");
    858             if (tr_bencDictFindInt (t, "id", &i))
     857            if (tr_variantDictFindInt (t, "id", &i))
    859858                printf ("  Id: %" PRId64 "\n", i);
    860             if (tr_bencDictFindStr (t, "name", &str))
     859            if (tr_variantDictFindStr (t, "name", &str, NULL))
    861860                printf ("  Name: %s\n", str);
    862             if (tr_bencDictFindStr (t, "hashString", &str))
     861            if (tr_variantDictFindStr (t, "hashString", &str, NULL))
    863862                printf ("  Hash: %s\n", str);
    864             if (tr_bencDictFindStr (t, "magnetLink", &str))
     863            if (tr_variantDictFindStr (t, "magnetLink", &str, NULL))
    865864                printf ("  Magnet: %s\n", str);
    866865            printf ("\n");
     
    870869            printf ("  State: %s\n", buf);
    871870
    872             if (tr_bencDictFindStr (t, "downloadDir", &str))
     871            if (tr_variantDictFindStr (t, "downloadDir", &str, NULL))
    873872                printf ("  Location: %s\n", str);
    874873
    875             if (tr_bencDictFindInt (t, "sizeWhenDone", &i)
    876               && tr_bencDictFindInt (t, "leftUntilDone", &j))
     874            if (tr_variantDictFindInt (t, "sizeWhenDone", &i)
     875              && tr_variantDictFindInt (t, "leftUntilDone", &j))
    877876            {
    878877                strlpercent (buf, 100.0 * (i - j) / i, sizeof (buf));
     
    880879            }
    881880
    882             if (tr_bencDictFindInt (t, "eta", &i))
     881            if (tr_variantDictFindInt (t, "eta", &i))
    883882                printf ("  ETA: %s\n", tr_strltime (buf, i, sizeof (buf)));
    884             if (tr_bencDictFindInt (t, "rateDownload", &i))
     883            if (tr_variantDictFindInt (t, "rateDownload", &i))
    885884                printf ("  Download Speed: %s\n", tr_formatter_speed_KBps (buf, i/ (double)tr_speed_K, sizeof (buf)));
    886             if (tr_bencDictFindInt (t, "rateUpload", &i))
     885            if (tr_variantDictFindInt (t, "rateUpload", &i))
    887886                printf ("  Upload Speed: %s\n", tr_formatter_speed_KBps (buf, i/ (double)tr_speed_K, sizeof (buf)));
    888             if (tr_bencDictFindInt (t, "haveUnchecked", &i)
    889               && tr_bencDictFindInt (t, "haveValid", &j))
     887            if (tr_variantDictFindInt (t, "haveUnchecked", &i)
     888              && tr_variantDictFindInt (t, "haveValid", &j))
    890889            {
    891890                strlsize (buf, i + j, sizeof (buf));
     
    894893            }
    895894
    896             if (tr_bencDictFindInt (t, "sizeWhenDone", &i))
     895            if (tr_variantDictFindInt (t, "sizeWhenDone", &i))
    897896            {
    898897                if (i < 1)
    899898                    printf ("  Availability: None\n");
    900                 if (tr_bencDictFindInt (t, "desiredAvailable", &j)
    901                     && tr_bencDictFindInt (t, "leftUntilDone", &k))
     899                if (tr_variantDictFindInt (t, "desiredAvailable", &j)
     900                    && tr_variantDictFindInt (t, "leftUntilDone", &k))
    902901                {
    903902                    j += i - k;
     
    905904                    printf ("  Availability: %s%%\n", buf);
    906905                }
    907                 if (tr_bencDictFindInt (t, "totalSize", &j))
     906                if (tr_variantDictFindInt (t, "totalSize", &j))
    908907                {
    909908                    strlsize (buf2, i, sizeof (buf2));
     
    912911                }
    913912            }
    914             if (tr_bencDictFindInt (t, "downloadedEver", &i)
    915               && tr_bencDictFindInt (t, "uploadedEver", &j))
     913            if (tr_variantDictFindInt (t, "downloadedEver", &i)
     914              && tr_variantDictFindInt (t, "uploadedEver", &j))
    916915            {
    917916                strlsize (buf, i, sizeof (buf));
     
    922921                printf ("  Ratio: %s\n", buf);
    923922            }
    924             if (tr_bencDictFindInt (t, "corruptEver", &i))
     923            if (tr_variantDictFindInt (t, "corruptEver", &i))
    925924            {
    926925                strlsize (buf, i, sizeof (buf));
    927926                printf ("  Corrupt DL: %s\n", buf);
    928927            }
    929             if (tr_bencDictFindStr (t, "errorString", &str) && str && *str &&
    930                 tr_bencDictFindInt (t, "error", &i) && i)
     928            if (tr_variantDictFindStr (t, "errorString", &str, NULL) && str && *str &&
     929                tr_variantDictFindInt (t, "error", &i) && i)
    931930            {
    932931                switch (i) {
     
    937936                }
    938937            }
    939             if (tr_bencDictFindInt (t, "peersConnected", &i)
    940               && tr_bencDictFindInt (t, "peersGettingFromUs", &j)
    941               && tr_bencDictFindInt (t, "peersSendingToUs", &k))
     938            if (tr_variantDictFindInt (t, "peersConnected", &i)
     939              && tr_variantDictFindInt (t, "peersGettingFromUs", &j)
     940              && tr_variantDictFindInt (t, "peersSendingToUs", &k))
    942941            {
    943942                printf (
     
    951950            }
    952951
    953             if (tr_bencDictFindList (t, "webseeds", &l)
    954               && tr_bencDictFindInt (t, "webseedsSendingToUs", &i))
    955             {
    956                 const int64_t n = tr_bencListSize (l);
     952            if (tr_variantDictFindList (t, "webseeds", &l)
     953              && tr_variantDictFindInt (t, "webseedsSendingToUs", &i))
     954            {
     955                const int64_t n = tr_variantListSize (l);
    957956                if (n > 0)
    958957                    printf (
     
    964963
    965964            printf ("HISTORY\n");
    966             if (tr_bencDictFindInt (t, "addedDate", &i) && i)
     965            if (tr_variantDictFindInt (t, "addedDate", &i) && i)
    967966            {
    968967                const time_t tt = i;
    969968                printf ("  Date added:       %s", ctime (&tt));
    970969            }
    971             if (tr_bencDictFindInt (t, "doneDate", &i) && i)
     970            if (tr_variantDictFindInt (t, "doneDate", &i) && i)
    972971            {
    973972                const time_t tt = i;
    974973                printf ("  Date finished:    %s", ctime (&tt));
    975974            }
    976             if (tr_bencDictFindInt (t, "startDate", &i) && i)
     975            if (tr_variantDictFindInt (t, "startDate", &i) && i)
    977976            {
    978977                const time_t tt = i;
    979978                printf ("  Date started:     %s", ctime (&tt));
    980979            }
    981             if (tr_bencDictFindInt (t, "activityDate", &i) && i)
     980            if (tr_variantDictFindInt (t, "activityDate", &i) && i)
    982981            {
    983982                const time_t tt = i;
    984983                printf ("  Latest activity:  %s", ctime (&tt));
    985984            }
    986             if (tr_bencDictFindInt (t, "secondsDownloading", &i) && (i > 0))
     985            if (tr_variantDictFindInt (t, "secondsDownloading", &i) && (i > 0))
    987986                printf ("  Downloading Time: %s\n", tr_strltime (buf, i, sizeof (buf)));
    988             if (tr_bencDictFindInt (t, "secondsSeeding", &i) && (i > 0))
     987            if (tr_variantDictFindInt (t, "secondsSeeding", &i) && (i > 0))
    989988                printf ("  Seeding Time:     %s\n", tr_strltime (buf, i, sizeof (buf)));
    990989            printf ("\n");
    991990
    992991            printf ("ORIGINS\n");
    993             if (tr_bencDictFindInt (t, "dateCreated", &i) && i)
     992            if (tr_variantDictFindInt (t, "dateCreated", &i) && i)
    994993            {
    995994                const time_t tt = i;
    996995                printf ("  Date created: %s", ctime (&tt));
    997996            }
    998             if (tr_bencDictFindBool (t, "isPrivate", &boolVal))
     997            if (tr_variantDictFindBool (t, "isPrivate", &boolVal))
    999998                printf ("  Public torrent: %s\n", (boolVal ? "No" : "Yes"));
    1000             if (tr_bencDictFindStr (t, "comment", &str) && str && *str)
     999            if (tr_variantDictFindStr (t, "comment", &str, NULL) && str && *str)
    10011000                printf ("  Comment: %s\n", str);
    1002             if (tr_bencDictFindStr (t, "creator", &str) && str && *str)
     1001            if (tr_variantDictFindStr (t, "creator", &str, NULL) && str && *str)
    10031002                printf ("  Creator: %s\n", str);
    1004             if (tr_bencDictFindInt (t, "pieceCount", &i))
     1003            if (tr_variantDictFindInt (t, "pieceCount", &i))
    10051004                printf ("  Piece Count: %" PRId64 "\n", i);
    1006             if (tr_bencDictFindInt (t, "pieceSize", &i))
     1005            if (tr_variantDictFindInt (t, "pieceSize", &i))
    10071006                printf ("  Piece Size: %s\n", strlmem (buf, i, sizeof (buf)));
    10081007            printf ("\n");
    10091008
    10101009            printf ("LIMITS & BANDWIDTH\n");
    1011             if (tr_bencDictFindBool (t, "downloadLimited", &boolVal)
    1012                 && tr_bencDictFindInt (t, "downloadLimit", &i))
     1010            if (tr_variantDictFindBool (t, "downloadLimited", &boolVal)
     1011                && tr_variantDictFindInt (t, "downloadLimit", &i))
    10131012            {
    10141013                printf ("  Download Limit: ");
     
    10181017                    printf ("Unlimited\n");
    10191018            }
    1020             if (tr_bencDictFindBool (t, "uploadLimited", &boolVal)
    1021                 && tr_bencDictFindInt (t, "uploadLimit", &i))
     1019            if (tr_variantDictFindBool (t, "uploadLimited", &boolVal)
     1020                && tr_variantDictFindInt (t, "uploadLimit", &i))
    10221021            {
    10231022                printf ("  Upload Limit: ");
     
    10271026                    printf ("Unlimited\n");
    10281027            }
    1029             if (tr_bencDictFindInt (t, "seedRatioMode", &i))
     1028            if (tr_variantDictFindInt (t, "seedRatioMode", &i))
    10301029            {
    10311030                switch (i) {
     
    10341033                        break;
    10351034                    case TR_RATIOLIMIT_SINGLE:
    1036                         if (tr_bencDictFindReal (t, "seedRatioLimit", &d))
     1035                        if (tr_variantDictFindReal (t, "seedRatioLimit", &d))
    10371036                            printf ("  Ratio Limit: %.2f\n", d);
    10381037                        break;
     
    10431042                }
    10441043            }
    1045             if (tr_bencDictFindBool (t, "honorsSessionLimits", &boolVal))
     1044            if (tr_variantDictFindBool (t, "honorsSessionLimits", &boolVal))
    10461045                printf ("  Honors Session Limits: %s\n", (boolVal ? "Yes" : "No"));
    1047             if (tr_bencDictFindInt (t, "peer-limit", &i))
     1046            if (tr_variantDictFindInt (t, "peer-limit", &i))
    10481047                printf ("  Peer limit: %" PRId64 "\n", i);
    1049             if (tr_bencDictFindInt (t, "bandwidthPriority", &i))
     1048            if (tr_variantDictFindInt (t, "bandwidthPriority", &i))
    10501049                printf ("  Bandwidth Priority: %s\n",
    10511050                        bandwidthPriorityNames[ (i + 1) & 3]);
     
    10571056
    10581057static void
    1059 printFileList (tr_benc * top)
    1060 {
    1061     tr_benc *args, *torrents;
    1062 
    1063     if ((tr_bencDictFindDict (top, "arguments", &args))
    1064       && (tr_bencDictFindList (args, "torrents", &torrents)))
     1058printFileList (tr_variant * top)
     1059{
     1060    tr_variant *args, *torrents;
     1061
     1062    if ((tr_variantDictFindDict (top, "arguments", &args))
     1063      && (tr_variantDictFindList (args, "torrents", &torrents)))
    10651064    {
    10661065        int i, in;
    1067         for (i = 0, in = tr_bencListSize (torrents); i < in; ++i)
    1068         {
    1069             tr_benc *    d = tr_bencListChild (torrents, i);
    1070             tr_benc *    files, *priorities, *wanteds;
     1066        for (i = 0, in = tr_variantListSize (torrents); i < in; ++i)
     1067        {
     1068            tr_variant *    d = tr_variantListChild (torrents, i);
     1069            tr_variant *    files, *priorities, *wanteds;
    10711070            const char * name;
    1072             if (tr_bencDictFindStr (d, "name", &name)
    1073               && tr_bencDictFindList (d, "files", &files)
    1074               && tr_bencDictFindList (d, "priorities", &priorities)
    1075               && tr_bencDictFindList (d, "wanted", &wanteds))
    1076             {
    1077                 int j = 0, jn = tr_bencListSize (files);
     1071            if (tr_variantDictFindStr (d, "name", &name, NULL)
     1072              && tr_variantDictFindList (d, "files", &files)
     1073              && tr_variantDictFindList (d, "priorities", &priorities)
     1074              && tr_variantDictFindList (d, "wanted", &wanteds))
     1075            {
     1076                int j = 0, jn = tr_variantListSize (files);
    10781077                printf ("%s (%d files):\n", name, jn);
    10791078                printf ("%3s  %4s %8s %3s %9s  %s\n", "#", "Done",
    10801079                        "Priority", "Get", "Size",
    10811080                        "Name");
    1082                 for (j = 0, jn = tr_bencListSize (files); j < jn; ++j)
     1081                for (j = 0, jn = tr_variantListSize (files); j < jn; ++j)
    10831082                {
    10841083                    int64_t      have;
     
    10871086                    int64_t      wanted;
    10881087                    const char * filename;
    1089                     tr_benc *    file = tr_bencListChild (files, j);
    1090                     if (tr_bencDictFindInt (file, "length", &length)
    1091                       && tr_bencDictFindStr (file, "name", &filename)
    1092                       && tr_bencDictFindInt (file, "bytesCompleted", &have)
    1093                       && tr_bencGetInt (tr_bencListChild (priorities,
     1088                    tr_variant *    file = tr_variantListChild (files, j);
     1089                    if (tr_variantDictFindInt (file, "length", &length)
     1090                      && tr_variantDictFindStr (file, "name", &filename, NULL)
     1091                      && tr_variantDictFindInt (file, "bytesCompleted", &have)
     1092                      && tr_variantGetInt (tr_variantListChild (priorities,
    10941093                                                          j), &priority)
    1095                       && tr_bencGetInt (tr_bencListChild (wanteds,
     1094                      && tr_variantGetInt (tr_variantListChild (wanteds,
    10961095                                                          j), &wanted))
    10971096                    {
     
    11261125
    11271126static void
    1128 printPeersImpl (tr_benc * peers)
     1127printPeersImpl (tr_variant * peers)
    11291128{
    11301129    int i, n;
    11311130    printf ("%-20s  %-12s  %-5s %-6s  %-6s  %s\n",
    11321131            "Address", "Flags", "Done", "Down", "Up", "Client");
    1133     for (i = 0, n = tr_bencListSize (peers); i < n; ++i)
     1132    for (i = 0, n = tr_variantListSize (peers); i < n; ++i)
    11341133    {
    11351134        double progress;
    11361135        const char * address, * client, * flagstr;
    11371136        int64_t rateToClient, rateToPeer;
    1138         tr_benc * d = tr_bencListChild (peers, i);
    1139 
    1140         if (tr_bencDictFindStr (d, "address", &address)
    1141           && tr_bencDictFindStr (d, "clientName", &client)
    1142           && tr_bencDictFindReal (d, "progress", &progress)
    1143           && tr_bencDictFindStr (d, "flagStr", &flagstr)
    1144           && tr_bencDictFindInt (d, "rateToClient", &rateToClient)
    1145           && tr_bencDictFindInt (d, "rateToPeer", &rateToPeer))
     1137        tr_variant * d = tr_variantListChild (peers, i);
     1138
     1139        if (tr_variantDictFindStr (d, "address", &address, NULL)
     1140          && tr_variantDictFindStr (d, "clientName", &client, NULL)
     1141          && tr_variantDictFindReal (d, "progress", &progress)
     1142          && tr_variantDictFindStr (d, "flagStr", &flagstr, NULL)
     1143          && tr_variantDictFindInt (d, "rateToClient", &rateToClient)
     1144          && tr_variantDictFindInt (d, "rateToPeer", &rateToPeer))
    11461145        {
    11471146            printf ("%-20s  %-12s  %-5.1f %6.1f  %6.1f  %s\n",
     
    11551154
    11561155static void
    1157 printPeers (tr_benc * top)
    1158 {
    1159     tr_benc *args, *torrents;
    1160 
    1161     if (tr_bencDictFindDict (top, "arguments", &args)
    1162       && tr_bencDictFindList (args, "torrents", &torrents))
     1156printPeers (tr_variant * top)
     1157{
     1158    tr_variant *args, *torrents;
     1159
     1160    if (tr_variantDictFindDict (top, "arguments", &args)
     1161      && tr_variantDictFindList (args, "torrents", &torrents))
    11631162    {
    11641163        int i, n;
    1165         for (i=0, n=tr_bencListSize (torrents); i<n; ++i)
    1166         {
    1167             tr_benc * peers;
    1168             tr_benc * torrent = tr_bencListChild (torrents, i);
    1169             if (tr_bencDictFindList (torrent, "peers", &peers)) {
     1164        for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
     1165        {
     1166            tr_variant * peers;
     1167            tr_variant * torrent = tr_variantListChild (torrents, i);
     1168            if (tr_variantDictFindList (torrent, "peers", &peers)) {
    11701169                printPeersImpl (peers);
    11711170                if (i+1<n)
     
    11951194
    11961195static void
    1197 printPieces (tr_benc * top)
    1198 {
    1199     tr_benc *args, *torrents;
    1200 
    1201     if (tr_bencDictFindDict (top, "arguments", &args)
    1202       && tr_bencDictFindList (args, "torrents", &torrents))
     1196printPieces (tr_variant * top)
     1197{
     1198    tr_variant *args, *torrents;
     1199
     1200    if (tr_variantDictFindDict (top, "arguments", &args)
     1201      && tr_variantDictFindList (args, "torrents", &torrents))
    12031202    {
    12041203        int i, n;
    1205         for (i=0, n=tr_bencListSize (torrents); i<n; ++i)
     1204        for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
    12061205        {
    12071206            int64_t j;
    12081207            const uint8_t * raw;
    12091208            size_t       rawlen;
    1210             tr_benc * torrent = tr_bencListChild (torrents, i);
    1211             if (tr_bencDictFindRaw (torrent, "pieces", &raw, &rawlen) &&
    1212                 tr_bencDictFindInt (torrent, "pieceCount", &j)) {
     1209            tr_variant * torrent = tr_variantListChild (torrents, i);
     1210            if (tr_variantDictFindRaw (torrent, "pieces", &raw, &rawlen) &&
     1211                tr_variantDictFindInt (torrent, "pieceCount", &j)) {
    12131212                printPiecesImpl (raw, rawlen, j);
    12141213                if (i+1<n)
     
    12201219
    12211220static void
    1222 printPortTest (tr_benc * top)
    1223 {
    1224     tr_benc *args;
    1225     if ((tr_bencDictFindDict (top, "arguments", &args)))
     1221printPortTest (tr_variant * top)
     1222{
     1223    tr_variant *args;
     1224    if ((tr_variantDictFindDict (top, "arguments", &args)))
    12261225    {
    12271226        bool      boolVal;
    12281227
    1229         if (tr_bencDictFindBool (args, "port-is-open", &boolVal))
     1228        if (tr_variantDictFindBool (args, "port-is-open", &boolVal))
    12301229            printf ("Port is open: %s\n", (boolVal ? "Yes" : "No"));
    12311230    }
     
    12331232
    12341233static void
    1235 printTorrentList (tr_benc * top)
    1236 {
    1237     tr_benc *args, *list;
    1238 
    1239     if ((tr_bencDictFindDict (top, "arguments", &args))
    1240       && (tr_bencDictFindList (args, "torrents", &list)))
     1234printTorrentList (tr_variant * top)
     1235{
     1236    tr_variant *args, *list;
     1237
     1238    if ((tr_variantDictFindDict (top, "arguments", &args))
     1239      && (tr_variantDictFindList (args, "torrents", &list)))
    12411240    {
    12421241        int i, n;
     
    12491248                "Name");
    12501249
    1251         for (i = 0, n = tr_bencListSize (list); i < n; ++i)
     1250        for (i = 0, n = tr_variantListSize (list); i < n; ++i)
    12521251        {
    12531252            int64_t      id, eta, status, up, down;
     
    12551254            double       ratio;
    12561255            const char * name;
    1257             tr_benc *   d = tr_bencListChild (list, i);
    1258             if (tr_bencDictFindInt (d, "eta", &eta)
    1259               && tr_bencDictFindInt (d, "id", &id)
    1260               && tr_bencDictFindInt (d, "leftUntilDone", &leftUntilDone)
    1261               && tr_bencDictFindStr (d, "name", &name)
    1262               && tr_bencDictFindInt (d, "rateDownload", &down)
    1263               && tr_bencDictFindInt (d, "rateUpload", &up)
    1264               && tr_bencDictFindInt (d, "sizeWhenDone", &sizeWhenDone)
    1265               && tr_bencDictFindInt (d, "status", &status)
    1266               && tr_bencDictFindReal (d, "uploadRatio", &ratio))
     1256            tr_variant *   d = tr_variantListChild (list, i);
     1257            if (tr_variantDictFindInt (d, "eta", &eta)
     1258              && tr_variantDictFindInt (d, "id", &id)
     1259              && tr_variantDictFindInt (d, "leftUntilDone", &leftUntilDone)
     1260              && tr_variantDictFindStr (d, "name", &name, NULL)
     1261              && tr_variantDictFindInt (d, "rateDownload", &down)
     1262              && tr_variantDictFindInt (d, "rateUpload", &up)
     1263              && tr_variantDictFindInt (d, "sizeWhenDone", &sizeWhenDone)
     1264              && tr_variantDictFindInt (d, "status", &status)
     1265              && tr_variantDictFindReal (d, "uploadRatio", &ratio))
    12671266            {
    12681267                char etaStr[16];
     
    12841283                else
    12851284                    tr_snprintf (etaStr, sizeof (etaStr), "Done");
    1286                 if (tr_bencDictFindInt (d, "error", &error) && error)
     1285                if (tr_variantDictFindInt (d, "error", &error) && error)
    12871286                    errorMark = '*';
    12881287                else
     
    13141313
    13151314static void
    1316 printTrackersImpl (tr_benc * trackerStats)
     1315printTrackersImpl (tr_variant * trackerStats)
    13171316{
    13181317    int i;
    13191318    char         buf[512];
    1320     tr_benc * t;
    1321 
    1322     for (i=0; ((t = tr_bencListChild (trackerStats, i))); ++i)
     1319    tr_variant * t;
     1320
     1321    for (i=0; ((t = tr_variantListChild (trackerStats, i))); ++i)
    13231322    {
    13241323        int64_t downloadCount;
     
    13471346        int64_t scrapeState;
    13481347
    1349         if (tr_bencDictFindInt (t, "downloadCount", &downloadCount) &&
    1350             tr_bencDictFindBool (t, "hasAnnounced", &hasAnnounced) &&
    1351             tr_bencDictFindBool (t, "hasScraped", &hasScraped) &&
    1352             tr_bencDictFindStr (t, "host", &host) &&
    1353             tr_bencDictFindInt (t, "id", &id) &&
    1354             tr_bencDictFindBool (t, "isBackup", &isBackup) &&
    1355             tr_bencDictFindInt (t, "announceState", &announceState) &&
    1356             tr_bencDictFindInt (t, "scrapeState", &scrapeState) &&
    1357             tr_bencDictFindInt (t, "lastAnnouncePeerCount", &lastAnnouncePeerCount) &&
    1358             tr_bencDictFindStr (t, "lastAnnounceResult", &lastAnnounceResult) &&
    1359             tr_bencDictFindInt (t, "lastAnnounceStartTime", &lastAnnounceStartTime) &&
    1360             tr_bencDictFindBool (t, "lastAnnounceSucceeded", &lastAnnounceSucceeded) &&
    1361             tr_bencDictFindInt (t, "lastAnnounceTime", &lastAnnounceTime) &&
    1362             tr_bencDictFindBool (t, "lastAnnounceTimedOut", &lastAnnounceTimedOut) &&
    1363             tr_bencDictFindStr (t, "lastScrapeResult", &lastScrapeResult) &&
    1364             tr_bencDictFindInt (t, "lastScrapeStartTime", &lastScrapeStartTime) &&
    1365             tr_bencDictFindBool (t, "lastScrapeSucceeded", &lastScrapeSucceeded) &&
    1366             tr_bencDictFindInt (t, "lastScrapeTime", &lastScrapeTime) &&
    1367             tr_bencDictFindBool (t, "lastScrapeTimedOut", &lastScrapeTimedOut) &&
    1368             tr_bencDictFindInt (t, "leecherCount", &leecherCount) &&
    1369             tr_bencDictFindInt (t, "nextAnnounceTime", &nextAnnounceTime) &&
    1370             tr_bencDictFindInt (t, "nextScrapeTime", &nextScrapeTime) &&
    1371             tr_bencDictFindInt (t, "seederCount", &seederCount) &&
    1372             tr_bencDictFindInt (t, "tier", &tier))
     1348        if (tr_variantDictFindInt (t, "downloadCount", &downloadCount) &&
     1349            tr_variantDictFindBool (t, "hasAnnounced", &hasAnnounced) &&
     1350            tr_variantDictFindBool (t, "hasScraped", &hasScraped) &&
     1351            tr_variantDictFindStr (t, "host", &host, NULL) &&
     1352            tr_variantDictFindInt (t, "id", &id) &&
     1353            tr_variantDictFindBool (t, "isBackup", &isBackup) &&
     1354            tr_variantDictFindInt (t, "announceState", &announceState) &&
     1355            tr_variantDictFindInt (t, "scrapeState", &scrapeState) &&
     1356            tr_variantDictFindInt (t, "lastAnnouncePeerCount", &lastAnnouncePeerCount) &&
     1357            tr_variantDictFindStr (t, "lastAnnounceResult", &lastAnnounceResult, NULL) &&
     1358            tr_variantDictFindInt (t, "lastAnnounceStartTime", &lastAnnounceStartTime) &&
     1359            tr_variantDictFindBool (t, "lastAnnounceSucceeded", &lastAnnounceSucceeded) &&
     1360            tr_variantDictFindInt (t, "lastAnnounceTime", &lastAnnounceTime) &&
     1361            tr_variantDictFindBool (t, "lastAnnounceTimedOut", &lastAnnounceTimedOut) &&
     1362            tr_variantDictFindStr (t, "lastScrapeResult", &lastScrapeResult, NULL) &&
     1363            tr_variantDictFindInt (t, "lastScrapeStartTime", &lastScrapeStartTime) &&
     1364            tr_variantDictFindBool (t, "lastScrapeSucceeded", &lastScrapeSucceeded) &&
     1365            tr_variantDictFindInt (t, "lastScrapeTime", &lastScrapeTime) &&
     1366            tr_variantDictFindBool (t, "lastScrapeTimedOut", &lastScrapeTimedOut) &&
     1367            tr_variantDictFindInt (t, "leecherCount", &leecherCount) &&
     1368            tr_variantDictFindInt (t, "nextAnnounceTime", &nextAnnounceTime) &&
     1369            tr_variantDictFindInt (t, "nextScrapeTime", &nextScrapeTime) &&
     1370            tr_variantDictFindInt (t, "seederCount", &seederCount) &&
     1371            tr_variantDictFindInt (t, "tier", &tier))
    13731372        {
    13741373            const time_t now = time (NULL);
     
    14491448
    14501449static void
    1451 printTrackers (tr_benc * top)
    1452 {
    1453     tr_benc *args, *torrents;
    1454 
    1455     if (tr_bencDictFindDict (top, "arguments", &args)
    1456       && tr_bencDictFindList (args, "torrents", &torrents))
     1450printTrackers (tr_variant * top)
     1451{
     1452    tr_variant *args, *torrents;
     1453
     1454    if (tr_variantDictFindDict (top, "arguments", &args)
     1455      && tr_variantDictFindList (args, "torrents", &torrents))
    14571456    {
    14581457        int i, n;
    1459         for (i=0, n=tr_bencListSize (torrents); i<n; ++i)
    1460         {
    1461             tr_benc * trackerStats;
    1462             tr_benc * torrent = tr_bencListChild (torrents, i);
    1463             if (tr_bencDictFindList (torrent, "trackerStats", &trackerStats)) {
     1458        for (i=0, n=tr_variantListSize (torrents); i<n; ++i)
     1459        {
     1460            tr_variant * trackerStats;
     1461            tr_variant * torrent = tr_variantListChild (torrents, i);
     1462            if (tr_variantDictFindList (torrent, "trackerStats", &trackerStats)) {
    14641463                printTrackersImpl (trackerStats);
    14651464                if (i+1<n)
     
    14711470
    14721471static void
    1473 printSession (tr_benc * top)
    1474 {
    1475     tr_benc *args;
    1476     if ((tr_bencDictFindDict (top, "arguments", &args)))
     1472printSession (tr_variant * top)
     1473{
     1474    tr_variant *args;
     1475    if ((tr_variantDictFindDict (top, "arguments", &args)))
    14771476    {
    14781477        int64_t i;
     
    14821481
    14831482        printf ("VERSION\n");
    1484         if (tr_bencDictFindStr (args,  "version", &str))
     1483        if (tr_variantDictFindStr (args,  "version", &str, NULL))
    14851484            printf ("  Daemon version: %s\n", str);
    1486         if (tr_bencDictFindInt (args, "rpc-version", &i))
     1485        if (tr_variantDictFindInt (args, "rpc-version", &i))
    14871486            printf ("  RPC version: %" PRId64 "\n", i);
    1488         if (tr_bencDictFindInt (args, "rpc-version-minimum", &i))
     1487        if (tr_variantDictFindInt (args, "rpc-version-minimum", &i))
    14891488            printf ("  RPC minimum version: %" PRId64 "\n", i);
    14901489        printf ("\n");
    14911490
    14921491        printf ("CONFIG\n");
    1493         if (tr_bencDictFindStr (args, "config-dir", &str))
     1492        if (tr_variantDictFindStr (args, "config-dir", &str, NULL))
    14941493            printf ("  Configuration directory: %s\n", str);
    1495         if (tr_bencDictFindStr (args,  TR_PREFS_KEY_DOWNLOAD_DIR, &str))
     1494        if (tr_variantDictFindStr (args,  TR_PREFS_KEY_DOWNLOAD_DIR, &str, NULL))
    14961495            printf ("  Download directory: %s\n", str);
    1497         if (tr_bencDictFindInt (args,  "download-dir-free-space", &i))
     1496        if (tr_variantDictFindInt (args,  "download-dir-free-space", &i))
    14981497            printf ("  Download directory free space: %s\n",  strlsize (buf, i, sizeof buf));
    1499         if (tr_bencDictFindInt (args, TR_PREFS_KEY_PEER_PORT, &i))
     1498        if (tr_variantDictFindInt (args, TR_PREFS_KEY_PEER_PORT, &i))
    15001499            printf ("  Listenport: %" PRId64 "\n", i);
    1501         if (tr_bencDictFindBool (args, TR_PREFS_KEY_PORT_FORWARDING, &boolVal))
     1500        if (tr_variantDictFindBool (args, TR_PREFS_KEY_PORT_FORWARDING, &boolVal))
    15021501            printf ("  Portforwarding enabled: %s\n", (boolVal ? "Yes" : "No"));
    1503         if (tr_bencDictFindBool (args, TR_PREFS_KEY_UTP_ENABLED, &boolVal))
     1502        if (tr_variantDictFindBool (args, TR_PREFS_KEY_UTP_ENABLED, &boolVal))
    15041503            printf ("  uTP enabled: %s\n", (boolVal ? "Yes" : "No"));
    1505         if (tr_bencDictFindBool (args, TR_PREFS_KEY_DHT_ENABLED, &boolVal))
     1504        if (tr_variantDictFindBool (args, TR_PREFS_KEY_DHT_ENABLED, &boolVal))
    15061505            printf ("  Distributed hash table enabled: %s\n", (boolVal ? "Yes" : "No"));
    1507         if (tr_bencDictFindBool (args, TR_PREFS_KEY_LPD_ENABLED, &boolVal))
     1506        if (tr_variantDictFindBool (args, TR_PREFS_KEY_LPD_ENABLED, &boolVal))
    15081507            printf ("  Local peer discovery enabled: %s\n", (boolVal ? "Yes" : "No"));
    1509         if (tr_bencDictFindBool (args, TR_PREFS_KEY_PEX_ENABLED, &boolVal))
     1508        if (tr_variantDictFindBool (args, TR_PREFS_KEY_PEX_ENABLED, &boolVal))
    15101509            printf ("  Peer exchange allowed: %s\n", (boolVal ? "Yes" : "No"));
    1511         if (tr_bencDictFindStr (args,  TR_PREFS_KEY_ENCRYPTION, &str))
     1510        if (tr_variantDictFindStr (args,  TR_PREFS_KEY_ENCRYPTION, &str, NULL))
    15121511            printf ("  Encryption: %s\n", str);
    1513         if (tr_bencDictFindInt (args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i))
     1512        if (tr_variantDictFindInt (args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, &i))
    15141513            printf ("  Maximum memory cache size: %s\n", tr_formatter_mem_MB (buf, i, sizeof (buf)));
    15151514        printf ("\n");
     
    15201519            double seedRatioLimit;
    15211520
    1522             if (tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &altDown) &&
    1523                 tr_bencDictFindBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, &altEnabled) &&
    1524                 tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &altBegin) &&
    1525                 tr_bencDictFindBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &altTimeEnabled) &&
    1526                 tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_END, &altEnd) &&
    1527                 tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &altDay) &&
    1528                 tr_bencDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &altUp) &&
    1529                 tr_bencDictFindInt (args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &peerLimit) &&
    1530                 tr_bencDictFindInt (args, TR_PREFS_KEY_DSPEED_KBps, &downLimit) &&
    1531                 tr_bencDictFindBool (args, TR_PREFS_KEY_DSPEED_ENABLED, &downEnabled) &&
    1532                 tr_bencDictFindInt (args, TR_PREFS_KEY_USPEED_KBps, &upLimit) &&
    1533                 tr_bencDictFindBool (args, TR_PREFS_KEY_USPEED_ENABLED, &upEnabled) &&
    1534                 tr_bencDictFindReal (args, "seedRatioLimit", &seedRatioLimit) &&
    1535                 tr_bencDictFindBool (args, "seedRatioLimited", &seedRatioLimited))
     1521            if (tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, &altDown) &&
     1522                tr_variantDictFindBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, &altEnabled) &&
     1523                tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, &altBegin) &&
     1524                tr_variantDictFindBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, &altTimeEnabled) &&
     1525                tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_END, &altEnd) &&
     1526                tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, &altDay) &&
     1527                tr_variantDictFindInt (args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, &altUp) &&
     1528                tr_variantDictFindInt (args, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, &peerLimit) &&
     1529                tr_variantDictFindInt (args, TR_PREFS_KEY_DSPEED_KBps, &downLimit) &&
     1530                tr_variantDictFindBool (args, TR_PREFS_KEY_DSPEED_ENABLED, &downEnabled) &&
     1531                tr_variantDictFindInt (args, TR_PREFS_KEY_USPEED_KBps, &upLimit) &&
     1532                tr_variantDictFindBool (args, TR_PREFS_KEY_USPEED_ENABLED, &upEnabled) &&
     1533                tr_variantDictFindReal (args, "seedRatioLimit", &seedRatioLimit) &&
     1534                tr_variantDictFindBool (args, "seedRatioLimited", &seedRatioLimited))
    15361535            {
    15371536                char buf[128];
     
    15921591
    15931592        printf ("MISC\n");
    1594         if (tr_bencDictFindBool (args, TR_PREFS_KEY_START, &boolVal))
     1593        if (tr_variantDictFindBool (args, TR_PREFS_KEY_START, &boolVal))
    15951594            printf ("  Autostart added torrents: %s\n", (boolVal ? "Yes" : "No"));
    1596         if (tr_bencDictFindBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal))
     1595        if (tr_variantDictFindBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, &boolVal))
    15971596            printf ("  Delete automatically added torrents: %s\n", (boolVal ? "Yes" : "No"));
    15981597    }
     
    16001599
    16011600static void
    1602 printSessionStats (tr_benc * top)
    1603 {
    1604     tr_benc *args, *d;
    1605     if ((tr_bencDictFindDict (top, "arguments", &args)))
     1601printSessionStats (tr_variant * top)
     1602{
     1603    tr_variant *args, *d;
     1604    if ((tr_variantDictFindDict (top, "arguments", &args)))
    16061605    {
    16071606        char buf[512];
    16081607        int64_t up, down, secs, sessions;
    16091608
    1610         if (tr_bencDictFindDict (args, "current-stats", &d)
    1611             && tr_bencDictFindInt (d, "uploadedBytes", &up)
    1612             && tr_bencDictFindInt (d, "downloadedBytes", &down)
    1613             && tr_bencDictFindInt (d, "secondsActive", &secs))
     1609        if (tr_variantDictFindDict (args, "current-stats", &d)
     1610            && tr_variantDictFindInt (d, "uploadedBytes", &up)
     1611            && tr_variantDictFindInt (d, "downloadedBytes", &down)
     1612            && tr_variantDictFindInt (d, "secondsActive", &secs))
    16141613        {
    16151614            printf ("\nCURRENT SESSION\n");
     
    16201619        }
    16211620
    1622         if (tr_bencDictFindDict (args, "cumulative-stats", &d)
    1623             && tr_bencDictFindInt (d, "sessionCount", &sessions)
    1624             && tr_bencDictFindInt (d, "uploadedBytes", &up)
    1625             && tr_bencDictFindInt (d, "downloadedBytes", &down)
    1626             && tr_bencDictFindInt (d, "secondsActive", &secs))
     1621        if (tr_variantDictFindDict (args, "cumulative-stats", &d)
     1622            && tr_variantDictFindInt (d, "sessionCount", &sessions)
     1623            && tr_variantDictFindInt (d, "uploadedBytes", &up)
     1624            && tr_variantDictFindInt (d, "downloadedBytes", &down)
     1625            && tr_variantDictFindInt (d, "secondsActive", &secs))
    16271626        {
    16281627            printf ("\nTOTAL\n");
     
    16411640processResponse (const char * rpcurl, const void * response, size_t len)
    16421641{
    1643     tr_benc top;
     1642    tr_variant top;
    16441643    int status = EXIT_SUCCESS;
    16451644
     
    16481647               (int)len, (int)len, (int)len, (const char*) response);
    16491648
    1650     if (tr_jsonParse (NULL, response, len, &top, NULL))
     1649    if (tr_variantFromJson (&top, response, len))
    16511650    {
    16521651        tr_nerr (MY_NAME, "Unable to parse response \"%*.*s\"", (int)len,
     
    16591658        const char * str;
    16601659
    1661         if (tr_bencDictFindStr (&top, "result", &str))
     1660        if (tr_variantDictFindStr (&top, "result", &str, NULL))
    16621661        {
    16631662            if (strcmp (str, "success"))
     
    16681667            else
    16691668            {
    1670         tr_bencDictFindInt (&top, "tag", &tag);
     1669        tr_variantDictFindInt (&top, "tag", &tag);
    16711670
    16721671        switch (tag)
     
    17011700            case TAG_TORRENT_ADD: {
    17021701                int64_t i;
    1703                 tr_benc * b = &top;
    1704                 if (tr_bencDictFindDict (&top, ARGUMENTS, &b)
    1705                         && tr_bencDictFindDict (b, "torrent-added", &b)
    1706                         && tr_bencDictFindInt (b, "id", &i))
     1702                tr_variant * b = &top;
     1703                if (tr_variantDictFindDict (&top, ARGUMENTS, &b)
     1704                        && tr_variantDictFindDict (b, "torrent-added", &b)
     1705                        && tr_variantDictFindInt (b, "id", &i))
    17071706                    tr_snprintf (id, sizeof (id), "%"PRId64, i);
    17081707                /* fall-through to default: to give success or failure msg */
    17091708            }
    17101709            default:
    1711                 if (!tr_bencDictFindStr (&top, "result", &str))
     1710                if (!tr_variantDictFindStr (&top, "result", &str, NULL))
    17121711                    status |= EXIT_FAILURE;
    17131712                else {
     
    17181717        }
    17191718
    1720         tr_bencFree (&top);
     1719        tr_variantFree (&top);
    17211720    }
    17221721        }
     
    17571756
    17581757static int
    1759 flush (const char * rpcurl, tr_benc ** benc)
     1758flush (const char * rpcurl, tr_variant ** benc)
    17601759{
    17611760    CURLcode res;
     
    17631762    int status = EXIT_SUCCESS;
    17641763    struct evbuffer * buf = evbuffer_new ();
    1765     char * json = tr_bencToStr (*benc, TR_FMT_JSON_LEAN, NULL);
     1764    char * json = tr_variantToStr (*benc, TR_VARIANT_FMT_JSON_LEAN, NULL);
    17661765    char *rpcurl_http =  tr_strdup_printf (UseSSL? "https://%s" : "http://%s", rpcurl);
    17671766
     
    18101809        curl_easy_cleanup (curl);
    18111810    if (benc != NULL) {
    1812         tr_bencFree (*benc);
     1811        tr_variantFree (*benc);
    18131812        *benc = 0;
    18141813    }
     
    18161815}
    18171816
    1818 static tr_benc*
    1819 ensure_sset (tr_benc ** sset)
    1820 {
    1821     tr_benc * args;
     1817static tr_variant*
     1818ensure_sset (tr_variant ** sset)
     1819{
     1820    tr_variant * args;
    18221821
    18231822    if (*sset)
    1824         args = tr_bencDictFind (*sset, ARGUMENTS);
     1823        args = tr_variantDictFind (*sset, ARGUMENTS);
    18251824    else {
    1826         *sset = tr_new0 (tr_benc, 1);
    1827         tr_bencInitDict (*sset, 3);
    1828         tr_bencDictAddStr (*sset, "method", "session-set");
    1829         args = tr_bencDictAddDict (*sset, ARGUMENTS, 0);
     1825        *sset = tr_new0 (tr_variant, 1);
     1826        tr_variantInitDict (*sset, 3);
     1827        tr_variantDictAddStr (*sset, "method", "session-set");
     1828        args = tr_variantDictAddDict (*sset, ARGUMENTS, 0);
    18301829    }
    18311830
     
    18331832}
    18341833
    1835 static tr_benc*
    1836 ensure_tset (tr_benc ** tset)
    1837 {
    1838     tr_benc * args;
     1834static tr_variant*
     1835ensure_tset (tr_variant ** tset)
     1836{
     1837    tr_variant * args;
    18391838
    18401839    if (*tset)
    1841         args = tr_bencDictFind (*tset, ARGUMENTS);
     1840        args = tr_variantDictFind (*tset, ARGUMENTS);
    18421841    else {
    1843         *tset = tr_new0 (tr_benc, 1);
    1844         tr_bencInitDict (*tset, 3);
    1845         tr_bencDictAddStr (*tset, "method", "torrent-set");
    1846         args = tr_bencDictAddDict (*tset, ARGUMENTS, 1);
     1842        *tset = tr_new0 (tr_variant, 1);
     1843        tr_variantInitDict (*tset, 3);
     1844        tr_variantDictAddStr (*tset, "method", "torrent-set");
     1845        args = tr_variantDictAddDict (*tset, ARGUMENTS, 1);
    18471846    }
    18481847
     
    18561855    int status = EXIT_SUCCESS;
    18571856    const char * optarg;
    1858     tr_benc *sset = 0;
    1859     tr_benc *tset = 0;
    1860     tr_benc *tadd = 0;
     1857    tr_variant *sset = 0;
     1858    tr_variant *tset = 0;
     1859    tr_variant *tadd = 0;
    18611860
    18621861    *id = '\0';
     
    18731872                    if (sset != 0) status |= flush (rpcurl, &sset);
    18741873                    if (tadd != 0) status |= flush (rpcurl, &tadd);
    1875                     if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
    1876                     tadd = tr_new0 (tr_benc, 1);
    1877                     tr_bencInitDict (tadd, 3);
    1878                     tr_bencDictAddStr (tadd, "method", "torrent-add");
    1879                     tr_bencDictAddInt (tadd, "tag", TAG_TORRENT_ADD);
    1880                     tr_bencDictAddDict (tadd, ARGUMENTS, 0);
     1874                    if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
     1875                    tadd = tr_new0 (tr_variant, 1);
     1876                    tr_variantInitDict (tadd, 3);
     1877                    tr_variantDictAddStr (tadd, "method", "torrent-add");
     1878                    tr_variantDictAddInt (tadd, "tag", TAG_TORRENT_ADD);
     1879                    tr_variantDictAddDict (tadd, ARGUMENTS, 0);
    18811880                    break;
    18821881
     
    19101909                case 't': /* set current torrent */
    19111910                    if (tadd != 0) status |= flush (rpcurl, &tadd);
    1912                     if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
     1911                    if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
    19131912                    tr_strlcpy (id, optarg, sizeof (id));
    19141913                    break;
     
    19271926                case TR_OPT_UNK:
    19281927                    if (tadd) {
    1929                         tr_benc * args = tr_bencDictFind (tadd, ARGUMENTS);
     1928                        tr_variant * args = tr_variantDictFind (tadd, ARGUMENTS);
    19301929                        char * tmp = getEncodedMetainfo (optarg);
    19311930                        if (tmp)
    1932                             tr_bencDictAddStr (args, "metainfo", tmp);
     1931                            tr_variantDictAddStr (args, "metainfo", tmp);
    19331932                        else
    1934                             tr_bencDictAddStr (args, "filename", optarg);
     1933                            tr_variantDictAddStr (args, "filename", optarg);
    19351934                        tr_free (tmp);
    19361935                    } else {
     
    19441943        {
    19451944            size_t i, n;
    1946             tr_benc * top = tr_new0 (tr_benc, 1);
    1947             tr_benc * args;
    1948             tr_benc * fields;
    1949             tr_bencInitDict (top, 3);
    1950             tr_bencDictAddStr (top, "method", "torrent-get");
    1951             args = tr_bencDictAddDict (top, ARGUMENTS, 0);
    1952             fields = tr_bencDictAddList (args, "fields", 0);
    1953 
    1954             if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
     1945            tr_variant * top = tr_new0 (tr_variant, 1);
     1946            tr_variant * args;
     1947            tr_variant * fields;
     1948            tr_variantInitDict (top, 3);
     1949            tr_variantDictAddStr (top, "method", "torrent-get");
     1950            args = tr_variantDictAddDict (top, ARGUMENTS, 0);
     1951            fields = tr_variantDictAddList (args, "fields", 0);
     1952
     1953            if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
    19551954
    19561955            switch (c)
    19571956            {
    1958                 case 'i': tr_bencDictAddInt (top, "tag", TAG_DETAILS);
     1957                case 'i': tr_variantDictAddInt (top, "tag", TAG_DETAILS);
    19591958                          n = TR_N_ELEMENTS (details_keys);
    1960                           for (i=0; i<n; ++i) tr_bencListAddStr (fields, details_keys[i]);
     1959                          for (i=0; i<n; ++i) tr_variantListAddStr (fields, details_keys[i]);
    19611960                          addIdArg (args, id);
    19621961                          break;
    1963                 case 'l': tr_bencDictAddInt (top, "tag", TAG_LIST);
     1962                case 'l': tr_variantDictAddInt (top, "tag", TAG_LIST);
    19641963                          n = TR_N_ELEMENTS (list_keys);
    1965                           for (i=0; i<n; ++i) tr_bencListAddStr (fields, list_keys[i]);
    1966                           break;
    1967                 case 940: tr_bencDictAddInt (top, "tag", TAG_FILES);
     1964                          for (i=0; i<n; ++i) tr_variantListAddStr (fields, list_keys[i]);
     1965                          break;
     1966                case 940: tr_variantDictAddInt (top, "tag", TAG_FILES);
    19681967                          n = TR_N_ELEMENTS (files_keys);
    1969                           for (i=0; i<n; ++i) tr_bencListAddStr (fields, files_keys[i]);
     1968                          for (i=0; i<n; ++i) tr_variantListAddStr (fields, files_keys[i]);
    19701969                          addIdArg (args, id);
    19711970                          break;
    1972                 case 941: tr_bencDictAddInt (top, "tag", TAG_PEERS);
    1973                           tr_bencListAddStr (fields, "peers");
     1971                case 941: tr_variantDictAddInt (top, "tag", TAG_PEERS);
     1972                          tr_variantListAddStr (fields, "peers");
    19741973                          addIdArg (args, id);
    19751974                          break;
    1976                 case 942: tr_bencDictAddInt (top, "tag", TAG_PIECES);
    1977                           tr_bencListAddStr (fields, "pieces");
    1978                           tr_bencListAddStr (fields, "pieceCount");
     1975                case 942: tr_variantDictAddInt (top, "tag", TAG_PIECES);
     1976                          tr_variantListAddStr (fields, "pieces");
     1977                          tr_variantListAddStr (fields, "pieceCount");
    19791978                          addIdArg (args, id);
    19801979                          break;
    1981                 case 943: tr_bencDictAddInt (top, "tag", TAG_TRACKERS);
    1982                           tr_bencListAddStr (fields, "trackerStats");
     1980                case 943: tr_variantDictAddInt (top, "tag", TAG_TRACKERS);
     1981                          tr_variantListAddStr (fields, "trackerStats");
    19831982                          addIdArg (args, id);
    19841983                          break;
     
    19901989        else if (stepMode == MODE_SESSION_SET)
    19911990        {
    1992             tr_benc * args = ensure_sset (&sset);
     1991            tr_variant * args = ensure_sset (&sset);
    19931992
    19941993            switch (c)
    19951994            {
    1996                 case 800: tr_bencDictAddStr (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg);
    1997                           tr_bencDictAddBool (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true);
    1998                           break;
    1999                 case 801: tr_bencDictAddBool (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, false);
    2000                           break;
    2001                 case 970: tr_bencDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, true);
    2002                           break;
    2003                 case 971: tr_bencDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, false);
    2004                           break;
    2005                 case 972: tr_bencDictAddInt (args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, numarg (optarg));
    2006                           break;
    2007                 case 973: tr_bencDictAddInt (args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, numarg (optarg));
    2008                           break;
    2009                 case 974: tr_bencDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, true);
    2010                           break;
    2011                 case 975: tr_bencDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, false);
     1995                case 800: tr_variantDictAddStr (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_FILENAME, optarg);
     1996                          tr_variantDictAddBool (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, true);
     1997                          break;
     1998                case 801: tr_variantDictAddBool (args, TR_PREFS_KEY_SCRIPT_TORRENT_DONE_ENABLED, false);
     1999                          break;
     2000                case 970: tr_variantDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, true);
     2001                          break;
     2002                case 971: tr_variantDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_ENABLED, false);
     2003                          break;
     2004                case 972: tr_variantDictAddInt (args, TR_PREFS_KEY_ALT_SPEED_DOWN_KBps, numarg (optarg));
     2005                          break;
     2006                case 973: tr_variantDictAddInt (args, TR_PREFS_KEY_ALT_SPEED_UP_KBps, numarg (optarg));
     2007                          break;
     2008                case 974: tr_variantDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, true);
     2009                          break;
     2010                case 975: tr_variantDictAddBool (args, TR_PREFS_KEY_ALT_SPEED_TIME_ENABLED, false);
    20122011                          break;
    20132012                case 976: addTime (args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, optarg);
     
    20172016                case 978: addDays (args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, optarg);
    20182017                          break;
    2019                 case 'c': tr_bencDictAddStr (args, TR_PREFS_KEY_INCOMPLETE_DIR, optarg);
    2020                           tr_bencDictAddBool (args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true);
    2021                           break;
    2022                 case 'C': tr_bencDictAddBool (args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false);
    2023                           break;
    2024                 case 'e': tr_bencDictAddInt (args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, atoi (optarg));
    2025                           break;
    2026                 case 910: tr_bencDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "required");
    2027                           break;
    2028                 case 911: tr_bencDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "preferred");
    2029                           break;
    2030                 case 912: tr_bencDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "tolerated");
    2031                           break;
    2032                 case 'm': tr_bencDictAddBool (args, TR_PREFS_KEY_PORT_FORWARDING, true);
    2033                           break;
    2034                 case 'M': tr_bencDictAddBool (args, TR_PREFS_KEY_PORT_FORWARDING, false);
    2035                           break;
    2036                 case 'o': tr_bencDictAddBool (args, TR_PREFS_KEY_DHT_ENABLED, true);
    2037                           break;
    2038                 case 'O': tr_bencDictAddBool (args, TR_PREFS_KEY_DHT_ENABLED, false);
    2039                           break;
    2040                 case 830: tr_bencDictAddBool (args, TR_PREFS_KEY_UTP_ENABLED, true);
    2041                           break;
    2042                 case 831: tr_bencDictAddBool (args, TR_PREFS_KEY_UTP_ENABLED, false);
    2043                           break;
    2044                 case 'p': tr_bencDictAddInt (args, TR_PREFS_KEY_PEER_PORT, numarg (optarg));
    2045                           break;
    2046                 case 'P': tr_bencDictAddBool (args, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, true);
    2047                           break;
    2048                 case 'x': tr_bencDictAddBool (args, TR_PREFS_KEY_PEX_ENABLED, true);
    2049                           break;
    2050                 case 'X': tr_bencDictAddBool (args, TR_PREFS_KEY_PEX_ENABLED, false);
    2051                           break;
    2052                 case 'y': tr_bencDictAddBool (args, TR_PREFS_KEY_LPD_ENABLED, true);
    2053                           break;
    2054                 case 'Y': tr_bencDictAddBool (args, TR_PREFS_KEY_LPD_ENABLED, false);
    2055                           break;
    2056                 case 953: tr_bencDictAddReal (args, "seedRatioLimit", atof (optarg));
    2057                           tr_bencDictAddBool (args, "seedRatioLimited", true);
    2058                           break;
    2059                 case 954: tr_bencDictAddBool (args, "seedRatioLimited", false);
    2060                           break;
    2061                 case 990: tr_bencDictAddBool (args, TR_PREFS_KEY_START, false);
    2062                           break;
    2063                 case 991: tr_bencDictAddBool (args, TR_PREFS_KEY_START, true);
    2064                           break;
    2065                 case 992: tr_bencDictAddBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, true);
    2066                           break;
    2067                 case 993: tr_bencDictAddBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, false);
     2018                case 'c': tr_variantDictAddStr (args, TR_PREFS_KEY_INCOMPLETE_DIR, optarg);
     2019                          tr_variantDictAddBool (args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, true);
     2020                          break;
     2021                case 'C': tr_variantDictAddBool (args, TR_PREFS_KEY_INCOMPLETE_DIR_ENABLED, false);
     2022                          break;
     2023                case 'e': tr_variantDictAddInt (args, TR_PREFS_KEY_MAX_CACHE_SIZE_MB, atoi (optarg));
     2024                          break;
     2025                case 910: tr_variantDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "required");
     2026                          break;
     2027                case 911: tr_variantDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "preferred");
     2028                          break;
     2029                case 912: tr_variantDictAddStr (args, TR_PREFS_KEY_ENCRYPTION, "tolerated");
     2030                          break;
     2031                case 'm': tr_variantDictAddBool (args, TR_PREFS_KEY_PORT_FORWARDING, true);
     2032                          break;
     2033                case 'M': tr_variantDictAddBool (args, TR_PREFS_KEY_PORT_FORWARDING, false);
     2034                          break;
     2035                case 'o': tr_variantDictAddBool (args, TR_PREFS_KEY_DHT_ENABLED, true);
     2036                          break;
     2037                case 'O': tr_variantDictAddBool (args, TR_PREFS_KEY_DHT_ENABLED, false);
     2038                          break;
     2039                case 830: tr_variantDictAddBool (args, TR_PREFS_KEY_UTP_ENABLED, true);
     2040                          break;
     2041                case 831: tr_variantDictAddBool (args, TR_PREFS_KEY_UTP_ENABLED, false);
     2042                          break;
     2043                case 'p': tr_variantDictAddInt (args, TR_PREFS_KEY_PEER_PORT, numarg (optarg));
     2044                          break;
     2045                case 'P': tr_variantDictAddBool (args, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, true);
     2046                          break;
     2047                case 'x': tr_variantDictAddBool (args, TR_PREFS_KEY_PEX_ENABLED, true);
     2048                          break;
     2049                case 'X': tr_variantDictAddBool (args, TR_PREFS_KEY_PEX_ENABLED, false);
     2050                          break;
     2051                case 'y': tr_variantDictAddBool (args, TR_PREFS_KEY_LPD_ENABLED, true);
     2052                          break;
     2053                case 'Y': tr_variantDictAddBool (args, TR_PREFS_KEY_LPD_ENABLED, false);
     2054                          break;
     2055                case 953: tr_variantDictAddReal (args, "seedRatioLimit", atof (optarg));
     2056                          tr_variantDictAddBool (args, "seedRatioLimited", true);
     2057                          break;
     2058                case 954: tr_variantDictAddBool (args, "seedRatioLimited", false);
     2059                          break;
     2060                case 990: tr_variantDictAddBool (args, TR_PREFS_KEY_START, false);
     2061                          break;
     2062                case 991: tr_variantDictAddBool (args, TR_PREFS_KEY_START, true);
     2063                          break;
     2064                case 992: tr_variantDictAddBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, true);
     2065                          break;
     2066                case 993: tr_variantDictAddBool (args, TR_PREFS_KEY_TRASH_ORIGINAL, false);
    20682067                          break;
    20692068                default:  assert ("unhandled value" && 0);
     
    20732072        else if (stepMode == (MODE_SESSION_SET | MODE_TORRENT_SET))
    20742073        {
    2075             tr_benc * targs = 0;
    2076             tr_benc * sargs = 0;
     2074            tr_variant * targs = 0;
     2075            tr_variant * sargs = 0;
    20772076
    20782077            if (*id)
     
    20842083            {
    20852084                case 'd': if (targs) {
    2086                               tr_bencDictAddInt (targs, "downloadLimit", numarg (optarg));
    2087                               tr_bencDictAddBool (targs, "downloadLimited", true);
     2085                              tr_variantDictAddInt (targs, "downloadLimit", numarg (optarg));
     2086                              tr_variantDictAddBool (targs, "downloadLimited", true);
    20882087                          } else {
    2089                               tr_bencDictAddInt (sargs, TR_PREFS_KEY_DSPEED_KBps, numarg (optarg));
    2090                               tr_bencDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, true);
     2088                              tr_variantDictAddInt (sargs, TR_PREFS_KEY_DSPEED_KBps, numarg (optarg));
     2089                              tr_variantDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, true);
    20912090                          }
    20922091                          break;
    20932092                case 'D': if (targs)
    2094                               tr_bencDictAddBool (targs, "downloadLimited", false);
     2093                              tr_variantDictAddBool (targs, "downloadLimited", false);
    20952094                          else
    2096                               tr_bencDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, false);
     2095                              tr_variantDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, false);
    20972096                          break;
    20982097                case 'u': if (targs) {
    2099                               tr_bencDictAddInt (targs, "uploadLimit", numarg (optarg));
    2100                               tr_bencDictAddBool (targs, "uploadLimited", true);
     2098                              tr_variantDictAddInt (targs, "uploadLimit", numarg (optarg));
     2099                              tr_variantDictAddBool (targs, "uploadLimited", true);
    21012100                          } else {
    2102                               tr_bencDictAddInt (sargs, TR_PREFS_KEY_USPEED_KBps, numarg (optarg));
    2103                               tr_bencDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, true);
     2101                              tr_variantDictAddInt (sargs, TR_PREFS_KEY_USPEED_KBps, numarg (optarg));
     2102                              tr_variantDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, true);
    21042103                          }
    21052104                          break;
    21062105                case 'U': if (targs)
    2107                               tr_bencDictAddBool (targs, "uploadLimited", false);
     2106                              tr_variantDictAddBool (targs, "uploadLimited", false);
    21082107                          else
    2109                               tr_bencDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, false);
     2108                              tr_variantDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, false);
    21102109                          break;
    21112110                case 930: if (targs)
    2112                               tr_bencDictAddInt (targs, "peer-limit", atoi (optarg));
     2111                              tr_variantDictAddInt (targs, "peer-limit", atoi (optarg));
    21132112                          else
    2114                               tr_bencDictAddInt (sargs, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi (optarg));
     2113                              tr_variantDictAddInt (sargs, TR_PREFS_KEY_PEER_LIMIT_GLOBAL, atoi (optarg));
    21152114                          break;
    21162115                default:  assert ("unhandled value" && 0);
     
    21202119        else if (stepMode == MODE_TORRENT_SET)
    21212120        {
    2122             tr_benc * args = ensure_tset (&tset);
     2121            tr_variant * args = ensure_tset (&tset);
    21232122
    21242123            switch (c)
    21252124            {
    2126                 case 712: tr_bencListAddInt (tr_bencDictAddList (args, "trackerRemove", 1), atoi (optarg));
    2127                           break;
    2128                 case 950: tr_bencDictAddReal (args, "seedRatioLimit", atof (optarg));
    2129                           tr_bencDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_SINGLE);
    2130                           break;
    2131                 case 951: tr_bencDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_GLOBAL);
    2132                           break;
    2133                 case 952: tr_bencDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_UNLIMITED);
    2134                           break;
    2135                 case 984: tr_bencDictAddBool (args, "honorsSessionLimits", true);
    2136                           break;
    2137                 case 985: tr_bencDictAddBool (args, "honorsSessionLimits", false);
     2125                case 712: tr_variantListAddInt (tr_variantDictAddList (args, "trackerRemove", 1), atoi (optarg));
     2126                          break;
     2127                case 950: tr_variantDictAddReal (args, "seedRatioLimit", atof (optarg));
     2128                          tr_variantDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_SINGLE);
     2129                          break;
     2130                case 951: tr_variantDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_GLOBAL);
     2131                          break;
     2132                case 952: tr_variantDictAddInt (args, "seedRatioMode", TR_RATIOLIMIT_UNLIMITED);
     2133                          break;
     2134                case 984: tr_variantDictAddBool (args, "honorsSessionLimits", true);
     2135                          break;
     2136                case 985: tr_variantDictAddBool (args, "honorsSessionLimits", false);
    21382137                          break;
    21392138                default:  assert ("unhandled value" && 0);
     
    21432142        else if (stepMode == (MODE_TORRENT_SET | MODE_TORRENT_ADD))
    21442143        {
    2145             tr_benc * args;
     2144            tr_variant * args;
    21462145
    21472146            if (tadd)
    2148                 args = tr_bencDictFind (tadd, ARGUMENTS);
     2147                args = tr_variantDictFind (tadd, ARGUMENTS);
    21492148            else
    21502149                args = ensure_tset (&tset);
     
    21622161                case 902: addFiles (args, "priority-low", optarg);
    21632162                          break;
    2164                 case 700: tr_bencDictAddInt (args, "bandwidthPriority",  1);
    2165                           break;
    2166                 case 701: tr_bencDictAddInt (args, "bandwidthPriority",  0);
    2167                           break;
    2168                 case 702: tr_bencDictAddInt (args, "bandwidthPriority", -1);
    2169                           break;
    2170                 case 710: tr_bencListAddStr (tr_bencDictAddList (args, "trackerAdd", 1), optarg);
     2163                case 700: tr_variantDictAddInt (args, "bandwidthPriority",  1);
     2164                          break;
     2165                case 701: tr_variantDictAddInt (args, "bandwidthPriority",  0);
     2166                          break;
     2167                case 702: tr_variantDictAddInt (args, "bandwidthPriority", -1);
     2168                          break;
     2169                case 710: tr_variantListAddStr (tr_variantDictAddList (args, "trackerAdd", 1), optarg);
    21712170                          break;
    21722171                default:  assert ("unhandled value" && 0);
     
    21782177            if (tadd)
    21792178            {
    2180                 tr_benc * args = tr_bencDictFind (tadd, ARGUMENTS);
    2181                 tr_bencDictAddStr (args, "download-dir", optarg);
     2179                tr_variant * args = tr_variantDictFind (tadd, ARGUMENTS);
     2180                tr_variantDictAddStr (args, "download-dir", optarg);
    21822181            }
    21832182            else
    21842183            {
    2185                 tr_benc * args;
    2186                 tr_benc * top = tr_new0 (tr_benc, 1);
    2187                 tr_bencInitDict (top, 2);
    2188                 tr_bencDictAddStr (top, "method", "torrent-set-location");
    2189                 args = tr_bencDictAddDict (top, ARGUMENTS, 3);
    2190                 tr_bencDictAddStr (args, "location", optarg);
    2191                 tr_bencDictAddBool (args, "move", false);
     2184                tr_variant * args;
     2185                tr_variant * top = tr_new0 (tr_variant, 1);
     2186                tr_variantInitDict (top, 2);
     2187                tr_variantDictAddStr (top, "method", "torrent-set-location");
     2188                args = tr_variantDictAddDict (top, ARGUMENTS, 3);
     2189                tr_variantDictAddStr (args, "location", optarg);
     2190                tr_variantDictAddBool (args, "move", false);
    21922191                addIdArg (args, id);
    21932192                status |= flush (rpcurl, &top);
     
    21992198            case 920: /* session-info */
    22002199            {
    2201                 tr_benc * top = tr_new0 (tr_benc, 1);
    2202                 tr_bencInitDict (top, 2);
    2203                 tr_bencDictAddStr (top, "method", "session-get");
    2204                 tr_bencDictAddInt (top, "tag", TAG_SESSION);
     2200                tr_variant * top = tr_new0 (tr_variant, 1);
     2201                tr_variantInitDict (top, 2);
     2202                tr_variantDictAddStr (top, "method", "session-get");
     2203                tr_variantDictAddInt (top, "tag", TAG_SESSION);
    22052204                status |= flush (rpcurl, &top);
    22062205                break;
     
    22092208            {
    22102209                if (tadd)
    2211                     tr_bencDictAddBool (tr_bencDictFind (tadd, "arguments"), "paused", false);
     2210                    tr_variantDictAddBool (tr_variantDictFind (tadd, "arguments"), "paused", false);
    22122211                else {
    2213                     tr_benc * top = tr_new0 (tr_benc, 1);
    2214                     tr_bencInitDict (top, 2);
    2215                     tr_bencDictAddStr (top, "method", "torrent-start");
    2216                     addIdArg (tr_bencDictAddDict (top, ARGUMENTS, 1), id);
     2212                    tr_variant * top = tr_new0 (tr_variant, 1);
     2213                    tr_variantInitDict (top, 2);
     2214                    tr_variantDictAddStr (top, "method", "torrent-start");
     2215                    addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id);
    22172216                    status |= flush (rpcurl, &top);
    22182217                }
     
    22222221            {
    22232222                if (tadd)
    2224                     tr_bencDictAddBool (tr_bencDictFind (tadd, "arguments"), "paused", true);
     2223                    tr_variantDictAddBool (tr_variantDictFind (tadd, "arguments"), "paused", true);
    22252224                else {
    2226                     tr_benc * top = tr_new0 (tr_benc, 1);
    2227                     tr_bencInitDict (top, 2);
    2228                     tr_bencDictAddStr (top, "method", "torrent-stop");
    2229                     addIdArg (tr_bencDictAddDict (top, ARGUMENTS, 1), id);
     2225                    tr_variant * top = tr_new0 (tr_variant, 1);
     2226                    tr_variantInitDict (top, 2);
     2227                    tr_variantDictAddStr (top, "method", "torrent-stop");
     2228                    addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id);
    22302229                    status |= flush (rpcurl, &top);
    22312230                }
     
    22362235                char * path = absolutify (optarg);
    22372236                if (tadd)
    2238                     tr_bencDictAddStr (tr_bencDictFind (tadd, "arguments"), "download-dir", path);
     2237                    tr_variantDictAddStr (tr_variantDictFind (tadd, "arguments"), "download-dir", path);
    22392238                else {
    2240                     tr_benc * args = ensure_sset (&sset);
    2241                     tr_bencDictAddStr (args, "download-dir", path);
     2239                    tr_variant * args = ensure_sset (&sset);
     2240                    tr_variantDictAddStr (args, "download-dir", path);
    22422241                }
    22432242                tr_free (path);
     
    22462245            case 850:
    22472246            {
    2248                 tr_benc * top = tr_new0 (tr_benc, 1);
    2249                 tr_bencInitDict (top, 1);
    2250                 tr_bencDictAddStr (top, "method", "session-close");
     2247                tr_variant * top = tr_new0 (tr_variant, 1);
     2248                tr_variantInitDict (top, 1);
     2249                tr_variantDictAddStr (top, "method", "session-close");
    22512250                status |= flush (rpcurl, &top);
    22522251                break;
     
    22542253            case 963:
    22552254            {
    2256                 tr_benc * top = tr_new0 (tr_benc, 1);
    2257                 tr_bencInitDict (top, 1);
    2258                 tr_bencDictAddStr (top, "method", "blocklist-update");
     2255                tr_variant * top = tr_new0 (tr_variant, 1);
     2256                tr_variantInitDict (top, 1);
     2257                tr_variantDictAddStr (top, "method", "blocklist-update");
    22592258                status |= flush (rpcurl, &top);
    22602259                break;
     
    22622261            case 921:
    22632262            {
    2264                 tr_benc * top = tr_new0 (tr_benc, 1);
    2265                 tr_bencInitDict (top, 2);
    2266                 tr_bencDictAddStr (top, "method", "session-stats");
    2267                 tr_bencDictAddInt (top, "tag", TAG_STATS);
     2263                tr_variant * top = tr_new0 (tr_variant, 1);
     2264                tr_variantInitDict (top, 2);
     2265                tr_variantDictAddStr (top, "method", "session-stats");
     2266                tr_variantDictAddInt (top, "tag", TAG_STATS);
    22682267                status |= flush (rpcurl, &top);
    22692268                break;
     
    22712270            case 962:
    22722271            {
    2273                 tr_benc * top = tr_new0 (tr_benc, 1);
    2274                 tr_bencInitDict (top, 2);
    2275                 tr_bencDictAddStr (top, "method", "port-test");
    2276                 tr_bencDictAddInt (top, "tag", TAG_PORTTEST);
     2272                tr_variant * top = tr_new0 (tr_variant, 1);
     2273                tr_variantInitDict (top, 2);
     2274                tr_variantDictAddStr (top, "method", "port-test");
     2275                tr_variantDictAddInt (top, "tag", TAG_PORTTEST);
    22772276                status |= flush (rpcurl, &top);
    22782277                break;
     
    22802279            case 600:
    22812280            {
    2282                 tr_benc * top;
    2283                 if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
    2284                 top = tr_new0 (tr_benc, 1);
    2285                 tr_bencInitDict (top, 2);
    2286                 tr_bencDictAddStr (top, "method", "torrent-reannounce");
    2287                 addIdArg (tr_bencDictAddDict (top, ARGUMENTS, 1), id);
     2281                tr_variant * top;
     2282                if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
     2283                top = tr_new0 (tr_variant, 1);
     2284                tr_variantInitDict (top, 2);
     2285                tr_variantDictAddStr (top, "method", "torrent-reannounce");
     2286                addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id);
    22882287                status |= flush (rpcurl, &top);
    22892288                break;
     
    22912290            case 'v':
    22922291            {
    2293                 tr_benc * top;
    2294                 if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
    2295                 top = tr_new0 (tr_benc, 1);
    2296                 tr_bencInitDict (top, 2);
    2297                 tr_bencDictAddStr (top, "method", "torrent-verify");
    2298                 addIdArg (tr_bencDictAddDict (top, ARGUMENTS, 1), id);
     2292                tr_variant * top;
     2293                if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
     2294                top = tr_new0 (tr_variant, 1);
     2295                tr_variantInitDict (top, 2);
     2296                tr_variantDictAddStr (top, "method", "torrent-verify");
     2297                addIdArg (tr_variantDictAddDict (top, ARGUMENTS, 1), id);
    22992298                status |= flush (rpcurl, &top);
    23002299                break;
     
    23032302            case 'R':
    23042303            {
    2305                 tr_benc * args;
    2306                 tr_benc * top = tr_new0 (tr_benc, 1);
    2307                 tr_bencInitDict (top, 2);
    2308                 tr_bencDictAddStr (top, "method", "torrent-remove");
    2309                 args = tr_bencDictAddDict (top, ARGUMENTS, 2);
    2310                 tr_bencDictAddBool (args, "delete-local-data", c=='R');
     2304                tr_variant * args;
     2305                tr_variant * top = tr_new0 (tr_variant, 1);
     2306                tr_variantInitDict (top, 2);
     2307                tr_variantDictAddStr (top, "method", "torrent-remove");
     2308                args = tr_variantDictAddDict (top, ARGUMENTS, 2);
     2309                tr_variantDictAddBool (args, "delete-local-data", c=='R');
    23112310                addIdArg (args, id);
    23122311                status |= flush (rpcurl, &top);
     
    23152314            case 960:
    23162315            {
    2317                 tr_benc * args;
    2318                 tr_benc * top = tr_new0 (tr_benc, 1);
    2319                 tr_bencInitDict (top, 2);
    2320                 tr_bencDictAddStr (top, "method", "torrent-set-location");
    2321                 args = tr_bencDictAddDict (top, ARGUMENTS, 3);
    2322                 tr_bencDictAddStr (args, "location", optarg);
    2323                 tr_bencDictAddBool (args, "move", true);
     2316                tr_variant * args;
     2317                tr_variant * top = tr_new0 (tr_variant, 1);
     2318                tr_variantInitDict (top, 2);
     2319                tr_variantDictAddStr (top, "method", "torrent-set-location");
     2320                args = tr_variantDictAddDict (top, ARGUMENTS, 3);
     2321                tr_variantDictAddStr (args, "location", optarg);
     2322                tr_variantDictAddBool (args, "move", true);
    23242323                addIdArg (args, id);
    23252324                status |= flush (rpcurl, &top);
     
    23362335
    23372336    if (tadd != 0) status |= flush (rpcurl, &tadd);
    2338     if (tset != 0) { addIdArg (tr_bencDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
     2337    if (tset != 0) { addIdArg (tr_variantDictFind (tset, ARGUMENTS), id); status |= flush (rpcurl, &tset); }
    23392338    if (sset != 0) status |= flush (rpcurl, &sset);
    23402339    return status;
  • trunk/gtk/conf.c

    r13638 r13667  
    3535
    3636#include <libtransmission/transmission.h>
    37 #include <libtransmission/bencode.h>
     37#include <libtransmission/variant.h>
    3838
    3939#include "conf.h"
     
    6565 */
    6666static void
    67 tr_prefs_init_defaults (tr_benc * d)
     67tr_prefs_init_defaults (tr_variant * d)
    6868{
    6969  const char * str;
     
    7878    str = tr_getDefaultDownloadDir ();
    7979
    80   tr_bencDictReserve (d, 29);
    81 
    82   tr_bencDictAddStr (d, PREF_KEY_DIR_WATCH, str);
    83   tr_bencDictAddBool (d, PREF_KEY_DIR_WATCH_ENABLED, FALSE);
    84 
    85   tr_bencDictAddBool (d, PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, FALSE);
    86   tr_bencDictAddBool (d, PREF_KEY_INHIBIT_HIBERNATION, FALSE);
    87   tr_bencDictAddBool (d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE);
    88 
    89   tr_bencDictAddStr (d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir ());
    90 
    91   tr_bencDictAddBool (d, PREF_KEY_TOOLBAR, TRUE);
    92   tr_bencDictAddBool (d, PREF_KEY_FILTERBAR, TRUE);
    93   tr_bencDictAddBool (d, PREF_KEY_STATUSBAR, TRUE);
    94   tr_bencDictAddBool (d, PREF_KEY_TRASH_CAN_ENABLED, TRUE);
    95   tr_bencDictAddBool (d, PREF_KEY_SHOW_TRAY_ICON, FALSE);
    96   tr_bencDictAddBool (d, PREF_KEY_SHOW_MORE_TRACKER_INFO, FALSE);
    97   tr_bencDictAddBool (d, PREF_KEY_SHOW_MORE_PEER_INFO, FALSE);
    98   tr_bencDictAddBool (d, PREF_KEY_SHOW_BACKUP_TRACKERS, FALSE);
    99   tr_bencDictAddStr (d, PREF_KEY_STATUSBAR_STATS, "total-ratio");
    100 
    101   tr_bencDictAddBool (d, PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED, true);
    102   tr_bencDictAddBool (d, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED, true);
    103   tr_bencDictAddStr (d, PREF_KEY_TORRENT_COMPLETE_SOUND_COMMAND, "canberra-gtk-play -i complete-download -d 'transmission torrent downloaded'");
    104   tr_bencDictAddBool (d, PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED, true);
    105 
    106   tr_bencDictAddBool (d, PREF_KEY_OPTIONS_PROMPT, TRUE);
    107 
    108   tr_bencDictAddBool (d, PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, FALSE);
    109   tr_bencDictAddInt (d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500);
    110   tr_bencDictAddInt (d, PREF_KEY_MAIN_WINDOW_WIDTH, 300);
    111   tr_bencDictAddInt (d, PREF_KEY_MAIN_WINDOW_X, 50);
    112   tr_bencDictAddInt (d, PREF_KEY_MAIN_WINDOW_Y, 50);
    113 
    114   tr_bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, special_dl_dir ? special_dl_dir : str);
    115 
    116   tr_bencDictAddStr (d, PREF_KEY_SORT_MODE, "sort-by-name");
    117   tr_bencDictAddBool (d, PREF_KEY_SORT_REVERSED, FALSE);
    118   tr_bencDictAddBool (d, PREF_KEY_COMPACT_VIEW, FALSE);
     80  tr_variantDictReserve (d, 29);
     81
     82  tr_variantDictAddStr (d, PREF_KEY_DIR_WATCH, str);
     83  tr_variantDictAddBool (d, PREF_KEY_DIR_WATCH_ENABLED, FALSE);
     84
     85  tr_variantDictAddBool (d, PREF_KEY_USER_HAS_GIVEN_INFORMED_CONSENT, FALSE);
     86  tr_variantDictAddBool (d, PREF_KEY_INHIBIT_HIBERNATION, FALSE);
     87  tr_variantDictAddBool (d, PREF_KEY_BLOCKLIST_UPDATES_ENABLED, TRUE);
     88
     89  tr_variantDictAddStr (d, PREF_KEY_OPEN_DIALOG_FOLDER, g_get_home_dir ());
     90
     91  tr_variantDictAddBool (d, PREF_KEY_TOOLBAR, TRUE);
     92  tr_variantDictAddBool (d, PREF_KEY_FILTERBAR, TRUE);
     93  tr_variantDictAddBool (d, PREF_KEY_STATUSBAR, TRUE);
     94  tr_variantDictAddBool (d, PREF_KEY_TRASH_CAN_ENABLED, TRUE);
     95  tr_variantDictAddBool (d, PREF_KEY_SHOW_TRAY_ICON, FALSE);
     96  tr_variantDictAddBool (d, PREF_KEY_SHOW_MORE_TRACKER_INFO, FALSE);
     97  tr_variantDictAddBool (d, PREF_KEY_SHOW_MORE_PEER_INFO, FALSE);
     98  tr_variantDictAddBool (d, PREF_KEY_SHOW_BACKUP_TRACKERS, FALSE);
     99  tr_variantDictAddStr (d, PREF_KEY_STATUSBAR_STATS, "total-ratio");
     100
     101  tr_variantDictAddBool (d, PREF_KEY_TORRENT_ADDED_NOTIFICATION_ENABLED, true);
     102  tr_variantDictAddBool (d, PREF_KEY_TORRENT_COMPLETE_NOTIFICATION_ENABLED, true);
     103  tr_variantDictAddStr (d, PREF_KEY_TORRENT_COMPLETE_SOUND_COMMAND, "canberra-gtk-play -i complete-download -d 'transmission torrent downloaded'");
     104  tr_variantDictAddBool (d, PREF_KEY_TORRENT_COMPLETE_SOUND_ENABLED, true);
     105
     106  tr_variantDictAddBool (d, PREF_KEY_OPTIONS_PROMPT, TRUE);
     107
     108  tr_variantDictAddBool (d, PREF_KEY_MAIN_WINDOW_IS_MAXIMIZED, FALSE);
     109  tr_variantDictAddInt (d, PREF_KEY_MAIN_WINDOW_HEIGHT, 500);
     110  tr_variantDictAddInt (d, PREF_KEY_MAIN_WINDOW_WIDTH, 300);
     111  tr_variantDictAddInt (d, PREF_KEY_MAIN_WINDOW_X, 50);
     112  tr_variantDictAddInt (d, PREF_KEY_MAIN_WINDOW_Y, 50);
     113
     114  tr_variantDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, special_dl_dir ? special_dl_dir : str);
     115
     116  tr_variantDictAddStr (d, PREF_KEY_SORT_MODE, "sort-by-name");
     117  tr_variantDictAddBool (d, PREF_KEY_SORT_REVERSED, FALSE);
     118  tr_variantDictAddBool (d, PREF_KEY_COMPACT_VIEW, FALSE);
    119119}
    120120
     
    126126}
    127127
    128 static tr_benc*
     128static tr_variant*
    129129getPrefs (void)
    130130{
    131   static tr_benc settings;
     131  static tr_variant settings;
    132132  static gboolean loaded = FALSE;
    133133
    134134  if (!loaded)
    135135    {
    136       tr_bencInitDict (&settings, 0);
     136      tr_variantInitDict (&settings, 0);
    137137      tr_prefs_init_defaults (&settings);
    138138      tr_sessionLoadSettings (&settings, gl_confdir, MY_CONFIG_NAME);
     
    147147***/
    148148
    149 tr_benc*
     149tr_variant*
    150150gtr_pref_get_all (void)
    151151{
     
    158158  int64_t i = 0;
    159159
    160   tr_bencDictFindInt (getPrefs (), key, &i);
     160  tr_variantDictFindInt (getPrefs (), key, &i);
    161161
    162162  return i;
     
    166166gtr_pref_int_set (const char * key, int64_t value)
    167167{
    168   tr_bencDictAddInt (getPrefs (), key, value);
     168  tr_variantDictAddInt (getPrefs (), key, value);
    169169}
    170170
     
    174174  double d = 0.0;
    175175
    176   tr_bencDictFindReal (getPrefs (), key, &d);
     176  tr_variantDictFindReal (getPrefs (), key, &d);
    177177
    178178  return d;
     
    182182gtr_pref_double_set (const char * key, double value)
    183183{
    184   tr_bencDictAddReal (getPrefs (), key, value);
     184  tr_variantDictAddReal (getPrefs (), key, value);
    185185}
    186186
     
    194194  bool boolVal;
    195195
    196   tr_bencDictFindBool (getPrefs (), key, &boolVal);
     196  tr_variantDictFindBool (getPrefs (), key, &boolVal);
    197197
    198198  return boolVal != 0;
     
    202202gtr_pref_flag_set (const char * key, gboolean value)
    203203{
    204   tr_bencDictAddBool (getPrefs (), key, value);
     204  tr_variantDictAddBool (getPrefs (), key, value);
    205205}
    206206
     
    214214  const char * str = NULL;
    215215
    216   tr_bencDictFindStr (getPrefs (), key, &str);
     216  tr_variantDictFindStr (getPrefs (), key, &str, NULL);
    217217
    218218  return str;
     
    222222gtr_pref_string_set (const char * key, const char * value)
    223223{
    224   tr_bencDictAddStr (getPrefs (), key, value);
     224  tr_variantDictAddStr (getPrefs (), key, value);
    225225}
    226226
     
    256256translate_keyfile_to_json (const char * old_file, const char * new_file)
    257257{
    258   tr_benc    dict;
     258  tr_variant    dict;
    259259  GKeyFile * keyfile;
    260260  gchar **   keys;
     
    280280  keys = g_key_file_get_keys (keyfile, "general", &length, NULL);
    281281
    282   tr_bencInitDict (&dict, length);
     282  tr_variantInitDict (&dict, length);
    283283  for (i=0; i<length; i++)
    284284    {
     
    293293      if (!strcmp (val, "true") || !strcmp (val, "false"))
    294294        {
    295           tr_bencDictAddInt (&dict, key, !strcmp (val, "true"));
     295          tr_variantDictAddInt (&dict, key, !strcmp (val, "true"));
    296296        }
    297297      else
     
    304304          l = strtol (val, &end, 10);
    305305          if (!errno && end && !*end)
    306             tr_bencDictAddInt (&dict, key, l);
     306            tr_variantDictAddInt (&dict, key, l);
    307307          else
    308             tr_bencDictAddStr (&dict, key, val);
     308            tr_variantDictAddStr (&dict, key, val);
    309309        }
    310310
     
    313313
    314314  g_key_file_free (keyfile);
    315   tr_bencToFile (&dict, TR_FMT_JSON, new_file);
    316   tr_bencFree (&dict);
     315  tr_variantToFile (&dict, TR_VARIANT_FMT_JSON, new_file);
     316  tr_variantFree (&dict);
    317317}
    318318
  • trunk/gtk/conf.h

    r13625 r13667  
    2727
    2828#include <inttypes.h>
    29 #include <libtransmission/transmission.h> /* tr_benc, tr_session */
     29#include <libtransmission/transmission.h> /* tr_variant, tr_session */
    3030
    3131void             gtr_pref_init            (const char * config_dir);
     
    4444
    4545void             gtr_pref_save            (tr_session *);
    46 struct tr_benc*  gtr_pref_get_all         (void);
     46struct tr_variant*  gtr_pref_get_all         (void);
    4747
    4848#endif /* GTR_CONFIG_H */
  • trunk/gtk/details.c

    r13651 r13667  
    319319{
    320320    GSList *l;
    321     tr_benc top, *args, *ids;
    322 
    323     tr_bencInitDict (&top, 2);
    324     tr_bencDictAddStr (&top, "method", "torrent-set");
    325     args = tr_bencDictAddDict (&top, "arguments", 2);
    326     tr_bencDictAddBool (args, key, value);
    327     ids = tr_bencDictAddList (args, "ids", g_slist_length (di->ids));
     321    tr_variant top, *args, *ids;
     322
     323    tr_variantInitDict (&top, 2);
     324    tr_variantDictAddStr (&top, "method", "torrent-set");
     325    args = tr_variantDictAddDict (&top, "arguments", 2);
     326    tr_variantDictAddBool (args, key, value);
     327    ids = tr_variantDictAddList (args, "ids", g_slist_length (di->ids));
    328328    for (l=di->ids; l; l=l->next)
    329         tr_bencListAddInt (ids, GPOINTER_TO_INT (l->data));
     329        tr_variantListAddInt (ids, GPOINTER_TO_INT (l->data));
    330330
    331331    gtr_core_exec (di->core, &top);
    332     tr_bencFree (&top);
     332    tr_variantFree (&top);
    333333}
    334334
     
    337337{
    338338    GSList *l;
    339     tr_benc top, *args, *ids;
    340 
    341     tr_bencInitDict (&top, 2);
    342     tr_bencDictAddStr (&top, "method", "torrent-set");
    343     args = tr_bencDictAddDict (&top, "arguments", 2);
    344     tr_bencDictAddInt (args, key, value);
    345     ids = tr_bencDictAddList (args, "ids", g_slist_length (di->ids));
     339    tr_variant top, *args, *ids;
     340
     341    tr_variantInitDict (&top, 2);
     342    tr_variantDictAddStr (&top, "method", "torrent-set");
     343    args = tr_variantDictAddDict (&top, "arguments", 2);
     344    tr_variantDictAddInt (args, key, value);
     345    ids = tr_variantDictAddList (args, "ids", g_slist_length (di->ids));
    346346    for (l=di->ids; l; l=l->next)
    347         tr_bencListAddInt (ids, GPOINTER_TO_INT (l->data));
     347        tr_variantListAddInt (ids, GPOINTER_TO_INT (l->data));
    348348
    349349    gtr_core_exec (di->core, &top);
    350     tr_bencFree (&top);
     350    tr_variantFree (&top);
    351351}
    352352
     
    355355{
    356356    GSList *l;
    357     tr_benc top, *args, *ids;
    358 
    359     tr_bencInitDict (&top, 2);
    360     tr_bencDictAddStr (&top, "method", "torrent-set");
    361     args = tr_bencDictAddDict (&top, "arguments", 2);
    362     tr_bencDictAddReal (args, key, value);
    363     ids = tr_bencDictAddList (args, "ids", g_slist_length (di->ids));
     357    tr_variant top, *args, *ids;
     358
     359    tr_variantInitDict (&top, 2);
     360    tr_variantDictAddStr (&top, "method", "torrent-set");
     361    args = tr_variantDictAddDict (&top, "arguments", 2);
     362    tr_variantDictAddReal (args, key, value);
     363    ids = tr_variantDictAddList (args, "ids", g_slist_length (di->ids));
    364364    for (l=di->ids; l; l=l->next)
    365         tr_bencListAddInt (ids, GPOINTER_TO_INT (l->data));
     365        tr_variantListAddInt (ids, GPOINTER_TO_INT (l->data));
    366366
    367367    gtr_core_exec (di->core, &top);
    368     tr_bencFree (&top);
     368    tr_variantFree (&top);
    369369}
    370370
  • trunk/gtk/main.c

    r13625 r13667  
    403403      case TR_RPC_SESSION_CHANGED: {
    404404        int i;
    405         tr_benc tmp;
    406         tr_benc * newval;
    407         tr_benc * oldvals = gtr_pref_get_all ();
     405        tr_variant tmp;
     406        tr_variant * newval;
     407        tr_variant * oldvals = gtr_pref_get_all ();
    408408        const char * key;
    409409        GSList * l;
    410410        GSList * changed_keys = NULL;
    411         tr_bencInitDict (&tmp, 100);
     411        tr_variantInitDict (&tmp, 100);
    412412        tr_sessionGetSettings (session, &tmp);
    413         for (i=0; tr_bencDictChild (&tmp, i, &key, &newval); ++i)
     413        for (i=0; tr_variantDictChild (&tmp, i, &key, &newval); ++i)
    414414          {
    415415            bool changed;
    416             tr_benc * oldval = tr_bencDictFind (oldvals, key);
     416            tr_variant * oldval = tr_variantDictFind (oldvals, key);
    417417            if (!oldval)
    418418              {
     
    421421            else
    422422              {
    423                 char * a = tr_bencToStr (oldval, TR_FMT_BENC, NULL);
    424                 char * b = tr_bencToStr (newval, TR_FMT_BENC, NULL);
     423                char * a = tr_variantToStr (oldval, TR_VARIANT_FMT_BENC, NULL);
     424                char * b = tr_variantToStr (newval, TR_VARIANT_FMT_BENC, NULL);
    425425                changed = strcmp (a, b) != 0;
    426426                tr_free (b);
     
    437437
    438438        g_slist_free (changed_keys);
    439         tr_bencFree (&tmp);
     439        tr_variantFree (&tmp);
    440440        break;
    441441      }
     
    13441344  tr_torrent * tor = NULL;
    13451345  gtk_tree_model_get (m, iter, MC_TORRENT, &tor, -1);
    1346   tr_bencListAddInt (list, tr_torrentId (tor));
     1346  tr_variantListAddInt (list, tr_torrentId (tor));
    13471347}
    13481348
     
    13501350call_rpc_for_selected_torrents (struct cbdata * data, const char * method)
    13511351{
    1352   tr_benc top, *args, *ids;
     1352  tr_variant top, *args, *ids;
    13531353  gboolean invoked = FALSE;
    13541354  GtkTreeSelection * s = data->sel;
    13551355  tr_session * session = gtr_core_session (data->core);
    13561356
    1357   tr_bencInitDict (&top, 2);
    1358   tr_bencDictAddStr (&top, "method", method);
    1359   args = tr_bencDictAddDict (&top, "arguments", 1);
    1360   ids = tr_bencDictAddList (args, "ids", 0);
     1357  tr_variantInitDict (&top, 2);
     1358  tr_variantDictAddStr (&top, "method", method);
     1359  args = tr_variantDictAddDict (&top, "arguments", 1);
     1360  ids = tr_variantDictAddList (args, "ids", 0);
    13611361  gtk_tree_selection_selected_foreach (s, append_id_to_benc_list, ids);
    13621362
    1363   if (tr_bencListSize (ids) != 0)
     1363  if (tr_variantListSize (ids) != 0)
    13641364    {
    13651365      int json_len;
    1366       char * json = tr_bencToStr (&top, TR_FMT_JSON_LEAN, &json_len);
     1366      char * json = tr_variantToStr (&top, TR_VARIANT_FMT_JSON_LEAN, &json_len);
    13671367      tr_rpc_request_exec_json (session, json, json_len, NULL, NULL);
    13681368      g_free (json);
     
    13701370    }
    13711371
    1372   tr_bencFree (&top);
     1372  tr_variantFree (&top);
    13731373  return invoked;
    13741374}
  • trunk/gtk/tr-core.c

    r13625 r13667  
    3333
    3434#include <libtransmission/transmission.h>
    35 #include <libtransmission/bencode.h>
    3635#include <libtransmission/rpcimpl.h>
    37 #include <libtransmission/json.h>
    3836#include <libtransmission/utils.h> /* tr_free */
     37#include <libtransmission/variant.h>
    3938
    4039#include "actions.h"
     
    16661665static int nextTag = 1;
    16671666
    1668 typedef void (server_response_func)(TrCore * core, tr_benc * response, gpointer user_data);
     1667typedef void (server_response_func)(TrCore * core, tr_variant * response, gpointer user_data);
    16691668
    16701669struct pending_request_data
     
    16801679core_read_rpc_response_idle (void * vresponse)
    16811680{
    1682   tr_benc top;
     1681  tr_variant top;
    16831682  int64_t intVal;
    16841683  struct evbuffer * response = vresponse;
    16851684
    1686   tr_jsonParse (NULL, evbuffer_pullup (response, -1), evbuffer_get_length (response), &top, NULL);
    1687 
    1688   if (tr_bencDictFindInt (&top, "tag", &intVal))
     1685  tr_variantFromJson (&top, evbuffer_pullup (response, -1), evbuffer_get_length (response));
     1686
     1687  if (tr_variantDictFindInt (&top, "tag", &intVal))
    16891688    {
    16901689      const int tag = (int)intVal;
     
    16981697    }
    16991698
    1700   tr_bencFree (&top);
     1699  tr_variantFree (&top);
    17011700  evbuffer_free (response);
    17021701  return FALSE;
     
    17521751
    17531752static void
    1754 on_port_test_response (TrCore * core, tr_benc * response, gpointer u UNUSED)
    1755 {
    1756   tr_benc * args;
     1753on_port_test_response (TrCore * core, tr_variant * response, gpointer u UNUSED)
     1754{
     1755  tr_variant * args;
    17571756  bool is_open = FALSE;
    17581757
    1759   if (tr_bencDictFindDict (response, "arguments", &args))
    1760     tr_bencDictFindBool (args, "port-is-open", &is_open);
     1758  if (tr_variantDictFindDict (response, "arguments", &args))
     1759    tr_variantDictFindBool (args, "port-is-open", &is_open);
    17611760
    17621761  core_emit_port_tested (core, is_open);
     
    17771776
    17781777static void
    1779 on_blocklist_response (TrCore * core, tr_benc * response, gpointer data UNUSED)
    1780 {
    1781   tr_benc * args;
     1778on_blocklist_response (TrCore * core, tr_variant * response, gpointer data UNUSED)
     1779{
     1780  tr_variant * args;
    17821781  int64_t ruleCount = -1;
    17831782
    1784   if (tr_bencDictFindDict (response, "arguments", &args))
    1785     tr_bencDictFindInt (args, "blocklist-size", &ruleCount);
     1783  if (tr_variantDictFindDict (response, "arguments", &args))
     1784    tr_variantDictFindInt (args, "blocklist-size", &ruleCount);
    17861785
    17871786  if (ruleCount > 0)
     
    18121811
    18131812void
    1814 gtr_core_exec (TrCore * core, const tr_benc * top)
    1815 {
    1816   char * json = tr_bencToStr (top, TR_FMT_JSON_LEAN, NULL);
     1813gtr_core_exec (TrCore * core, const tr_variant * top)
     1814{
     1815  char * json = tr_variantToStr (top, TR_VARIANT_FMT_JSON_LEAN, NULL);
    18171816  gtr_core_exec_json (core, json);
    18181817  tr_free (json);
  • trunk/gtk/tr-core.h

    r13625 r13667  
    2929
    3030#include <libtransmission/transmission.h>
    31 #include <libtransmission/bencode.h>
     31#include <libtransmission/variant.h>
    3232
    3333G_BEGIN_DECLS
     
    154154void gtr_core_blocklist_update (TrCore * core);
    155155
    156 void gtr_core_exec (TrCore * core, const tr_benc * benc);
     156void gtr_core_exec (TrCore * core, const tr_variant * benc);
    157157
    158158void gtr_core_exec_json (TrCore * core, const char * json);
  • trunk/libtransmission/Makefile.am

    r13635 r13667  
    2222    announcer-udp.c \
    2323    bandwidth.c \
    24     bencode.c \
    2524    bitfield.c \
    2625    blocklist.c \
     
    3433    history.c \
    3534    inout.c \
    36     json.c \
    3735    list.c \
    3836    magnet.c \
     
    6361    upnp.c \
    6462    utils.c \
     63    variant.c \
     64    variant-benc.c \
     65    variant-json.c \
    6566    verify.c \
    6667    web.c \
     
    7273    announcer-common.h \
    7374    bandwidth.h \
    74     bencode.h \
    7575    bitfield.h \
    7676    blocklist.h \
     
    8686    jsonsl.c \
    8787    jsonsl.h \
    88     json.h \
    8988    libtransmission-test.h \
    9089    list.h \
     
    117116    upnp.h \
    118117    utils.h \
     118    variant.h \
     119    variant-common.h \
    119120    verify.h \
    120121    version.h \
     
    125126    bitfield-test \
    126127    blocklist-test \
    127     bencode-test \
    128128    clients-test \
    129129    history-test \
     
    134134    rpc-test \
    135135    test-peer-id \
    136     utils-test
     136    utils-test \
     137    variant-test
    137138
    138139noinst_PROGRAMS = $(TESTS)
     
    154155    @ZLIB_LIBS@
    155156
    156 bencode_test_SOURCES = bencode-test.c
    157 bencode_test_LDADD = ${apps_ldadd}
    158 bencode_test_LDFLAGS = ${apps_ldflags}
    159 
    160 bitfield_test_SOURCES = bitfield-test.c
     157TEST_SOURCES = libtransmission-test.c
     158
     159bitfield_test_SOURCES = bitfield-test.c $(TEST_SOURCES)
    161160bitfield_test_LDADD = ${apps_ldadd}
    162161bitfield_test_LDFLAGS = ${apps_ldflags}
    163162
    164 blocklist_test_SOURCES = blocklist-test.c
     163blocklist_test_SOURCES = blocklist-test.c $(TEST_SOURCES)
    165164blocklist_test_LDADD = ${apps_ldadd}
    166165blocklist_test_LDFLAGS = ${apps_ldflags}
    167166
    168 clients_test_SOURCES = clients-test.c
     167clients_test_SOURCES = clients-test.c $(TEST_SOURCES)
    169168clients_test_LDADD = ${apps_ldadd}
    170169clients_test_LDFLAGS = ${apps_ldflags}
    171170
    172 history_test_SOURCES = history-test.c
     171history_test_SOURCES = history-test.c $(TEST_SOURCES)
    173172history_test_LDADD = ${apps_ldadd}
    174173history_test_LDFLAGS = ${apps_ldflags}
    175174
    176 json_test_SOURCES = json-test.c
     175json_test_SOURCES = json-test.c $(TEST_SOURCES)
    177176json_test_LDADD = ${apps_ldadd}
    178177json_test_LDFLAGS = ${apps_ldflags}
    179178
    180 magnet_test_SOURCES = magnet-test.c
     179magnet_test_SOURCES = magnet-test.c $(TEST_SOURCES)
    181180magnet_test_LDADD = ${apps_ldadd}
    182181magnet_test_LDFLAGS = ${apps_ldflags}
    183182
    184 metainfo_test_SOURCES = metainfo-test.c
     183metainfo_test_SOURCES = metainfo-test.c $(TEST_SOURCES)
    185184metainfo_test_LDADD = ${apps_ldadd}
    186185metainfo_test_LDFLAGS = ${apps_ldflags}
    187186
    188 peer_msgs_test_SOURCES = peer-msgs-test.c
     187peer_msgs_test_SOURCES = peer-msgs-test.c $(TEST_SOURCES)
    189188peer_msgs_test_LDADD = ${apps_ldadd}
    190189peer_msgs_test_LDFLAGS = ${apps_ldflags}
    191190
    192 rpc_test_SOURCES = rpc-test.c
     191rpc_test_SOURCES = rpc-test.c $(TEST_SOURCES)
    193192rpc_test_LDADD = ${apps_ldadd}
    194193rpc_test_LDFLAGS = ${apps_ldflags}
    195194
    196 test_peer_id_SOURCES = test-peer-id.c
     195test_peer_id_SOURCES = test-peer-id.c $(TEST_SOURCES)
    197196test_peer_id_LDADD = ${apps_ldadd}
    198197test_peer_id_LDFLAGS = ${apps_ldflags}
    199198
    200 utils_test_SOURCES = utils-test.c
     199utils_test_SOURCES = utils-test.c $(TEST_SOURCES)
    201200utils_test_LDADD = ${apps_ldadd}
    202201utils_test_LDFLAGS = ${apps_ldflags}
     202
     203variant_test_SOURCES = variant-test.c $(TEST_SOURCES)
     204variant_test_LDADD = ${apps_ldadd}
     205variant_test_LDFLAGS = ${apps_ldflags}
  • trunk/libtransmission/announcer-http.c

    r13631 r13667  
    2828#include "trevent.h" /* tr_runInEventThread () */
    2929#include "utils.h"
     30#include "variant.h"
    3031#include "web.h" /* tr_http_escape () */
    3132
     
    121122
    122123static tr_pex*
    123 listToPex (tr_benc * peerList, size_t * setme_len)
     124listToPex (tr_variant * peerList, size_t * setme_len)
    124125{
    125126    size_t i;
    126127    size_t n;
    127     const size_t len = tr_bencListSize (peerList);
     128    const size_t len = tr_variantListSize (peerList);
    128129    tr_pex * pex = tr_new0 (tr_pex, len);
    129130
     
    133134        const char * ip;
    134135        tr_address addr;
    135         tr_benc * peer = tr_bencListChild (peerList, i);
     136        tr_variant * peer = tr_variantListChild (peerList, i);
    136137
    137138        if (peer == NULL)
    138139            continue;
    139         if (!tr_bencDictFindStr (peer, "ip", &ip))
     140        if (!tr_variantDictFindStr (peer, "ip", &ip, NULL))
    140141            continue;
    141142        if (!tr_address_from_string (&addr, ip))
    142143            continue;
    143         if (!tr_bencDictFindInt (peer, "port", &port))
     144        if (!tr_variantDictFindInt (peer, "port", &port))
    144145            continue;
    145146        if ((port < 0) || (port > USHRT_MAX))
     
    207208    else
    208209    {
    209         tr_benc benc;
    210         const int benc_loaded = !tr_bencLoad (msg, msglen, &benc, NULL);
     210        tr_variant benc;
     211        const bool variant_loaded = !tr_variantFromBenc (&benc, msg, msglen);
    211212
    212213        if (getenv ("TR_CURL_VERBOSE") != NULL)
    213214        {
    214             if (!benc_loaded)
     215            if (!variant_loaded)
    215216                fprintf (stderr, "%s", "Announce response was not in benc format\n");
    216217            else {
    217218                int i, len;
    218                 char * str = tr_bencToStr (&benc, TR_FMT_JSON, &len);
     219                char * str = tr_variantToStr (&benc, TR_VARIANT_FMT_JSON, &len);
    219220                fprintf (stderr, "%s", "Announce response:\n< ");
    220221                for (i=0; i<len; ++i)
     
    225226        }
    226227
    227         if (benc_loaded && tr_bencIsDict (&benc))
     228        if (variant_loaded && tr_variantIsDict (&benc))
    228229        {
    229230            int64_t i;
    230             size_t rawlen;
    231             tr_benc * tmp;
     231            size_t len;
     232            tr_variant * tmp;
    232233            const char * str;
    233234            const uint8_t * raw;
    234235
    235             if (tr_bencDictFindStr (&benc, "failure reason", &str))
    236                 response->errmsg = tr_strdup (str);
    237 
    238             if (tr_bencDictFindStr (&benc, "warning message", &str))
    239                 response->warning = tr_strdup (str);
    240 
    241             if (tr_bencDictFindInt (&benc, "interval", &i))
     236            if (tr_variantDictFindStr (&benc, "failure reason", &str, &len))
     237                response->errmsg = tr_strndup (str, len);
     238
     239            if (tr_variantDictFindStr (&benc, "warning message", &str, &len))
     240                response->warning = tr_strndup (str, len);
     241
     242            if (tr_variantDictFindInt (&benc, "interval", &i))
    242243                response->interval = i;
    243244
    244             if (tr_bencDictFindInt (&benc, "min interval", &i))
     245            if (tr_variantDictFindInt (&benc, "min interval", &i))
    245246                response->min_interval = i;
    246247
    247             if (tr_bencDictFindStr (&benc, "tracker id", &str))
    248                 response->tracker_id_str = tr_strdup (str);
    249 
    250             if (tr_bencDictFindInt (&benc, "complete", &i))
     248            if (tr_variantDictFindStr (&benc, "tracker id", &str, &len))
     249                response->tracker_id_str = tr_strndup (str, len);
     250
     251            if (tr_variantDictFindInt (&benc, "complete", &i))
    251252                response->seeders = i;
    252253
    253             if (tr_bencDictFindInt (&benc, "incomplete", &i))
     254            if (tr_variantDictFindInt (&benc, "incomplete", &i))
    254255                response->leechers = i;
    255256
    256             if (tr_bencDictFindInt (&benc, "downloaded", &i))
     257            if (tr_variantDictFindInt (&benc, "downloaded", &i))
    257258                response->downloads = i;
    258259
    259             if (tr_bencDictFindRaw (&benc, "peers6", &raw, &rawlen)) {
    260                 dbgmsg (data->log_name, "got a peers6 length of %zu", rawlen);
    261                 response->pex6 = tr_peerMgrCompact6ToPex (raw, rawlen,
     260            if (tr_variantDictFindRaw (&benc, "peers6", &raw, &len)) {
     261                dbgmsg (data->log_name, "got a peers6 length of %zu", len);
     262                response->pex6 = tr_peerMgrCompact6ToPex (raw, len,
    262263                                              NULL, 0, &response->pex6_count);
    263264            }
    264265
    265             if (tr_bencDictFindRaw (&benc, "peers", &raw, &rawlen)) {
    266                 dbgmsg (data->log_name, "got a compact peers length of %zu", rawlen);
    267                 response->pex = tr_peerMgrCompactToPex (raw, rawlen,
     266            if (tr_variantDictFindRaw (&benc, "peers", &raw, &len)) {
     267                dbgmsg (data->log_name, "got a compact peers length of %zu", len);
     268                response->pex = tr_peerMgrCompactToPex (raw, len,
    268269                                               NULL, 0, &response->pex_count);
    269             } else if (tr_bencDictFindList (&benc, "peers", &tmp)) {
     270            } else if (tr_variantDictFindList (&benc, "peers", &tmp)) {
    270271                response->pex = listToPex (tmp, &response->pex_count);
    271272                dbgmsg (data->log_name, "got a peers list with %zu entries",
     
    274275        }
    275276
    276         if (benc_loaded)
    277             tr_bencFree (&benc);
     277        if (variant_loaded)
     278            tr_variantFree (&benc);
    278279    }
    279280
     
    357358    else
    358359    {
    359         tr_benc top;
     360        tr_variant top;
    360361        int64_t intVal;
    361         tr_benc * files;
    362         tr_benc * flags;
     362        tr_variant * files;
     363        tr_variant * flags;
     364        size_t len;
    363365        const char * str;
    364         const int benc_loaded = !tr_bencLoad (msg, msglen, &top, NULL);
     366        const bool variant_loaded = !tr_variantFromBenc (&top, msg, msglen);
    365367
    366368        if (getenv ("TR_CURL_VERBOSE") != NULL)
    367369        {
    368             if (!benc_loaded)
     370            if (!variant_loaded)
    369371                fprintf (stderr, "%s", "Scrape response was not in benc format\n");
    370372            else {
    371373                int i, len;
    372                 char * str = tr_bencToStr (&top, TR_FMT_JSON, &len);
     374                char * str = tr_variantToStr (&top, TR_VARIANT_FMT_JSON, &len);
    373375                fprintf (stderr, "%s", "Scrape response:\n< ");
    374376                for (i=0; i<len; ++i)
     
    379381        }
    380382
    381         if (benc_loaded)
     383        if (variant_loaded)
    382384        {
    383             if (tr_bencDictFindStr (&top, "failure reason", &str))
    384                 response->errmsg = tr_strdup (str);
    385 
    386             if (tr_bencDictFindDict (&top, "flags", &flags))
    387                 if (tr_bencDictFindInt (flags, "min_request_interval", &intVal))
     385            if (tr_variantDictFindStr (&top, "failure reason", &str, &len))
     386                response->errmsg = tr_strndup (str, len);
     387
     388            if (tr_variantDictFindDict (&top, "flags", &flags))
     389                if (tr_variantDictFindInt (flags, "min_request_interval", &intVal))
    388390                    response->min_request_interval = intVal;
    389391
    390             if (tr_bencDictFindDict (&top, "files", &files))
     392            if (tr_variantDictFindDict (&top, "files", &files))
    391393            {
    392394                int i = 0;
     
    395397                {
    396398                    int j;
    397                     tr_benc * val;
     399                    tr_variant * val;
    398400                    const char * key;
    399401
    400402                    /* get the next "file" */
    401                     if (!tr_bencDictChild (files, i++, &key, &val))
     403                    if (!tr_variantDictChild (files, i++, &key, &val))
    402404                        break;
    403405
     
    408410                        if (!memcmp (key, row->info_hash, SHA_DIGEST_LENGTH))
    409411                        {
    410                             if (tr_bencDictFindInt (val, "complete", &intVal))
     412                            if (tr_variantDictFindInt (val, "complete", &intVal))
    411413                                row->seeders = intVal;
    412                             if (tr_bencDictFindInt (val, "incomplete", &intVal))
     414                            if (tr_variantDictFindInt (val, "incomplete", &intVal))
    413415                                row->leechers = intVal;
    414                             if (tr_bencDictFindInt (val, "downloaded", &intVal))
     416                            if (tr_variantDictFindInt (val, "downloaded", &intVal))
    415417                                row->downloads = intVal;
    416                             if (tr_bencDictFindInt (val, "downloaders", &intVal))
     418                            if (tr_variantDictFindInt (val, "downloaders", &intVal))
    417419                                row->downloaders = intVal;
    418420                            break;
     
    422424            }
    423425
    424             tr_bencFree (&top);
     426            tr_variantFree (&top);
    425427        }
    426428    }
  • trunk/libtransmission/bitfield-test.c

    r13635 r13667  
    55#include "utils.h" /* tr_free */
    66
    7 #undef VERBOSE
    87#include "libtransmission-test.h"
    98
  • trunk/libtransmission/blocklist-test.c

    r13625 r13667  
    55#include "utils.h"
    66
    7 #undef VERBOSE
    87#include "libtransmission-test.h"
    98
  • trunk/libtransmission/clients-test.c

    r13625 r13667  
    22#include "clients.h"
    33
    4 #undef VERBOSE
    54#include "libtransmission-test.h"
    6 
    75
    86#define TEST_CLIENT(A, B) \
  • trunk/libtransmission/history-test.c

    r13625 r13667  
    44#include "history.h"
    55
    6 #undef VERBOSE
    76#include "libtransmission-test.h"
    87
  • trunk/libtransmission/json-test.c

    r13625 r13667  
    11#include <string.h> /* strlen () */
    22#include "transmission.h"
    3 #include "bencode.h"
    4 #include "json.h"
    53#include "utils.h" /* tr_free */
    6 
    7 #undef VERBOSE
     4#include "variant.h"
     5
    86#include "libtransmission-test.h"
    97
     
    1210{
    1311    const char * in;
    14     tr_benc top;
     12    tr_variant top;
    1513    const char * str;
    1614    bool f;
     
    2725         "  \"null\": null }";
    2826
    29     err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
     27    err = tr_variantFromJson (&top, in, strlen(in));
    3028    check_int_eq (0, err);
    31     check (tr_bencIsDict (&top));
     29    check (tr_variantIsDict (&top));
    3230    str = NULL;
    33     check (tr_bencDictFindStr (&top, "string", &str));
     31    check (tr_variantDictFindStr (&top, "string", &str, NULL));
    3432    check_streq ("hello world", str);
    35     check (tr_bencDictFindStr (&top, "escaped", &str));
     33    check (tr_variantDictFindStr (&top, "escaped", &str, NULL));
    3634    check_streq ("bell \b formfeed \f linefeed \n carriage return \r tab \t", str);
    3735    i = 0;
    38     check (tr_bencDictFindInt (&top, "int", &i));
     36    check (tr_variantDictFindInt (&top, "int", &i));
    3937    check_int_eq (5, i);
    4038    d = 0;
    41     check (tr_bencDictFindReal (&top, "float", &d));
     39    check (tr_variantDictFindReal (&top, "float", &d));
    4240    check_int_eq (65, ((int)(d*10)));
    4341    f = false;
    44     check (tr_bencDictFindBool (&top, "true", &f));
     42    check (tr_variantDictFindBool (&top, "true", &f));
    4543    check_int_eq (true, f);
    46     check (tr_bencDictFindBool (&top, "false", &f));
     44    check (tr_variantDictFindBool (&top, "false", &f));
    4745    check_int_eq (false, f);
    48     check (tr_bencDictFindStr (&top, "null", &str));
     46    check (tr_variantDictFindStr (&top, "null", &str, NULL));
    4947    check_streq ("", str);
    5048
    5149    if (!err)
    52         tr_bencFree (&top);
     50        tr_variantFree (&top);
    5351
    5452    return 0;
     
    5856{
    5957    const char      * in = "{ \"key\": \"Letöltések\" }";
    60     tr_benc           top;
     58    tr_variant           top;
    6159    const char      * str;
    6260    char            * json;
    6361    int               err;
    6462
    65     err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
    66     check (!err);
    67     check (tr_bencIsDict (&top));
    68     check (tr_bencDictFindStr (&top, "key", &str));
     63    err = tr_variantFromJson (&top, in, strlen(in));
     64    check (!err);
     65    check (tr_variantIsDict (&top));
     66    check (tr_variantDictFindStr (&top, "key", &str, NULL));
    6967    check_streq ("Letöltések", str);
    7068    if (!err)
    71         tr_bencFree (&top);
     69        tr_variantFree (&top);
    7270
    7371    in = "{ \"key\": \"\\u005C\" }";
    74     err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
    75     check (!err);
    76     check (tr_bencIsDict (&top));
    77     check (tr_bencDictFindStr (&top, "key", &str));
     72    err = tr_variantFromJson (&top, in, strlen(in));
     73    check (!err);
     74    check (tr_variantIsDict (&top));
     75    check (tr_variantDictFindStr (&top, "key", &str, NULL));
    7876    check_streq ("\\", str);
    7977    if (!err)
    80         tr_bencFree (&top);
     78        tr_variantFree (&top);
    8179
    8280    /**
     
    8987     */
    9088    in = "{ \"key\": \"Let\\u00f6lt\\u00e9sek\" }";
    91     err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
    92     check (!err);
    93     check (tr_bencIsDict (&top));
    94     check (tr_bencDictFindStr (&top, "key", &str));
     89    err = tr_variantFromJson (&top, in, strlen(in));
     90    check (!err);
     91    check (tr_variantIsDict (&top));
     92    check (tr_variantDictFindStr (&top, "key", &str, NULL));
    9593    check_streq ("Letöltések", str);
    96     json = tr_bencToStr (&top, TR_FMT_JSON, NULL);
    97     if (!err)
    98         tr_bencFree (&top);
     94    json = tr_variantToStr (&top, TR_VARIANT_FMT_JSON, NULL);
     95    if (!err)
     96        tr_variantFree (&top);
    9997    check (json);
    10098    check (strstr (json, "\\u00f6") != NULL);
    10199    check (strstr (json, "\\u00e9") != NULL);
    102     err = tr_jsonParse (NULL, json, strlen (json), &top, NULL);
    103     check (!err);
    104     check (tr_bencIsDict (&top));
    105     check (tr_bencDictFindStr (&top, "key", &str));
     100    err = tr_variantFromJson (&top, json, strlen(json));
     101    check (!err);
     102    check (tr_variantIsDict (&top));
     103    check (tr_variantDictFindStr (&top, "key", &str, NULL));
    106104    check_streq ("Letöltések", str);
    107105    if (!err)
    108         tr_bencFree (&top);
     106        tr_variantFree (&top);
    109107    tr_free (json);
    110108
     
    128126        "    }\n"
    129127        "}\n";
    130     tr_benc      top, *headers, *body, *args, *ids;
     128    tr_variant      top, *headers, *body, *args, *ids;
    131129    const char * str;
    132130    int64_t      i;
    133     const int    err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
    134 
    135     check (!err);
    136     check (tr_bencIsDict (&top));
    137     check ((headers = tr_bencDictFind (&top, "headers")));
    138     check (tr_bencIsDict (headers));
    139     check (tr_bencDictFindStr (headers, "type", &str));
     131    const int    err = tr_variantFromJson (&top, in, strlen(in));
     132
     133    check (!err);
     134    check (tr_variantIsDict (&top));
     135    check ((headers = tr_variantDictFind (&top, "headers")));
     136    check (tr_variantIsDict (headers));
     137    check (tr_variantDictFindStr (headers, "type", &str, NULL));
    140138    check_streq ("request", str);
    141     check (tr_bencDictFindInt (headers, "tag", &i));
     139    check (tr_variantDictFindInt (headers, "tag", &i));
    142140    check_int_eq (666, i);
    143     check ((body = tr_bencDictFind (&top, "body")));
    144     check (tr_bencDictFindStr (body, "name", &str));
     141    check ((body = tr_variantDictFind (&top, "body")));
     142    check (tr_variantDictFindStr (body, "name", &str, NULL));
    145143    check_streq ("torrent-info", str);
    146     check ((args = tr_bencDictFind (body, "arguments")));
    147     check (tr_bencIsDict (args));
    148     check ((ids = tr_bencDictFind (args, "ids")));
    149     check (tr_bencIsList (ids));
    150     check_int_eq (2, tr_bencListSize (ids));
    151     check (tr_bencGetInt (tr_bencListChild (ids, 0), &i));
     144    check ((args = tr_variantDictFind (body, "arguments")));
     145    check (tr_variantIsDict (args));
     146    check ((ids = tr_variantDictFind (args, "ids")));
     147    check (tr_variantIsList (ids));
     148    check_int_eq (2, tr_variantListSize (ids));
     149    check (tr_variantGetInt (tr_variantListChild (ids, 0), &i));
    152150    check_int_eq (7, i);
    153     check (tr_bencGetInt (tr_bencListChild (ids, 1), &i));
     151    check (tr_variantGetInt (tr_variantListChild (ids, 1), &i));
    154152    check_int_eq (10, i);
    155153
    156     tr_bencFree (&top);
     154    tr_variantFree (&top);
    157155    return 0;
    158156}
     
    161159test2 (void)
    162160{
    163     tr_benc top;
     161    tr_variant top;
    164162    const char * in = " ";
    165163    int err;
    166164
    167165    top.type = 0;
    168     err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
     166    err = tr_variantFromJson (&top, in, strlen(in));
    169167
    170168    check (err);
    171     check (!tr_bencIsDict (&top));
     169    check (!tr_variantIsDict (&top));
    172170
    173171    return 0;
     
    182180                      "  \"id\": 25,"
    183181                      "  \"leftUntilDone\": 2275655680 }";
    184     tr_benc top;
    185     const char * str;
    186 
    187     const int err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
    188     check (!err);
    189     check (tr_bencDictFindStr (&top, "errorString", &str));
     182    tr_variant top;
     183    const char * str;
     184
     185    const int err = tr_variantFromJson (&top, in, strlen(in));
     186    check (!err);
     187    check (tr_variantDictFindStr (&top, "errorString", &str, NULL));
    190188    check_streq ("torrent not registered with this tracker 6UHsVW'*C", str);
    191189
    192     tr_bencFree (&top);
     190    tr_variantFree (&top);
    193191    return 0;
    194192}
     
    198196{
    199197    const char * in = "{ \"string-1\": \"\\/usr\\/lib\" }";
    200     tr_benc top;
    201     const char * str;
    202 
    203     const int err = tr_jsonParse (NULL, in, strlen (in), &top, NULL);
     198    tr_variant top;
     199    const char * str;
     200
     201    const int err = tr_variantFromJson (&top, in, strlen(in));
    204202    check_int_eq (0, err);
    205     check (tr_bencDictFindStr (&top, "string-1", &str));
     203    check (tr_variantDictFindStr (&top, "string-1", &str, NULL));
    206204    check_streq ("/usr/lib", str);
    207205
    208     tr_bencFree (&top);
     206    tr_variantFree (&top);
    209207    return 0;
    210208}
  • trunk/libtransmission/libtransmission-test.h

    r13655 r13667  
    88#include "utils.h" /* tr_strcmp0 () */
    99
    10 static int current_test = 0;
     10extern int current_test;
    1111
    12 #define REPORT_TEST(test, result) \
    13     fprintf (stderr, "%s %s:%d\n", result, __FILE__, __LINE__)
     12extern bool verbose;
    1413
    15 static bool
    16 should_print (bool pass)
    17 {
    18   if (!pass)
    19     return true;
     14bool should_print (bool pass);
    2015
    21 #ifdef VERBOSE
    22   return true;
    23 #else
    24   return false;
    25 #endif
    26 }
    27 
    28 static bool
    29 check_condition_impl (const char * file, int line, bool condition)
    30 {
    31   const bool pass = condition;
    32 
    33   if (should_print (pass))
    34     fprintf (stderr, "%s %s:%d\n", pass?"PASS":"FAIL", file, line);
    35 
    36   return pass;
    37 }
    38 
    39 static bool
    40 check_streq_impl (const char * file, int line, const char * expected, const char * actual)
    41 {
    42   const bool pass = !tr_strcmp0 (expected, actual);
    43 
    44   if (should_print (pass)) {
    45     if (pass)
    46       fprintf (stderr, "PASS %s:%d\n", file, line);
    47     else
    48       fprintf (stderr, "FAIL %s:%d, expected \"%s\", got \"%s\"\n", file, line, expected?expected:" (null)", actual?actual:" (null)");
    49   }
    50 
    51   return pass;
    52 }
    53 
    54 static bool
    55 check_int_eq_impl (const char * file, int line, int64_t expected, int64_t actual)
    56 {
    57   const bool pass = expected == actual;
    58 
    59   if (should_print (pass)) {
    60     if (pass)
    61       fprintf (stderr, "PASS %s:%d\n", file, line);
    62     else
    63       fprintf (stderr, "FAIL %s:%d, expected \"%"PRId64"\", got \"%"PRId64"\"\n", file, line, expected, actual);
    64   }
    65 
    66   return pass;
    67 }
    68 
    69 static bool
    70 check_ptr_eq_impl (const char * file, int line, const void * expected, const void * actual)
    71 {
    72   const bool pass = expected == actual;
    73 
    74   if (should_print (pass)) {
    75     if (pass)
    76       fprintf (stderr, "PASS %s:%d\n", file, line);
    77     else
    78       fprintf (stderr, "FAIL %s:%d, expected \"%p\", got \"%p\"\n", file, line, expected, actual);
    79   }
    80 
    81   return pass;
    82 }
     16bool check_condition_impl (const char * file, int line, bool condition);
     17bool check_int_eq_impl (const char * file, int line, int64_t expected, int64_t actual);
     18bool check_ptr_eq_impl (const char * file, int line, const void * expected, const void * actual);
     19bool check_streq_impl (const char * file, int line, const char * expected, const char * actual);
    8320
    8421/***
     
    12158#define NUM_TESTS(tarray)((int)(sizeof (tarray)/sizeof (tarray[0])))
    12259
    123 static int
    124 runTests (const testFunc * const tests, int numTests)
    125 {
    126     int ret, i;
    127 
    128   (void) current_test; /* Use test even if we don't have any tests to run */
    129 
    130     for (i = 0; i < numTests; i++)
    131         if ((ret = (*tests[i])()))
    132             return ret;
    133 
    134     return 0;   /* All tests passed */
    135 }
     60int runTests (const testFunc * const tests, int numTests);
    13661
    13762#define MAIN_SINGLE_TEST(test) \
  • trunk/libtransmission/magnet-test.c

    r13625 r13667  
    33#include "utils.h"
    44
    5 #undef VERBOSE
    65#include "libtransmission-test.h"
    76
  • trunk/libtransmission/magnet.c

    r13625 r13667  
    1616
    1717#include "transmission.h"
    18 #include "bencode.h"
    1918#include "magnet.h"
    2019#include "utils.h"
     20#include "variant.h"
    2121#include "web.h"
    2222
     
    212212
    213213void
    214 tr_magnetCreateMetainfo (const tr_magnet_info * info, tr_benc * top)
     214tr_magnetCreateMetainfo (const tr_magnet_info * info, tr_variant * top)
    215215{
    216216  int i;
    217   tr_benc * d;
    218   tr_bencInitDict (top, 4);
     217  tr_variant * d;
     218  tr_variantInitDict (top, 4);
    219219
    220220  /* announce list */
    221221  if (info->trackerCount == 1)
    222222    {
    223       tr_bencDictAddStr (top, "announce", info->trackers[0]);
     223      tr_variantDictAddStr (top, "announce", info->trackers[0]);
    224224    }
    225225  else
    226226    {
    227       tr_benc * trackers = tr_bencDictAddList (top, "announce-list", info->trackerCount);
     227      tr_variant * trackers = tr_variantDictAddList (top, "announce-list", info->trackerCount);
    228228      for (i=0; i<info->trackerCount; ++i)
    229         tr_bencListAddStr (tr_bencListAddList (trackers, 1), info->trackers[i]);
     229        tr_variantListAddStr (tr_variantListAddList (trackers, 1), info->trackers[i]);
    230230    }
    231231
     
    233233  if (info->webseedCount > 0)
    234234    {
    235       tr_benc * urls = tr_bencDictAddList (top, "url-list", info->webseedCount);
     235      tr_variant * urls = tr_variantDictAddList (top, "url-list", info->webseedCount);
    236236      for (i=0; i<info->webseedCount; ++i)
    237         tr_bencListAddStr (urls, info->webseeds[i]);
     237        tr_variantListAddStr (urls, info->webseeds[i]);
    238238    }
    239239
    240240  /* nonstandard keys */
    241   d = tr_bencDictAddDict (top, "magnet-info", 2);
    242   tr_bencDictAddRaw (d, "info_hash", info->hash, 20);
     241  d = tr_variantDictAddDict (top, "magnet-info", 2);
     242  tr_variantDictAddRaw (d, "info_hash", info->hash, 20);
    243243  if (info->displayName != NULL)
    244     tr_bencDictAddStr (d, "display-name", info->displayName);
    245 }
    246 
    247 
     244    tr_variantDictAddStr (d, "display-name", info->displayName);
     245}
     246
     247
  • trunk/libtransmission/magnet.h

    r13625 r13667  
    1919
    2020#include "transmission.h"
     21#include "variant.h"
    2122
    2223typedef struct tr_magnet_info
     
    3637tr_magnet_info * tr_magnetParse (const char * uri);
    3738
    38 struct tr_benc;
     39struct tr_variant;
    3940
    40 void tr_magnetCreateMetainfo (const tr_magnet_info *, struct tr_benc *);
     41void tr_magnetCreateMetainfo (const tr_magnet_info *, tr_variant *);
    4142
    4243void tr_magnetFree (tr_magnet_info * info);
  • trunk/libtransmission/makemeta.c

    r13631 r13667  
    2828#include "fdlimit.h" /* tr_open_file_for_scanning () */
    2929#include "session.h"
    30 #include "bencode.h"
    3130#include "makemeta.h"
    3231#include "platform.h" /* threads, locks */
    3332#include "utils.h" /* buildpath */
     33#include "variant.h"
    3434#include "version.h"
    3535
     
    291291getFileInfo (const char *                     topFile,
    292292             const tr_metainfo_builder_file * file,
    293              tr_benc *                        uninitialized_length,
    294              tr_benc *                        uninitialized_path)
     293             tr_variant *                        uninitialized_length,
     294             tr_variant *                        uninitialized_path)
    295295{
    296296    size_t offset;
    297297
    298298    /* get the file size */
    299     tr_bencInitInt (uninitialized_length, file->size);
     299    tr_variantInitInt (uninitialized_length, file->size);
    300300
    301301    /* how much of file->filename to walk past */
     
    305305
    306306    /* build the path list */
    307     tr_bencInitList (uninitialized_path, 0);
     307    tr_variantInitList (uninitialized_path, 0);
    308308    if (strlen (file->filename) > offset) {
    309309        char * filename = tr_strdup (file->filename + offset);
     
    311311        const char * token;
    312312        while ((token = tr_strsep (&walk, TR_PATH_DELIMITER_STR)))
    313             tr_bencListAddStr (uninitialized_path, token);
     313            tr_variantListAddStr (uninitialized_path, token);
    314314        tr_free (filename);
    315315    }
     
    317317
    318318static void
    319 makeInfoDict (tr_benc *             dict,
     319makeInfoDict (tr_variant *             dict,
    320320              tr_metainfo_builder * builder)
    321321{
     
    323323    char    * base;
    324324
    325     tr_bencDictReserve (dict, 5);
     325    tr_variantDictReserve (dict, 5);
    326326
    327327    if (builder->isSingleFile)
    328328    {
    329         tr_bencDictAddInt (dict, "length", builder->files[0].size);
     329        tr_variantDictAddInt (dict, "length", builder->files[0].size);
    330330    }
    331331    else /* root node is a directory */
    332332    {
    333333        uint32_t  i;
    334         tr_benc * list = tr_bencDictAddList (dict, "files",
     334        tr_variant * list = tr_variantDictAddList (dict, "files",
    335335                                             builder->fileCount);
    336336        for (i = 0; i < builder->fileCount; ++i)
    337337        {
    338             tr_benc * d = tr_bencListAddDict (list, 2);
    339             tr_benc * length = tr_bencDictAdd (d, "length");
    340             tr_benc * pathVal = tr_bencDictAdd (d, "path");
     338            tr_variant * d = tr_variantListAddDict (list, 2);
     339            tr_variant * length = tr_variantDictAdd (d, "length");
     340            tr_variant * pathVal = tr_variantDictAdd (d, "path");
    341341            getFileInfo (builder->top, &builder->files[i], length, pathVal);
    342342        }
     
    344344
    345345    base = tr_basename (builder->top);
    346     tr_bencDictAddStr (dict, "name", base);
     346    tr_variantDictAddStr (dict, "name", base);
    347347    tr_free (base);
    348348
    349     tr_bencDictAddInt (dict, "piece length", builder->pieceSize);
     349    tr_variantDictAddInt (dict, "piece length", builder->pieceSize);
    350350
    351351    if ((pch = getHashInfo (builder)))
    352352    {
    353         tr_bencDictAddRaw (dict, "pieces", pch,
     353        tr_variantDictAddRaw (dict, "pieces", pch,
    354354                           SHA_DIGEST_LENGTH * builder->pieceCount);
    355355        tr_free (pch);
    356356    }
    357357
    358     tr_bencDictAddInt (dict, "private", builder->isPrivate ? 1 : 0);
     358    tr_variantDictAddInt (dict, "private", builder->isPrivate ? 1 : 0);
    359359}
    360360
     
    363363{
    364364    int     i;
    365     tr_benc top;
     365    tr_variant top;
    366366
    367367    /* allow an empty set, but if URLs *are* listed, verify them. #814, #971 */
     
    374374    }
    375375
    376     tr_bencInitDict (&top, 6);
     376    tr_variantInitDict (&top, 6);
    377377
    378378    if (!builder->fileCount || !builder->totalSize ||
     
    388388    {
    389389        int       prevTier = -1;
    390         tr_benc * tier = NULL;
     390        tr_variant * tier = NULL;
    391391
    392392        if (builder->trackerCount > 1)
    393393        {
    394             tr_benc * annList = tr_bencDictAddList (&top, "announce-list",
     394            tr_variant * annList = tr_variantDictAddList (&top, "announce-list",
    395395                                                    0);
    396396            for (i = 0; i < builder->trackerCount; ++i)
     
    399399                {
    400400                    prevTier = builder->trackers[i].tier;
    401                     tier = tr_bencListAddList (annList, 0);
     401                    tier = tr_variantListAddList (annList, 0);
    402402                }
    403                 tr_bencListAddStr (tier, builder->trackers[i].announce);
     403                tr_variantListAddStr (tier, builder->trackers[i].announce);
    404404            }
    405405        }
    406406
    407         tr_bencDictAddStr (&top, "announce", builder->trackers[0].announce);
     407        tr_variantDictAddStr (&top, "announce", builder->trackers[0].announce);
    408408    }
    409409
     
    411411    {
    412412        if (builder->comment && *builder->comment)
    413             tr_bencDictAddStr (&top, "comment", builder->comment);
    414         tr_bencDictAddStr (&top, "created by",
     413            tr_variantDictAddStr (&top, "comment", builder->comment);
     414        tr_variantDictAddStr (&top, "created by",
    415415                           TR_NAME "/" LONG_VERSION_STRING);
    416         tr_bencDictAddInt (&top, "creation date", time (NULL));
    417         tr_bencDictAddStr (&top, "encoding", "UTF-8");
    418         makeInfoDict (tr_bencDictAddDict (&top, "info", 666), builder);
     416        tr_variantDictAddInt (&top, "creation date", time (NULL));
     417        tr_variantDictAddStr (&top, "encoding", "UTF-8");
     418        makeInfoDict (tr_variantDictAddDict (&top, "info", 666), builder);
    419419    }
    420420
     
    422422    if (!builder->result && !builder->abortFlag)
    423423    {
    424         if (tr_bencToFile (&top, TR_FMT_BENC, builder->outputFile))
     424        if (tr_variantToFile (&top, TR_VARIANT_FMT_BENC, builder->outputFile))
    425425        {
    426426            builder->my_errno = errno;
     
    432432
    433433    /* cleanup */
    434     tr_bencFree (&top);
     434    tr_variantFree (&top);
    435435    if (builder->abortFlag)
    436436        builder->result = TR_MAKEMETA_CANCELLED;
  • trunk/libtransmission/metainfo-test.c

    r13625 r13667  
    11#include "transmission.h"
    22
    3 #undef VERBOSE
    43#include "libtransmission-test.h"
    54
  • trunk/libtransmission/metainfo.c

    r13641 r13667  
    2323#include "transmission.h"
    2424#include "session.h"
    25 #include "bencode.h"
    2625#include "crypto.h" /* tr_sha1 */
    2726#include "metainfo.h"
    2827#include "platform.h" /* tr_getTorrentDir () */
    2928#include "utils.h"
     29#include "variant.h"
    3030
    3131/***
     
    6969
    7070static bool
    71 getfile (char ** setme, const char * root, tr_benc * path, struct evbuffer * buf)
     71getfile (char ** setme, const char * root, tr_variant * path, struct evbuffer * buf)
    7272{
    7373  bool success = false;
    7474
    75   if (tr_bencIsList (path))
     75  if (tr_variantIsList (path))
    7676    {
    7777      int i;
    78       const int n = tr_bencListSize (path);
     78      const int n = tr_variantListSize (path);
    7979
    8080      evbuffer_drain (buf, evbuffer_get_length (buf));
     
    8282      for (i=0; i<n; i++)
    8383        {
     84          size_t len;
    8485          const char * str;
    8586
    86           if (tr_bencGetStr (tr_bencListChild (path, i), &str))
     87          if (tr_variantGetStr (tr_variantListChild (path, i), &str, &len))
    8788            {
    8889              evbuffer_add (buf, TR_PATH_DELIMITER_STR, 1);
    89               evbuffer_add (buf, str, strlen (str));
     90              evbuffer_add (buf, str, len);
    9091            }
    9192        }
     
    107108
    108109static const char*
    109 parseFiles (tr_info * inf, tr_benc * files, const tr_benc * length)
     110parseFiles (tr_info * inf, tr_variant * files, const tr_variant * length)
    110111{
    111112  int64_t len;
     
    113114  inf->totalSize = 0;
    114115
    115   if (tr_bencIsList (files)) /* multi-file mode */
     116  if (tr_variantIsList (files)) /* multi-file mode */
    116117    {
    117118      tr_file_index_t i;
     
    119120
    120121      inf->isMultifile = 1;
    121       inf->fileCount = tr_bencListSize (files);
     122      inf->fileCount = tr_variantListSize (files);
    122123      inf->files = tr_new0 (tr_file, inf->fileCount);
    123124
    124125      for (i=0; i<inf->fileCount; i++)
    125126        {
    126           tr_benc * file;
    127           tr_benc * path;
    128 
    129           file = tr_bencListChild (files, i);
    130           if (!tr_bencIsDict (file))
     127          tr_variant * file;
     128          tr_variant * path;
     129
     130          file = tr_variantListChild (files, i);
     131          if (!tr_variantIsDict (file))
    131132            return "files";
    132133
    133           if (!tr_bencDictFindList (file, "path.utf-8", &path))
    134             if (!tr_bencDictFindList (file, "path", &path))
     134          if (!tr_variantDictFindList (file, "path.utf-8", &path))
     135            if (!tr_variantDictFindList (file, "path", &path))
    135136              return "path";
    136137
     
    138139            return "path";
    139140
    140           if (!tr_bencDictFindInt (file, "length", &len))
     141          if (!tr_variantDictFindInt (file, "length", &len))
    141142            return "length";
    142143
     
    147148      evbuffer_free (buf);
    148149    }
    149   else if (tr_bencGetInt (length, &len)) /* single-file mode */
     150  else if (tr_variantGetInt (length, &len)) /* single-file mode */
    150151    {
    151152      if (path_is_suspicious (inf->name))
     
    203204
    204205static const char*
    205 getannounce (tr_info * inf, tr_benc * meta)
    206 {
     206getannounce (tr_info * inf, tr_variant * meta)
     207{
     208  size_t len;
    207209  const char * str;
    208210  tr_tracker_info * trackers = NULL;
    209211  int trackerCount = 0;
    210   tr_benc * tiers;
     212  tr_variant * tiers;
    211213
    212214  /* Announce-list */
    213   if (tr_bencDictFindList (meta, "announce-list", &tiers))
     215  if (tr_variantDictFindList (meta, "announce-list", &tiers))
    214216    {
    215217      int n;
    216218      int i, j, validTiers;
    217       const int numTiers = tr_bencListSize (tiers);
     219      const int numTiers = tr_variantListSize (tiers);
    218220
    219221      n = 0;
    220222      for (i=0; i<numTiers; i++)
    221         n += tr_bencListSize (tr_bencListChild (tiers, i));
     223        n += tr_variantListSize (tr_variantListChild (tiers, i));
    222224
    223225      trackers = tr_new0 (tr_tracker_info, n);
     
    225227      for (i=0, validTiers=0; i<numTiers; i++)
    226228        {
    227           tr_benc * tier = tr_bencListChild (tiers, i);
    228           const int tierSize = tr_bencListSize (tier);
     229          tr_variant * tier = tr_variantListChild (tiers, i);
     230          const int tierSize = tr_variantListSize (tier);
    229231          bool anyAdded = false;
    230232          for (j=0; j<tierSize; j++)
    231233            {
    232               if (tr_bencGetStr (tr_bencListChild (tier, j), &str))
     234              if (tr_variantGetStr (tr_variantListChild (tier, j), &str, &len))
    233235                {
    234                   char * url = tr_strstrip (tr_strdup (str));
     236                  char * url = tr_strstrip (tr_strndup (str, len));
    235237                  if (!tr_urlIsValidTracker (url))
    236238                    {
     
    264266
    265267  /* Regular announce value */
    266   if (!trackerCount && tr_bencDictFindStr (meta, "announce", &str))
    267     {
    268       char * url = tr_strstrip (tr_strdup (str));
     268  if (!trackerCount && tr_variantDictFindStr (meta, "announce", &str, &len))
     269    {
     270      char * url = tr_strstrip (tr_strndup (str, len));
    269271      if (!tr_urlIsValidTracker (url))
    270272        {
     
    324326
    325327static void
    326 geturllist (tr_info * inf, tr_benc * meta)
    327 {
    328   tr_benc * urls;
     328geturllist (tr_info * inf, tr_variant * meta)
     329{
     330  tr_variant * urls;
    329331  const char * url;
    330332
    331   if (tr_bencDictFindList (meta, "url-list", &urls))
     333  if (tr_variantDictFindList (meta, "url-list", &urls))
    332334    {
    333335      int i;
    334       const int n = tr_bencListSize (urls);
     336      const int n = tr_variantListSize (urls);
    335337
    336338      inf->webseedCount = 0;
     
    339341      for (i=0; i<n; i++)
    340342        {
    341           if (tr_bencGetStr (tr_bencListChild (urls, i), &url))
     343          if (tr_variantGetStr (tr_variantListChild (urls, i), &url, NULL))
    342344            {
    343345              char * fixed_url = fix_webseed_url (inf, url);
     
    348350        }
    349351    }
    350   else if (tr_bencDictFindStr (meta, "url-list", &url)) /* handle single items in webseeds */
     352  else if (tr_variantDictFindStr (meta, "url-list", &url, NULL)) /* handle single items in webseeds */
    351353    {
    352354      char * fixed_url = fix_webseed_url (inf, url);
     
    366368                      bool              * hasInfoDict,
    367369                      int               * infoDictLength,
    368                       const tr_benc     * meta_in)
     370                      const tr_variant     * meta_in)
    369371{
    370372  int64_t i;
    371   size_t raw_len;
     373  size_t len;
    372374  const char * str;
    373375  const uint8_t * raw;
    374   tr_benc * d;
    375   tr_benc * infoDict = NULL;
    376   tr_benc * meta = (tr_benc *) meta_in;
     376  tr_variant * d;
     377  tr_variant * infoDict = NULL;
     378  tr_variant * meta = (tr_variant *) meta_in;
    377379  bool b;
    378380  bool isMagnet = false;
     
    381383   * from the Metainfo file. Note that the value will be a bencoded
    382384   * dictionary, given the definition of the info key above. */
    383   b = tr_bencDictFindDict (meta, "info", &infoDict);
     385  b = tr_variantDictFindDict (meta, "info", &infoDict);
    384386  if (hasInfoDict != NULL)
    385387    *hasInfoDict = b;
     
    388390    {
    389391      /* no info dictionary... is this a magnet link? */
    390       if (tr_bencDictFindDict (meta, "magnet-info", &d))
     392      if (tr_variantDictFindDict (meta, "magnet-info", &d))
    391393        {
    392394          isMagnet = true;
    393395
    394396          /* get the info-hash */
    395           if (!tr_bencDictFindRaw (d, "info_hash", &raw, &raw_len))
     397          if (!tr_variantDictFindRaw (d, "info_hash", &raw, &len))
    396398            return "info_hash";
    397           if (raw_len != SHA_DIGEST_LENGTH)
     399          if (len != SHA_DIGEST_LENGTH)
    398400            return "info_hash";
    399           memcpy (inf->hash, raw, raw_len);
     401          memcpy (inf->hash, raw, len);
    400402          tr_sha1_to_hex (inf->hashString, inf->hash);
    401403
    402404          /* maybe get the display name */
    403           if (tr_bencDictFindStr (d, "display-name", &str))
     405          if (tr_variantDictFindStr (d, "display-name", &str, &len))
    404406            {
    405407              tr_free (inf->name);
    406               inf->name = tr_strdup (str);
     408              inf->name = tr_strndup (str, len);
    407409            }
    408410
     
    418420    {
    419421      int len;
    420       char * bstr = tr_bencToStr (infoDict, TR_FMT_BENC, &len);
     422      char * bstr = tr_variantToStr (infoDict, TR_VARIANT_FMT_BENC, &len);
    421423      tr_sha1 (inf->hash, bstr, len, NULL);
    422424      tr_sha1_to_hex (inf->hashString, inf->hash);
     
    431433  if (!isMagnet)
    432434    {
    433       if (!tr_bencDictFindStr (infoDict, "name.utf-8", &str))
    434         if (!tr_bencDictFindStr (infoDict, "name", &str))
     435      len = 0;
     436      if (!tr_variantDictFindStr (infoDict, "name.utf-8", &str, &len))
     437        if (!tr_variantDictFindStr (infoDict, "name", &str, &len))
    435438          str = "";
    436439      if (!str || !*str)
    437440        return "name";
    438441      tr_free (inf->name);
    439       inf->name = tr_utf8clean (str, -1);
     442      inf->name = tr_utf8clean (str, len);
    440443    }
    441444
    442445  /* comment */
    443   if (!tr_bencDictFindStr (meta, "comment.utf-8", &str))
    444     if (!tr_bencDictFindStr (meta, "comment", &str))
     446  len = 0;
     447  if (!tr_variantDictFindStr (meta, "comment.utf-8", &str, &len))
     448    if (!tr_variantDictFindStr (meta, "comment", &str, &len))
    445449      str = "";
    446450  tr_free (inf->comment);
    447   inf->comment = tr_utf8clean (str, -1);
     451  inf->comment = tr_utf8clean (str, len);
    448452
    449453  /* created by */
    450   if (!tr_bencDictFindStr (meta, "created by.utf-8", &str))
    451     if (!tr_bencDictFindStr (meta, "created by", &str))
     454  len = 0;
     455  if (!tr_variantDictFindStr (meta, "created by.utf-8", &str, &len))
     456    if (!tr_variantDictFindStr (meta, "created by", &str, &len))
    452457      str = "";
    453458  tr_free (inf->creator);
    454   inf->creator = tr_utf8clean (str, -1);
     459  inf->creator = tr_utf8clean (str, len);
    455460
    456461  /* creation date */
    457   if (!tr_bencDictFindInt (meta, "creation date", &i))
     462  if (!tr_variantDictFindInt (meta, "creation date", &i))
    458463    i = 0;
    459464  inf->dateCreated = i;
    460465
    461466  /* private */
    462   if (!tr_bencDictFindInt (infoDict, "private", &i))
    463     if (!tr_bencDictFindInt (meta, "private", &i))
     467  if (!tr_variantDictFindInt (infoDict, "private", &i))
     468    if (!tr_variantDictFindInt (meta, "private", &i))
    464469      i = 0;
    465470  inf->isPrivate = i != 0;
     
    468473  if (!isMagnet)
    469474    {
    470       if (!tr_bencDictFindInt (infoDict, "piece length", &i) || (i < 1))
     475      if (!tr_variantDictFindInt (infoDict, "piece length", &i) || (i < 1))
    471476        return "piece length";
    472477      inf->pieceSize = i;
     
    476481  if (!isMagnet)
    477482    {
    478       if (!tr_bencDictFindRaw (infoDict, "pieces", &raw, &raw_len))
     483      if (!tr_variantDictFindRaw (infoDict, "pieces", &raw, &len))
    479484        return "pieces";
    480       if (raw_len % SHA_DIGEST_LENGTH)
     485      if (len % SHA_DIGEST_LENGTH)
    481486        return "pieces";
    482487
    483       inf->pieceCount = raw_len / SHA_DIGEST_LENGTH;
     488      inf->pieceCount = len / SHA_DIGEST_LENGTH;
    484489      inf->pieces = tr_new0 (tr_piece, inf->pieceCount);
    485490      for (i=0; i<inf->pieceCount; i++)
     
    490495  if (!isMagnet)
    491496    {
    492       if ((str = parseFiles (inf, tr_bencDictFind (infoDict, "files"),
    493                                   tr_bencDictFind (infoDict, "length"))))
     497      if ((str = parseFiles (inf, tr_variantDictFind (infoDict, "files"),
     498                                  tr_variantDictFind (infoDict, "length"))))
    494499        return str;
    495500
     
    517522bool
    518523tr_metainfoParse (const tr_session * session,
    519                   const tr_benc    * meta_in,
     524                  const tr_variant * meta_in,
    520525                  tr_info          * inf,
    521526                  bool             * hasInfoDict,
  • trunk/libtransmission/metainfo.h

    r13632 r13667  
    1919
    2020#include "transmission.h"
     21#include "variant.h"
    2122
    22 struct tr_benc;
    23 
    24 bool  tr_metainfoParse (const tr_session     * session,
    25                         const struct tr_benc * benc,
    26                         tr_info              * setmeInfo,
    27                         bool                 * setmeHasInfoDict,
    28                         int                  * setmeInfoDictLength);
     23bool  tr_metainfoParse (const tr_session  * session,
     24                        const tr_variant  * variant,
     25                        tr_info           * setmeInfo,
     26                        bool              * setmeHasInfoDict,
     27                        int               * setmeInfoDictLength);
    2928
    3029void tr_metainfoRemoveSaved (const tr_session * session,
  • trunk/libtransmission/peer-io.c

    r13625 r13667  
    507507
    508508static void
    509 utp_on_overhead (void *closure, bool send, size_t count, int type UNUSED)
     509utp_on_overhead (void *closure, uint8_t send, size_t count, int type UNUSED)
    510510{
    511511    tr_peerIo *io = closure;
     
    568568
    569569static void
    570 dummy_on_overhead (void *closure UNUSED, bool send UNUSED, size_t count UNUSED, int type UNUSED)
     570dummy_on_overhead (void *closure UNUSED, uint8_t send UNUSED, size_t count UNUSED, int type UNUSED)
    571571{
    572572    return;
  • trunk/libtransmission/peer-msgs-test.c

    r13625 r13667  
    44#include "utils.h"
    55
    6 #undef VERBOSE
    76#include "libtransmission-test.h"
    87
  • trunk/libtransmission/peer-msgs.c

    r13651 r13667  
    2222
    2323#include "transmission.h"
    24 #include "bencode.h"
    2524#include "cache.h"
    2625#include "completion.h"
     
    3433#include "tr-dht.h"
    3534#include "utils.h"
     35#include "variant.h"
    3636#include "version.h"
    3737
     
    791791sendLtepHandshake (tr_peermsgs * msgs)
    792792{
    793     tr_benc val;
     793    tr_variant val;
    794794    bool allow_pex;
    795795    bool allow_metadata_xfer;
     
    818818        allow_pex = 1;
    819819
    820     tr_bencInitDict (&val, 8);
    821     tr_bencDictAddInt (&val, "e", getSession (msgs)->encryptionMode != TR_CLEAR_PREFERRED);
     820    tr_variantInitDict (&val, 8);
     821    tr_variantDictAddInt (&val, "e", getSession (msgs)->encryptionMode != TR_CLEAR_PREFERRED);
    822822    if (ipv6 != NULL)
    823         tr_bencDictAddRaw (&val, "ipv6", ipv6, 16);
     823        tr_variantDictAddRaw (&val, "ipv6", ipv6, 16);
    824824    if (allow_metadata_xfer && tr_torrentHasMetadata (msgs->torrent)
    825825                            && (msgs->torrent->infoDictLength > 0))
    826         tr_bencDictAddInt (&val, "metadata_size", msgs->torrent->infoDictLength);
    827     tr_bencDictAddInt (&val, "p", tr_sessionGetPublicPeerPort (getSession (msgs)));
    828     tr_bencDictAddInt (&val, "reqq", REQQ);
    829     tr_bencDictAddInt (&val, "upload_only", tr_torrentIsSeed (msgs->torrent));
    830     tr_bencDictAddStr (&val, "v", TR_NAME " " USERAGENT_PREFIX);
     826        tr_variantDictAddInt (&val, "metadata_size", msgs->torrent->infoDictLength);
     827    tr_variantDictAddInt (&val, "p", tr_sessionGetPublicPeerPort (getSession (msgs)));
     828    tr_variantDictAddInt (&val, "reqq", REQQ);
     829    tr_variantDictAddInt (&val, "upload_only", tr_torrentIsSeed (msgs->torrent));
     830    tr_variantDictAddStr (&val, "v", TR_NAME " " USERAGENT_PREFIX);
    831831    if (allow_metadata_xfer || allow_pex) {
    832         tr_benc * m  = tr_bencDictAddDict (&val, "m", 2);
     832        tr_variant * m  = tr_variantDictAddDict (&val, "m", 2);
    833833        if (allow_metadata_xfer)
    834             tr_bencDictAddInt (m, "ut_metadata", UT_METADATA_ID);
     834            tr_variantDictAddInt (m, "ut_metadata", UT_METADATA_ID);
    835835        if (allow_pex)
    836             tr_bencDictAddInt (m, "ut_pex", UT_PEX_ID);
    837     }
    838 
    839     payload = tr_bencToBuf (&val, TR_FMT_BENC);
     836            tr_variantDictAddInt (m, "ut_pex", UT_PEX_ID);
     837    }
     838
     839    payload = tr_variantToBuf (&val, TR_VARIANT_FMT_BENC);
    840840
    841841    evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload));
     
    848848    /* cleanup */
    849849    evbuffer_free (payload);
    850     tr_bencFree (&val);
     850    tr_variantFree (&val);
    851851}
    852852
     
    855855{
    856856    int64_t   i;
    857     tr_benc   val, * sub;
     857    tr_variant   val, * sub;
    858858    uint8_t * tmp = tr_new (uint8_t, len);
    859859    const uint8_t *addr;
     
    867867    msgs->peerSentLtepHandshake = 1;
    868868
    869     if (tr_bencLoad (tmp, len, &val, NULL) || !tr_bencIsDict (&val))
     869    if (tr_variantFromBenc (&val, tmp, len) || !tr_variantIsDict (&val))
    870870    {
    871871        dbgmsg (msgs, "GET  extended-handshake, couldn't get dictionary");
     
    877877
    878878    /* does the peer prefer encrypted connections? */
    879     if (tr_bencDictFindInt (&val, "e", &i)) {
     879    if (tr_variantDictFindInt (&val, "e", &i)) {
    880880        msgs->peer->encryption_preference = i ? ENCRYPTION_PREFERENCE_YES
    881881                                              : ENCRYPTION_PREFERENCE_NO;
     
    888888    msgs->peerSupportsMetadataXfer = 0;
    889889
    890     if (tr_bencDictFindDict (&val, "m", &sub)) {
    891         if (tr_bencDictFindInt (sub, "ut_pex", &i)) {
     890    if (tr_variantDictFindDict (&val, "m", &sub)) {
     891        if (tr_variantDictFindInt (sub, "ut_pex", &i)) {
    892892            msgs->peerSupportsPex = i != 0;
    893893            msgs->ut_pex_id = (uint8_t) i;
    894894            dbgmsg (msgs, "msgs->ut_pex is %d", (int)msgs->ut_pex_id);
    895895        }
    896         if (tr_bencDictFindInt (sub, "ut_metadata", &i)) {
     896        if (tr_variantDictFindInt (sub, "ut_metadata", &i)) {
    897897            msgs->peerSupportsMetadataXfer = i != 0;
    898898            msgs->ut_metadata_id = (uint8_t) i;
    899899            dbgmsg (msgs, "msgs->ut_metadata_id is %d", (int)msgs->ut_metadata_id);
    900900        }
    901         if (tr_bencDictFindInt (sub, "ut_holepunch", &i)) {
     901        if (tr_variantDictFindInt (sub, "ut_holepunch", &i)) {
    902902            /* Mysterious µTorrent extension that we don't grok.  However,
    903903               it implies support for µTP, so use it to indicate that. */
     
    909909
    910910    /* look for metainfo size (BEP 9) */
    911     if (tr_bencDictFindInt (&val, "metadata_size", &i)) {
     911    if (tr_variantDictFindInt (&val, "metadata_size", &i)) {
    912912        tr_torrentSetMetadataSizeHint (msgs->torrent, i);
    913913        msgs->metadata_size_hint = (size_t) i;
     
    915915
    916916    /* look for upload_only (BEP 21) */
    917     if (tr_bencDictFindInt (&val, "upload_only", &i))
     917    if (tr_variantDictFindInt (&val, "upload_only", &i))
    918918        seedProbability = i==0 ? 0 : 100;
    919919
    920920    /* get peer's listening port */
    921     if (tr_bencDictFindInt (&val, "p", &i)) {
     921    if (tr_variantDictFindInt (&val, "p", &i)) {
    922922        pex.port = htons ((uint16_t)i);
    923923        fireClientGotPort (msgs, pex.port);
     
    926926
    927927    if (tr_peerIoIsIncoming (msgs->peer->io)
    928         && tr_bencDictFindRaw (&val, "ipv4", &addr, &addr_len)
     928        && tr_variantDictFindRaw (&val, "ipv4", &addr, &addr_len)
    929929        && (addr_len == 4))
    930930    {
     
    935935
    936936    if (tr_peerIoIsIncoming (msgs->peer->io)
    937         && tr_bencDictFindRaw (&val, "ipv6", &addr, &addr_len)
     937        && tr_variantDictFindRaw (&val, "ipv6", &addr, &addr_len)
    938938        && (addr_len == 16))
    939939    {
     
    944944
    945945    /* get peer's maximum request queue size */
    946     if (tr_bencDictFindInt (&val, "reqq", &i))
     946    if (tr_variantDictFindInt (&val, "reqq", &i))
    947947        msgs->reqq = i;
    948948
    949     tr_bencFree (&val);
     949    tr_variantFree (&val);
    950950    tr_free (tmp);
    951951}
     
    954954parseUtMetadata (tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf)
    955955{
    956     tr_benc dict;
     956    tr_variant dict;
    957957    char * msg_end;
    958     char * benc_end;
     958    const char * benc_end;
    959959    int64_t msg_type = -1;
    960960    int64_t piece = -1;
     
    965965    msg_end = (char*)tmp + msglen;
    966966
    967     if (!tr_bencLoad (tmp, msglen, &dict, &benc_end))
    968     {
    969         tr_bencDictFindInt (&dict, "msg_type", &msg_type);
    970         tr_bencDictFindInt (&dict, "piece", &piece);
    971         tr_bencDictFindInt (&dict, "total_size", &total_size);
    972         tr_bencFree (&dict);
     967    if (!tr_variantFromBencFull (&dict, tmp, msglen, NULL, &benc_end))
     968    {
     969        tr_variantDictFindInt (&dict, "msg_type", &msg_type);
     970        tr_variantDictFindInt (&dict, "piece", &piece);
     971        tr_variantDictFindInt (&dict, "total_size", &total_size);
     972        tr_variantFree (&dict);
    973973    }
    974974
     
    10011001        else
    10021002        {
    1003             tr_benc tmp;
     1003            tr_variant tmp;
    10041004            struct evbuffer * payload;
    10051005            struct evbuffer * out = msgs->outMessages;
    10061006
    10071007            /* build the rejection message */
    1008             tr_bencInitDict (&tmp, 2);
    1009             tr_bencDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_REJECT);
    1010             tr_bencDictAddInt (&tmp, "piece", piece);
    1011             payload = tr_bencToBuf (&tmp, TR_FMT_BENC);
     1008            tr_variantInitDict (&tmp, 2);
     1009            tr_variantDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_REJECT);
     1010            tr_variantDictAddInt (&tmp, "piece", piece);
     1011            payload = tr_variantToBuf (&tmp, TR_VARIANT_FMT_BENC);
    10121012
    10131013            /* write it out as a LTEP message to our outMessages buffer */
     
    10211021            /* cleanup */
    10221022            evbuffer_free (payload);
    1023             tr_bencFree (&tmp);
     1023            tr_variantFree (&tmp);
    10241024        }
    10251025    }
     
    10331033    int loaded = 0;
    10341034    uint8_t * tmp = tr_new (uint8_t, msglen);
    1035     tr_benc val;
     1035    tr_variant val;
    10361036    tr_torrent * tor = msgs->torrent;
    10371037    const uint8_t * added;
     
    10411041
    10421042    if (tr_torrentAllowsPex (tor)
    1043       && ((loaded = !tr_bencLoad (tmp, msglen, &val, NULL))))
    1044     {
    1045         if (tr_bencDictFindRaw (&val, "added", &added, &added_len))
     1043      && ((loaded = !tr_variantFromBenc (&val, tmp, msglen))))
     1044    {
     1045        if (tr_variantDictFindRaw (&val, "added", &added, &added_len))
    10461046        {
    10471047            tr_pex * pex;
     
    10501050            const uint8_t * added_f = NULL;
    10511051
    1052             tr_bencDictFindRaw (&val, "added.f", &added_f, &added_f_len);
     1052            tr_variantDictFindRaw (&val, "added.f", &added_f, &added_f_len);
    10531053            pex = tr_peerMgrCompactToPex (added, added_len, added_f, added_f_len, &n);
    10541054
     
    10641064        }
    10651065
    1066         if (tr_bencDictFindRaw (&val, "added6", &added, &added_len))
     1066        if (tr_variantDictFindRaw (&val, "added6", &added, &added_len))
    10671067        {
    10681068            tr_pex * pex;
     
    10711071            const uint8_t * added_f = NULL;
    10721072
    1073             tr_bencDictFindRaw (&val, "added6.f", &added_f, &added_f_len);
     1073            tr_variantDictFindRaw (&val, "added6.f", &added_f, &added_f_len);
    10741074            pex = tr_peerMgrCompact6ToPex (added, added_len, added_f, added_f_len, &n);
    10751075
     
    10871087
    10881088    if (loaded)
    1089         tr_bencFree (&val);
     1089        tr_variantFree (&val);
    10901090    tr_free (tmp);
    10911091}
     
    17161716        && tr_torrentGetNextMetadataRequest (msgs->torrent, now, &piece))
    17171717    {
    1718         tr_benc tmp;
     1718        tr_variant tmp;
    17191719        struct evbuffer * payload;
    17201720        struct evbuffer * out = msgs->outMessages;
    17211721
    17221722        /* build the data message */
    1723         tr_bencInitDict (&tmp, 3);
    1724         tr_bencDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_REQUEST);
    1725         tr_bencDictAddInt (&tmp, "piece", piece);
    1726         payload = tr_bencToBuf (&tmp, TR_FMT_BENC);
     1723        tr_variantInitDict (&tmp, 3);
     1724        tr_variantDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_REQUEST);
     1725        tr_variantDictAddInt (&tmp, "piece", piece);
     1726        payload = tr_variantToBuf (&tmp, TR_VARIANT_FMT_BENC);
    17271727
    17281728        dbgmsg (msgs, "requesting metadata piece #%d", piece);
     
    17381738        /* cleanup */
    17391739        evbuffer_free (payload);
    1740         tr_bencFree (&tmp);
     1740        tr_variantFree (&tmp);
    17411741    }
    17421742}
     
    18111811        if ((dataLen > 0) && (data != NULL))
    18121812        {
    1813             tr_benc tmp;
     1813            tr_variant tmp;
    18141814            struct evbuffer * payload;
    18151815            struct evbuffer * out = msgs->outMessages;
    18161816
    18171817            /* build the data message */
    1818             tr_bencInitDict (&tmp, 3);
    1819             tr_bencDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_DATA);
    1820             tr_bencDictAddInt (&tmp, "piece", piece);
    1821             tr_bencDictAddInt (&tmp, "total_size", msgs->torrent->infoDictLength);
    1822             payload = tr_bencToBuf (&tmp, TR_FMT_BENC);
     1818            tr_variantInitDict (&tmp, 3);
     1819            tr_variantDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_DATA);
     1820            tr_variantDictAddInt (&tmp, "piece", piece);
     1821            tr_variantDictAddInt (&tmp, "total_size", msgs->torrent->infoDictLength);
     1822            payload = tr_variantToBuf (&tmp, TR_VARIANT_FMT_BENC);
    18231823
    18241824            /* write it out as a LTEP message to our outMessages buffer */
     
    18321832
    18331833            evbuffer_free (payload);
    1834             tr_bencFree (&tmp);
     1834            tr_variantFree (&tmp);
    18351835            tr_free (data);
    18361836
     
    18401840        if (!ok) /* send a rejection message */
    18411841        {
    1842             tr_benc tmp;
     1842            tr_variant tmp;
    18431843            struct evbuffer * payload;
    18441844            struct evbuffer * out = msgs->outMessages;
    18451845
    18461846            /* build the rejection message */
    1847             tr_bencInitDict (&tmp, 2);
    1848             tr_bencDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_REJECT);
    1849             tr_bencDictAddInt (&tmp, "piece", piece);
    1850             payload = tr_bencToBuf (&tmp, TR_FMT_BENC);
     1847            tr_variantInitDict (&tmp, 2);
     1848            tr_variantDictAddInt (&tmp, "msg_type", METADATA_MSG_TYPE_REJECT);
     1849            tr_variantDictAddInt (&tmp, "piece", piece);
     1850            payload = tr_variantToBuf (&tmp, TR_VARIANT_FMT_BENC);
    18511851
    18521852            /* write it out as a LTEP message to our outMessages buffer */
     
    18591859
    18601860            evbuffer_free (payload);
    1861             tr_bencFree (&tmp);
     1861            tr_variantFree (&tmp);
    18621862        }
    18631863    }
     
    21942194        {
    21952195            int  i;
    2196             tr_benc val;
     2196            tr_variant val;
    21972197            uint8_t * tmp, *walk;
    21982198            struct evbuffer * payload;
     
    22082208
    22092209            /* build the pex payload */
    2210             tr_bencInitDict (&val, 3); /* ipv6 support: left as 3:
     2210            tr_variantInitDict (&val, 3); /* ipv6 support: left as 3:
    22112211                                         * speed vs. likelihood? */
    22122212
     
    22202220                }
    22212221                assert ((walk - tmp) == diffs.addedCount * 6);
    2222                 tr_bencDictAddRaw (&val, "added", tmp, walk - tmp);
     2222                tr_variantDictAddRaw (&val, "added", tmp, walk - tmp);
    22232223                tr_free (tmp);
    22242224
     
    22292229                    *walk++ = diffs.added[i].flags & ~ADDED_F_HOLEPUNCH;
    22302230                assert ((walk - tmp) == diffs.addedCount);
    2231                 tr_bencDictAddRaw (&val, "added.f", tmp, walk - tmp);
     2231                tr_variantDictAddRaw (&val, "added.f", tmp, walk - tmp);
    22322232                tr_free (tmp);
    22332233            }
     
    22422242                }
    22432243                assert ((walk - tmp) == diffs.droppedCount * 6);
    2244                 tr_bencDictAddRaw (&val, "dropped", tmp, walk - tmp);
     2244                tr_variantDictAddRaw (&val, "dropped", tmp, walk - tmp);
    22452245                tr_free (tmp);
    22462246            }
     
    22572257                }
    22582258                assert ((walk - tmp) == diffs6.addedCount * 18);
    2259                 tr_bencDictAddRaw (&val, "added6", tmp, walk - tmp);
     2259                tr_variantDictAddRaw (&val, "added6", tmp, walk - tmp);
    22602260                tr_free (tmp);
    22612261
     
    22662266                    *walk++ = diffs6.added[i].flags & ~ADDED_F_HOLEPUNCH;
    22672267                assert ((walk - tmp) == diffs6.addedCount);
    2268                 tr_bencDictAddRaw (&val, "added6.f", tmp, walk - tmp);
     2268                tr_variantDictAddRaw (&val, "added6.f", tmp, walk - tmp);
    22692269                tr_free (tmp);
    22702270            }
     
    22812281                }
    22822282                assert ((walk - tmp) == diffs6.droppedCount * 18);
    2283                 tr_bencDictAddRaw (&val, "dropped6", tmp, walk - tmp);
     2283                tr_variantDictAddRaw (&val, "dropped6", tmp, walk - tmp);
    22842284                tr_free (tmp);
    22852285            }
    22862286
    22872287            /* write the pex message */
    2288             payload = tr_bencToBuf (&val, TR_FMT_BENC);
     2288            payload = tr_variantToBuf (&val, TR_VARIANT_FMT_BENC);
    22892289            evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload));
    22902290            evbuffer_add_uint8 (out, BT_LTEP);
     
    22962296
    22972297            evbuffer_free (payload);
    2298             tr_bencFree (&val);
     2298            tr_variantFree (&val);
    22992299        }
    23002300
  • trunk/libtransmission/resume.c

    r13651 r13667  
    1616
    1717#include "transmission.h"
    18 #include "bencode.h"
    1918#include "completion.h"
    2019#include "metainfo.h" /* tr_metainfoGetBasename () */
     
    2524#include "torrent.h"
    2625#include "utils.h" /* tr_buildPath */
     26#include "variant.h"
    2727
    2828#define KEY_ACTIVITY_DATE       "activity-date"
     
    8989
    9090static void
    91 savePeers (tr_benc * dict, const tr_torrent * tor)
     91savePeers (tr_variant * dict, const tr_torrent * tor)
    9292{
    9393    int count;
     
    9696    count = tr_peerMgrGetPeers ((tr_torrent*) tor, &pex, TR_AF_INET, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS);
    9797    if (count > 0)
    98         tr_bencDictAddRaw (dict, KEY_PEERS, pex, sizeof (tr_pex) * count);
     98        tr_variantDictAddRaw (dict, KEY_PEERS, pex, sizeof (tr_pex) * count);
    9999    tr_free (pex);
    100100
    101101    count = tr_peerMgrGetPeers ((tr_torrent*) tor, &pex, TR_AF_INET6, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS);
    102102    if (count > 0)
    103         tr_bencDictAddRaw (dict, KEY_PEERS6, pex, sizeof (tr_pex) * count);
     103        tr_variantDictAddRaw (dict, KEY_PEERS6, pex, sizeof (tr_pex) * count);
    104104
    105105    tr_free (pex);
     
    129129
    130130static uint64_t
    131 loadPeers (tr_benc * dict, tr_torrent * tor)
     131loadPeers (tr_variant * dict, tr_torrent * tor)
    132132{
    133133    uint64_t        ret = 0;
     
    135135    size_t          len;
    136136
    137     if (tr_bencDictFindRaw (dict, KEY_PEERS, &str, &len))
     137    if (tr_variantDictFindRaw (dict, KEY_PEERS, &str, &len))
    138138    {
    139139        const int numAdded = addPeers (tor, str, len);
     
    142142    }
    143143
    144     if (tr_bencDictFindRaw (dict, KEY_PEERS6, &str, &len))
     144    if (tr_variantDictFindRaw (dict, KEY_PEERS6, &str, &len))
    145145    {
    146146        const int numAdded = addPeers (tor, str, len);
     
    157157
    158158static void
    159 saveDND (tr_benc * dict, const tr_torrent * tor)
    160 {
    161     tr_benc * list;
     159saveDND (tr_variant * dict, const tr_torrent * tor)
     160{
     161    tr_variant * list;
    162162    tr_file_index_t i;
    163163    const tr_info * const inf = tr_torrentInfo (tor);
    164164    const tr_file_index_t n = inf->fileCount;
    165165
    166     list = tr_bencDictAddList (dict, KEY_DND, n);
     166    list = tr_variantDictAddList (dict, KEY_DND, n);
    167167    for (i=0; i<n; ++i)
    168         tr_bencListAddInt (list, inf->files[i].dnd ? 1 : 0);
    169 }
    170 
    171 static uint64_t
    172 loadDND (tr_benc * dict, tr_torrent * tor)
     168        tr_variantListAddInt (list, inf->files[i].dnd ? 1 : 0);
     169}
     170
     171static uint64_t
     172loadDND (tr_variant * dict, tr_torrent * tor)
    173173{
    174174    uint64_t ret = 0;
    175     tr_benc * list = NULL;
     175    tr_variant * list = NULL;
    176176    const tr_file_index_t n = tor->info.fileCount;
    177177
    178     if (tr_bencDictFindList (dict, KEY_DND, &list)
    179       && (tr_bencListSize (list) == n))
     178    if (tr_variantDictFindList (dict, KEY_DND, &list)
     179      && (tr_variantListSize (list) == n))
    180180    {
    181181        int64_t           tmp;
     
    186186        for (i=0; i<n; ++i)
    187187        {
    188             if (tr_bencGetInt (tr_bencListChild (list, i), &tmp) && tmp)
     188            if (tr_variantGetInt (tr_variantListChild (list, i), &tmp) && tmp)
    189189                dnd[dndCount++] = i;
    190190            else
     
    215215            tor,
    216216            "Couldn't load DND flags. DND list (%p) has %zu children; torrent has %d files",
    217             list, tr_bencListSize (list), (int)n);
     217            list, tr_variantListSize (list), (int)n);
    218218    }
    219219
     
    226226
    227227static void
    228 saveFilePriorities (tr_benc * dict, const tr_torrent * tor)
    229 {
    230     tr_benc * list;
     228saveFilePriorities (tr_variant * dict, const tr_torrent * tor)
     229{
     230    tr_variant * list;
    231231    tr_file_index_t i;
    232232    const tr_info * const inf = tr_torrentInfo (tor);
    233233    const tr_file_index_t n = inf->fileCount;
    234234
    235     list = tr_bencDictAddList (dict, KEY_FILE_PRIORITIES, n);
     235    list = tr_variantDictAddList (dict, KEY_FILE_PRIORITIES, n);
    236236    for (i = 0; i < n; ++i)
    237         tr_bencListAddInt (list, inf->files[i].priority);
    238 }
    239 
    240 static uint64_t
    241 loadFilePriorities (tr_benc * dict, tr_torrent * tor)
    242 {
    243     tr_benc * list;
     237        tr_variantListAddInt (list, inf->files[i].priority);
     238}
     239
     240static uint64_t
     241loadFilePriorities (tr_variant * dict, tr_torrent * tor)
     242{
     243    tr_variant * list;
    244244    uint64_t ret = 0;
    245245    const tr_file_index_t n = tor->info.fileCount;
    246246
    247     if (tr_bencDictFindList (dict, KEY_FILE_PRIORITIES, &list)
    248       && (tr_bencListSize (list) == n))
     247    if (tr_variantDictFindList (dict, KEY_FILE_PRIORITIES, &list)
     248      && (tr_variantListSize (list) == n))
    249249    {
    250250        int64_t priority;
    251251        tr_file_index_t i;
    252252        for (i = 0; i < n; ++i)
    253             if (tr_bencGetInt (tr_bencListChild (list, i), &priority))
     253            if (tr_variantGetInt (tr_variantListChild (list, i), &priority))
    254254                tr_torrentInitFilePriority (tor, i, priority);
    255255        ret = TR_FR_FILE_PRIORITIES;
     
    264264
    265265static void
    266 saveSingleSpeedLimit (tr_benc * d, tr_torrent * tor, tr_direction dir)
    267 {
    268     tr_bencDictReserve (d, 3);
    269     tr_bencDictAddInt (d, KEY_SPEED_Bps, tr_torrentGetSpeedLimit_Bps (tor, dir));
    270     tr_bencDictAddBool (d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits (tor));
    271     tr_bencDictAddBool (d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit (tor, dir));
    272 }
    273 
    274 static void
    275 saveSpeedLimits (tr_benc * dict, tr_torrent * tor)
    276 {
    277     saveSingleSpeedLimit (tr_bencDictAddDict (dict, KEY_SPEEDLIMIT_DOWN, 0), tor, TR_DOWN);
    278     saveSingleSpeedLimit (tr_bencDictAddDict (dict, KEY_SPEEDLIMIT_UP, 0), tor, TR_UP);
    279 }
    280 
    281 static void
    282 saveRatioLimits (tr_benc * dict, tr_torrent * tor)
    283 {
    284     tr_benc * d = tr_bencDictAddDict (dict, KEY_RATIOLIMIT, 2);
    285     tr_bencDictAddReal (d, KEY_RATIOLIMIT_RATIO, tr_torrentGetRatioLimit (tor));
    286     tr_bencDictAddInt (d, KEY_RATIOLIMIT_MODE, tr_torrentGetRatioMode (tor));
    287 }
    288 
    289 static void
    290 saveIdleLimits (tr_benc * dict, tr_torrent * tor)
    291 {
    292     tr_benc * d = tr_bencDictAddDict (dict, KEY_IDLELIMIT, 2);
    293     tr_bencDictAddInt (d, KEY_IDLELIMIT_MINS, tr_torrentGetIdleLimit (tor));
    294     tr_bencDictAddInt (d, KEY_IDLELIMIT_MODE, tr_torrentGetIdleMode (tor));
    295 }
    296 
    297 static void
    298 loadSingleSpeedLimit (tr_benc * d, tr_direction dir, tr_torrent * tor)
     266saveSingleSpeedLimit (tr_variant * d, tr_torrent * tor, tr_direction dir)
     267{
     268    tr_variantDictReserve (d, 3);
     269    tr_variantDictAddInt (d, KEY_SPEED_Bps, tr_torrentGetSpeedLimit_Bps (tor, dir));
     270    tr_variantDictAddBool (d, KEY_USE_GLOBAL_SPEED_LIMIT, tr_torrentUsesSessionLimits (tor));
     271    tr_variantDictAddBool (d, KEY_USE_SPEED_LIMIT, tr_torrentUsesSpeedLimit (tor, dir));
     272}
     273
     274static void
     275saveSpeedLimits (tr_variant * dict, tr_torrent * tor)
     276{
     277    saveSingleSpeedLimit (tr_variantDictAddDict (dict, KEY_SPEEDLIMIT_DOWN, 0), tor, TR_DOWN);
     278    saveSingleSpeedLimit (tr_variantDictAddDict (dict, KEY_SPEEDLIMIT_UP, 0), tor, TR_UP);
     279}
     280
     281static void
     282saveRatioLimits (tr_variant * dict, tr_torrent * tor)
     283{
     284    tr_variant * d = tr_variantDictAddDict (dict, KEY_RATIOLIMIT, 2);
     285    tr_variantDictAddReal (d, KEY_RATIOLIMIT_RATIO, tr_torrentGetRatioLimit (tor));
     286    tr_variantDictAddInt (d, KEY_RATIOLIMIT_MODE, tr_torrentGetRatioMode (tor));
     287}
     288
     289static void
     290saveIdleLimits (tr_variant * dict, tr_torrent * tor)
     291{
     292    tr_variant * d = tr_variantDictAddDict (dict, KEY_IDLELIMIT, 2);
     293    tr_variantDictAddInt (d, KEY_IDLELIMIT_MINS, tr_torrentGetIdleLimit (tor));
     294    tr_variantDictAddInt (d, KEY_IDLELIMIT_MODE, tr_torrentGetIdleMode (tor));
     295}
     296
     297static void
     298loadSingleSpeedLimit (tr_variant * d, tr_direction dir, tr_torrent * tor)
    299299{
    300300    int64_t i;
    301301    bool boolVal;
    302302
    303     if (tr_bencDictFindInt (d, KEY_SPEED_Bps, &i))
     303    if (tr_variantDictFindInt (d, KEY_SPEED_Bps, &i))
    304304        tr_torrentSetSpeedLimit_Bps (tor, dir, i);
    305     else if (tr_bencDictFindInt (d, KEY_SPEED_KiBps, &i))
     305    else if (tr_variantDictFindInt (d, KEY_SPEED_KiBps, &i))
    306306        tr_torrentSetSpeedLimit_Bps (tor, dir, i*1024);
    307307
    308     if (tr_bencDictFindBool (d, KEY_USE_SPEED_LIMIT, &boolVal))
     308    if (tr_variantDictFindBool (d, KEY_USE_SPEED_LIMIT, &boolVal))
    309309        tr_torrentUseSpeedLimit (tor, dir, boolVal);
    310310
    311     if (tr_bencDictFindBool (d, KEY_USE_GLOBAL_SPEED_LIMIT, &boolVal))
     311    if (tr_variantDictFindBool (d, KEY_USE_GLOBAL_SPEED_LIMIT, &boolVal))
    312312        tr_torrentUseSessionLimits (tor, boolVal);
    313313}
     
    320320
    321321static uint64_t
    322 loadSpeedLimits (tr_benc * dict, tr_torrent * tor)
    323 {
    324     tr_benc * d;
     322loadSpeedLimits (tr_variant * dict, tr_torrent * tor)
     323{
     324    tr_variant * d;
    325325    uint64_t ret = 0;
    326326
    327327
    328     if (tr_bencDictFindDict (dict, KEY_SPEEDLIMIT_UP, &d))
     328    if (tr_variantDictFindDict (dict, KEY_SPEEDLIMIT_UP, &d))
    329329    {
    330330        loadSingleSpeedLimit (d, TR_UP, tor);
    331331        ret = TR_FR_SPEEDLIMIT;
    332332    }
    333     if (tr_bencDictFindDict (dict, KEY_SPEEDLIMIT_DOWN, &d))
     333    if (tr_variantDictFindDict (dict, KEY_SPEEDLIMIT_DOWN, &d))
    334334    {
    335335        loadSingleSpeedLimit (d, TR_DOWN, tor);
     
    338338
    339339    /* older speedlimit structure */
    340     if (!ret && tr_bencDictFindDict (dict, KEY_SPEEDLIMIT_OLD, &d))
     340    if (!ret && tr_variantDictFindDict (dict, KEY_SPEEDLIMIT_OLD, &d))
    341341    {
    342342
    343343        int64_t i;
    344         if (tr_bencDictFindInt (d, KEY_SPEEDLIMIT_DOWN_SPEED, &i))
     344        if (tr_variantDictFindInt (d, KEY_SPEEDLIMIT_DOWN_SPEED, &i))
    345345            tr_torrentSetSpeedLimit_Bps (tor, TR_DOWN, i*1024);
    346         if (tr_bencDictFindInt (d, KEY_SPEEDLIMIT_DOWN_MODE, &i)) {
     346        if (tr_variantDictFindInt (d, KEY_SPEEDLIMIT_DOWN_MODE, &i)) {
    347347            tr_torrentUseSpeedLimit (tor, TR_DOWN, i==TR_SPEEDLIMIT_SINGLE);
    348348            tr_torrentUseSessionLimits (tor, i==TR_SPEEDLIMIT_GLOBAL);
    349349         }
    350         if (tr_bencDictFindInt (d, KEY_SPEEDLIMIT_UP_SPEED, &i))
     350        if (tr_variantDictFindInt (d, KEY_SPEEDLIMIT_UP_SPEED, &i))
    351351            tr_torrentSetSpeedLimit_Bps (tor, TR_UP, i*1024);
    352         if (tr_bencDictFindInt (d, KEY_SPEEDLIMIT_UP_MODE, &i)) {
     352        if (tr_variantDictFindInt (d, KEY_SPEEDLIMIT_UP_MODE, &i)) {
    353353            tr_torrentUseSpeedLimit (tor, TR_UP, i==TR_SPEEDLIMIT_SINGLE);
    354354            tr_torrentUseSessionLimits (tor, i==TR_SPEEDLIMIT_GLOBAL);
     
    361361
    362362static uint64_t
    363 loadRatioLimits (tr_benc * dict, tr_torrent * tor)
    364 {
    365     tr_benc * d;
     363loadRatioLimits (tr_variant * dict, tr_torrent * tor)
     364{
     365    tr_variant * d;
    366366    uint64_t ret = 0;
    367367
    368     if (tr_bencDictFindDict (dict, KEY_RATIOLIMIT, &d))
     368    if (tr_variantDictFindDict (dict, KEY_RATIOLIMIT, &d))
    369369    {
    370370        int64_t i;
    371371        double dratio;
    372         if (tr_bencDictFindReal (d, KEY_RATIOLIMIT_RATIO, &dratio))
     372        if (tr_variantDictFindReal (d, KEY_RATIOLIMIT_RATIO, &dratio))
    373373            tr_torrentSetRatioLimit (tor, dratio);
    374         if (tr_bencDictFindInt (d, KEY_RATIOLIMIT_MODE, &i))
     374        if (tr_variantDictFindInt (d, KEY_RATIOLIMIT_MODE, &i))
    375375            tr_torrentSetRatioMode (tor, i);
    376376      ret = TR_FR_RATIOLIMIT;
     
    381381
    382382static uint64_t
    383 loadIdleLimits (tr_benc * dict, tr_torrent * tor)
    384 {
    385     tr_benc * d;
     383loadIdleLimits (tr_variant * dict, tr_torrent * tor)
     384{
     385    tr_variant * d;
    386386    uint64_t ret = 0;
    387387
    388     if (tr_bencDictFindDict (dict, KEY_IDLELIMIT, &d))
     388    if (tr_variantDictFindDict (dict, KEY_IDLELIMIT, &d))
    389389    {
    390390        int64_t i;
    391391        int64_t imin;
    392         if (tr_bencDictFindInt (d, KEY_IDLELIMIT_MINS, &imin))
     392        if (tr_variantDictFindInt (d, KEY_IDLELIMIT_MINS, &imin))
    393393            tr_torrentSetIdleLimit (tor, imin);
    394         if (tr_bencDictFindInt (d, KEY_IDLELIMIT_MODE, &i))
     394        if (tr_variantDictFindInt (d, KEY_IDLELIMIT_MODE, &i))
    395395            tr_torrentSetIdleMode (tor, i);
    396396      ret = TR_FR_IDLELIMIT;
     
    404404
    405405static void
    406 bitfieldToBenc (const tr_bitfield * b, tr_benc * benc)
     406bitfieldToBenc (const tr_bitfield * b, tr_variant * benc)
    407407{
    408408    if (tr_bitfieldHasAll (b))
    409         tr_bencInitStr (benc, "all", 3);
     409        tr_variantInitStr (benc, "all", 3);
    410410    else if (tr_bitfieldHasNone (b))
    411         tr_bencInitStr (benc, "none", 4);
     411        tr_variantInitStr (benc, "none", 4);
    412412    else {
    413413        size_t byte_count = 0;
    414414        uint8_t * raw = tr_bitfieldGetRaw (b, &byte_count);
    415         tr_bencInitRaw (benc, raw, byte_count);
     415        tr_variantInitRaw (benc, raw, byte_count);
    416416        tr_free (raw);
    417417    }
     
    420420
    421421static void
    422 saveProgress (tr_benc * dict, tr_torrent * tor)
    423 {
    424     tr_benc * l;
    425     tr_benc * prog;
     422saveProgress (tr_variant * dict, tr_torrent * tor)
     423{
     424    tr_variant * l;
     425    tr_variant * prog;
    426426    tr_file_index_t fi;
    427427    const tr_info * inf = tr_torrentInfo (tor);
    428428    const time_t now = tr_time ();
    429429
    430     prog = tr_bencDictAddDict (dict, KEY_PROGRESS, 3);
     430    prog = tr_variantDictAddDict (dict, KEY_PROGRESS, 3);
    431431
    432432    /* add the file/piece check timestamps... */
    433     l = tr_bencDictAddList (prog, KEY_PROGRESS_CHECKTIME, inf->fileCount);
     433    l = tr_variantDictAddList (prog, KEY_PROGRESS_CHECKTIME, inf->fileCount);
    434434    for (fi=0; fi<inf->fileCount; ++fi)
    435435    {
     
    463463
    464464        if (!has_zero && (mtime <= oldest_nonzero)) /* all checked */
    465             tr_bencListAddInt (l, oldest_nonzero);
     465            tr_variantListAddInt (l, oldest_nonzero);
    466466        else if (newest < mtime) /* none checked */
    467             tr_bencListAddInt (l, newest);
     467            tr_variantListAddInt (l, newest);
    468468        else { /* some are checked, some aren't... so list piece by piece */
    469469            const int offset = oldest_nonzero - 1;
    470             tr_benc * ll = tr_bencListAddList (l, 2 + f->lastPiece - f->firstPiece);
    471             tr_bencListAddInt (ll, offset);
     470            tr_variant * ll = tr_variantListAddList (l, 2 + f->lastPiece - f->firstPiece);
     471            tr_variantListAddInt (ll, offset);
    472472            for (p=&inf->pieces[f->firstPiece], pend=&inf->pieces[f->lastPiece]+1; p!=pend; ++p)
    473                 tr_bencListAddInt (ll, p->timeChecked ? p->timeChecked - offset : 0);
     473                tr_variantListAddInt (ll, p->timeChecked ? p->timeChecked - offset : 0);
    474474        }
    475475    }
     
    477477    /* add the progress */
    478478    if (tor->completeness == TR_SEED)
    479         tr_bencDictAddStr (prog, KEY_PROGRESS_HAVE, "all");
     479        tr_variantDictAddStr (prog, KEY_PROGRESS_HAVE, "all");
    480480
    481481    /* add the blocks bitfield */
    482482    bitfieldToBenc (&tor->completion.blockBitfield,
    483                     tr_bencDictAdd (prog, KEY_PROGRESS_BLOCKS));
    484 }
    485 
    486 static uint64_t
    487 loadProgress (tr_benc * dict, tr_torrent * tor)
     483                    tr_variantDictAdd (prog, KEY_PROGRESS_BLOCKS));
     484}
     485
     486static uint64_t
     487loadProgress (tr_variant * dict, tr_torrent * tor)
    488488{
    489489    size_t i, n;
    490490    uint64_t ret = 0;
    491     tr_benc * prog;
     491    tr_variant * prog;
    492492    const tr_info * inf = tr_torrentInfo (tor);
    493493
     
    495495        inf->pieces[i].timeChecked = 0;
    496496
    497     if (tr_bencDictFindDict (dict, KEY_PROGRESS, &prog))
     497    if (tr_variantDictFindDict (dict, KEY_PROGRESS, &prog))
    498498    {
    499499        const char * err;
     
    501501        const uint8_t * raw;
    502502        size_t rawlen;
    503         tr_benc * l;
    504         tr_benc * b;
     503        tr_variant * l;
     504        tr_variant * b;
    505505        struct tr_bitfield blocks = TR_BITFIELD_INIT;
    506506
    507         if (tr_bencDictFindList (prog, KEY_PROGRESS_CHECKTIME, &l))
     507        if (tr_variantDictFindList (prog, KEY_PROGRESS_CHECKTIME, &l))
    508508        {
    509509            /* per-piece timestamps were added in 2.20.
     
    522522            for (fi=0; fi<inf->fileCount; ++fi)
    523523            {
    524                 tr_benc * b = tr_bencListChild (l, fi);
     524                tr_variant * b = tr_variantListChild (l, fi);
    525525                const tr_file * f = &inf->files[fi];
    526526                tr_piece * p = &inf->pieces[f->firstPiece];
    527527                const tr_piece * pend = &inf->pieces[f->lastPiece]+1;
    528528
    529                 if (tr_bencIsInt (b))
     529                if (tr_variantIsInt (b))
    530530                {
    531531                    int64_t t;
    532                     tr_bencGetInt (b, &t);
     532                    tr_variantGetInt (b, &t);
    533533                    for (; p!=pend; ++p)
    534534                        p->timeChecked = (time_t)t;