static tr_variant*
get_node (struct jsonsl_st * jsn)
{
tr_variant * parent;
tr_variant * node = NULL;
struct json_wrapper_data * data = jsn->data;
parent = tr_ptrArrayEmpty (&data->stack)
? NULL
: tr_ptrArrayBack (&data->stack);
if (!parent)
{
node = data->top;
}
else if (tr_variantIsList (parent))
{
node = tr_variantListAdd (parent);
}
else if (tr_variantIsDict (parent) && (data->key!=NULL))
{
node = tr_variantDictAdd (parent, tr_quark_new (data->key, data->keylen));
data->key = NULL;
data->keylen = 0;
}
return node;
}
static tr_variant*
get_node (tr_ptrArray * stack, tr_quark * key, tr_variant * top, int * err)
{
tr_variant * node = NULL;
if (tr_ptrArrayEmpty (stack))
{
node = top;
}
else
{
tr_variant * parent = tr_ptrArrayBack (stack);
if (tr_variantIsList (parent))
{
node = tr_variantListAdd (parent);
}
else if (*key && tr_variantIsDict (parent))
{
node = tr_variantDictAdd (parent, *key);
*key = 0;
}
else
{
*err = EILSEQ;
}
}
return node;
}
static void saveProgress(tr_variant* dict, tr_torrent* tor)
{
tr_variant* l;
tr_variant* prog;
tr_info const* inf = tr_torrentInfo(tor);
time_t const now = tr_time();
prog = tr_variantDictAddDict(dict, TR_KEY_progress, 3);
/* add the file/piece check timestamps... */
l = tr_variantDictAddList(prog, TR_KEY_time_checked, inf->fileCount);
for (tr_file_index_t fi = 0; fi < inf->fileCount; ++fi)
{
time_t oldest_nonzero = now;
time_t newest = 0;
bool has_zero = false;
time_t const mtime = tr_torrentGetFileMTime(tor, fi);
tr_file const* f = &inf->files[fi];
/* get the oldest and newest nonzero timestamps for pieces in this file */
for (tr_piece_index_t i = f->firstPiece; i <= f->lastPiece; ++i)
{
tr_piece const* const p = &inf->pieces[i];
if (p->timeChecked == 0)
{
has_zero = true;
}
else if (oldest_nonzero > p->timeChecked)
{
oldest_nonzero = p->timeChecked;
}
if (newest < p->timeChecked)
{
newest = p->timeChecked;
}
}
/* If some of a file's pieces have been checked more recently than
the file's mtime, and some less recently, then that file will
have a list containing timestamps for each piece.
However, the most common use case is that the file doesn't change
after it's downloaded. To reduce overhead in the .resume file,
only a single timestamp is saved for the file if *all* or *none*
of the pieces were tested more recently than the file's mtime. */
if (!has_zero && mtime <= oldest_nonzero) /* all checked */
{
tr_variantListAddInt(l, oldest_nonzero);
}
else if (newest < mtime) /* none checked */
{
tr_variantListAddInt(l, newest);
}
else /* some are checked, some aren't... so list piece by piece */
{
int const offset = oldest_nonzero - 1;
tr_variant* ll = tr_variantListAddList(l, 2 + f->lastPiece - f->firstPiece);
tr_variantListAddInt(ll, offset);
for (tr_piece_index_t i = f->firstPiece; i <= f->lastPiece; ++i)
{
tr_piece const* const p = &inf->pieces[i];
tr_variantListAddInt(ll, p->timeChecked != 0 ? p->timeChecked - offset : 0);
}
}
}
/* add the progress */
if (tor->completeness == TR_SEED)
{
tr_variantDictAddStr(prog, TR_KEY_have, "all");
}
/* add the blocks bitfield */
bitfieldToBenc(&tor->completion.blockBitfield, tr_variantDictAdd(prog, TR_KEY_blocks));
}
