Changeset 13667
- Timestamp:
- Dec 14, 2012, 4:34:42 AM (8 years ago)
- Location:
- trunk
- Files:
-
- 3 added
- 2 deleted
- 64 edited
- 3 moved
Legend:
- Unmodified
- Added
- Removed
-
trunk/cli/cli.c
r13625 r13667 29 29 30 30 #include <libtransmission/transmission.h> 31 #include <libtransmission/bencode.h>32 31 #include <libtransmission/tr-getopt.h> 33 32 #include <libtransmission/utils.h> /* tr_wait_msec */ 33 #include <libtransmission/variant.h> 34 34 #include <libtransmission/version.h> 35 35 #include <libtransmission/web.h> /* tr_webRun */ … … 105 105 } 106 106 107 static int parseCommandLine (tr_ benc*, int argc, const char ** argv);107 static int parseCommandLine (tr_variant*, int argc, const char ** argv); 108 108 109 109 static void sigHandler (int signal); … … 227 227 tr_ctor * ctor; 228 228 tr_torrent * tor = NULL; 229 tr_ bencsettings;229 tr_variant settings; 230 230 const char * configDir; 231 231 uint8_t * fileContents; … … 248 248 249 249 /* load the defaults from config file + libtransmission defaults */ 250 tr_ bencInitDict (&settings, 0);250 tr_variantInitDict (&settings, 0); 251 251 configDir = getConfigDir (argc, (const char**)argv); 252 252 tr_sessionLoadSettings (&settings, configDir, MY_CONFIG_NAME); … … 266 266 } 267 267 268 if (tr_ bencDictFindStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str))268 if (tr_variantDictFindStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, &str, NULL)) 269 269 { 270 270 str = tr_realpath (str, buf); … … 272 272 if (str != NULL) 273 273 { 274 tr_ bencDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, str);274 tr_variantDictAddStr (&settings, TR_PREFS_KEY_DOWNLOAD_DIR, str); 275 275 } 276 276 else … … 379 379 380 380 printf ("\n"); 381 tr_ bencFree (&settings);381 tr_variantFree (&settings); 382 382 tr_sessionClose (h); 383 383 return EXIT_SUCCESS; … … 390 390 391 391 static int 392 parseCommandLine (tr_ benc* d, int argc, const char ** argv)392 parseCommandLine (tr_variant * d, int argc, const char ** argv) 393 393 { 394 394 int c; … … 400 400 { 401 401 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); 406 406 break; 407 407 408 408 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); 414 414 break; 415 415 416 416 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); 419 419 break; 420 420 … … 423 423 424 424 case 'm': 425 tr_ bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, true);425 tr_variantDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, true); 426 426 break; 427 427 428 428 case 'M': 429 tr_ bencDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, false);429 tr_variantDictAddBool (d, TR_PREFS_KEY_PORT_FORWARDING, false); 430 430 break; 431 431 432 432 case 'p': 433 tr_ bencDictAddInt (d, TR_PREFS_KEY_PEER_PORT, atoi (optarg));433 tr_variantDictAddInt (d, TR_PREFS_KEY_PEER_PORT, atoi (optarg)); 434 434 break; 435 435 436 436 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)); 438 438 break; 439 439 440 440 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); 443 443 break; 444 444 445 445 case 'U': 446 tr_ bencDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, false);446 tr_variantDictAddBool (d, TR_PREFS_KEY_USPEED_ENABLED, false); 447 447 break; 448 448 … … 456 456 457 457 case 'w': 458 tr_ bencDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, optarg);458 tr_variantDictAddStr (d, TR_PREFS_KEY_DOWNLOAD_DIR, optarg); 459 459 break; 460 460 461 461 case 910: 462 tr_ bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED);462 tr_variantDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_REQUIRED); 463 463 break; 464 464 465 465 case 911: 466 tr_ bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED);466 tr_variantDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED); 467 467 break; 468 468 469 469 case 912: 470 tr_ bencDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED);470 tr_variantDictAddInt (d, TR_PREFS_KEY_ENCRYPTION, TR_CLEAR_PREFERRED); 471 471 break; 472 472 -
trunk/daemon/daemon.c
r13625 r13667 25 25 26 26 #include <libtransmission/transmission.h> 27 #include <libtransmission/bencode.h>28 27 #include <libtransmission/tr-getopt.h> 29 28 #include <libtransmission/utils.h> 29 #include <libtransmission/variant.h> 30 30 #include <libtransmission/version.h> 31 31 … … 154 154 else 155 155 { 156 tr_ bencsettings;156 tr_variant settings; 157 157 const char * configDir; 158 158 … … 166 166 configDir = tr_sessionGetConfigDir (mySession); 167 167 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); 170 170 tr_sessionLoadSettings (&settings, configDir, MY_NAME); 171 171 tr_sessionSet (mySession, &settings); 172 tr_ bencFree (&settings);172 tr_variantFree (&settings); 173 173 tr_sessionReloadBlocklists (mySession); 174 174 } … … 359 359 int c; 360 360 const char * optarg; 361 tr_ bencsettings;361 tr_variant settings; 362 362 bool boolVal; 363 363 bool loaded; … … 377 377 378 378 /* 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); 381 381 configDir = getConfigDir (argc, (const char**)argv); 382 382 loaded = tr_sessionLoadSettings (&settings, configDir, MY_NAME); … … 386 386 while ((c = tr_getopt (getUsage (), argc, (const char**)argv, options, &optarg))) { 387 387 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); 404 404 break; 405 405 case 'd': dumpSettings = true; … … 418 418 fprintf (stderr, "%s %s\n", MY_NAME, LONG_VERSION_STRING); 419 419 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)); 445 445 break; 446 446 case 800: paused = true; 447 447 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); 480 480 break; 481 481 default: showUsage (); … … 495 495 if (dumpSettings) 496 496 { 497 char * str = tr_ bencToStr (&settings, TR_FMT_JSON, NULL);497 char * str = tr_variantToStr (&settings, TR_VARIANT_FMT_JSON, NULL); 498 498 fprintf (stderr, "%s", str); 499 499 tr_free (str); … … 519 519 520 520 pid_filename = NULL; 521 tr_ bencDictFindStr (&settings, PREF_KEY_PIDFILE, &pid_filename);521 tr_variantDictFindStr (&settings, PREF_KEY_PIDFILE, &pid_filename, NULL); 522 522 if (pid_filename && *pid_filename) 523 523 { … … 534 534 } 535 535 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) 537 537 tr_ninf (MY_NAME, "requiring authentication"); 538 538 … … 547 547 const char * dir; 548 548 549 if (tr_ bencDictFindBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal)549 if (tr_variantDictFindBool (&settings, PREF_KEY_DIR_WATCH_ENABLED, &boolVal) 550 550 && boolVal 551 && tr_ bencDictFindStr (&settings, PREF_KEY_DIR_WATCH, &dir)551 && tr_variantDictFindStr (&settings, PREF_KEY_DIR_WATCH, &dir, NULL) 552 552 && dir 553 553 && *dir) … … 599 599 if (pidfile_created) 600 600 remove (pid_filename); 601 tr_ bencFree (&settings);601 tr_variantFree (&settings); 602 602 return 0; 603 603 } -
trunk/daemon/my-valgrind.sh
r6347 r13667 3 3 export G_DEBUG=gc-friendly 4 4 export 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 6 valgrind --tool=cachegrind ./transmission-daemon -f -g /home/charles/.config/transmission -
trunk/daemon/remote.c
r13625 r13667 31 31 32 32 #include <libtransmission/transmission.h> 33 #include <libtransmission/bencode.h>34 33 #include <libtransmission/rpcimpl.h> 35 #include <libtransmission/json.h>36 34 #include <libtransmission/tr-getopt.h> 37 35 #include <libtransmission/utils.h> 36 #include <libtransmission/variant.h> 38 37 #include <libtransmission/version.h> 39 38 … … 547 546 548 547 static void 549 addIdArg (tr_ benc* args, const char * id)548 addIdArg (tr_variant * args, const char * id) 550 549 { 551 550 if (!*id) … … 565 564 isNum = false; 566 565 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)); 568 567 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 */ 570 569 } 571 570 } 572 571 573 572 static void 574 addTime (tr_ benc* args, const char * key, const char * arg)573 addTime (tr_variant * args, const char * key, const char * arg) 575 574 { 576 575 int time; … … 592 591 593 592 if (success) 594 tr_ bencDictAddInt (args, key, time);593 tr_variantDictAddInt (args, key, time); 595 594 else 596 595 fprintf (stderr, "Please specify the time of day in 'hhmm' format.\n"); … … 598 597 599 598 static void 600 addDays (tr_ benc* args, const char * key, const char * arg)599 addDays (tr_variant * args, const char * key, const char * arg) 601 600 { 602 601 int days = 0; … … 618 617 619 618 if (days) 620 tr_ bencDictAddInt (args, key, days);619 tr_variantDictAddInt (args, key, days); 621 620 else 622 621 fprintf (stderr, "Please specify the days of the week in '1-3,4,7' format.\n"); … … 624 623 625 624 static void 626 addFiles (tr_ benc* args,625 addFiles (tr_variant * args, 627 626 const char * key, 628 627 const char * arg) 629 628 { 630 tr_ benc * files = tr_bencDictAddList (args, key, 100);629 tr_variant * files = tr_variantDictAddList (args, key, 100); 631 630 632 631 if (!*arg) … … 641 640 int * values = tr_parseNumberRange (arg, -1, &valueCount); 642 641 for (i=0; i<valueCount; ++i) 643 tr_ bencListAddInt (files, values[i]);642 tr_variantListAddInt (files, values[i]); 644 643 tr_free (values); 645 644 } … … 763 762 764 763 static char* 765 getStatusString (tr_ benc* t, char * buf, size_t buflen)764 getStatusString (tr_variant * t, char * buf, size_t buflen) 766 765 { 767 766 int64_t status; 768 767 bool boolVal; 769 768 770 if (!tr_ bencDictFindInt (t, "status", &status))769 if (!tr_variantDictFindInt (t, "status", &status)) 771 770 { 772 771 *buf = '\0'; … … 780 779 781 780 case TR_STATUS_STOPPED: 782 if (tr_ bencDictFindBool (t, "isFinished", &boolVal) && boolVal)781 if (tr_variantDictFindBool (t, "isFinished", &boolVal) && boolVal) 783 782 tr_strlcpy (buf, "Finished", buflen); 784 783 else … … 792 791 : "Verifying"; 793 792 double percent; 794 if (tr_ bencDictFindReal (t, "recheckProgress", &percent))793 if (tr_variantDictFindReal (t, "recheckProgress", &percent)) 795 794 tr_snprintf (buf, buflen, "%s (%.0f%%)", str, floor (percent*100.0)); 796 795 else … … 804 803 int64_t fromUs = 0; 805 804 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); 808 807 if (fromUs && toUs) 809 808 tr_strlcpy (buf, "Up & Down", buflen); … … 812 811 else if (fromUs) { 813 812 int64_t leftUntilDone = 0; 814 tr_ bencDictFindInt (t, "leftUntilDone", &leftUntilDone);813 tr_variantDictFindInt (t, "leftUntilDone", &leftUntilDone); 815 814 if (leftUntilDone > 0) 816 815 tr_strlcpy (buf, "Uploading", buflen); … … 835 834 836 835 static 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)))836 printDetails (tr_variant * top) 837 { 838 tr_variant *args, *torrents; 839 840 if ((tr_variantDictFindDict (top, "arguments", &args)) 841 && (tr_variantDictFindList (args, "torrents", &torrents))) 843 842 { 844 843 int ti, tCount; 845 for (ti = 0, tCount = tr_ bencListSize (torrents); ti < tCount;844 for (ti = 0, tCount = tr_variantListSize (torrents); ti < tCount; 846 845 ++ti) 847 846 { 848 tr_ benc * t = tr_bencListChild (torrents, ti);849 tr_ benc* l;847 tr_variant * t = tr_variantListChild (torrents, ti); 848 tr_variant * l; 850 849 const char * str; 851 850 char buf[512]; … … 856 855 857 856 printf ("NAME\n"); 858 if (tr_ bencDictFindInt (t, "id", &i))857 if (tr_variantDictFindInt (t, "id", &i)) 859 858 printf (" Id: %" PRId64 "\n", i); 860 if (tr_ bencDictFindStr (t, "name", &str))859 if (tr_variantDictFindStr (t, "name", &str, NULL)) 861 860 printf (" Name: %s\n", str); 862 if (tr_ bencDictFindStr (t, "hashString", &str))861 if (tr_variantDictFindStr (t, "hashString", &str, NULL)) 863 862 printf (" Hash: %s\n", str); 864 if (tr_ bencDictFindStr (t, "magnetLink", &str))863 if (tr_variantDictFindStr (t, "magnetLink", &str, NULL)) 865 864 printf (" Magnet: %s\n", str); 866 865 printf ("\n"); … … 870 869 printf (" State: %s\n", buf); 871 870 872 if (tr_ bencDictFindStr (t, "downloadDir", &str))871 if (tr_variantDictFindStr (t, "downloadDir", &str, NULL)) 873 872 printf (" Location: %s\n", str); 874 873 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)) 877 876 { 878 877 strlpercent (buf, 100.0 * (i - j) / i, sizeof (buf)); … … 880 879 } 881 880 882 if (tr_ bencDictFindInt (t, "eta", &i))881 if (tr_variantDictFindInt (t, "eta", &i)) 883 882 printf (" ETA: %s\n", tr_strltime (buf, i, sizeof (buf))); 884 if (tr_ bencDictFindInt (t, "rateDownload", &i))883 if (tr_variantDictFindInt (t, "rateDownload", &i)) 885 884 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)) 887 886 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)) 890 889 { 891 890 strlsize (buf, i + j, sizeof (buf)); … … 894 893 } 895 894 896 if (tr_ bencDictFindInt (t, "sizeWhenDone", &i))895 if (tr_variantDictFindInt (t, "sizeWhenDone", &i)) 897 896 { 898 897 if (i < 1) 899 898 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)) 902 901 { 903 902 j += i - k; … … 905 904 printf (" Availability: %s%%\n", buf); 906 905 } 907 if (tr_ bencDictFindInt (t, "totalSize", &j))906 if (tr_variantDictFindInt (t, "totalSize", &j)) 908 907 { 909 908 strlsize (buf2, i, sizeof (buf2)); … … 912 911 } 913 912 } 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)) 916 915 { 917 916 strlsize (buf, i, sizeof (buf)); … … 922 921 printf (" Ratio: %s\n", buf); 923 922 } 924 if (tr_ bencDictFindInt (t, "corruptEver", &i))923 if (tr_variantDictFindInt (t, "corruptEver", &i)) 925 924 { 926 925 strlsize (buf, i, sizeof (buf)); 927 926 printf (" Corrupt DL: %s\n", buf); 928 927 } 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) 931 930 { 932 931 switch (i) { … … 937 936 } 938 937 } 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)) 942 941 { 943 942 printf ( … … 951 950 } 952 951 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); 957 956 if (n > 0) 958 957 printf ( … … 964 963 965 964 printf ("HISTORY\n"); 966 if (tr_ bencDictFindInt (t, "addedDate", &i) && i)965 if (tr_variantDictFindInt (t, "addedDate", &i) && i) 967 966 { 968 967 const time_t tt = i; 969 968 printf (" Date added: %s", ctime (&tt)); 970 969 } 971 if (tr_ bencDictFindInt (t, "doneDate", &i) && i)970 if (tr_variantDictFindInt (t, "doneDate", &i) && i) 972 971 { 973 972 const time_t tt = i; 974 973 printf (" Date finished: %s", ctime (&tt)); 975 974 } 976 if (tr_ bencDictFindInt (t, "startDate", &i) && i)975 if (tr_variantDictFindInt (t, "startDate", &i) && i) 977 976 { 978 977 const time_t tt = i; 979 978 printf (" Date started: %s", ctime (&tt)); 980 979 } 981 if (tr_ bencDictFindInt (t, "activityDate", &i) && i)980 if (tr_variantDictFindInt (t, "activityDate", &i) && i) 982 981 { 983 982 const time_t tt = i; 984 983 printf (" Latest activity: %s", ctime (&tt)); 985 984 } 986 if (tr_ bencDictFindInt (t, "secondsDownloading", &i) && (i > 0))985 if (tr_variantDictFindInt (t, "secondsDownloading", &i) && (i > 0)) 987 986 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)) 989 988 printf (" Seeding Time: %s\n", tr_strltime (buf, i, sizeof (buf))); 990 989 printf ("\n"); 991 990 992 991 printf ("ORIGINS\n"); 993 if (tr_ bencDictFindInt (t, "dateCreated", &i) && i)992 if (tr_variantDictFindInt (t, "dateCreated", &i) && i) 994 993 { 995 994 const time_t tt = i; 996 995 printf (" Date created: %s", ctime (&tt)); 997 996 } 998 if (tr_ bencDictFindBool (t, "isPrivate", &boolVal))997 if (tr_variantDictFindBool (t, "isPrivate", &boolVal)) 999 998 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) 1001 1000 printf (" Comment: %s\n", str); 1002 if (tr_ bencDictFindStr (t, "creator", &str) && str && *str)1001 if (tr_variantDictFindStr (t, "creator", &str, NULL) && str && *str) 1003 1002 printf (" Creator: %s\n", str); 1004 if (tr_ bencDictFindInt (t, "pieceCount", &i))1003 if (tr_variantDictFindInt (t, "pieceCount", &i)) 1005 1004 printf (" Piece Count: %" PRId64 "\n", i); 1006 if (tr_ bencDictFindInt (t, "pieceSize", &i))1005 if (tr_variantDictFindInt (t, "pieceSize", &i)) 1007 1006 printf (" Piece Size: %s\n", strlmem (buf, i, sizeof (buf))); 1008 1007 printf ("\n"); 1009 1008 1010 1009 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)) 1013 1012 { 1014 1013 printf (" Download Limit: "); … … 1018 1017 printf ("Unlimited\n"); 1019 1018 } 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)) 1022 1021 { 1023 1022 printf (" Upload Limit: "); … … 1027 1026 printf ("Unlimited\n"); 1028 1027 } 1029 if (tr_ bencDictFindInt (t, "seedRatioMode", &i))1028 if (tr_variantDictFindInt (t, "seedRatioMode", &i)) 1030 1029 { 1031 1030 switch (i) { … … 1034 1033 break; 1035 1034 case TR_RATIOLIMIT_SINGLE: 1036 if (tr_ bencDictFindReal (t, "seedRatioLimit", &d))1035 if (tr_variantDictFindReal (t, "seedRatioLimit", &d)) 1037 1036 printf (" Ratio Limit: %.2f\n", d); 1038 1037 break; … … 1043 1042 } 1044 1043 } 1045 if (tr_ bencDictFindBool (t, "honorsSessionLimits", &boolVal))1044 if (tr_variantDictFindBool (t, "honorsSessionLimits", &boolVal)) 1046 1045 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)) 1048 1047 printf (" Peer limit: %" PRId64 "\n", i); 1049 if (tr_ bencDictFindInt (t, "bandwidthPriority", &i))1048 if (tr_variantDictFindInt (t, "bandwidthPriority", &i)) 1050 1049 printf (" Bandwidth Priority: %s\n", 1051 1050 bandwidthPriorityNames[ (i + 1) & 3]); … … 1057 1056 1058 1057 static 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)))1058 printFileList (tr_variant * top) 1059 { 1060 tr_variant *args, *torrents; 1061 1062 if ((tr_variantDictFindDict (top, "arguments", &args)) 1063 && (tr_variantDictFindList (args, "torrents", &torrents))) 1065 1064 { 1066 1065 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; 1071 1070 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); 1078 1077 printf ("%s (%d files):\n", name, jn); 1079 1078 printf ("%3s %4s %8s %3s %9s %s\n", "#", "Done", 1080 1079 "Priority", "Get", "Size", 1081 1080 "Name"); 1082 for (j = 0, jn = tr_ bencListSize (files); j < jn; ++j)1081 for (j = 0, jn = tr_variantListSize (files); j < jn; ++j) 1083 1082 { 1084 1083 int64_t have; … … 1087 1086 int64_t wanted; 1088 1087 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, 1094 1093 j), &priority) 1095 && tr_ bencGetInt (tr_bencListChild (wanteds,1094 && tr_variantGetInt (tr_variantListChild (wanteds, 1096 1095 j), &wanted)) 1097 1096 { … … 1126 1125 1127 1126 static void 1128 printPeersImpl (tr_ benc* peers)1127 printPeersImpl (tr_variant * peers) 1129 1128 { 1130 1129 int i, n; 1131 1130 printf ("%-20s %-12s %-5s %-6s %-6s %s\n", 1132 1131 "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) 1134 1133 { 1135 1134 double progress; 1136 1135 const char * address, * client, * flagstr; 1137 1136 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)) 1146 1145 { 1147 1146 printf ("%-20s %-12s %-5.1f %6.1f %6.1f %s\n", … … 1155 1154 1156 1155 static 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))1156 printPeers (tr_variant * top) 1157 { 1158 tr_variant *args, *torrents; 1159 1160 if (tr_variantDictFindDict (top, "arguments", &args) 1161 && tr_variantDictFindList (args, "torrents", &torrents)) 1163 1162 { 1164 1163 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)) { 1170 1169 printPeersImpl (peers); 1171 1170 if (i+1<n) … … 1195 1194 1196 1195 static 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))1196 printPieces (tr_variant * top) 1197 { 1198 tr_variant *args, *torrents; 1199 1200 if (tr_variantDictFindDict (top, "arguments", &args) 1201 && tr_variantDictFindList (args, "torrents", &torrents)) 1203 1202 { 1204 1203 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) 1206 1205 { 1207 1206 int64_t j; 1208 1207 const uint8_t * raw; 1209 1208 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)) { 1213 1212 printPiecesImpl (raw, rawlen, j); 1214 1213 if (i+1<n) … … 1220 1219 1221 1220 static void 1222 printPortTest (tr_ benc* top)1223 { 1224 tr_ benc*args;1225 if ((tr_ bencDictFindDict (top, "arguments", &args)))1221 printPortTest (tr_variant * top) 1222 { 1223 tr_variant *args; 1224 if ((tr_variantDictFindDict (top, "arguments", &args))) 1226 1225 { 1227 1226 bool boolVal; 1228 1227 1229 if (tr_ bencDictFindBool (args, "port-is-open", &boolVal))1228 if (tr_variantDictFindBool (args, "port-is-open", &boolVal)) 1230 1229 printf ("Port is open: %s\n", (boolVal ? "Yes" : "No")); 1231 1230 } … … 1233 1232 1234 1233 static 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)))1234 printTorrentList (tr_variant * top) 1235 { 1236 tr_variant *args, *list; 1237 1238 if ((tr_variantDictFindDict (top, "arguments", &args)) 1239 && (tr_variantDictFindList (args, "torrents", &list))) 1241 1240 { 1242 1241 int i, n; … … 1249 1248 "Name"); 1250 1249 1251 for (i = 0, n = tr_ bencListSize (list); i < n; ++i)1250 for (i = 0, n = tr_variantListSize (list); i < n; ++i) 1252 1251 { 1253 1252 int64_t id, eta, status, up, down; … … 1255 1254 double ratio; 1256 1255 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)) 1267 1266 { 1268 1267 char etaStr[16]; … … 1284 1283 else 1285 1284 tr_snprintf (etaStr, sizeof (etaStr), "Done"); 1286 if (tr_ bencDictFindInt (d, "error", &error) && error)1285 if (tr_variantDictFindInt (d, "error", &error) && error) 1287 1286 errorMark = '*'; 1288 1287 else … … 1314 1313 1315 1314 static void 1316 printTrackersImpl (tr_ benc* trackerStats)1315 printTrackersImpl (tr_variant * trackerStats) 1317 1316 { 1318 1317 int i; 1319 1318 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) 1323 1322 { 1324 1323 int64_t downloadCount; … … 1347 1346 int64_t scrapeState; 1348 1347 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)) 1373 1372 { 1374 1373 const time_t now = time (NULL); … … 1449 1448 1450 1449 static 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))1450 printTrackers (tr_variant * top) 1451 { 1452 tr_variant *args, *torrents; 1453 1454 if (tr_variantDictFindDict (top, "arguments", &args) 1455 && tr_variantDictFindList (args, "torrents", &torrents)) 1457 1456 { 1458 1457 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)) { 1464 1463 printTrackersImpl (trackerStats); 1465 1464 if (i+1<n) … … 1471 1470 1472 1471 static void 1473 printSession (tr_ benc* top)1474 { 1475 tr_ benc*args;1476 if ((tr_ bencDictFindDict (top, "arguments", &args)))1472 printSession (tr_variant * top) 1473 { 1474 tr_variant *args; 1475 if ((tr_variantDictFindDict (top, "arguments", &args))) 1477 1476 { 1478 1477 int64_t i; … … 1482 1481 1483 1482 printf ("VERSION\n"); 1484 if (tr_ bencDictFindStr (args, "version", &str))1483 if (tr_variantDictFindStr (args, "version", &str, NULL)) 1485 1484 printf (" Daemon version: %s\n", str); 1486 if (tr_ bencDictFindInt (args, "rpc-version", &i))1485 if (tr_variantDictFindInt (args, "rpc-version", &i)) 1487 1486 printf (" RPC version: %" PRId64 "\n", i); 1488 if (tr_ bencDictFindInt (args, "rpc-version-minimum", &i))1487 if (tr_variantDictFindInt (args, "rpc-version-minimum", &i)) 1489 1488 printf (" RPC minimum version: %" PRId64 "\n", i); 1490 1489 printf ("\n"); 1491 1490 1492 1491 printf ("CONFIG\n"); 1493 if (tr_ bencDictFindStr (args, "config-dir", &str))1492 if (tr_variantDictFindStr (args, "config-dir", &str, NULL)) 1494 1493 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)) 1496 1495 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)) 1498 1497 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)) 1500 1499 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)) 1502 1501 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)) 1504 1503 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)) 1506 1505 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)) 1508 1507 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)) 1510 1509 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)) 1512 1511 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)) 1514 1513 printf (" Maximum memory cache size: %s\n", tr_formatter_mem_MB (buf, i, sizeof (buf))); 1515 1514 printf ("\n"); … … 1520 1519 double seedRatioLimit; 1521 1520 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)) 1536 1535 { 1537 1536 char buf[128]; … … 1592 1591 1593 1592 printf ("MISC\n"); 1594 if (tr_ bencDictFindBool (args, TR_PREFS_KEY_START, &boolVal))1593 if (tr_variantDictFindBool (args, TR_PREFS_KEY_START, &boolVal)) 1595 1594 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)) 1597 1596 printf (" Delete automatically added torrents: %s\n", (boolVal ? "Yes" : "No")); 1598 1597 } … … 1600 1599 1601 1600 static void 1602 printSessionStats (tr_ benc* top)1603 { 1604 tr_ benc*args, *d;1605 if ((tr_ bencDictFindDict (top, "arguments", &args)))1601 printSessionStats (tr_variant * top) 1602 { 1603 tr_variant *args, *d; 1604 if ((tr_variantDictFindDict (top, "arguments", &args))) 1606 1605 { 1607 1606 char buf[512]; 1608 1607 int64_t up, down, secs, sessions; 1609 1608 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)) 1614 1613 { 1615 1614 printf ("\nCURRENT SESSION\n"); … … 1620 1619 } 1621 1620 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)) 1627 1626 { 1628 1627 printf ("\nTOTAL\n"); … … 1641 1640 processResponse (const char * rpcurl, const void * response, size_t len) 1642 1641 { 1643 tr_ benctop;1642 tr_variant top; 1644 1643 int status = EXIT_SUCCESS; 1645 1644 … … 1648 1647 (int)len, (int)len, (int)len, (const char*) response); 1649 1648 1650 if (tr_ jsonParse (NULL, response, len, &top, NULL))1649 if (tr_variantFromJson (&top, response, len)) 1651 1650 { 1652 1651 tr_nerr (MY_NAME, "Unable to parse response \"%*.*s\"", (int)len, … … 1659 1658 const char * str; 1660 1659 1661 if (tr_ bencDictFindStr (&top, "result", &str))1660 if (tr_variantDictFindStr (&top, "result", &str, NULL)) 1662 1661 { 1663 1662 if (strcmp (str, "success")) … … 1668 1667 else 1669 1668 { 1670 tr_ bencDictFindInt (&top, "tag", &tag);1669 tr_variantDictFindInt (&top, "tag", &tag); 1671 1670 1672 1671 switch (tag) … … 1701 1700 case TAG_TORRENT_ADD: { 1702 1701 int64_t i; 1703 tr_ benc* b = ⊤1704 if (tr_ bencDictFindDict (&top, ARGUMENTS, &b)1705 && tr_ bencDictFindDict (b, "torrent-added", &b)1706 && tr_ bencDictFindInt (b, "id", &i))1702 tr_variant * b = ⊤ 1703 if (tr_variantDictFindDict (&top, ARGUMENTS, &b) 1704 && tr_variantDictFindDict (b, "torrent-added", &b) 1705 && tr_variantDictFindInt (b, "id", &i)) 1707 1706 tr_snprintf (id, sizeof (id), "%"PRId64, i); 1708 1707 /* fall-through to default: to give success or failure msg */ 1709 1708 } 1710 1709 default: 1711 if (!tr_ bencDictFindStr (&top, "result", &str))1710 if (!tr_variantDictFindStr (&top, "result", &str, NULL)) 1712 1711 status |= EXIT_FAILURE; 1713 1712 else { … … 1718 1717 } 1719 1718 1720 tr_ bencFree (&top);1719 tr_variantFree (&top); 1721 1720 } 1722 1721 } … … 1757 1756 1758 1757 static int 1759 flush (const char * rpcurl, tr_ benc** benc)1758 flush (const char * rpcurl, tr_variant ** benc) 1760 1759 { 1761 1760 CURLcode res; … … 1763 1762 int status = EXIT_SUCCESS; 1764 1763 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); 1766 1765 char *rpcurl_http = tr_strdup_printf (UseSSL? "https://%s" : "http://%s", rpcurl); 1767 1766 … … 1810 1809 curl_easy_cleanup (curl); 1811 1810 if (benc != NULL) { 1812 tr_ bencFree (*benc);1811 tr_variantFree (*benc); 1813 1812 *benc = 0; 1814 1813 } … … 1816 1815 } 1817 1816 1818 static tr_ benc*1819 ensure_sset (tr_ benc** sset)1820 { 1821 tr_ benc* args;1817 static tr_variant* 1818 ensure_sset (tr_variant ** sset) 1819 { 1820 tr_variant * args; 1822 1821 1823 1822 if (*sset) 1824 args = tr_ bencDictFind (*sset, ARGUMENTS);1823 args = tr_variantDictFind (*sset, ARGUMENTS); 1825 1824 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); 1830 1829 } 1831 1830 … … 1833 1832 } 1834 1833 1835 static tr_ benc*1836 ensure_tset (tr_ benc** tset)1837 { 1838 tr_ benc* args;1834 static tr_variant* 1835 ensure_tset (tr_variant ** tset) 1836 { 1837 tr_variant * args; 1839 1838 1840 1839 if (*tset) 1841 args = tr_ bencDictFind (*tset, ARGUMENTS);1840 args = tr_variantDictFind (*tset, ARGUMENTS); 1842 1841 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); 1847 1846 } 1848 1847 … … 1856 1855 int status = EXIT_SUCCESS; 1857 1856 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; 1861 1860 1862 1861 *id = '\0'; … … 1873 1872 if (sset != 0) status |= flush (rpcurl, &sset); 1874 1873 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); 1881 1880 break; 1882 1881 … … 1910 1909 case 't': /* set current torrent */ 1911 1910 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); } 1913 1912 tr_strlcpy (id, optarg, sizeof (id)); 1914 1913 break; … … 1927 1926 case TR_OPT_UNK: 1928 1927 if (tadd) { 1929 tr_ benc * args = tr_bencDictFind (tadd, ARGUMENTS);1928 tr_variant * args = tr_variantDictFind (tadd, ARGUMENTS); 1930 1929 char * tmp = getEncodedMetainfo (optarg); 1931 1930 if (tmp) 1932 tr_ bencDictAddStr (args, "metainfo", tmp);1931 tr_variantDictAddStr (args, "metainfo", tmp); 1933 1932 else 1934 tr_ bencDictAddStr (args, "filename", optarg);1933 tr_variantDictAddStr (args, "filename", optarg); 1935 1934 tr_free (tmp); 1936 1935 } else { … … 1944 1943 { 1945 1944 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); } 1955 1954 1956 1955 switch (c) 1957 1956 { 1958 case 'i': tr_ bencDictAddInt (top, "tag", TAG_DETAILS);1957 case 'i': tr_variantDictAddInt (top, "tag", TAG_DETAILS); 1959 1958 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]); 1961 1960 addIdArg (args, id); 1962 1961 break; 1963 case 'l': tr_ bencDictAddInt (top, "tag", TAG_LIST);1962 case 'l': tr_variantDictAddInt (top, "tag", TAG_LIST); 1964 1963 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); 1968 1967 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]); 1970 1969 addIdArg (args, id); 1971 1970 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"); 1974 1973 addIdArg (args, id); 1975 1974 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"); 1979 1978 addIdArg (args, id); 1980 1979 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"); 1983 1982 addIdArg (args, id); 1984 1983 break; … … 1990 1989 else if (stepMode == MODE_SESSION_SET) 1991 1990 { 1992 tr_ benc* args = ensure_sset (&sset);1991 tr_variant * args = ensure_sset (&sset); 1993 1992 1994 1993 switch (c) 1995 1994 { 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); 2012 2011 break; 2013 2012 case 976: addTime (args, TR_PREFS_KEY_ALT_SPEED_TIME_BEGIN, optarg); … … 2017 2016 case 978: addDays (args, TR_PREFS_KEY_ALT_SPEED_TIME_DAY, optarg); 2018 2017 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); 2068 2067 break; 2069 2068 default: assert ("unhandled value" && 0); … … 2073 2072 else if (stepMode == (MODE_SESSION_SET | MODE_TORRENT_SET)) 2074 2073 { 2075 tr_ benc* targs = 0;2076 tr_ benc* sargs = 0;2074 tr_variant * targs = 0; 2075 tr_variant * sargs = 0; 2077 2076 2078 2077 if (*id) … … 2084 2083 { 2085 2084 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); 2088 2087 } 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); 2091 2090 } 2092 2091 break; 2093 2092 case 'D': if (targs) 2094 tr_ bencDictAddBool (targs, "downloadLimited", false);2093 tr_variantDictAddBool (targs, "downloadLimited", false); 2095 2094 else 2096 tr_ bencDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, false);2095 tr_variantDictAddBool (sargs, TR_PREFS_KEY_DSPEED_ENABLED, false); 2097 2096 break; 2098 2097 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); 2101 2100 } 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); 2104 2103 } 2105 2104 break; 2106 2105 case 'U': if (targs) 2107 tr_ bencDictAddBool (targs, "uploadLimited", false);2106 tr_variantDictAddBool (targs, "uploadLimited", false); 2108 2107 else 2109 tr_ bencDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, false);2108 tr_variantDictAddBool (sargs, TR_PREFS_KEY_USPEED_ENABLED, false); 2110 2109 break; 2111 2110 case 930: if (targs) 2112 tr_ bencDictAddInt (targs, "peer-limit", atoi (optarg));2111 tr_variantDictAddInt (targs, "peer-limit", atoi (optarg)); 2113 2112 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)); 2115 2114 break; 2116 2115 default: assert ("unhandled value" && 0); … … 2120 2119 else if (stepMode == MODE_TORRENT_SET) 2121 2120 { 2122 tr_ benc* args = ensure_tset (&tset);2121 tr_variant * args = ensure_tset (&tset); 2123 2122 2124 2123 switch (c) 2125 2124 { 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); 2138 2137 break; 2139 2138 default: assert ("unhandled value" && 0); … … 2143 2142 else if (stepMode == (MODE_TORRENT_SET | MODE_TORRENT_ADD)) 2144 2143 { 2145 tr_ benc* args;2144 tr_variant * args; 2146 2145 2147 2146 if (tadd) 2148 args = tr_ bencDictFind (tadd, ARGUMENTS);2147 args = tr_variantDictFind (tadd, ARGUMENTS); 2149 2148 else 2150 2149 args = ensure_tset (&tset); … … 2162 2161 case 902: addFiles (args, "priority-low", optarg); 2163 2162 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); 2171 2170 break; 2172 2171 default: assert ("unhandled value" && 0); … … 2178 2177 if (tadd) 2179 2178 { 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); 2182 2181 } 2183 2182 else 2184 2183 { 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); 2192 2191 addIdArg (args, id); 2193 2192 status |= flush (rpcurl, &top); … … 2199 2198 case 920: /* session-info */ 2200 2199 { 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); 2205 2204 status |= flush (rpcurl, &top); 2206 2205 break; … … 2209 2208 { 2210 2209 if (tadd) 2211 tr_ bencDictAddBool (tr_bencDictFind (tadd, "arguments"), "paused", false);2210 tr_variantDictAddBool (tr_variantDictFind (tadd, "arguments"), "paused", false); 2212 2211 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); 2217 2216 status |= flush (rpcurl, &top); 2218 2217 } … … 2222 2221 { 2223 2222 if (tadd) 2224 tr_ bencDictAddBool (tr_bencDictFind (tadd, "arguments"), "paused", true);2223 tr_variantDictAddBool (tr_variantDictFind (tadd, "arguments"), "paused", true); 2225 2224 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); 2230 2229 status |= flush (rpcurl, &top); 2231 2230 } … … 2236 2235 char * path = absolutify (optarg); 2237 2236 if (tadd) 2238 tr_ bencDictAddStr (tr_bencDictFind (tadd, "arguments"), "download-dir", path);2237 tr_variantDictAddStr (tr_variantDictFind (tadd, "arguments"), "download-dir", path); 2239 2238 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); 2242 2241 } 2243 2242 tr_free (path); … … 2246 2245 case 850: 2247 2246 { 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"); 2251 2250 status |= flush (rpcurl, &top); 2252 2251 break; … … 2254 2253 case 963: 2255 2254 { 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"); 2259 2258 status |= flush (rpcurl, &top); 2260 2259 break; … … 2262 2261 case 921: 2263 2262 { 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); 2268 2267 status |= flush (rpcurl, &top); 2269 2268 break; … … 2271 2270 case 962: 2272 2271 { 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); 2277 2276 status |= flush (rpcurl, &top); 2278 2277 break; … … 2280 2279 case 600: 2281 2280 { 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); 2288 2287 status |= flush (rpcurl, &top); 2289 2288 break; … … 2291 2290 case 'v': 2292 2291 { 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); 2299 2298 status |= flush (rpcurl, &top); 2300 2299 break; … … 2303 2302 case 'R': 2304 2303 { 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'); 2311 2310 addIdArg (args, id); 2312 2311 status |= flush (rpcurl, &top); … … 2315 2314 case 960: 2316 2315 { 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); 2324 2323 addIdArg (args, id); 2325 2324 status |= flush (rpcurl, &top); … … 2336 2335 2337 2336 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); } 2339 2338 if (sset != 0) status |= flush (rpcurl, &sset); 2340 2339 return status; -
trunk/gtk/conf.c
r13638 r13667 35 35 36 36 #include <libtransmission/transmission.h> 37 #include <libtransmission/ bencode.h>37 #include <libtransmission/variant.h> 38 38 39 39 #include "conf.h" … … 65 65 */ 66 66 static void 67 tr_prefs_init_defaults (tr_ benc* d)67 tr_prefs_init_defaults (tr_variant * d) 68 68 { 69 69 const char * str; … … 78 78 str = tr_getDefaultDownloadDir (); 79 79 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); 119 119 } 120 120 … … 126 126 } 127 127 128 static tr_ benc*128 static tr_variant* 129 129 getPrefs (void) 130 130 { 131 static tr_ bencsettings;131 static tr_variant settings; 132 132 static gboolean loaded = FALSE; 133 133 134 134 if (!loaded) 135 135 { 136 tr_ bencInitDict (&settings, 0);136 tr_variantInitDict (&settings, 0); 137 137 tr_prefs_init_defaults (&settings); 138 138 tr_sessionLoadSettings (&settings, gl_confdir, MY_CONFIG_NAME); … … 147 147 ***/ 148 148 149 tr_ benc*149 tr_variant* 150 150 gtr_pref_get_all (void) 151 151 { … … 158 158 int64_t i = 0; 159 159 160 tr_ bencDictFindInt (getPrefs (), key, &i);160 tr_variantDictFindInt (getPrefs (), key, &i); 161 161 162 162 return i; … … 166 166 gtr_pref_int_set (const char * key, int64_t value) 167 167 { 168 tr_ bencDictAddInt (getPrefs (), key, value);168 tr_variantDictAddInt (getPrefs (), key, value); 169 169 } 170 170 … … 174 174 double d = 0.0; 175 175 176 tr_ bencDictFindReal (getPrefs (), key, &d);176 tr_variantDictFindReal (getPrefs (), key, &d); 177 177 178 178 return d; … … 182 182 gtr_pref_double_set (const char * key, double value) 183 183 { 184 tr_ bencDictAddReal (getPrefs (), key, value);184 tr_variantDictAddReal (getPrefs (), key, value); 185 185 } 186 186 … … 194 194 bool boolVal; 195 195 196 tr_ bencDictFindBool (getPrefs (), key, &boolVal);196 tr_variantDictFindBool (getPrefs (), key, &boolVal); 197 197 198 198 return boolVal != 0; … … 202 202 gtr_pref_flag_set (const char * key, gboolean value) 203 203 { 204 tr_ bencDictAddBool (getPrefs (), key, value);204 tr_variantDictAddBool (getPrefs (), key, value); 205 205 } 206 206 … … 214 214 const char * str = NULL; 215 215 216 tr_ bencDictFindStr (getPrefs (), key, &str);216 tr_variantDictFindStr (getPrefs (), key, &str, NULL); 217 217 218 218 return str; … … 222 222 gtr_pref_string_set (const char * key, const char * value) 223 223 { 224 tr_ bencDictAddStr (getPrefs (), key, value);224 tr_variantDictAddStr (getPrefs (), key, value); 225 225 } 226 226 … … 256 256 translate_keyfile_to_json (const char * old_file, const char * new_file) 257 257 { 258 tr_ bencdict;258 tr_variant dict; 259 259 GKeyFile * keyfile; 260 260 gchar ** keys; … … 280 280 keys = g_key_file_get_keys (keyfile, "general", &length, NULL); 281 281 282 tr_ bencInitDict (&dict, length);282 tr_variantInitDict (&dict, length); 283 283 for (i=0; i<length; i++) 284 284 { … … 293 293 if (!strcmp (val, "true") || !strcmp (val, "false")) 294 294 { 295 tr_ bencDictAddInt (&dict, key, !strcmp (val, "true"));295 tr_variantDictAddInt (&dict, key, !strcmp (val, "true")); 296 296 } 297 297 else … … 304 304 l = strtol (val, &end, 10); 305 305 if (!errno && end && !*end) 306 tr_ bencDictAddInt (&dict, key, l);306 tr_variantDictAddInt (&dict, key, l); 307 307 else 308 tr_ bencDictAddStr (&dict, key, val);308 tr_variantDictAddStr (&dict, key, val); 309 309 } 310 310 … … 313 313 314 314 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); 317 317 } 318 318 -
trunk/gtk/conf.h
r13625 r13667 27 27 28 28 #include <inttypes.h> 29 #include <libtransmission/transmission.h> /* tr_ benc, tr_session */29 #include <libtransmission/transmission.h> /* tr_variant, tr_session */ 30 30 31 31 void gtr_pref_init (const char * config_dir); … … 44 44 45 45 void gtr_pref_save (tr_session *); 46 struct tr_ benc* gtr_pref_get_all (void);46 struct tr_variant* gtr_pref_get_all (void); 47 47 48 48 #endif /* GTR_CONFIG_H */ -
trunk/gtk/details.c
r13651 r13667 319 319 { 320 320 GSList *l; 321 tr_ benctop, *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)); 328 328 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)); 330 330 331 331 gtr_core_exec (di->core, &top); 332 tr_ bencFree (&top);332 tr_variantFree (&top); 333 333 } 334 334 … … 337 337 { 338 338 GSList *l; 339 tr_ benctop, *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)); 346 346 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)); 348 348 349 349 gtr_core_exec (di->core, &top); 350 tr_ bencFree (&top);350 tr_variantFree (&top); 351 351 } 352 352 … … 355 355 { 356 356 GSList *l; 357 tr_ benctop, *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)); 364 364 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)); 366 366 367 367 gtr_core_exec (di->core, &top); 368 tr_ bencFree (&top);368 tr_variantFree (&top); 369 369 } 370 370 -
trunk/gtk/main.c
r13625 r13667 403 403 case TR_RPC_SESSION_CHANGED: { 404 404 int i; 405 tr_ benctmp;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 (); 408 408 const char * key; 409 409 GSList * l; 410 410 GSList * changed_keys = NULL; 411 tr_ bencInitDict (&tmp, 100);411 tr_variantInitDict (&tmp, 100); 412 412 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) 414 414 { 415 415 bool changed; 416 tr_ benc * oldval = tr_bencDictFind (oldvals, key);416 tr_variant * oldval = tr_variantDictFind (oldvals, key); 417 417 if (!oldval) 418 418 { … … 421 421 else 422 422 { 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); 425 425 changed = strcmp (a, b) != 0; 426 426 tr_free (b); … … 437 437 438 438 g_slist_free (changed_keys); 439 tr_ bencFree (&tmp);439 tr_variantFree (&tmp); 440 440 break; 441 441 } … … 1344 1344 tr_torrent * tor = NULL; 1345 1345 gtk_tree_model_get (m, iter, MC_TORRENT, &tor, -1); 1346 tr_ bencListAddInt (list, tr_torrentId (tor));1346 tr_variantListAddInt (list, tr_torrentId (tor)); 1347 1347 } 1348 1348 … … 1350 1350 call_rpc_for_selected_torrents (struct cbdata * data, const char * method) 1351 1351 { 1352 tr_ benctop, *args, *ids;1352 tr_variant top, *args, *ids; 1353 1353 gboolean invoked = FALSE; 1354 1354 GtkTreeSelection * s = data->sel; 1355 1355 tr_session * session = gtr_core_session (data->core); 1356 1356 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); 1361 1361 gtk_tree_selection_selected_foreach (s, append_id_to_benc_list, ids); 1362 1362 1363 if (tr_ bencListSize (ids) != 0)1363 if (tr_variantListSize (ids) != 0) 1364 1364 { 1365 1365 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); 1367 1367 tr_rpc_request_exec_json (session, json, json_len, NULL, NULL); 1368 1368 g_free (json); … … 1370 1370 } 1371 1371 1372 tr_ bencFree (&top);1372 tr_variantFree (&top); 1373 1373 return invoked; 1374 1374 } -
trunk/gtk/tr-core.c
r13625 r13667 33 33 34 34 #include <libtransmission/transmission.h> 35 #include <libtransmission/bencode.h>36 35 #include <libtransmission/rpcimpl.h> 37 #include <libtransmission/json.h>38 36 #include <libtransmission/utils.h> /* tr_free */ 37 #include <libtransmission/variant.h> 39 38 40 39 #include "actions.h" … … 1666 1665 static int nextTag = 1; 1667 1666 1668 typedef void (server_response_func)(TrCore * core, tr_ benc* response, gpointer user_data);1667 typedef void (server_response_func)(TrCore * core, tr_variant * response, gpointer user_data); 1669 1668 1670 1669 struct pending_request_data … … 1680 1679 core_read_rpc_response_idle (void * vresponse) 1681 1680 { 1682 tr_ benctop;1681 tr_variant top; 1683 1682 int64_t intVal; 1684 1683 struct evbuffer * response = vresponse; 1685 1684 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)) 1689 1688 { 1690 1689 const int tag = (int)intVal; … … 1698 1697 } 1699 1698 1700 tr_ bencFree (&top);1699 tr_variantFree (&top); 1701 1700 evbuffer_free (response); 1702 1701 return FALSE; … … 1752 1751 1753 1752 static void 1754 on_port_test_response (TrCore * core, tr_ benc* response, gpointer u UNUSED)1755 { 1756 tr_ benc* args;1753 on_port_test_response (TrCore * core, tr_variant * response, gpointer u UNUSED) 1754 { 1755 tr_variant * args; 1757 1756 bool is_open = FALSE; 1758 1757 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); 1761 1760 1762 1761 core_emit_port_tested (core, is_open); … … 1777 1776 1778 1777 static void 1779 on_blocklist_response (TrCore * core, tr_ benc* response, gpointer data UNUSED)1780 { 1781 tr_ benc* args;1778 on_blocklist_response (TrCore * core, tr_variant * response, gpointer data UNUSED) 1779 { 1780 tr_variant * args; 1782 1781 int64_t ruleCount = -1; 1783 1782 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); 1786 1785 1787 1786 if (ruleCount > 0) … … 1812 1811 1813 1812 void 1814 gtr_core_exec (TrCore * core, const tr_ benc* top)1815 { 1816 char * json = tr_ bencToStr (top, TR_FMT_JSON_LEAN, NULL);1813 gtr_core_exec (TrCore * core, const tr_variant * top) 1814 { 1815 char * json = tr_variantToStr (top, TR_VARIANT_FMT_JSON_LEAN, NULL); 1817 1816 gtr_core_exec_json (core, json); 1818 1817 tr_free (json); -
trunk/gtk/tr-core.h
r13625 r13667 29 29 30 30 #include <libtransmission/transmission.h> 31 #include <libtransmission/ bencode.h>31 #include <libtransmission/variant.h> 32 32 33 33 G_BEGIN_DECLS … … 154 154 void gtr_core_blocklist_update (TrCore * core); 155 155 156 void gtr_core_exec (TrCore * core, const tr_ benc* benc);156 void gtr_core_exec (TrCore * core, const tr_variant * benc); 157 157 158 158 void gtr_core_exec_json (TrCore * core, const char * json); -
trunk/libtransmission/Makefile.am
r13635 r13667 22 22 announcer-udp.c \ 23 23 bandwidth.c \ 24 bencode.c \25 24 bitfield.c \ 26 25 blocklist.c \ … … 34 33 history.c \ 35 34 inout.c \ 36 json.c \37 35 list.c \ 38 36 magnet.c \ … … 63 61 upnp.c \ 64 62 utils.c \ 63 variant.c \ 64 variant-benc.c \ 65 variant-json.c \ 65 66 verify.c \ 66 67 web.c \ … … 72 73 announcer-common.h \ 73 74 bandwidth.h \ 74 bencode.h \75 75 bitfield.h \ 76 76 blocklist.h \ … … 86 86 jsonsl.c \ 87 87 jsonsl.h \ 88 json.h \89 88 libtransmission-test.h \ 90 89 list.h \ … … 117 116 upnp.h \ 118 117 utils.h \ 118 variant.h \ 119 variant-common.h \ 119 120 verify.h \ 120 121 version.h \ … … 125 126 bitfield-test \ 126 127 blocklist-test \ 127 bencode-test \128 128 clients-test \ 129 129 history-test \ … … 134 134 rpc-test \ 135 135 test-peer-id \ 136 utils-test 136 utils-test \ 137 variant-test 137 138 138 139 noinst_PROGRAMS = $(TESTS) … … 154 155 @ZLIB_LIBS@ 155 156 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 157 TEST_SOURCES = libtransmission-test.c 158 159 bitfield_test_SOURCES = bitfield-test.c $(TEST_SOURCES) 161 160 bitfield_test_LDADD = ${apps_ldadd} 162 161 bitfield_test_LDFLAGS = ${apps_ldflags} 163 162 164 blocklist_test_SOURCES = blocklist-test.c 163 blocklist_test_SOURCES = blocklist-test.c $(TEST_SOURCES) 165 164 blocklist_test_LDADD = ${apps_ldadd} 166 165 blocklist_test_LDFLAGS = ${apps_ldflags} 167 166 168 clients_test_SOURCES = clients-test.c 167 clients_test_SOURCES = clients-test.c $(TEST_SOURCES) 169 168 clients_test_LDADD = ${apps_ldadd} 170 169 clients_test_LDFLAGS = ${apps_ldflags} 171 170 172 history_test_SOURCES = history-test.c 171 history_test_SOURCES = history-test.c $(TEST_SOURCES) 173 172 history_test_LDADD = ${apps_ldadd} 174 173 history_test_LDFLAGS = ${apps_ldflags} 175 174 176 json_test_SOURCES = json-test.c 175 json_test_SOURCES = json-test.c $(TEST_SOURCES) 177 176 json_test_LDADD = ${apps_ldadd} 178 177 json_test_LDFLAGS = ${apps_ldflags} 179 178 180 magnet_test_SOURCES = magnet-test.c 179 magnet_test_SOURCES = magnet-test.c $(TEST_SOURCES) 181 180 magnet_test_LDADD = ${apps_ldadd} 182 181 magnet_test_LDFLAGS = ${apps_ldflags} 183 182 184 metainfo_test_SOURCES = metainfo-test.c 183 metainfo_test_SOURCES = metainfo-test.c $(TEST_SOURCES) 185 184 metainfo_test_LDADD = ${apps_ldadd} 186 185 metainfo_test_LDFLAGS = ${apps_ldflags} 187 186 188 peer_msgs_test_SOURCES = peer-msgs-test.c 187 peer_msgs_test_SOURCES = peer-msgs-test.c $(TEST_SOURCES) 189 188 peer_msgs_test_LDADD = ${apps_ldadd} 190 189 peer_msgs_test_LDFLAGS = ${apps_ldflags} 191 190 192 rpc_test_SOURCES = rpc-test.c 191 rpc_test_SOURCES = rpc-test.c $(TEST_SOURCES) 193 192 rpc_test_LDADD = ${apps_ldadd} 194 193 rpc_test_LDFLAGS = ${apps_ldflags} 195 194 196 test_peer_id_SOURCES = test-peer-id.c 195 test_peer_id_SOURCES = test-peer-id.c $(TEST_SOURCES) 197 196 test_peer_id_LDADD = ${apps_ldadd} 198 197 test_peer_id_LDFLAGS = ${apps_ldflags} 199 198 200 utils_test_SOURCES = utils-test.c 199 utils_test_SOURCES = utils-test.c $(TEST_SOURCES) 201 200 utils_test_LDADD = ${apps_ldadd} 202 201 utils_test_LDFLAGS = ${apps_ldflags} 202 203 variant_test_SOURCES = variant-test.c $(TEST_SOURCES) 204 variant_test_LDADD = ${apps_ldadd} 205 variant_test_LDFLAGS = ${apps_ldflags} -
trunk/libtransmission/announcer-http.c
r13631 r13667 28 28 #include "trevent.h" /* tr_runInEventThread () */ 29 29 #include "utils.h" 30 #include "variant.h" 30 31 #include "web.h" /* tr_http_escape () */ 31 32 … … 121 122 122 123 static tr_pex* 123 listToPex (tr_ benc* peerList, size_t * setme_len)124 listToPex (tr_variant * peerList, size_t * setme_len) 124 125 { 125 126 size_t i; 126 127 size_t n; 127 const size_t len = tr_ bencListSize (peerList);128 const size_t len = tr_variantListSize (peerList); 128 129 tr_pex * pex = tr_new0 (tr_pex, len); 129 130 … … 133 134 const char * ip; 134 135 tr_address addr; 135 tr_ benc * peer = tr_bencListChild (peerList, i);136 tr_variant * peer = tr_variantListChild (peerList, i); 136 137 137 138 if (peer == NULL) 138 139 continue; 139 if (!tr_ bencDictFindStr (peer, "ip", &ip))140 if (!tr_variantDictFindStr (peer, "ip", &ip, NULL)) 140 141 continue; 141 142 if (!tr_address_from_string (&addr, ip)) 142 143 continue; 143 if (!tr_ bencDictFindInt (peer, "port", &port))144 if (!tr_variantDictFindInt (peer, "port", &port)) 144 145 continue; 145 146 if ((port < 0) || (port > USHRT_MAX)) … … 207 208 else 208 209 { 209 tr_ bencbenc;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); 211 212 212 213 if (getenv ("TR_CURL_VERBOSE") != NULL) 213 214 { 214 if (! benc_loaded)215 if (!variant_loaded) 215 216 fprintf (stderr, "%s", "Announce response was not in benc format\n"); 216 217 else { 217 218 int i, len; 218 char * str = tr_ bencToStr (&benc, TR_FMT_JSON, &len);219 char * str = tr_variantToStr (&benc, TR_VARIANT_FMT_JSON, &len); 219 220 fprintf (stderr, "%s", "Announce response:\n< "); 220 221 for (i=0; i<len; ++i) … … 225 226 } 226 227 227 if ( benc_loaded && tr_bencIsDict (&benc))228 if (variant_loaded && tr_variantIsDict (&benc)) 228 229 { 229 230 int64_t i; 230 size_t rawlen;231 tr_ benc* tmp;231 size_t len; 232 tr_variant * tmp; 232 233 const char * str; 233 234 const uint8_t * raw; 234 235 235 if (tr_ bencDictFindStr (&benc, "failure reason", &str))236 response->errmsg = tr_str dup (str);237 238 if (tr_ bencDictFindStr (&benc, "warning message", &str))239 response->warning = tr_str dup (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)) 242 243 response->interval = i; 243 244 244 if (tr_ bencDictFindInt (&benc, "min interval", &i))245 if (tr_variantDictFindInt (&benc, "min interval", &i)) 245 246 response->min_interval = i; 246 247 247 if (tr_ bencDictFindStr (&benc, "tracker id", &str))248 response->tracker_id_str = tr_str dup (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)) 251 252 response->seeders = i; 252 253 253 if (tr_ bencDictFindInt (&benc, "incomplete", &i))254 if (tr_variantDictFindInt (&benc, "incomplete", &i)) 254 255 response->leechers = i; 255 256 256 if (tr_ bencDictFindInt (&benc, "downloaded", &i))257 if (tr_variantDictFindInt (&benc, "downloaded", &i)) 257 258 response->downloads = i; 258 259 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, 262 263 NULL, 0, &response->pex6_count); 263 264 } 264 265 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, 268 269 NULL, 0, &response->pex_count); 269 } else if (tr_ bencDictFindList (&benc, "peers", &tmp)) {270 } else if (tr_variantDictFindList (&benc, "peers", &tmp)) { 270 271 response->pex = listToPex (tmp, &response->pex_count); 271 272 dbgmsg (data->log_name, "got a peers list with %zu entries", … … 274 275 } 275 276 276 if ( benc_loaded)277 tr_ bencFree (&benc);277 if (variant_loaded) 278 tr_variantFree (&benc); 278 279 } 279 280 … … 357 358 else 358 359 { 359 tr_ benctop;360 tr_variant top; 360 361 int64_t intVal; 361 tr_benc * files; 362 tr_benc * flags; 362 tr_variant * files; 363 tr_variant * flags; 364 size_t len; 363 365 const char * str; 364 const int benc_loaded = !tr_bencLoad (msg, msglen, &top, NULL);366 const bool variant_loaded = !tr_variantFromBenc (&top, msg, msglen); 365 367 366 368 if (getenv ("TR_CURL_VERBOSE") != NULL) 367 369 { 368 if (! benc_loaded)370 if (!variant_loaded) 369 371 fprintf (stderr, "%s", "Scrape response was not in benc format\n"); 370 372 else { 371 373 int i, len; 372 char * str = tr_ bencToStr (&top, TR_FMT_JSON, &len);374 char * str = tr_variantToStr (&top, TR_VARIANT_FMT_JSON, &len); 373 375 fprintf (stderr, "%s", "Scrape response:\n< "); 374 376 for (i=0; i<len; ++i) … … 379 381 } 380 382 381 if ( benc_loaded)383 if (variant_loaded) 382 384 { 383 if (tr_ bencDictFindStr (&top, "failure reason", &str))384 response->errmsg = tr_str dup (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)) 388 390 response->min_request_interval = intVal; 389 391 390 if (tr_ bencDictFindDict (&top, "files", &files))392 if (tr_variantDictFindDict (&top, "files", &files)) 391 393 { 392 394 int i = 0; … … 395 397 { 396 398 int j; 397 tr_ benc* val;399 tr_variant * val; 398 400 const char * key; 399 401 400 402 /* get the next "file" */ 401 if (!tr_ bencDictChild (files, i++, &key, &val))403 if (!tr_variantDictChild (files, i++, &key, &val)) 402 404 break; 403 405 … … 408 410 if (!memcmp (key, row->info_hash, SHA_DIGEST_LENGTH)) 409 411 { 410 if (tr_ bencDictFindInt (val, "complete", &intVal))412 if (tr_variantDictFindInt (val, "complete", &intVal)) 411 413 row->seeders = intVal; 412 if (tr_ bencDictFindInt (val, "incomplete", &intVal))414 if (tr_variantDictFindInt (val, "incomplete", &intVal)) 413 415 row->leechers = intVal; 414 if (tr_ bencDictFindInt (val, "downloaded", &intVal))416 if (tr_variantDictFindInt (val, "downloaded", &intVal)) 415 417 row->downloads = intVal; 416 if (tr_ bencDictFindInt (val, "downloaders", &intVal))418 if (tr_variantDictFindInt (val, "downloaders", &intVal)) 417 419 row->downloaders = intVal; 418 420 break; … … 422 424 } 423 425 424 tr_ bencFree (&top);426 tr_variantFree (&top); 425 427 } 426 428 } -
trunk/libtransmission/bitfield-test.c
r13635 r13667 5 5 #include "utils.h" /* tr_free */ 6 6 7 #undef VERBOSE8 7 #include "libtransmission-test.h" 9 8 -
trunk/libtransmission/blocklist-test.c
r13625 r13667 5 5 #include "utils.h" 6 6 7 #undef VERBOSE8 7 #include "libtransmission-test.h" 9 8 -
trunk/libtransmission/clients-test.c
r13625 r13667 2 2 #include "clients.h" 3 3 4 #undef VERBOSE5 4 #include "libtransmission-test.h" 6 7 5 8 6 #define TEST_CLIENT(A, B) \ -
trunk/libtransmission/history-test.c
r13625 r13667 4 4 #include "history.h" 5 5 6 #undef VERBOSE7 6 #include "libtransmission-test.h" 8 7 -
trunk/libtransmission/json-test.c
r13625 r13667 1 1 #include <string.h> /* strlen () */ 2 2 #include "transmission.h" 3 #include "bencode.h"4 #include "json.h"5 3 #include "utils.h" /* tr_free */ 6 7 #undef VERBOSE 4 #include "variant.h" 5 8 6 #include "libtransmission-test.h" 9 7 … … 12 10 { 13 11 const char * in; 14 tr_ benctop;12 tr_variant top; 15 13 const char * str; 16 14 bool f; … … 27 25 " \"null\": null }"; 28 26 29 err = tr_ jsonParse (NULL, in, strlen (in), &top, NULL);27 err = tr_variantFromJson (&top, in, strlen(in)); 30 28 check_int_eq (0, err); 31 check (tr_ bencIsDict (&top));29 check (tr_variantIsDict (&top)); 32 30 str = NULL; 33 check (tr_ bencDictFindStr (&top, "string", &str));31 check (tr_variantDictFindStr (&top, "string", &str, NULL)); 34 32 check_streq ("hello world", str); 35 check (tr_ bencDictFindStr (&top, "escaped", &str));33 check (tr_variantDictFindStr (&top, "escaped", &str, NULL)); 36 34 check_streq ("bell \b formfeed \f linefeed \n carriage return \r tab \t", str); 37 35 i = 0; 38 check (tr_ bencDictFindInt (&top, "int", &i));36 check (tr_variantDictFindInt (&top, "int", &i)); 39 37 check_int_eq (5, i); 40 38 d = 0; 41 check (tr_ bencDictFindReal (&top, "float", &d));39 check (tr_variantDictFindReal (&top, "float", &d)); 42 40 check_int_eq (65, ((int)(d*10))); 43 41 f = false; 44 check (tr_ bencDictFindBool (&top, "true", &f));42 check (tr_variantDictFindBool (&top, "true", &f)); 45 43 check_int_eq (true, f); 46 check (tr_ bencDictFindBool (&top, "false", &f));44 check (tr_variantDictFindBool (&top, "false", &f)); 47 45 check_int_eq (false, f); 48 check (tr_ bencDictFindStr (&top, "null", &str));46 check (tr_variantDictFindStr (&top, "null", &str, NULL)); 49 47 check_streq ("", str); 50 48 51 49 if (!err) 52 tr_ bencFree (&top);50 tr_variantFree (&top); 53 51 54 52 return 0; … … 58 56 { 59 57 const char * in = "{ \"key\": \"Letöltések\" }"; 60 tr_ benctop;58 tr_variant top; 61 59 const char * str; 62 60 char * json; 63 61 int err; 64 62 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)); 69 67 check_streq ("Letöltések", str); 70 68 if (!err) 71 tr_ bencFree (&top);69 tr_variantFree (&top); 72 70 73 71 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)); 78 76 check_streq ("\\", str); 79 77 if (!err) 80 tr_ bencFree (&top);78 tr_variantFree (&top); 81 79 82 80 /** … … 89 87 */ 90 88 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)); 95 93 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); 99 97 check (json); 100 98 check (strstr (json, "\\u00f6") != NULL); 101 99 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)); 106 104 check_streq ("Letöltések", str); 107 105 if (!err) 108 tr_ bencFree (&top);106 tr_variantFree (&top); 109 107 tr_free (json); 110 108 … … 128 126 " }\n" 129 127 "}\n"; 130 tr_ benctop, *headers, *body, *args, *ids;128 tr_variant top, *headers, *body, *args, *ids; 131 129 const char * str; 132 130 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)); 140 138 check_streq ("request", str); 141 check (tr_ bencDictFindInt (headers, "tag", &i));139 check (tr_variantDictFindInt (headers, "tag", &i)); 142 140 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)); 145 143 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)); 152 150 check_int_eq (7, i); 153 check (tr_ bencGetInt (tr_bencListChild (ids, 1), &i));151 check (tr_variantGetInt (tr_variantListChild (ids, 1), &i)); 154 152 check_int_eq (10, i); 155 153 156 tr_ bencFree (&top);154 tr_variantFree (&top); 157 155 return 0; 158 156 } … … 161 159 test2 (void) 162 160 { 163 tr_ benctop;161 tr_variant top; 164 162 const char * in = " "; 165 163 int err; 166 164 167 165 top.type = 0; 168 err = tr_ jsonParse (NULL, in, strlen (in), &top, NULL);166 err = tr_variantFromJson (&top, in, strlen(in)); 169 167 170 168 check (err); 171 check (!tr_ bencIsDict (&top));169 check (!tr_variantIsDict (&top)); 172 170 173 171 return 0; … … 182 180 " \"id\": 25," 183 181 " \"leftUntilDone\": 2275655680 }"; 184 tr_ benctop;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)); 190 188 check_streq ("torrent not registered with this tracker 6UHsVW'*C", str); 191 189 192 tr_ bencFree (&top);190 tr_variantFree (&top); 193 191 return 0; 194 192 } … … 198 196 { 199 197 const char * in = "{ \"string-1\": \"\\/usr\\/lib\" }"; 200 tr_ benctop;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)); 204 202 check_int_eq (0, err); 205 check (tr_ bencDictFindStr (&top, "string-1", &str));203 check (tr_variantDictFindStr (&top, "string-1", &str, NULL)); 206 204 check_streq ("/usr/lib", str); 207 205 208 tr_ bencFree (&top);206 tr_variantFree (&top); 209 207 return 0; 210 208 } -
trunk/libtransmission/libtransmission-test.h
r13655 r13667 8 8 #include "utils.h" /* tr_strcmp0 () */ 9 9 10 static int current_test = 0;10 extern int current_test; 11 11 12 #define REPORT_TEST(test, result) \ 13 fprintf (stderr, "%s %s:%d\n", result, __FILE__, __LINE__) 12 extern bool verbose; 14 13 15 static bool 16 should_print (bool pass) 17 { 18 if (!pass) 19 return true; 14 bool should_print (bool pass); 20 15 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 } 16 bool check_condition_impl (const char * file, int line, bool condition); 17 bool check_int_eq_impl (const char * file, int line, int64_t expected, int64_t actual); 18 bool check_ptr_eq_impl (const char * file, int line, const void * expected, const void * actual); 19 bool check_streq_impl (const char * file, int line, const char * expected, const char * actual); 83 20 84 21 /*** … … 121 58 #define NUM_TESTS(tarray)((int)(sizeof (tarray)/sizeof (tarray[0]))) 122 59 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 } 60 int runTests (const testFunc * const tests, int numTests); 136 61 137 62 #define MAIN_SINGLE_TEST(test) \ -
trunk/libtransmission/magnet-test.c
r13625 r13667 3 3 #include "utils.h" 4 4 5 #undef VERBOSE6 5 #include "libtransmission-test.h" 7 6 -
trunk/libtransmission/magnet.c
r13625 r13667 16 16 17 17 #include "transmission.h" 18 #include "bencode.h"19 18 #include "magnet.h" 20 19 #include "utils.h" 20 #include "variant.h" 21 21 #include "web.h" 22 22 … … 212 212 213 213 void 214 tr_magnetCreateMetainfo (const tr_magnet_info * info, tr_ benc* top)214 tr_magnetCreateMetainfo (const tr_magnet_info * info, tr_variant * top) 215 215 { 216 216 int i; 217 tr_ benc* d;218 tr_ bencInitDict (top, 4);217 tr_variant * d; 218 tr_variantInitDict (top, 4); 219 219 220 220 /* announce list */ 221 221 if (info->trackerCount == 1) 222 222 { 223 tr_ bencDictAddStr (top, "announce", info->trackers[0]);223 tr_variantDictAddStr (top, "announce", info->trackers[0]); 224 224 } 225 225 else 226 226 { 227 tr_ benc * trackers = tr_bencDictAddList (top, "announce-list", info->trackerCount);227 tr_variant * trackers = tr_variantDictAddList (top, "announce-list", info->trackerCount); 228 228 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]); 230 230 } 231 231 … … 233 233 if (info->webseedCount > 0) 234 234 { 235 tr_ benc * urls = tr_bencDictAddList (top, "url-list", info->webseedCount);235 tr_variant * urls = tr_variantDictAddList (top, "url-list", info->webseedCount); 236 236 for (i=0; i<info->webseedCount; ++i) 237 tr_ bencListAddStr (urls, info->webseeds[i]);237 tr_variantListAddStr (urls, info->webseeds[i]); 238 238 } 239 239 240 240 /* 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); 243 243 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 19 19 20 20 #include "transmission.h" 21 #include "variant.h" 21 22 22 23 typedef struct tr_magnet_info … … 36 37 tr_magnet_info * tr_magnetParse (const char * uri); 37 38 38 struct tr_ benc;39 struct tr_variant; 39 40 40 void tr_magnetCreateMetainfo (const tr_magnet_info *, struct tr_benc*);41 void tr_magnetCreateMetainfo (const tr_magnet_info *, tr_variant *); 41 42 42 43 void tr_magnetFree (tr_magnet_info * info); -
trunk/libtransmission/makemeta.c
r13631 r13667 28 28 #include "fdlimit.h" /* tr_open_file_for_scanning () */ 29 29 #include "session.h" 30 #include "bencode.h"31 30 #include "makemeta.h" 32 31 #include "platform.h" /* threads, locks */ 33 32 #include "utils.h" /* buildpath */ 33 #include "variant.h" 34 34 #include "version.h" 35 35 … … 291 291 getFileInfo (const char * topFile, 292 292 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) 295 295 { 296 296 size_t offset; 297 297 298 298 /* get the file size */ 299 tr_ bencInitInt (uninitialized_length, file->size);299 tr_variantInitInt (uninitialized_length, file->size); 300 300 301 301 /* how much of file->filename to walk past */ … … 305 305 306 306 /* build the path list */ 307 tr_ bencInitList (uninitialized_path, 0);307 tr_variantInitList (uninitialized_path, 0); 308 308 if (strlen (file->filename) > offset) { 309 309 char * filename = tr_strdup (file->filename + offset); … … 311 311 const char * token; 312 312 while ((token = tr_strsep (&walk, TR_PATH_DELIMITER_STR))) 313 tr_ bencListAddStr (uninitialized_path, token);313 tr_variantListAddStr (uninitialized_path, token); 314 314 tr_free (filename); 315 315 } … … 317 317 318 318 static void 319 makeInfoDict (tr_ benc* dict,319 makeInfoDict (tr_variant * dict, 320 320 tr_metainfo_builder * builder) 321 321 { … … 323 323 char * base; 324 324 325 tr_ bencDictReserve (dict, 5);325 tr_variantDictReserve (dict, 5); 326 326 327 327 if (builder->isSingleFile) 328 328 { 329 tr_ bencDictAddInt (dict, "length", builder->files[0].size);329 tr_variantDictAddInt (dict, "length", builder->files[0].size); 330 330 } 331 331 else /* root node is a directory */ 332 332 { 333 333 uint32_t i; 334 tr_ benc * list = tr_bencDictAddList (dict, "files",334 tr_variant * list = tr_variantDictAddList (dict, "files", 335 335 builder->fileCount); 336 336 for (i = 0; i < builder->fileCount; ++i) 337 337 { 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"); 341 341 getFileInfo (builder->top, &builder->files[i], length, pathVal); 342 342 } … … 344 344 345 345 base = tr_basename (builder->top); 346 tr_ bencDictAddStr (dict, "name", base);346 tr_variantDictAddStr (dict, "name", base); 347 347 tr_free (base); 348 348 349 tr_ bencDictAddInt (dict, "piece length", builder->pieceSize);349 tr_variantDictAddInt (dict, "piece length", builder->pieceSize); 350 350 351 351 if ((pch = getHashInfo (builder))) 352 352 { 353 tr_ bencDictAddRaw (dict, "pieces", pch,353 tr_variantDictAddRaw (dict, "pieces", pch, 354 354 SHA_DIGEST_LENGTH * builder->pieceCount); 355 355 tr_free (pch); 356 356 } 357 357 358 tr_ bencDictAddInt (dict, "private", builder->isPrivate ? 1 : 0);358 tr_variantDictAddInt (dict, "private", builder->isPrivate ? 1 : 0); 359 359 } 360 360 … … 363 363 { 364 364 int i; 365 tr_ benctop;365 tr_variant top; 366 366 367 367 /* allow an empty set, but if URLs *are* listed, verify them. #814, #971 */ … … 374 374 } 375 375 376 tr_ bencInitDict (&top, 6);376 tr_variantInitDict (&top, 6); 377 377 378 378 if (!builder->fileCount || !builder->totalSize || … … 388 388 { 389 389 int prevTier = -1; 390 tr_ benc* tier = NULL;390 tr_variant * tier = NULL; 391 391 392 392 if (builder->trackerCount > 1) 393 393 { 394 tr_ benc * annList = tr_bencDictAddList (&top, "announce-list",394 tr_variant * annList = tr_variantDictAddList (&top, "announce-list", 395 395 0); 396 396 for (i = 0; i < builder->trackerCount; ++i) … … 399 399 { 400 400 prevTier = builder->trackers[i].tier; 401 tier = tr_ bencListAddList (annList, 0);401 tier = tr_variantListAddList (annList, 0); 402 402 } 403 tr_ bencListAddStr (tier, builder->trackers[i].announce);403 tr_variantListAddStr (tier, builder->trackers[i].announce); 404 404 } 405 405 } 406 406 407 tr_ bencDictAddStr (&top, "announce", builder->trackers[0].announce);407 tr_variantDictAddStr (&top, "announce", builder->trackers[0].announce); 408 408 } 409 409 … … 411 411 { 412 412 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", 415 415 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); 419 419 } 420 420 … … 422 422 if (!builder->result && !builder->abortFlag) 423 423 { 424 if (tr_ bencToFile (&top, TR_FMT_BENC, builder->outputFile))424 if (tr_variantToFile (&top, TR_VARIANT_FMT_BENC, builder->outputFile)) 425 425 { 426 426 builder->my_errno = errno; … … 432 432 433 433 /* cleanup */ 434 tr_ bencFree (&top);434 tr_variantFree (&top); 435 435 if (builder->abortFlag) 436 436 builder->result = TR_MAKEMETA_CANCELLED; -
trunk/libtransmission/metainfo-test.c
r13625 r13667 1 1 #include "transmission.h" 2 2 3 #undef VERBOSE4 3 #include "libtransmission-test.h" 5 4 -
trunk/libtransmission/metainfo.c
r13641 r13667 23 23 #include "transmission.h" 24 24 #include "session.h" 25 #include "bencode.h"26 25 #include "crypto.h" /* tr_sha1 */ 27 26 #include "metainfo.h" 28 27 #include "platform.h" /* tr_getTorrentDir () */ 29 28 #include "utils.h" 29 #include "variant.h" 30 30 31 31 /*** … … 69 69 70 70 static bool 71 getfile (char ** setme, const char * root, tr_ benc* path, struct evbuffer * buf)71 getfile (char ** setme, const char * root, tr_variant * path, struct evbuffer * buf) 72 72 { 73 73 bool success = false; 74 74 75 if (tr_ bencIsList (path))75 if (tr_variantIsList (path)) 76 76 { 77 77 int i; 78 const int n = tr_ bencListSize (path);78 const int n = tr_variantListSize (path); 79 79 80 80 evbuffer_drain (buf, evbuffer_get_length (buf)); … … 82 82 for (i=0; i<n; i++) 83 83 { 84 size_t len; 84 85 const char * str; 85 86 86 if (tr_ bencGetStr (tr_bencListChild (path, i), &str))87 if (tr_variantGetStr (tr_variantListChild (path, i), &str, &len)) 87 88 { 88 89 evbuffer_add (buf, TR_PATH_DELIMITER_STR, 1); 89 evbuffer_add (buf, str, strlen (str));90 evbuffer_add (buf, str, len); 90 91 } 91 92 } … … 107 108 108 109 static const char* 109 parseFiles (tr_info * inf, tr_ benc * files, const tr_benc* length)110 parseFiles (tr_info * inf, tr_variant * files, const tr_variant * length) 110 111 { 111 112 int64_t len; … … 113 114 inf->totalSize = 0; 114 115 115 if (tr_ bencIsList (files)) /* multi-file mode */116 if (tr_variantIsList (files)) /* multi-file mode */ 116 117 { 117 118 tr_file_index_t i; … … 119 120 120 121 inf->isMultifile = 1; 121 inf->fileCount = tr_ bencListSize (files);122 inf->fileCount = tr_variantListSize (files); 122 123 inf->files = tr_new0 (tr_file, inf->fileCount); 123 124 124 125 for (i=0; i<inf->fileCount; i++) 125 126 { 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)) 131 132 return "files"; 132 133 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)) 135 136 return "path"; 136 137 … … 138 139 return "path"; 139 140 140 if (!tr_ bencDictFindInt (file, "length", &len))141 if (!tr_variantDictFindInt (file, "length", &len)) 141 142 return "length"; 142 143 … … 147 148 evbuffer_free (buf); 148 149 } 149 else if (tr_ bencGetInt (length, &len)) /* single-file mode */150 else if (tr_variantGetInt (length, &len)) /* single-file mode */ 150 151 { 151 152 if (path_is_suspicious (inf->name)) … … 203 204 204 205 static const char* 205 getannounce (tr_info * inf, tr_benc * meta) 206 { 206 getannounce (tr_info * inf, tr_variant * meta) 207 { 208 size_t len; 207 209 const char * str; 208 210 tr_tracker_info * trackers = NULL; 209 211 int trackerCount = 0; 210 tr_ benc* tiers;212 tr_variant * tiers; 211 213 212 214 /* Announce-list */ 213 if (tr_ bencDictFindList (meta, "announce-list", &tiers))215 if (tr_variantDictFindList (meta, "announce-list", &tiers)) 214 216 { 215 217 int n; 216 218 int i, j, validTiers; 217 const int numTiers = tr_ bencListSize (tiers);219 const int numTiers = tr_variantListSize (tiers); 218 220 219 221 n = 0; 220 222 for (i=0; i<numTiers; i++) 221 n += tr_ bencListSize (tr_bencListChild (tiers, i));223 n += tr_variantListSize (tr_variantListChild (tiers, i)); 222 224 223 225 trackers = tr_new0 (tr_tracker_info, n); … … 225 227 for (i=0, validTiers=0; i<numTiers; i++) 226 228 { 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); 229 231 bool anyAdded = false; 230 232 for (j=0; j<tierSize; j++) 231 233 { 232 if (tr_ bencGetStr (tr_bencListChild (tier, j), &str))234 if (tr_variantGetStr (tr_variantListChild (tier, j), &str, &len)) 233 235 { 234 char * url = tr_strstrip (tr_str dup (str));236 char * url = tr_strstrip (tr_strndup (str, len)); 235 237 if (!tr_urlIsValidTracker (url)) 236 238 { … … 264 266 265 267 /* Regular announce value */ 266 if (!trackerCount && tr_ bencDictFindStr (meta, "announce", &str))267 { 268 char * url = tr_strstrip (tr_str dup (str));268 if (!trackerCount && tr_variantDictFindStr (meta, "announce", &str, &len)) 269 { 270 char * url = tr_strstrip (tr_strndup (str, len)); 269 271 if (!tr_urlIsValidTracker (url)) 270 272 { … … 324 326 325 327 static void 326 geturllist (tr_info * inf, tr_ benc* meta)327 { 328 tr_ benc* urls;328 geturllist (tr_info * inf, tr_variant * meta) 329 { 330 tr_variant * urls; 329 331 const char * url; 330 332 331 if (tr_ bencDictFindList (meta, "url-list", &urls))333 if (tr_variantDictFindList (meta, "url-list", &urls)) 332 334 { 333 335 int i; 334 const int n = tr_ bencListSize (urls);336 const int n = tr_variantListSize (urls); 335 337 336 338 inf->webseedCount = 0; … … 339 341 for (i=0; i<n; i++) 340 342 { 341 if (tr_ bencGetStr (tr_bencListChild (urls, i), &url))343 if (tr_variantGetStr (tr_variantListChild (urls, i), &url, NULL)) 342 344 { 343 345 char * fixed_url = fix_webseed_url (inf, url); … … 348 350 } 349 351 } 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 */ 351 353 { 352 354 char * fixed_url = fix_webseed_url (inf, url); … … 366 368 bool * hasInfoDict, 367 369 int * infoDictLength, 368 const tr_ benc* meta_in)370 const tr_variant * meta_in) 369 371 { 370 372 int64_t i; 371 size_t raw_len;373 size_t len; 372 374 const char * str; 373 375 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; 377 379 bool b; 378 380 bool isMagnet = false; … … 381 383 * from the Metainfo file. Note that the value will be a bencoded 382 384 * dictionary, given the definition of the info key above. */ 383 b = tr_ bencDictFindDict (meta, "info", &infoDict);385 b = tr_variantDictFindDict (meta, "info", &infoDict); 384 386 if (hasInfoDict != NULL) 385 387 *hasInfoDict = b; … … 388 390 { 389 391 /* no info dictionary... is this a magnet link? */ 390 if (tr_ bencDictFindDict (meta, "magnet-info", &d))392 if (tr_variantDictFindDict (meta, "magnet-info", &d)) 391 393 { 392 394 isMagnet = true; 393 395 394 396 /* get the info-hash */ 395 if (!tr_ bencDictFindRaw (d, "info_hash", &raw, &raw_len))397 if (!tr_variantDictFindRaw (d, "info_hash", &raw, &len)) 396 398 return "info_hash"; 397 if ( raw_len != SHA_DIGEST_LENGTH)399 if (len != SHA_DIGEST_LENGTH) 398 400 return "info_hash"; 399 memcpy (inf->hash, raw, raw_len);401 memcpy (inf->hash, raw, len); 400 402 tr_sha1_to_hex (inf->hashString, inf->hash); 401 403 402 404 /* maybe get the display name */ 403 if (tr_ bencDictFindStr (d, "display-name", &str))405 if (tr_variantDictFindStr (d, "display-name", &str, &len)) 404 406 { 405 407 tr_free (inf->name); 406 inf->name = tr_str dup (str);408 inf->name = tr_strndup (str, len); 407 409 } 408 410 … … 418 420 { 419 421 int len; 420 char * bstr = tr_ bencToStr (infoDict, TR_FMT_BENC, &len);422 char * bstr = tr_variantToStr (infoDict, TR_VARIANT_FMT_BENC, &len); 421 423 tr_sha1 (inf->hash, bstr, len, NULL); 422 424 tr_sha1_to_hex (inf->hashString, inf->hash); … … 431 433 if (!isMagnet) 432 434 { 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)) 435 438 str = ""; 436 439 if (!str || !*str) 437 440 return "name"; 438 441 tr_free (inf->name); 439 inf->name = tr_utf8clean (str, -1);442 inf->name = tr_utf8clean (str, len); 440 443 } 441 444 442 445 /* 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)) 445 449 str = ""; 446 450 tr_free (inf->comment); 447 inf->comment = tr_utf8clean (str, -1);451 inf->comment = tr_utf8clean (str, len); 448 452 449 453 /* 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)) 452 457 str = ""; 453 458 tr_free (inf->creator); 454 inf->creator = tr_utf8clean (str, -1);459 inf->creator = tr_utf8clean (str, len); 455 460 456 461 /* creation date */ 457 if (!tr_ bencDictFindInt (meta, "creation date", &i))462 if (!tr_variantDictFindInt (meta, "creation date", &i)) 458 463 i = 0; 459 464 inf->dateCreated = i; 460 465 461 466 /* 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)) 464 469 i = 0; 465 470 inf->isPrivate = i != 0; … … 468 473 if (!isMagnet) 469 474 { 470 if (!tr_ bencDictFindInt (infoDict, "piece length", &i) || (i < 1))475 if (!tr_variantDictFindInt (infoDict, "piece length", &i) || (i < 1)) 471 476 return "piece length"; 472 477 inf->pieceSize = i; … … 476 481 if (!isMagnet) 477 482 { 478 if (!tr_ bencDictFindRaw (infoDict, "pieces", &raw, &raw_len))483 if (!tr_variantDictFindRaw (infoDict, "pieces", &raw, &len)) 479 484 return "pieces"; 480 if ( raw_len % SHA_DIGEST_LENGTH)485 if (len % SHA_DIGEST_LENGTH) 481 486 return "pieces"; 482 487 483 inf->pieceCount = raw_len / SHA_DIGEST_LENGTH;488 inf->pieceCount = len / SHA_DIGEST_LENGTH; 484 489 inf->pieces = tr_new0 (tr_piece, inf->pieceCount); 485 490 for (i=0; i<inf->pieceCount; i++) … … 490 495 if (!isMagnet) 491 496 { 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")))) 494 499 return str; 495 500 … … 517 522 bool 518 523 tr_metainfoParse (const tr_session * session, 519 const tr_ benc* meta_in,524 const tr_variant * meta_in, 520 525 tr_info * inf, 521 526 bool * hasInfoDict, -
trunk/libtransmission/metainfo.h
r13632 r13667 19 19 20 20 #include "transmission.h" 21 #include "variant.h" 21 22 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); 23 bool tr_metainfoParse (const tr_session * session, 24 const tr_variant * variant, 25 tr_info * setmeInfo, 26 bool * setmeHasInfoDict, 27 int * setmeInfoDictLength); 29 28 30 29 void tr_metainfoRemoveSaved (const tr_session * session, -
trunk/libtransmission/peer-io.c
r13625 r13667 507 507 508 508 static void 509 utp_on_overhead (void *closure, boolsend, size_t count, int type UNUSED)509 utp_on_overhead (void *closure, uint8_t send, size_t count, int type UNUSED) 510 510 { 511 511 tr_peerIo *io = closure; … … 568 568 569 569 static void 570 dummy_on_overhead (void *closure UNUSED, boolsend UNUSED, size_t count UNUSED, int type UNUSED)570 dummy_on_overhead (void *closure UNUSED, uint8_t send UNUSED, size_t count UNUSED, int type UNUSED) 571 571 { 572 572 return; -
trunk/libtransmission/peer-msgs-test.c
r13625 r13667 4 4 #include "utils.h" 5 5 6 #undef VERBOSE7 6 #include "libtransmission-test.h" 8 7 -
trunk/libtransmission/peer-msgs.c
r13651 r13667 22 22 23 23 #include "transmission.h" 24 #include "bencode.h"25 24 #include "cache.h" 26 25 #include "completion.h" … … 34 33 #include "tr-dht.h" 35 34 #include "utils.h" 35 #include "variant.h" 36 36 #include "version.h" 37 37 … … 791 791 sendLtepHandshake (tr_peermsgs * msgs) 792 792 { 793 tr_ bencval;793 tr_variant val; 794 794 bool allow_pex; 795 795 bool allow_metadata_xfer; … … 818 818 allow_pex = 1; 819 819 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); 822 822 if (ipv6 != NULL) 823 tr_ bencDictAddRaw (&val, "ipv6", ipv6, 16);823 tr_variantDictAddRaw (&val, "ipv6", ipv6, 16); 824 824 if (allow_metadata_xfer && tr_torrentHasMetadata (msgs->torrent) 825 825 && (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); 831 831 if (allow_metadata_xfer || allow_pex) { 832 tr_ benc * m = tr_bencDictAddDict (&val, "m", 2);832 tr_variant * m = tr_variantDictAddDict (&val, "m", 2); 833 833 if (allow_metadata_xfer) 834 tr_ bencDictAddInt (m, "ut_metadata", UT_METADATA_ID);834 tr_variantDictAddInt (m, "ut_metadata", UT_METADATA_ID); 835 835 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); 840 840 841 841 evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload)); … … 848 848 /* cleanup */ 849 849 evbuffer_free (payload); 850 tr_ bencFree (&val);850 tr_variantFree (&val); 851 851 } 852 852 … … 855 855 { 856 856 int64_t i; 857 tr_ bencval, * sub;857 tr_variant val, * sub; 858 858 uint8_t * tmp = tr_new (uint8_t, len); 859 859 const uint8_t *addr; … … 867 867 msgs->peerSentLtepHandshake = 1; 868 868 869 if (tr_ bencLoad (tmp, len, &val, NULL) || !tr_bencIsDict (&val))869 if (tr_variantFromBenc (&val, tmp, len) || !tr_variantIsDict (&val)) 870 870 { 871 871 dbgmsg (msgs, "GET extended-handshake, couldn't get dictionary"); … … 877 877 878 878 /* does the peer prefer encrypted connections? */ 879 if (tr_ bencDictFindInt (&val, "e", &i)) {879 if (tr_variantDictFindInt (&val, "e", &i)) { 880 880 msgs->peer->encryption_preference = i ? ENCRYPTION_PREFERENCE_YES 881 881 : ENCRYPTION_PREFERENCE_NO; … … 888 888 msgs->peerSupportsMetadataXfer = 0; 889 889 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)) { 892 892 msgs->peerSupportsPex = i != 0; 893 893 msgs->ut_pex_id = (uint8_t) i; 894 894 dbgmsg (msgs, "msgs->ut_pex is %d", (int)msgs->ut_pex_id); 895 895 } 896 if (tr_ bencDictFindInt (sub, "ut_metadata", &i)) {896 if (tr_variantDictFindInt (sub, "ut_metadata", &i)) { 897 897 msgs->peerSupportsMetadataXfer = i != 0; 898 898 msgs->ut_metadata_id = (uint8_t) i; 899 899 dbgmsg (msgs, "msgs->ut_metadata_id is %d", (int)msgs->ut_metadata_id); 900 900 } 901 if (tr_ bencDictFindInt (sub, "ut_holepunch", &i)) {901 if (tr_variantDictFindInt (sub, "ut_holepunch", &i)) { 902 902 /* Mysterious µTorrent extension that we don't grok. However, 903 903 it implies support for µTP, so use it to indicate that. */ … … 909 909 910 910 /* look for metainfo size (BEP 9) */ 911 if (tr_ bencDictFindInt (&val, "metadata_size", &i)) {911 if (tr_variantDictFindInt (&val, "metadata_size", &i)) { 912 912 tr_torrentSetMetadataSizeHint (msgs->torrent, i); 913 913 msgs->metadata_size_hint = (size_t) i; … … 915 915 916 916 /* look for upload_only (BEP 21) */ 917 if (tr_ bencDictFindInt (&val, "upload_only", &i))917 if (tr_variantDictFindInt (&val, "upload_only", &i)) 918 918 seedProbability = i==0 ? 0 : 100; 919 919 920 920 /* get peer's listening port */ 921 if (tr_ bencDictFindInt (&val, "p", &i)) {921 if (tr_variantDictFindInt (&val, "p", &i)) { 922 922 pex.port = htons ((uint16_t)i); 923 923 fireClientGotPort (msgs, pex.port); … … 926 926 927 927 if (tr_peerIoIsIncoming (msgs->peer->io) 928 && tr_ bencDictFindRaw (&val, "ipv4", &addr, &addr_len)928 && tr_variantDictFindRaw (&val, "ipv4", &addr, &addr_len) 929 929 && (addr_len == 4)) 930 930 { … … 935 935 936 936 if (tr_peerIoIsIncoming (msgs->peer->io) 937 && tr_ bencDictFindRaw (&val, "ipv6", &addr, &addr_len)937 && tr_variantDictFindRaw (&val, "ipv6", &addr, &addr_len) 938 938 && (addr_len == 16)) 939 939 { … … 944 944 945 945 /* get peer's maximum request queue size */ 946 if (tr_ bencDictFindInt (&val, "reqq", &i))946 if (tr_variantDictFindInt (&val, "reqq", &i)) 947 947 msgs->reqq = i; 948 948 949 tr_ bencFree (&val);949 tr_variantFree (&val); 950 950 tr_free (tmp); 951 951 } … … 954 954 parseUtMetadata (tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf) 955 955 { 956 tr_ bencdict;956 tr_variant dict; 957 957 char * msg_end; 958 c har * benc_end;958 const char * benc_end; 959 959 int64_t msg_type = -1; 960 960 int64_t piece = -1; … … 965 965 msg_end = (char*)tmp + msglen; 966 966 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); 973 973 } 974 974 … … 1001 1001 else 1002 1002 { 1003 tr_ benctmp;1003 tr_variant tmp; 1004 1004 struct evbuffer * payload; 1005 1005 struct evbuffer * out = msgs->outMessages; 1006 1006 1007 1007 /* 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); 1012 1012 1013 1013 /* write it out as a LTEP message to our outMessages buffer */ … … 1021 1021 /* cleanup */ 1022 1022 evbuffer_free (payload); 1023 tr_ bencFree (&tmp);1023 tr_variantFree (&tmp); 1024 1024 } 1025 1025 } … … 1033 1033 int loaded = 0; 1034 1034 uint8_t * tmp = tr_new (uint8_t, msglen); 1035 tr_ bencval;1035 tr_variant val; 1036 1036 tr_torrent * tor = msgs->torrent; 1037 1037 const uint8_t * added; … … 1041 1041 1042 1042 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)) 1046 1046 { 1047 1047 tr_pex * pex; … … 1050 1050 const uint8_t * added_f = NULL; 1051 1051 1052 tr_ bencDictFindRaw (&val, "added.f", &added_f, &added_f_len);1052 tr_variantDictFindRaw (&val, "added.f", &added_f, &added_f_len); 1053 1053 pex = tr_peerMgrCompactToPex (added, added_len, added_f, added_f_len, &n); 1054 1054 … … 1064 1064 } 1065 1065 1066 if (tr_ bencDictFindRaw (&val, "added6", &added, &added_len))1066 if (tr_variantDictFindRaw (&val, "added6", &added, &added_len)) 1067 1067 { 1068 1068 tr_pex * pex; … … 1071 1071 const uint8_t * added_f = NULL; 1072 1072 1073 tr_ bencDictFindRaw (&val, "added6.f", &added_f, &added_f_len);1073 tr_variantDictFindRaw (&val, "added6.f", &added_f, &added_f_len); 1074 1074 pex = tr_peerMgrCompact6ToPex (added, added_len, added_f, added_f_len, &n); 1075 1075 … … 1087 1087 1088 1088 if (loaded) 1089 tr_ bencFree (&val);1089 tr_variantFree (&val); 1090 1090 tr_free (tmp); 1091 1091 } … … 1716 1716 && tr_torrentGetNextMetadataRequest (msgs->torrent, now, &piece)) 1717 1717 { 1718 tr_ benctmp;1718 tr_variant tmp; 1719 1719 struct evbuffer * payload; 1720 1720 struct evbuffer * out = msgs->outMessages; 1721 1721 1722 1722 /* 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); 1727 1727 1728 1728 dbgmsg (msgs, "requesting metadata piece #%d", piece); … … 1738 1738 /* cleanup */ 1739 1739 evbuffer_free (payload); 1740 tr_ bencFree (&tmp);1740 tr_variantFree (&tmp); 1741 1741 } 1742 1742 } … … 1811 1811 if ((dataLen > 0) && (data != NULL)) 1812 1812 { 1813 tr_ benctmp;1813 tr_variant tmp; 1814 1814 struct evbuffer * payload; 1815 1815 struct evbuffer * out = msgs->outMessages; 1816 1816 1817 1817 /* 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); 1823 1823 1824 1824 /* write it out as a LTEP message to our outMessages buffer */ … … 1832 1832 1833 1833 evbuffer_free (payload); 1834 tr_ bencFree (&tmp);1834 tr_variantFree (&tmp); 1835 1835 tr_free (data); 1836 1836 … … 1840 1840 if (!ok) /* send a rejection message */ 1841 1841 { 1842 tr_ benctmp;1842 tr_variant tmp; 1843 1843 struct evbuffer * payload; 1844 1844 struct evbuffer * out = msgs->outMessages; 1845 1845 1846 1846 /* 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); 1851 1851 1852 1852 /* write it out as a LTEP message to our outMessages buffer */ … … 1859 1859 1860 1860 evbuffer_free (payload); 1861 tr_ bencFree (&tmp);1861 tr_variantFree (&tmp); 1862 1862 } 1863 1863 } … … 2194 2194 { 2195 2195 int i; 2196 tr_ bencval;2196 tr_variant val; 2197 2197 uint8_t * tmp, *walk; 2198 2198 struct evbuffer * payload; … … 2208 2208 2209 2209 /* build the pex payload */ 2210 tr_ bencInitDict (&val, 3); /* ipv6 support: left as 3:2210 tr_variantInitDict (&val, 3); /* ipv6 support: left as 3: 2211 2211 * speed vs. likelihood? */ 2212 2212 … … 2220 2220 } 2221 2221 assert ((walk - tmp) == diffs.addedCount * 6); 2222 tr_ bencDictAddRaw (&val, "added", tmp, walk - tmp);2222 tr_variantDictAddRaw (&val, "added", tmp, walk - tmp); 2223 2223 tr_free (tmp); 2224 2224 … … 2229 2229 *walk++ = diffs.added[i].flags & ~ADDED_F_HOLEPUNCH; 2230 2230 assert ((walk - tmp) == diffs.addedCount); 2231 tr_ bencDictAddRaw (&val, "added.f", tmp, walk - tmp);2231 tr_variantDictAddRaw (&val, "added.f", tmp, walk - tmp); 2232 2232 tr_free (tmp); 2233 2233 } … … 2242 2242 } 2243 2243 assert ((walk - tmp) == diffs.droppedCount * 6); 2244 tr_ bencDictAddRaw (&val, "dropped", tmp, walk - tmp);2244 tr_variantDictAddRaw (&val, "dropped", tmp, walk - tmp); 2245 2245 tr_free (tmp); 2246 2246 } … … 2257 2257 } 2258 2258 assert ((walk - tmp) == diffs6.addedCount * 18); 2259 tr_ bencDictAddRaw (&val, "added6", tmp, walk - tmp);2259 tr_variantDictAddRaw (&val, "added6", tmp, walk - tmp); 2260 2260 tr_free (tmp); 2261 2261 … … 2266 2266 *walk++ = diffs6.added[i].flags & ~ADDED_F_HOLEPUNCH; 2267 2267 assert ((walk - tmp) == diffs6.addedCount); 2268 tr_ bencDictAddRaw (&val, "added6.f", tmp, walk - tmp);2268 tr_variantDictAddRaw (&val, "added6.f", tmp, walk - tmp); 2269 2269 tr_free (tmp); 2270 2270 } … … 2281 2281 } 2282 2282 assert ((walk - tmp) == diffs6.droppedCount * 18); 2283 tr_ bencDictAddRaw (&val, "dropped6", tmp, walk - tmp);2283 tr_variantDictAddRaw (&val, "dropped6", tmp, walk - tmp); 2284 2284 tr_free (tmp); 2285 2285 } 2286 2286 2287 2287 /* write the pex message */ 2288 payload = tr_ bencToBuf (&val, TR_FMT_BENC);2288 payload = tr_variantToBuf (&val, TR_VARIANT_FMT_BENC); 2289 2289 evbuffer_add_uint32 (out, 2 * sizeof (uint8_t) + evbuffer_get_length (payload)); 2290 2290 evbuffer_add_uint8 (out, BT_LTEP); … … 2296 2296 2297 2297 evbuffer_free (payload); 2298 tr_ bencFree (&val);2298 tr_variantFree (&val); 2299 2299 } 2300 2300 -
trunk/libtransmission/resume.c
r13651 r13667 16 16 17 17 #include "transmission.h" 18 #include "bencode.h"19 18 #include "completion.h" 20 19 #include "metainfo.h" /* tr_metainfoGetBasename () */ … … 25 24 #include "torrent.h" 26 25 #include "utils.h" /* tr_buildPath */ 26 #include "variant.h" 27 27 28 28 #define KEY_ACTIVITY_DATE "activity-date" … … 89 89 90 90 static void 91 savePeers (tr_ benc* dict, const tr_torrent * tor)91 savePeers (tr_variant * dict, const tr_torrent * tor) 92 92 { 93 93 int count; … … 96 96 count = tr_peerMgrGetPeers ((tr_torrent*) tor, &pex, TR_AF_INET, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS); 97 97 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); 99 99 tr_free (pex); 100 100 101 101 count = tr_peerMgrGetPeers ((tr_torrent*) tor, &pex, TR_AF_INET6, TR_PEERS_INTERESTING, MAX_REMEMBERED_PEERS); 102 102 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); 104 104 105 105 tr_free (pex); … … 129 129 130 130 static uint64_t 131 loadPeers (tr_ benc* dict, tr_torrent * tor)131 loadPeers (tr_variant * dict, tr_torrent * tor) 132 132 { 133 133 uint64_t ret = 0; … … 135 135 size_t len; 136 136 137 if (tr_ bencDictFindRaw (dict, KEY_PEERS, &str, &len))137 if (tr_variantDictFindRaw (dict, KEY_PEERS, &str, &len)) 138 138 { 139 139 const int numAdded = addPeers (tor, str, len); … … 142 142 } 143 143 144 if (tr_ bencDictFindRaw (dict, KEY_PEERS6, &str, &len))144 if (tr_variantDictFindRaw (dict, KEY_PEERS6, &str, &len)) 145 145 { 146 146 const int numAdded = addPeers (tor, str, len); … … 157 157 158 158 static void 159 saveDND (tr_ benc* dict, const tr_torrent * tor)160 { 161 tr_ benc* list;159 saveDND (tr_variant * dict, const tr_torrent * tor) 160 { 161 tr_variant * list; 162 162 tr_file_index_t i; 163 163 const tr_info * const inf = tr_torrentInfo (tor); 164 164 const tr_file_index_t n = inf->fileCount; 165 165 166 list = tr_ bencDictAddList (dict, KEY_DND, n);166 list = tr_variantDictAddList (dict, KEY_DND, n); 167 167 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 171 static uint64_t 172 loadDND (tr_variant * dict, tr_torrent * tor) 173 173 { 174 174 uint64_t ret = 0; 175 tr_ benc* list = NULL;175 tr_variant * list = NULL; 176 176 const tr_file_index_t n = tor->info.fileCount; 177 177 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)) 180 180 { 181 181 int64_t tmp; … … 186 186 for (i=0; i<n; ++i) 187 187 { 188 if (tr_ bencGetInt (tr_bencListChild (list, i), &tmp) && tmp)188 if (tr_variantGetInt (tr_variantListChild (list, i), &tmp) && tmp) 189 189 dnd[dndCount++] = i; 190 190 else … … 215 215 tor, 216 216 "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); 218 218 } 219 219 … … 226 226 227 227 static void 228 saveFilePriorities (tr_ benc* dict, const tr_torrent * tor)229 { 230 tr_ benc* list;228 saveFilePriorities (tr_variant * dict, const tr_torrent * tor) 229 { 230 tr_variant * list; 231 231 tr_file_index_t i; 232 232 const tr_info * const inf = tr_torrentInfo (tor); 233 233 const tr_file_index_t n = inf->fileCount; 234 234 235 list = tr_ bencDictAddList (dict, KEY_FILE_PRIORITIES, n);235 list = tr_variantDictAddList (dict, KEY_FILE_PRIORITIES, n); 236 236 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 240 static uint64_t 241 loadFilePriorities (tr_variant * dict, tr_torrent * tor) 242 { 243 tr_variant * list; 244 244 uint64_t ret = 0; 245 245 const tr_file_index_t n = tor->info.fileCount; 246 246 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)) 249 249 { 250 250 int64_t priority; 251 251 tr_file_index_t i; 252 252 for (i = 0; i < n; ++i) 253 if (tr_ bencGetInt (tr_bencListChild (list, i), &priority))253 if (tr_variantGetInt (tr_variantListChild (list, i), &priority)) 254 254 tr_torrentInitFilePriority (tor, i, priority); 255 255 ret = TR_FR_FILE_PRIORITIES; … … 264 264 265 265 static 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)266 saveSingleSpeedLimit (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 274 static void 275 saveSpeedLimits (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 281 static void 282 saveRatioLimits (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 289 static void 290 saveIdleLimits (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 297 static void 298 loadSingleSpeedLimit (tr_variant * d, tr_direction dir, tr_torrent * tor) 299 299 { 300 300 int64_t i; 301 301 bool boolVal; 302 302 303 if (tr_ bencDictFindInt (d, KEY_SPEED_Bps, &i))303 if (tr_variantDictFindInt (d, KEY_SPEED_Bps, &i)) 304 304 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)) 306 306 tr_torrentSetSpeedLimit_Bps (tor, dir, i*1024); 307 307 308 if (tr_ bencDictFindBool (d, KEY_USE_SPEED_LIMIT, &boolVal))308 if (tr_variantDictFindBool (d, KEY_USE_SPEED_LIMIT, &boolVal)) 309 309 tr_torrentUseSpeedLimit (tor, dir, boolVal); 310 310 311 if (tr_ bencDictFindBool (d, KEY_USE_GLOBAL_SPEED_LIMIT, &boolVal))311 if (tr_variantDictFindBool (d, KEY_USE_GLOBAL_SPEED_LIMIT, &boolVal)) 312 312 tr_torrentUseSessionLimits (tor, boolVal); 313 313 } … … 320 320 321 321 static uint64_t 322 loadSpeedLimits (tr_ benc* dict, tr_torrent * tor)323 { 324 tr_ benc* d;322 loadSpeedLimits (tr_variant * dict, tr_torrent * tor) 323 { 324 tr_variant * d; 325 325 uint64_t ret = 0; 326 326 327 327 328 if (tr_ bencDictFindDict (dict, KEY_SPEEDLIMIT_UP, &d))328 if (tr_variantDictFindDict (dict, KEY_SPEEDLIMIT_UP, &d)) 329 329 { 330 330 loadSingleSpeedLimit (d, TR_UP, tor); 331 331 ret = TR_FR_SPEEDLIMIT; 332 332 } 333 if (tr_ bencDictFindDict (dict, KEY_SPEEDLIMIT_DOWN, &d))333 if (tr_variantDictFindDict (dict, KEY_SPEEDLIMIT_DOWN, &d)) 334 334 { 335 335 loadSingleSpeedLimit (d, TR_DOWN, tor); … … 338 338 339 339 /* older speedlimit structure */ 340 if (!ret && tr_ bencDictFindDict (dict, KEY_SPEEDLIMIT_OLD, &d))340 if (!ret && tr_variantDictFindDict (dict, KEY_SPEEDLIMIT_OLD, &d)) 341 341 { 342 342 343 343 int64_t i; 344 if (tr_ bencDictFindInt (d, KEY_SPEEDLIMIT_DOWN_SPEED, &i))344 if (tr_variantDictFindInt (d, KEY_SPEEDLIMIT_DOWN_SPEED, &i)) 345 345 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)) { 347 347 tr_torrentUseSpeedLimit (tor, TR_DOWN, i==TR_SPEEDLIMIT_SINGLE); 348 348 tr_torrentUseSessionLimits (tor, i==TR_SPEEDLIMIT_GLOBAL); 349 349 } 350 if (tr_ bencDictFindInt (d, KEY_SPEEDLIMIT_UP_SPEED, &i))350 if (tr_variantDictFindInt (d, KEY_SPEEDLIMIT_UP_SPEED, &i)) 351 351 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)) { 353 353 tr_torrentUseSpeedLimit (tor, TR_UP, i==TR_SPEEDLIMIT_SINGLE); 354 354 tr_torrentUseSessionLimits (tor, i==TR_SPEEDLIMIT_GLOBAL); … … 361 361 362 362 static uint64_t 363 loadRatioLimits (tr_ benc* dict, tr_torrent * tor)364 { 365 tr_ benc* d;363 loadRatioLimits (tr_variant * dict, tr_torrent * tor) 364 { 365 tr_variant * d; 366 366 uint64_t ret = 0; 367 367 368 if (tr_ bencDictFindDict (dict, KEY_RATIOLIMIT, &d))368 if (tr_variantDictFindDict (dict, KEY_RATIOLIMIT, &d)) 369 369 { 370 370 int64_t i; 371 371 double dratio; 372 if (tr_ bencDictFindReal (d, KEY_RATIOLIMIT_RATIO, &dratio))372 if (tr_variantDictFindReal (d, KEY_RATIOLIMIT_RATIO, &dratio)) 373 373 tr_torrentSetRatioLimit (tor, dratio); 374 if (tr_ bencDictFindInt (d, KEY_RATIOLIMIT_MODE, &i))374 if (tr_variantDictFindInt (d, KEY_RATIOLIMIT_MODE, &i)) 375 375 tr_torrentSetRatioMode (tor, i); 376 376 ret = TR_FR_RATIOLIMIT; … … 381 381 382 382 static uint64_t 383 loadIdleLimits (tr_ benc* dict, tr_torrent * tor)384 { 385 tr_ benc* d;383 loadIdleLimits (tr_variant * dict, tr_torrent * tor) 384 { 385 tr_variant * d; 386 386 uint64_t ret = 0; 387 387 388 if (tr_ bencDictFindDict (dict, KEY_IDLELIMIT, &d))388 if (tr_variantDictFindDict (dict, KEY_IDLELIMIT, &d)) 389 389 { 390 390 int64_t i; 391 391 int64_t imin; 392 if (tr_ bencDictFindInt (d, KEY_IDLELIMIT_MINS, &imin))392 if (tr_variantDictFindInt (d, KEY_IDLELIMIT_MINS, &imin)) 393 393 tr_torrentSetIdleLimit (tor, imin); 394 if (tr_ bencDictFindInt (d, KEY_IDLELIMIT_MODE, &i))394 if (tr_variantDictFindInt (d, KEY_IDLELIMIT_MODE, &i)) 395 395 tr_torrentSetIdleMode (tor, i); 396 396 ret = TR_FR_IDLELIMIT; … … 404 404 405 405 static void 406 bitfieldToBenc (const tr_bitfield * b, tr_ benc* benc)406 bitfieldToBenc (const tr_bitfield * b, tr_variant * benc) 407 407 { 408 408 if (tr_bitfieldHasAll (b)) 409 tr_ bencInitStr (benc, "all", 3);409 tr_variantInitStr (benc, "all", 3); 410 410 else if (tr_bitfieldHasNone (b)) 411 tr_ bencInitStr (benc, "none", 4);411 tr_variantInitStr (benc, "none", 4); 412 412 else { 413 413 size_t byte_count = 0; 414 414 uint8_t * raw = tr_bitfieldGetRaw (b, &byte_count); 415 tr_ bencInitRaw (benc, raw, byte_count);415 tr_variantInitRaw (benc, raw, byte_count); 416 416 tr_free (raw); 417 417 } … … 420 420 421 421 static void 422 saveProgress (tr_ benc* dict, tr_torrent * tor)423 { 424 tr_ benc* l;425 tr_ benc* prog;422 saveProgress (tr_variant * dict, tr_torrent * tor) 423 { 424 tr_variant * l; 425 tr_variant * prog; 426 426 tr_file_index_t fi; 427 427 const tr_info * inf = tr_torrentInfo (tor); 428 428 const time_t now = tr_time (); 429 429 430 prog = tr_ bencDictAddDict (dict, KEY_PROGRESS, 3);430 prog = tr_variantDictAddDict (dict, KEY_PROGRESS, 3); 431 431 432 432 /* 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); 434 434 for (fi=0; fi<inf->fileCount; ++fi) 435 435 { … … 463 463 464 464 if (!has_zero && (mtime <= oldest_nonzero)) /* all checked */ 465 tr_ bencListAddInt (l, oldest_nonzero);465 tr_variantListAddInt (l, oldest_nonzero); 466 466 else if (newest < mtime) /* none checked */ 467 tr_ bencListAddInt (l, newest);467 tr_variantListAddInt (l, newest); 468 468 else { /* some are checked, some aren't... so list piece by piece */ 469 469 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); 472 472 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); 474 474 } 475 475 } … … 477 477 /* add the progress */ 478 478 if (tor->completeness == TR_SEED) 479 tr_ bencDictAddStr (prog, KEY_PROGRESS_HAVE, "all");479 tr_variantDictAddStr (prog, KEY_PROGRESS_HAVE, "all"); 480 480 481 481 /* add the blocks bitfield */ 482 482 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 486 static uint64_t 487 loadProgress (tr_variant * dict, tr_torrent * tor) 488 488 { 489 489 size_t i, n; 490 490 uint64_t ret = 0; 491 tr_ benc* prog;491 tr_variant * prog; 492 492 const tr_info * inf = tr_torrentInfo (tor); 493 493 … … 495 495 inf->pieces[i].timeChecked = 0; 496 496 497 if (tr_ bencDictFindDict (dict, KEY_PROGRESS, &prog))497 if (tr_variantDictFindDict (dict, KEY_PROGRESS, &prog)) 498 498 { 499 499 const char * err; … … 501 501 const uint8_t * raw; 502 502 size_t rawlen; 503 tr_ benc* l;504 tr_ benc* b;503 tr_variant * l; 504 tr_variant * b; 505 505 struct tr_bitfield blocks = TR_BITFIELD_INIT; 506 506 507 if (tr_ bencDictFindList (prog, KEY_PROGRESS_CHECKTIME, &l))507 if (tr_variantDictFindList (prog, KEY_PROGRESS_CHECKTIME, &l)) 508 508 { 509 509 /* per-piece timestamps were added in 2.20. … … 522 522 for (fi=0; fi<inf->fileCount; ++fi) 523 523 { 524 tr_ benc * b = tr_bencListChild (l, fi);524 tr_variant * b = tr_variantListChild (l, fi); 525 525 const tr_file * f = &inf->files[fi]; 526 526 tr_piece * p = &inf->pieces[f->firstPiece]; 527 527 const tr_piece * pend = &inf->pieces[f->lastPiece]+1; 528 528 529 if (tr_ bencIsInt (b))529 if (tr_variantIsInt (b)) 530 530 { 531 531 int64_t t; 532 tr_ bencGetInt (b, &t);532 tr_variantGetInt (b, &t); 533 533 for (; p!=pend; ++p) 534 534 p->timeChecked = (time_t)t;