/* * This file Copyright (C) Mnemosyne LLC * * This file is licensed by the GPL version 2. Works owned by the * Transmission project are granted a special exemption to clause 2 (b) * so that the bulk of its code can remain under the MIT license. * This exemption does not extend to derived works not owned by * the Transmission project. * * $Id$ */ #include #include #include #include /* bsearch (), qsort () */ #include #include /* unlink () */ #ifdef WIN32 #include #define WINVER WindowsXP #include #define PROT_READ PAGE_READONLY #define MAP_PRIVATE FILE_MAP_COPY #endif #ifndef WIN32 #include #endif #include #include #include #include "transmission.h" #include "blocklist.h" #include "net.h" #include "utils.h" #ifndef O_BINARY #define O_BINARY 0 #endif /*** **** PRIVATE ***/ struct tr_ipv4_range { uint32_t begin; uint32_t end; }; struct tr_blocklist { bool isEnabled; int fd; size_t ruleCount; size_t byteCount; char * filename; struct tr_ipv4_range * rules; }; static void blocklistClose (tr_blocklist * b) { if (b->rules) { munmap (b->rules, b->byteCount); close (b->fd); b->rules = NULL; b->ruleCount = 0; b->byteCount = 0; b->fd = -1; } } static void blocklistLoad (tr_blocklist * b) { int fd; size_t byteCount; struct stat st; const char * err_fmt = _("Couldn't read \"%1$s\": %2$s"); blocklistClose (b); if (stat (b->filename, &st) == -1) return; fd = open (b->filename, O_RDONLY | O_BINARY); if (fd == -1) { tr_err (err_fmt, b->filename, tr_strerror (errno)); return; } byteCount = (size_t) st.st_size; b->rules = mmap (NULL, byteCount, PROT_READ, MAP_PRIVATE, fd, 0); if (!b->rules) { tr_err (err_fmt, b->filename, tr_strerror (errno)); close (fd); return; } b->fd = fd; b->byteCount = byteCount; b->ruleCount = byteCount / sizeof (struct tr_ipv4_range); { char * base = tr_basename (b->filename); tr_inf (_("Blocklist \"%s\" contains %zu entries"), base, b->ruleCount); tr_free (base); } } static void blocklistEnsureLoaded (tr_blocklist * b) { if (!b->rules) blocklistLoad (b); } static int compareAddressToRange (const void * va, const void * vb) { const uint32_t * a = va; const struct tr_ipv4_range * b = vb; if (*a < b->begin) return -1; if (*a > b->end) return 1; return 0; } static void blocklistDelete (tr_blocklist * b) { blocklistClose (b); unlink (b->filename); } /*** **** PACKAGE-VISIBLE ***/ tr_blocklist * _tr_blocklistNew (const char * filename, bool isEnabled) { tr_blocklist * b; b = tr_new0 (tr_blocklist, 1); b->fd = -1; b->filename = tr_strdup (filename); b->isEnabled = isEnabled; return b; } const char* _tr_blocklistGetFilename (const tr_blocklist * b) { return b->filename; } void _tr_blocklistFree (tr_blocklist * b) { blocklistClose (b); tr_free (b->filename); tr_free (b); } int _tr_blocklistExists (const tr_blocklist * b) { struct stat st; return !stat (b->filename, &st); } int _tr_blocklistGetRuleCount (const tr_blocklist * b) { blocklistEnsureLoaded ((tr_blocklist*)b); return b->ruleCount; } int _tr_blocklistIsEnabled (tr_blocklist * b) { return b->isEnabled; } void _tr_blocklistSetEnabled (tr_blocklist * b, bool isEnabled) { b->isEnabled = isEnabled ? 1 : 0; } int _tr_blocklistHasAddress (tr_blocklist * b, const tr_address * addr) { uint32_t needle; const struct tr_ipv4_range * range; assert (tr_address_is_valid (addr)); if (!b->isEnabled || addr->type == TR_AF_INET6) return 0; blocklistEnsureLoaded (b); if (!b->rules || !b->ruleCount) return 0; needle = ntohl (addr->addr.addr4.s_addr); range = bsearch (&needle, b->rules, b->ruleCount, sizeof (struct tr_ipv4_range), compareAddressToRange); return range != NULL; } /* * P2P plaintext format: "comment:x.x.x.x-y.y.y.y" * http://wiki.phoenixlabs.org/wiki/P2P_Format * http://en.wikipedia.org/wiki/PeerGuardian#P2P_plaintext_format */ static bool parseLine1 (const char * line, struct tr_ipv4_range * range) { char * walk; int b[4]; int e[4]; char str[64]; tr_address addr; walk = strrchr (line, ':'); if (!walk) return false; ++walk; /* walk past the colon */ if (sscanf (walk, "%d.%d.%d.%d-%d.%d.%d.%d", &b[0], &b[1], &b[2], &b[3], &e[0], &e[1], &e[2], &e[3]) != 8) return false; tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]); if (!tr_address_from_string (&addr, str)) return false; range->begin = ntohl (addr.addr.addr4.s_addr); tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", e[0], e[1], e[2], e[3]); if (!tr_address_from_string (&addr, str)) return false; range->end = ntohl (addr.addr.addr4.s_addr); return true; } /* * DAT format: "000.000.000.000 - 000.255.255.255 , 000 , invalid ip" * http://wiki.phoenixlabs.org/wiki/DAT_Format */ static bool parseLine2 (const char * line, struct tr_ipv4_range * range) { int unk; int a[4]; int b[4]; char str[32]; tr_address addr; if (sscanf (line, "%3d.%3d.%3d.%3d - %3d.%3d.%3d.%3d , %3d , ", &a[0], &a[1], &a[2], &a[3], &b[0], &b[1], &b[2], &b[3], &unk) != 9) return false; tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", a[0], a[1], a[2], a[3]); if (!tr_address_from_string (&addr, str)) return false; range->begin = ntohl (addr.addr.addr4.s_addr); tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]); if (!tr_address_from_string (&addr, str)) return false; range->end = ntohl (addr.addr.addr4.s_addr); return true; } static int parseLine (const char * line, struct tr_ipv4_range * range) { return parseLine1 (line, range) || parseLine2 (line, range); } static int compareAddressRangesByFirstAddress (const void * va, const void * vb) { const struct tr_ipv4_range * a = va; const struct tr_ipv4_range * b = vb; if (a->begin != b->begin) return a->begin < b->begin ? -1 : 1; return 0; } int _tr_blocklistSetContent (tr_blocklist * b, const char * filename) { FILE * in; FILE * out; int inCount = 0; char line[2048]; const char * err_fmt = _("Couldn't read \"%1$s\": %2$s"); struct tr_ipv4_range * ranges = NULL; size_t ranges_alloc = 0; size_t ranges_count = 0; if (!filename) { blocklistDelete (b); return 0; } in = fopen (filename, "rb"); if (!in) { tr_err (err_fmt, filename, tr_strerror (errno)); return 0; } blocklistClose (b); out = fopen (b->filename, "wb+"); if (!out) { tr_err (err_fmt, b->filename, tr_strerror (errno)); fclose (in); return 0; } /* load the rules into memory */ while (fgets (line, sizeof (line), in) != NULL) { char * walk; struct tr_ipv4_range range; ++inCount; /* zap the linefeed */ if ((walk = strchr (line, '\r'))) *walk = '\0'; if ((walk = strchr (line, '\n'))) *walk = '\0'; if (!parseLine (line, &range)) { /* don't try to display the actual lines - it causes issues */ tr_err (_("blocklist skipped invalid address at line %d"), inCount); continue; } if (ranges_alloc == ranges_count) { ranges_alloc += 4096; /* arbitrary */ ranges = tr_renew (struct tr_ipv4_range, ranges, ranges_alloc); } ranges[ranges_count++] = range; } if (ranges_count > 0) /* sort and merge */ { struct tr_ipv4_range * r; struct tr_ipv4_range * keep = ranges; const struct tr_ipv4_range * end; /* sort */ qsort (ranges, ranges_count, sizeof (struct tr_ipv4_range), compareAddressRangesByFirstAddress); /* merge */ for (r=ranges+1, end=ranges+ranges_count; r!=end; ++r) { if (keep->end < r->begin) *++keep = *r; else if (keep->end < r->end) keep->end = r->end; } ranges_count = keep + 1 - ranges; #ifndef NDEBUG /* sanity checks: make sure the rules are sorted * in ascending order and don't overlap */ { size_t i; for (i=0; ifilename, tr_strerror (errno)); else { char * base = tr_basename (b->filename); tr_inf (_("Blocklist \"%s\" updated with %zu entries"), base, ranges_count); tr_free (base); } tr_free (ranges); fclose (out); fclose (in); blocklistLoad (b); return ranges_count; }