diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/dht.c | 41 | ||||
| -rw-r--r-- | src/lib.c | 39 | ||||
| -rw-r--r-- | src/metainfo.c | 367 | ||||
| -rw-r--r-- | src/metainfo.h | 37 |
4 files changed, 404 insertions, 80 deletions
@@ -20,6 +20,7 @@ #include <bencoding.c> #define STRX(x) #x #define STR(x) STRX(x) +#include <lib.c> time_t seconds (void) { struct timespec tp; @@ -34,46 +35,6 @@ int family (const unsigned char * addr) { #define K 8 /** - * writes a hexadecimal representation of a binary string. does not NULL terminate destination. - * - * h and b may not overlap. period. - * - * @param h [out] destination (requires 2l space) - * @param b [in] source - * @param l [in] length of source - */ - -void bin2hex (char * h, const unsigned char * b, size_t l) { - for (size_t i = 0; i < l; i++) { - int ms = b[i] >> 4; - int ls = b[i] & 0xF; - assert(ms < 16); - assert(ls < 16); - *h++ = ms < 10 ? '0'+ms : 'a'+ms-10; - *h++ = ls < 10 ? '0'+ls : 'a'+ls-10; - } -} - -/** - * converts a hexadecimal string to bytes - * - * b and h may not overlap, unless they are the same address - * - * @param b [out] array of bytes to write to with capacity l - * @param h [in] array of hex to read from with 2l hex digits - * @param l [in] length of output array - */ - -void hex2bin (unsigned char * b, const char * h, int l) { - for (int i = 0; i < l; i++) { - char ms = *h++; - char ls = *h++; - b[i] = (ms >= 'a' ? ms - 'a' + 10 : (ms >= 'A' ? ms - 'A' + 10 : ms - '0')) << 4; - b[i] |= (ls >= 'a' ? ls - 'a' + 10 : (ls >= 'A' ? ls - 'A' + 10 : ls - '0')); - } -} - -/** * node representation */ diff --git a/src/lib.c b/src/lib.c new file mode 100644 index 0000000..891fd27 --- /dev/null +++ b/src/lib.c @@ -0,0 +1,39 @@ +/** + * writes a hexadecimal representation of a binary string. does not NULL terminate destination. + * + * h and b may not overlap. period. + * + * @param h [out] destination (requires 2l space) + * @param b [in] source + * @param l [in] length of source + */ + +void bin2hex (char * h, const unsigned char * b, size_t l) { + for (size_t i = 0; i < l; i++) { + int ms = b[i] >> 4; + int ls = b[i] & 0xF; + assert(ms < 16); + assert(ls < 16); + *h++ = ms < 10 ? '0'+ms : 'a'+ms-10; + *h++ = ls < 10 ? '0'+ls : 'a'+ls-10; + } +} + +/** + * converts a hexadecimal string to bytes + * + * b and h may not overlap, unless they are the same address + * + * @param b [out] array of bytes to write to with capacity l + * @param h [in] array of hex to read from with 2l hex digits + * @param l [in] length of output array + */ + +void hex2bin (unsigned char * b, const char * h, int l) { + for (int i = 0; i < l; i++) { + char ms = *h++; + char ls = *h++; + b[i] = (ms >= 'a' ? ms - 'a' + 10 : (ms >= 'A' ? ms - 'A' + 10 : ms - '0')) << 4; + b[i] |= (ls >= 'a' ? ls - 'a' + 10 : (ls >= 'A' ? ls - 'A' + 10 : ls - '0')); + } +} diff --git a/src/metainfo.c b/src/metainfo.c index 1a0adcc..680505a 100644 --- a/src/metainfo.c +++ b/src/metainfo.c @@ -1,60 +1,178 @@ +#include <assert.h> +#include <stdlib.h> +#include <arpa/inet.h> +#include <sha1.h> +#include <sha2.h> +#include <stddef.h> +#include <stdbool.h> +#include <metainfo.h> +#include <sys/types.h> +#include <dirent.h> +#include <fcntl.h> +#include <errno.h> +#include <fcntl.h> +#include <unistd.h> +#include <sys/stat.h> +#include <sys/mman.h> +#include <error.h> #include <bencoding.c> -struct inode { - char * name; - int length; - struct inode * next; - struct inode * child; - struct inode * parent; -}; -struct inode * next (struct inode * inode) { + +static void inode_free (struct inode * inode) { + if (!inode) + return; + inode_free(inode->child); + inode_free(inode->next); + free(inode); +} + +/** + * returns next file, be it file, not dir. not sure why is this useful actually. I thought I would sum filesizes with that, but I already store cached sums of dir size in dir inodes. + * maybe for searching files only, not dirs ?!?!?! + */ + +const struct inode * next_file (const struct inode * inode) { if (inode->child) - return next(inode->child); + return next_file(inode->child); if (inode->next) { if (inode->next->child) - return next(inode->next->child); + return next_file(inode->next); return inode->next; } - struct inode * predecesor = inode; + const struct inode * predecesor = inode; while (!predecesor->next) { predecesor = predecesor->parent; if (!predecesor) return NULL; } + if (predecesor->next->child) + return next_file(predecesor->next); return predecesor->next; } -enum type { - UNSPEC = 0, - V1 = 1, - V2 = 2 - HYBRID = 1 | 2 + +/** + * useful for dirlisting. + * + * @param inode [in] the inode of which next should be returned. start at metainfo->files inode to get the full tree + * @param paths [out] when user builds a path, this amount of paths needs to be popped from path stack before appending resulting inode's name name to it. may be NULL. writes -1 to variable if we descended into a directory. + * @return next inode, be it dir or file, or NULL if this is the end of inodes + */ + +const struct inode * next_inode (const struct inode * inode, int * paths) { + if (paths) + *paths = 0; + if (inode->child) { + if (paths) + *paths = -1; + return inode->child; + } + if (inode->next) + return inode->next; + const struct inode * predecesor = inode; + while (!predecesor->next) { + if (paths) + (*paths)++; // OB1 possible + predecesor = predecesor->parent; + if (!predecesor) + return NULL; + } + return predecesor->next; } -struct metainfo { - struct inode * files; - struct sockaddr_in6 ip; - time_t retrieved; - time_t created; - enum type type; - char sha1[20]; - char sha256[32]; - char * name; - char * client; - char * source; - char * publisher; - char * publisher_url; - char * comment; -}; + void metainfo_free (struct metainfo * metainfo) { inode_free(metainfo->files); free(metainfo->name); free(metainfo->client); free(metainfo->source); free(metainfo->publisher); - free(metainfo->publisher_url) + free(metainfo->publisher_url); free(metainfo->comment); free(metainfo); } -struct metainfo * parse (const struct bencoding * metainfo) { - struct metainfo * r = calloc(1, sizeof(metainfo)); + +/** + * note that strings of path get removed from path blist and their values are changed to NULL, to prevent the need for malloc. path list itself is not freed, only string ownership is transfered and strings are NULLed. some strings may be left in path list elements. existing files are overwritten and/or changed to dirs. + * + * @param root [io] pointer to root inode of torrent -- &(metainfo->files) + * @param path [io] first element of bencoding list describing the path + * @param size [in] size of file to be inserted + * @param prnt [in] parent/caller object -- used internally, user should call with NULL + * @return 1 on success, 0 on failure if path element had a NULL value, 2 if a padding file was skipped + */ + +static int insert_file (struct inode ** root, struct bencoding * path, inode_length_t size, struct inode * prnt) { +tail_recursion: + if (!path) + return 1; + if (!path->value) + return 0; + if (!strcmp(path->value, ".pad") || !strncmp(path->value, "_____padding_file_", strlen("_____padding_file_"))) + return 2; + if (!*root) { + *root = calloc(1, sizeof(struct inode)); + (*root)->parent = prnt; + (*root)->name = path->value; + path->value = NULL; + (*root)->length += size; + return insert_file(&(*root)->child, path->next, size, *root); + } + if (!path->next) { + struct inode * file = calloc(1, sizeof(struct inode)); + file->parent = prnt; + file->name = path->value; + path->value = NULL; + file->next = (*root)->next; + (*root)->next = file; + return 1; + } + if (strcmp((*root)->name, path->value)) { + root = &(*root)->next; + goto tail_recursion; + } else { + (*root)->length += size; + return insert_file(&(*root)->child, path->next, size, *root); + } +} + +/** + * parses a metainfo file tree into inode file tree. same as with insert_file, values are removed -- original is destroyed, but must stil be freed -- it will be together with metainfo decoded object + * + * @param root [io] pointer to root inode of torrent -- user sets this to &metainfo->files + * @param dict [io] first element of file tree dict -- user sets this to bpath(file, "info/file tree")->child + * @param cunt [out] increment this variable on every added file. may be NULL. + * @param prnt [in] parent/caller object -- used internally, user should call with NULL + * @return sum length of the filetree + */ + +static int filetree (struct inode ** root, struct bencoding * dict, unsigned * cunt, struct inode * prnt) { + if (!dict) + return 0; + assert(!*root); + if (!dict->key->valuelen) { + struct bencoding * length = bpath(dict, "length"); + if (cunt) + (*cunt)++; + if (length) + return (prnt->length = length->intvalue); // XXX crash if root element is "" + return 0; + } + *root = calloc(1, sizeof(struct inode)); + (*root)->parent = prnt; + (*root)->name = dict->key->value; // XXX crash + dict->key->value = NULL; + return ((*root)->length = filetree(&(*root)->child, dict->child, cunt, *root) + filetree(&(*root)->next, dict->next, cunt, prnt)); +} + +/** + * parses a torrent bencoding + * + * @param data [in] metainfo dict as bytes + * @param size [in] length of data + * @return allocated metainfo object on heap, memory ownership is transfered to the caller + */ + +struct metainfo * parse (const char * data, off_t size) { + struct bencoding * metainfo = bdecode(data, size, 0); + struct metainfo * r = calloc(1, sizeof(struct metainfo)); #define EXTRACT(attribute, localvar, from) \ struct bencoding * localvar = bpath(metainfo, from); \ if (localvar && localvar->valuelen) { \ @@ -71,20 +189,189 @@ struct metainfo * parse (const struct bencoding * metainfo) { EXTRACT(publisher_url, publisher_url, "info/publisher-url"); EXTRACT(publisher_url, publisher_urlutf8, "info/publisher-url.utf-8"); EXTRACT(comment, comment, "comment"); - struct bencoding * retrieved = bpath(metainfo, "info/creation date"); + struct bencoding * retrieved = bpath(metainfo, "creation date"); if (retrieved && retrieved->valuelen) r->retrieved = atoi(retrieved->value); - struct bencoding * created = bpath(metainfo, "creation date"); + struct bencoding * created = bpath(metainfo, "info/creation date"); if (created && created->intvalue) r->created = created->intvalue; + char * ip = bpath(metainfo, "source/ip")->value; // XXX crash if non-travnik torrents + char * slash = strchr(ip, '/'); + *slash = '\0'; // XXX crash if non-travnik torrents + r->ip.sin6_family = AF_INET6; + r->ip.sin6_port = htons(atoi(++slash)); + inet_pton(AF_INET6, ip, r->ip.sin6_addr.s6_addr); struct bencoding * files = bpath(metainfo, "info/files"); if (files) { r->type = V1; bforeach (files, file) { - struct attr * bpath(file, "attr"); - if (attr && attr->valuelen && strchr(attr, 'p')) - continue; - struct path * bpath(file, "path"); + struct bencoding * attr = bpath(file, "attr"); + if (attr && attr->valuelen && strchr(attr->value, 'p')) + continue; + inode_length_t len = bpath(file, "length")->intvalue; // XXX crash + r->length += len; + r->filecount++; + insert_file(&r->files, bpath(file, "path")->child, len, NULL); // XXX crash } } + struct bencoding * file_tree = bpath(metainfo, "info/file tree"); + if (file_tree && file_tree->child) { + r->type |= V2; + if (!r->files) + r->length = filetree(&r->files, file_tree->child, &r->filecount, NULL); + } + if (!r->files) { + r->filecount = 1; + r->type = V1; + r->files = calloc(1, sizeof(struct inode)); + r->files->name = strdup(r->name); // XXX crash + r->length = r->files->length = bpath(metainfo, "info/length")->intvalue; // XXX crash + } + if (!r->files->next && !r->files->child && !r->files->length) + r->files->length = bpath(metainfo, "info/length")->intvalue; // XXX crash + char * start = strstr(data, "4:info")+6; // XXX crash if non-travnik torrents + ptrdiff_t len = bpath(metainfo, "info")->after-start; // XXX crash if non-travnik torrents + SHA1_CTX sha1; // we abuse ->after private variable. this is nonstandard, but it's a monorepo + SHA1Init(&sha1); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wpointer-sign" + SHA1Update(&sha1, start, len); +#pragma GCC diagnostic pop + SHA1Final(r->sha1, &sha1); + SHA2_CTX sha2; + SHA256Init(&sha2); +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wpointer-sign" + SHA256Update(&sha2, start, len); +#pragma GCC diagnostic pop + SHA256Final(r->sha256, &sha2); + free_bencoding(metainfo); + return r; +} + +/** + * parse all .torrent files in directory + * + * @param path [in] path to directory + * @param out [out] pointer to variable into which a pointer to the array containing pointers to metainfo. you must metainfo_free() all elements of array and array itself. + * @return number of metainfo structures created or -errno on failure + */ + +int directory (const char * path, struct metainfo *** out) { + size_t size = 65536; + int dirfd = open(path, O_DIRECTORY | O_CLOEXEC | O_RDONLY); + if (dirfd == -1) + return -errno; + int fd2 = dup(dirfd); + if (fd2 == -1) { + int err = errno; + close(dirfd); + return -err; + } + DIR * dir = fdopendir(fd2); + if (!dir) { + int err = errno; + close(fd2); + close(dirfd); + return -err; + } + *out = malloc(65535*sizeof(*out)); + struct dirent * dirent; + unsigned i = 0; + while ((dirent = readdir(dir))) { + if (!(i % 1000)) { + fprintf(stderr, "%u\n", i); + } + if (dirent->d_type != DT_REG) + continue; + if (!strstr(dirent->d_name, ".torrent")) + continue; + if (i+1 >= size) { + size *= 2; + *out = reallocarray(*out, size, sizeof(*out)); + } + int fd = openat(dirfd, dirent->d_name, O_CLOEXEC | O_RDONLY); + if (fd == -1) { + error_at_line(0, errno, __FILE__, __LINE__, "openat(dirfd, %s, O_CLOEXEC | O_RDONLY)", dirent->d_name); + continue; + } + struct stat statbuf; + if (fstat(fd, &statbuf) == -1) { + error_at_line(0, errno, __FILE__, __LINE__, "stat(%s)", dirent->d_name); + close(fd); + continue; + } + char * content = mmap(NULL, statbuf.st_size, PROT_READ, MAP_SHARED, fd, 0); + if (content == MAP_FAILED) { + error_at_line(0, errno, __FILE__, __LINE__, "mmap(NULL, %lu, PROT_READ, MAP_SHARED, %s, 0)", statbuf.st_size, dirent->d_name); + close(fd); + continue; + } + (*out)[i++] = parse(content, statbuf.st_size); + munmap(content, statbuf.st_size); + close(fd); + } + closedir(dir); + close(dirfd); + return i; +} + +#if __INCLUDE_LEVEL__ == 0 +#include <lib.c> +#include <time.h> +#include <locale.h> +#define S0(x) ((x) ? (x) : "") +int main (int argc, char ** argv) { + setlocale(LC_ALL, ""); + int r = 0; + char * content = NULL; + if (argc < 1+1) + error_at_line(1, 0, __FILE__, __LINE__, "%s metainfo.torrent", S0(argv[0])); + int fd = open(argv[1], O_CLOEXEC | O_RDONLY); + if (fd == -1) + error_at_line(2, errno, __FILE__, __LINE__, "open(%s, O_CLOEXEC | O_RDONLY)", argv[1]); + struct stat statbuf; + if (fstat(fd, &statbuf) == -1) { + error_at_line(0, errno, __FILE__, __LINE__, "stat(%s)", argv[1]); + r = 3; + goto r; + } + if (!(content = mmap(NULL, statbuf.st_size, PROT_READ, MAP_SHARED, fd, 0))) { + error_at_line(0, errno, __FILE__, __LINE__, "mmap(NULL, %lu, PROT_READ, MAP_SHARED, %s, 0)", statbuf.st_size, argv[1]); + r = 4; + goto r; + } + struct metainfo * metainfo = parse(content, statbuf.st_size); + char bufip[INET6_ADDRSTRLEN]; + char created[256]; + char retrieved[256]; + strftime(created, 256, "%c", localtime(&metainfo->created)); + strftime(retrieved, 256, "%c", localtime(&metainfo->retrieved)); + char sha1[41]; + char sha256[65]; + bin2hex(sha1, metainfo->sha1, 20); + bin2hex(sha256, metainfo->sha256, 32); + sha1[40] = '\0'; + sha256[64] = '\0'; + printf("name: %s\nsha1: %s\nsha256: %s\ntype: %s\nlength: %f GiB\nfilecount: %u\nclient: %s\nsource: %s\npublisher: %s\npublisher_url: %s\ncomment: %s\nip: %s/%u\ncreated: %s\nretrieved: %s\nfiles:\n", metainfo->name, sha1, sha256, type_str[metainfo->type], (float) metainfo->length/(1024*1024*1024), metainfo->filecount, S0(metainfo->client), S0(metainfo->source), S0(metainfo->publisher), S0(metainfo->publisher_url), S0(metainfo->comment), inet_ntop(AF_INET6, metainfo->ip.sin6_addr.s6_addr, bufip, INET6_ADDRSTRLEN), ntohs(metainfo->ip.sin6_port), metainfo->created ? created : "", retrieved); // XXX crash if non-travnik torrent + int leap = 0; + int depth = 0; + for (const struct inode * inode = metainfo->files; inode; inode = next_inode(inode, &leap)) { + depth -= leap; + putchar('\t'); + for (int i = 0; i < depth; i++) + fwrite("|\t", 1, 2, stdout); + printf("%s %s (%f MiB)\n", inode->child ? "\\" : "*", inode->name, (float) inode->length/(1024*1024)); + } + metainfo_free(metainfo); + metainfo = NULL; + struct metainfo ** metainfos; + directory(".", &metainfos); + r: + if (content && munmap(content, statbuf.st_size)) + error_at_line(0, errno, __FILE__, __LINE__, "munmap(%s, %lu)", argv[1], statbuf.st_size); + if (close(fd) == -1) + error_at_line(0, errno, __FILE__, __LINE__, "close(%s)", argv[1]); + return r; } +#endif diff --git a/src/metainfo.h b/src/metainfo.h new file mode 100644 index 0000000..774b91a --- /dev/null +++ b/src/metainfo.h @@ -0,0 +1,37 @@ +typedef unsigned inode_length_t; +struct inode { + char * name; + size_t length; + struct inode * next; + struct inode * child; + struct inode * parent; +}; +const struct inode * next_file (const struct inode * inode); +const struct inode * next_inode (const struct inode * inode, int * paths); +enum type { + UNSPEC = 0, + V1 = 1, + V2 = 2, + HYBRID = 1 | 2 +}; +char * type_str[] = { "UNSPEC", "V1", "V2", "HYBRID" }; +struct metainfo { + struct inode * files; + struct sockaddr_in6 ip; + time_t retrieved; + time_t created; + enum type type; + unsigned char sha1[20]; + unsigned char sha256[32]; + char * name; + char * client; + char * source; + char * publisher; + char * publisher_url; + char * comment; + unsigned filecount; + inode_length_t length; +}; +void metainfo_free (struct metainfo * metainfo); +struct metainfo * parse (const char * data, off_t size); +int directory (const char * path, struct metainfo *** out); |