void
tr_logAddDeep (const char * file,
int line,
const char * name,
const char * fmt,
...)
{
const tr_sys_file_t fp = tr_logGetFile ();
if (fp != TR_BAD_SYS_FILE || IsDebuggerPresent ())
{
va_list args;
char timestr[64];
char * message;
size_t message_len;
struct evbuffer * buf = evbuffer_new ();
char * base = tr_sys_path_basename (file, NULL);
evbuffer_add_printf (buf, "[%s] ",
tr_logGetTimeStr (timestr, sizeof (timestr)));
if (name)
evbuffer_add_printf (buf, "%s ", name);
va_start (args, fmt);
evbuffer_add_vprintf (buf, fmt, args);
va_end (args);
evbuffer_add_printf (buf, " (%s:%d)" TR_NATIVE_EOL_STR, base, line);
/* FIXME (libevent2) ifdef this out for nonwindows platforms */
message = evbuffer_free_to_str (buf, &message_len);
OutputDebugStringA (message);
if (fp != TR_BAD_SYS_FILE)
tr_sys_file_write (fp, message, message_len, NULL, NULL);
tr_free (message);
tr_free (base);
}
}
static void blocklistLoad(tr_blocklistFile* b)
{
tr_sys_file_t fd;
uint64_t byteCount;
tr_sys_path_info info;
char* base;
tr_error* error = NULL;
char const* err_fmt = _("Couldn't read \"%1$s\": %2$s");
blocklistClose(b);
if (!tr_sys_path_get_info(b->filename, 0, &info, NULL))
{
return;
}
byteCount = info.size;
if (byteCount == 0)
{
return;
}
fd = tr_sys_file_open(b->filename, TR_SYS_FILE_READ, 0, &error);
if (fd == TR_BAD_SYS_FILE)
{
tr_logAddError(err_fmt, b->filename, error->message);
tr_error_free(error);
return;
}
b->rules = tr_sys_file_map_for_reading(fd, 0, byteCount, &error);
if (b->rules == NULL)
{
tr_logAddError(err_fmt, b->filename, error->message);
tr_sys_file_close(fd, NULL);
tr_error_free(error);
return;
}
b->fd = fd;
b->byteCount = byteCount;
b->ruleCount = byteCount / sizeof(struct tr_ipv4_range);
base = tr_sys_path_basename(b->filename, NULL);
tr_logAddInfo(_("Blocklist \"%s\" contains %zu entries"), base, b->ruleCount);
tr_free(base);
}
int
tr_ctorSetMetainfoFromFile (tr_ctor * ctor,
const char * filename)
{
uint8_t * metainfo;
size_t len;
int err;
metainfo = tr_loadFile (filename, &len);
if (metainfo && len)
err = tr_ctorSetMetainfo (ctor, metainfo, len);
else
{
clearMetainfo (ctor);
err = 1;
}
setSourceFile (ctor, filename);
/* if no `name' field was set, then set it from the filename */
if (ctor->isSet_metainfo)
{
tr_variant * info;
if (tr_variantDictFindDict (&ctor->metainfo, TR_KEY_info, &info))
{
const char * name;
if (!tr_variantDictFindStr (info, TR_KEY_name_utf_8, &name, NULL))
if (!tr_variantDictFindStr (info, TR_KEY_name, &name, NULL))
name = NULL;
if (!name || !*name)
{
char * base = tr_sys_path_basename (filename, NULL);
tr_variantDictAddStr (info, TR_KEY_name, base);
tr_free (base);
}
}
}
tr_free (metainfo);
return err;
}
static int
test_single_file_impl (const tr_tracker_info * trackers,
const size_t trackerCount,
const void * payload,
const size_t payloadSize,
const char * comment,
bool isPrivate)
{
char* sandbox;
char* input_file;
char* torrent_file;
tr_metainfo_builder* builder;
tr_ctor * ctor;
tr_parse_result parse_result;
tr_info inf;
char * tmpstr;
/* set up our local test sandbox */
sandbox = libtest_sandbox_create();
/* create a single input file */
input_file = tr_buildPath (sandbox, "test.XXXXXX", NULL);
libtest_create_tmpfile_with_contents (input_file, payload, payloadSize);
builder = tr_metaInfoBuilderCreate (input_file);
check_streq (input_file, builder->top);
check_int_eq (1, builder->fileCount);
check_streq (input_file, builder->files[0].filename);
check_int_eq (payloadSize, builder->files[0].size);
check_int_eq (payloadSize, builder->totalSize);
check (!builder->isFolder);
check (!builder->abortFlag);
/* have tr_makeMetaInfo() build the .torrent file */
torrent_file = tr_strdup_printf ("%s.torrent", input_file);
tr_makeMetaInfo (builder, torrent_file, trackers, trackerCount, comment, isPrivate);
check (isPrivate == builder->isPrivate);
check_streq (torrent_file, builder->outputFile);
check_streq (comment, builder->comment);
check_int_eq (trackerCount, builder->trackerCount);
while (!builder->isDone)
tr_wait_msec (100);
/* now let's check our work: parse the .torrent file */
ctor = tr_ctorNew (NULL);
libttest_sync ();
tr_ctorSetMetainfoFromFile (ctor, torrent_file);
parse_result = tr_torrentParse (ctor, &inf);
check_int_eq (TR_PARSE_OK, parse_result);
/* quick check of some of the parsed metainfo */
check_int_eq (payloadSize, inf.totalSize);
tmpstr = tr_sys_path_basename (input_file, NULL);
check_streq (tmpstr, inf.name);
tr_free (tmpstr);
check_streq (comment, inf.comment);
check_int_eq (1, inf.fileCount);
check_int_eq (isPrivate, inf.isPrivate);
check (!inf.isFolder);
check_int_eq (trackerCount, inf.trackerCount);
/* cleanup */
tr_free (torrent_file);
tr_free (input_file);
tr_ctorFree (ctor);
tr_metainfoFree (&inf);
tr_metaInfoBuilderFree (builder);
libtest_sandbox_destroy (sandbox);
tr_free (sandbox);
return 0;
}
static int
test_single_directory_impl (const tr_tracker_info * trackers,
const size_t trackerCount,
const void ** payloads,
const size_t * payloadSizes,
const size_t payloadCount,
const char * comment,
const bool isPrivate)
{
char* sandbox;
char* torrent_file;
tr_metainfo_builder* builder;
tr_ctor * ctor;
tr_parse_result parse_result;
tr_info inf;
char * top;
char ** files;
size_t totalSize;
size_t i;
char* tmpstr;
/* set up our local test sandbox */
sandbox = libtest_sandbox_create();
/* create the top temp directory */
top = tr_buildPath (sandbox, "folder.XXXXXX", NULL);
tr_sys_dir_create_temp (top, NULL);
/* build the payload files that go into the top temp directory */
files = tr_new (char*, payloadCount);
totalSize = 0;
for (i=0; i<payloadCount; i++)
{
char tmpl[16];
tr_snprintf (tmpl, sizeof(tmpl), "file.%04zu%s", i, "XXXXXX");
files[i] = tr_buildPath (top, tmpl, NULL);
libtest_create_tmpfile_with_contents (files[i], payloads[i], payloadSizes[i]);
totalSize += payloadSizes[i];
}
libttest_sync ();
/* init the builder */
builder = tr_metaInfoBuilderCreate (top);
check (!builder->abortFlag);
check_streq (top, builder->top);
check_int_eq (payloadCount, builder->fileCount);
check_int_eq (totalSize, builder->totalSize);
check (builder->isFolder);
for (i=0; i<builder->fileCount; i++)
{
check_streq (files[i], builder->files[i].filename);
check_int_eq (payloadSizes[i], builder->files[i].size);
}
/* call tr_makeMetaInfo() to build the .torrent file */
torrent_file = tr_strdup_printf ("%s.torrent", top);
tr_makeMetaInfo (builder, torrent_file, trackers, trackerCount, comment, isPrivate);
check (isPrivate == builder->isPrivate);
check_streq (torrent_file, builder->outputFile);
check_streq (comment, builder->comment);
check_int_eq (trackerCount, builder->trackerCount);
while (!builder->isDone)
tr_wait_msec (100);
/* now let's check our work: parse the .torrent file */
ctor = tr_ctorNew (NULL);
libttest_sync ();
tr_ctorSetMetainfoFromFile (ctor, torrent_file);
parse_result = tr_torrentParse (ctor, &inf);
check_int_eq (TR_PARSE_OK, parse_result);
/* quick check of some of the parsed metainfo */
check_int_eq (totalSize, inf.totalSize);
tmpstr = tr_sys_path_basename (top, NULL);
check_streq (tmpstr, inf.name);
tr_free (tmpstr);
check_streq (comment, inf.comment);
check_int_eq (payloadCount, inf.fileCount);
check_int_eq (isPrivate, inf.isPrivate);
check_int_eq (builder->isFolder, inf.isFolder);
check_int_eq (trackerCount, inf.trackerCount);
/* cleanup */
tr_free (torrent_file);
tr_ctorFree (ctor);
tr_metainfoFree (&inf);
tr_metaInfoBuilderFree (builder);
for (i=0; i<payloadCount; i++)
tr_free (files[i]);
tr_free (files);
libtest_sandbox_destroy (sandbox);
tr_free (sandbox);
tr_free (top);
return 0;
}
