Changeset 13823


Ignore:
Timestamp:
Jan 21, 2013, 5:39:20 PM (8 years ago)
Author:
jordan
Message:

(libT) copyediting: reformat blocklist.c to the new indentation style

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/blocklist.c

    r13631 r13823  
    5050struct tr_ipv4_range
    5151{
    52     uint32_t    begin;
    53     uint32_t    end;
     52  uint32_t begin;
     53  uint32_t end;
    5454};
    5555
    5656struct tr_blocklist
    5757{
    58     bool                   isEnabled;
    59     int                    fd;
    60     size_t                 ruleCount;
    61     size_t                 byteCount;
    62     char *                 filename;
    63     struct tr_ipv4_range * rules;
     58  bool                   isEnabled;
     59  int                    fd;
     60  size_t                 ruleCount;
     61  size_t                 byteCount;
     62  char *                 filename;
     63  struct tr_ipv4_range * rules;
    6464};
    6565
     
    6767blocklistClose (tr_blocklist * b)
    6868{
    69     if (b->rules)
    70     {
    71         munmap (b->rules, b->byteCount);
    72         close (b->fd);
    73         b->rules = NULL;
    74         b->ruleCount = 0;
    75         b->byteCount = 0;
    76         b->fd = -1;
     69  if (b->rules != NULL)
     70    {
     71      munmap (b->rules, b->byteCount);
     72      close (b->fd);
     73      b->rules = NULL;
     74      b->ruleCount = 0;
     75      b->byteCount = 0;
     76      b->fd = -1;
    7777    }
    7878}
     
    8181blocklistLoad (tr_blocklist * b)
    8282{
    83     int fd;
    84     size_t byteCount;
    85     struct stat st;
    86     const char * err_fmt = _("Couldn't read \"%1$s\": %2$s");
    87 
    88     blocklistClose (b);
    89 
    90     if (stat (b->filename, &st) == -1)
    91         return;
    92 
    93     fd = open (b->filename, O_RDONLY | O_BINARY);
    94     if (fd == -1)
    95     {
    96         tr_err (err_fmt, b->filename, tr_strerror (errno));
    97         return;
    98     }
    99 
    100     byteCount = (size_t) st.st_size;
    101     b->rules = mmap (NULL, byteCount, PROT_READ, MAP_PRIVATE, fd, 0);
    102     if (!b->rules)
    103     {
    104         tr_err (err_fmt, b->filename, tr_strerror (errno));
    105         close (fd);
    106         return;
    107     }
    108 
    109     b->fd = fd;
    110     b->byteCount = byteCount;
    111     b->ruleCount = byteCount / sizeof (struct tr_ipv4_range);
    112 
    113     {
    114         char * base = tr_basename (b->filename);
    115         tr_inf (_("Blocklist \"%s\" contains %zu entries"), base, b->ruleCount);
    116         tr_free (base);
    117     }
     83  int fd;
     84  size_t byteCount;
     85  struct stat st;
     86  char * base;
     87  const char * err_fmt = _("Couldn't read \"%1$s\": %2$s");
     88
     89  blocklistClose (b);
     90
     91  if (stat (b->filename, &st) == -1)
     92    return;
     93
     94  fd = open (b->filename, O_RDONLY | O_BINARY);
     95  if (fd == -1)
     96    {
     97      tr_err (err_fmt, b->filename, tr_strerror (errno));
     98      return;
     99    }
     100
     101  byteCount = (size_t) st.st_size;
     102  b->rules = mmap (NULL, byteCount, PROT_READ, MAP_PRIVATE, fd, 0);
     103  if (!b->rules)
     104    {
     105      tr_err (err_fmt, b->filename, tr_strerror (errno));
     106      close (fd);
     107      return;
     108    }
     109
     110  b->fd = fd;
     111  b->byteCount = byteCount;
     112  b->ruleCount = byteCount / sizeof (struct tr_ipv4_range);
     113
     114  base = tr_basename (b->filename);
     115  tr_inf (_("Blocklist \"%s\" contains %zu entries"), base, b->ruleCount);
     116  tr_free (base);
    118117}
    119118
     
    121120blocklistEnsureLoaded (tr_blocklist * b)
    122121{
    123     if (!b->rules)
    124         blocklistLoad (b);
     122  if (b->rules == NULL)
     123    blocklistLoad (b);
    125124}
    126125
    127126static int
    128 compareAddressToRange (const void * va,
    129                        const void * vb)
    130 {
    131     const uint32_t *             a = va;
    132     const struct tr_ipv4_range * b = vb;
    133 
    134     if (*a < b->begin) return -1;
    135     if (*a > b->end) return 1;
    136     return 0;
     127compareAddressToRange (const void * va, const void * vb)
     128{
     129  const uint32_t * a = va;
     130  const struct tr_ipv4_range * b = vb;
     131
     132  if (*a < b->begin) return -1;
     133  if (*a > b->end) return 1;
     134  return 0;
    137135}
    138136
     
    140138blocklistDelete (tr_blocklist * b)
    141139{
    142     blocklistClose (b);
    143     unlink (b->filename);
     140  blocklistClose (b);
     141  unlink (b->filename);
    144142}
    145143
     
    151149_tr_blocklistNew (const char * filename, bool isEnabled)
    152150{
    153     tr_blocklist * b;
    154 
    155     b = tr_new0 (tr_blocklist, 1);
    156     b->fd = -1;
    157     b->filename = tr_strdup (filename);
    158     b->isEnabled = isEnabled;
    159 
    160     return b;
     151  tr_blocklist * b;
     152
     153  b = tr_new0 (tr_blocklist, 1);
     154  b->fd = -1;
     155  b->filename = tr_strdup (filename);
     156  b->isEnabled = isEnabled;
     157
     158  return b;
    161159}
    162160
     
    164162_tr_blocklistGetFilename (const tr_blocklist * b)
    165163{
    166     return b->filename;
     164  return b->filename;
    167165}
    168166
     
    170168_tr_blocklistFree (tr_blocklist * b)
    171169{
    172     blocklistClose (b);
    173     tr_free (b->filename);
    174     tr_free (b);
     170  blocklistClose (b);
     171  tr_free (b->filename);
     172  tr_free (b);
    175173}
    176174
     
    178176_tr_blocklistExists (const tr_blocklist * b)
    179177{
    180     struct stat st;
    181 
    182     return !stat (b->filename, &st);
     178  struct stat st;
     179
     180  return !stat (b->filename, &st);
    183181}
    184182
     
    186184_tr_blocklistGetRuleCount (const tr_blocklist * b)
    187185{
    188     blocklistEnsureLoaded ((tr_blocklist*)b);
    189 
    190     return b->ruleCount;
     186  blocklistEnsureLoaded ((tr_blocklist*)b);
     187
     188  return b->ruleCount;
    191189}
    192190
     
    194192_tr_blocklistIsEnabled (tr_blocklist * b)
    195193{
    196     return b->isEnabled;
     194  return b->isEnabled;
    197195}
    198196
     
    200198_tr_blocklistSetEnabled (tr_blocklist * b, bool isEnabled)
    201199{
    202     b->isEnabled = isEnabled ? 1 : 0;
     200  b->isEnabled = isEnabled ? 1 : 0;
    203201}
    204202
     
    206204_tr_blocklistHasAddress (tr_blocklist * b, const tr_address * addr)
    207205{
    208     uint32_t                    needle;
    209     const struct tr_ipv4_range * range;
    210 
    211     assert (tr_address_is_valid (addr));
    212 
    213     if (!b->isEnabled || addr->type == TR_AF_INET6)
    214         return 0;
    215 
    216     blocklistEnsureLoaded (b);
    217 
    218     if (!b->rules || !b->ruleCount)
    219         return 0;
    220 
    221     needle = ntohl (addr->addr.addr4.s_addr);
    222 
    223     range = bsearch (&needle,
    224                      b->rules,
    225                      b->ruleCount,
    226                      sizeof (struct tr_ipv4_range),
    227                      compareAddressToRange);
    228 
    229     return range != NULL;
     206  uint32_t needle;
     207  const struct tr_ipv4_range * range;
     208
     209  assert (tr_address_is_valid (addr));
     210
     211  if (!b->isEnabled || addr->type == TR_AF_INET6)
     212    return 0;
     213
     214  blocklistEnsureLoaded (b);
     215
     216  if (!b->rules || !b->ruleCount)
     217    return 0;
     218
     219  needle = ntohl (addr->addr.addr4.s_addr);
     220
     221  range = bsearch (&needle,
     222                   b->rules,
     223                   b->ruleCount,
     224                   sizeof (struct tr_ipv4_range),
     225                   compareAddressToRange);
     226
     227  return range != NULL;
    230228}
    231229
     
    238236parseLine1 (const char * line, struct tr_ipv4_range * range)
    239237{
    240     char * walk;
    241     int b[4];
    242     int e[4];
    243     char str[64];
    244     tr_address addr;
    245 
    246     walk = strrchr (line, ':');
    247     if (!walk)
    248         return false;
    249     ++walk; /* walk past the colon */
    250 
    251     if (sscanf (walk, "%d.%d.%d.%d-%d.%d.%d.%d",
    252                 &b[0], &b[1], &b[2], &b[3],
    253                 &e[0], &e[1], &e[2], &e[3]) != 8)
    254         return false;
    255 
    256     tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
    257     if (!tr_address_from_string (&addr, str))
    258         return false;
    259     range->begin = ntohl (addr.addr.addr4.s_addr);
    260 
    261     tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", e[0], e[1], e[2], e[3]);
    262     if (!tr_address_from_string (&addr, str))
    263         return false;
    264     range->end = ntohl (addr.addr.addr4.s_addr);
    265 
    266     return true;
     238  char * walk;
     239  int b[4];
     240  int e[4];
     241  char str[64];
     242  tr_address addr;
     243
     244  walk = strrchr (line, ':');
     245  if (!walk)
     246    return false;
     247  ++walk; /* walk past the colon */
     248
     249  if (sscanf (walk, "%d.%d.%d.%d-%d.%d.%d.%d",
     250              &b[0], &b[1], &b[2], &b[3],
     251              &e[0], &e[1], &e[2], &e[3]) != 8)
     252    return false;
     253
     254  tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
     255  if (!tr_address_from_string (&addr, str))
     256    return false;
     257  range->begin = ntohl (addr.addr.addr4.s_addr);
     258
     259  tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", e[0], e[1], e[2], e[3]);
     260  if (!tr_address_from_string (&addr, str))
     261    return false;
     262  range->end = ntohl (addr.addr.addr4.s_addr);
     263
     264  return true;
    267265}
    268266
     
    274272parseLine2 (const char * line, struct tr_ipv4_range * range)
    275273{
    276     int unk;
    277     int a[4];
    278     int b[4];
    279     char str[32];
    280     tr_address addr;
    281 
    282     if (sscanf (line, "%3d.%3d.%3d.%3d - %3d.%3d.%3d.%3d , %3d , ",
    283                 &a[0], &a[1], &a[2], &a[3],
    284                 &b[0], &b[1], &b[2], &b[3],
    285                 &unk) != 9)
    286         return false;
    287 
    288     tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
    289     if (!tr_address_from_string (&addr, str))
    290         return false;
    291     range->begin = ntohl (addr.addr.addr4.s_addr);
    292 
    293     tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
    294     if (!tr_address_from_string (&addr, str))
    295         return false;
    296     range->end = ntohl (addr.addr.addr4.s_addr);
    297 
    298     return true;
     274  int unk;
     275  int a[4];
     276  int b[4];
     277  char str[32];
     278  tr_address addr;
     279
     280  if (sscanf (line, "%3d.%3d.%3d.%3d - %3d.%3d.%3d.%3d , %3d , ",
     281              &a[0], &a[1], &a[2], &a[3],
     282              &b[0], &b[1], &b[2], &b[3],
     283              &unk) != 9)
     284    return false;
     285
     286  tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
     287  if (!tr_address_from_string (&addr, str))
     288    return false;
     289  range->begin = ntohl (addr.addr.addr4.s_addr);
     290
     291  tr_snprintf (str, sizeof (str), "%d.%d.%d.%d", b[0], b[1], b[2], b[3]);
     292  if (!tr_address_from_string (&addr, str))
     293    return false;
     294  range->end = ntohl (addr.addr.addr4.s_addr);
     295
     296  return true;
    299297}
    300298
     
    302300parseLine (const char * line, struct tr_ipv4_range * range)
    303301{
    304     return parseLine1 (line, range)
    305         || parseLine2 (line, range);
     302  return parseLine1 (line, range)
     303      || parseLine2 (line, range);
    306304}
    307305
     
    309307compareAddressRangesByFirstAddress (const void * va, const void * vb)
    310308{
    311     const struct tr_ipv4_range * a = va;
    312     const struct tr_ipv4_range * b = vb;
    313     if (a->begin != b->begin)
    314         return a->begin < b->begin ? -1 : 1;
    315     return 0;
     309  const struct tr_ipv4_range * a = va;
     310  const struct tr_ipv4_range * b = vb;
     311  if (a->begin != b->begin)
     312    return a->begin < b->begin ? -1 : 1;
     313  return 0;
    316314}
    317315
     
    319317_tr_blocklistSetContent (tr_blocklist * b, const char * filename)
    320318{
    321     FILE * in;
    322     FILE * out;
    323     int inCount = 0;
    324     char line[2048];
    325     const char * err_fmt = _("Couldn't read \"%1$s\": %2$s");
    326     struct tr_ipv4_range * ranges = NULL;
    327     size_t ranges_alloc = 0;
    328     size_t ranges_count = 0;
    329 
    330     if (!filename)
    331     {
    332         blocklistDelete (b);
    333         return 0;
    334     }
    335 
    336     in = fopen (filename, "rb");
    337     if (!in)
    338     {
    339         tr_err (err_fmt, filename, tr_strerror (errno));
    340         return 0;
    341     }
    342 
    343     blocklistClose (b);
    344 
    345     out = fopen (b->filename, "wb+");
    346     if (!out)
    347     {
    348         tr_err (err_fmt, b->filename, tr_strerror (errno));
    349         fclose (in);
    350         return 0;
    351     }
    352 
    353     /* load the rules into memory */
    354     while (fgets (line, sizeof (line), in) != NULL)
    355     {
    356         char * walk;
    357         struct tr_ipv4_range range;
    358 
    359         ++inCount;
    360 
    361         /* zap the linefeed */
    362         if ((walk = strchr (line, '\r'))) *walk = '\0';
    363         if ((walk = strchr (line, '\n'))) *walk = '\0';
    364 
    365         if (!parseLine (line, &range))
     319  FILE * in;
     320  FILE * out;
     321  int inCount = 0;
     322  char line[2048];
     323  const char * err_fmt = _("Couldn't read \"%1$s\": %2$s");
     324  struct tr_ipv4_range * ranges = NULL;
     325  size_t ranges_alloc = 0;
     326  size_t ranges_count = 0;
     327
     328  if (!filename)
     329    {
     330      blocklistDelete (b);
     331      return 0;
     332    }
     333
     334  in = fopen (filename, "rb");
     335  if (in == NULL)
     336    {
     337      tr_err (err_fmt, filename, tr_strerror (errno));
     338      return 0;
     339    }
     340
     341  blocklistClose (b);
     342
     343  out = fopen (b->filename, "wb+");
     344  if (out == NULL)
     345    {
     346      tr_err (err_fmt, b->filename, tr_strerror (errno));
     347      fclose (in);
     348      return 0;
     349    }
     350
     351  /* load the rules into memory */
     352  while (fgets (line, sizeof (line), in) != NULL)
     353    {
     354      char * walk;
     355      struct tr_ipv4_range range;
     356
     357      ++inCount;
     358
     359      /* zap the linefeed */
     360      if ((walk = strchr (line, '\r'))) *walk = '\0';
     361      if ((walk = strchr (line, '\n'))) *walk = '\0';
     362
     363      if (!parseLine (line, &range))
    366364        {
    367             /* don't try to display the actual lines - it causes issues */
    368             tr_err (_("blocklist skipped invalid address at line %d"), inCount);
    369             continue;
     365          /* don't try to display the actual lines - it causes issues */
     366          tr_err (_("blocklist skipped invalid address at line %d"), inCount);
     367          continue;
    370368        }
    371369
    372         if (ranges_alloc == ranges_count)
     370      if (ranges_alloc == ranges_count)
    373371        {
    374             ranges_alloc += 4096; /* arbitrary */
    375             ranges = tr_renew (struct tr_ipv4_range, ranges, ranges_alloc);
     372          ranges_alloc += 4096; /* arbitrary */
     373          ranges = tr_renew (struct tr_ipv4_range, ranges, ranges_alloc);
    376374        }
    377375
    378         ranges[ranges_count++] = range;
    379     }
    380 
    381     if (ranges_count > 0) /* sort and merge */
    382     {
    383         struct tr_ipv4_range * r;
    384         struct tr_ipv4_range * keep = ranges;
    385         const struct tr_ipv4_range * end;
    386 
    387         /* sort */
    388         qsort (ranges, ranges_count, sizeof (struct tr_ipv4_range),
    389                compareAddressRangesByFirstAddress);
    390 
    391         /* merge */
    392         for (r=ranges+1, end=ranges+ranges_count; r!=end; ++r) {
    393             if (keep->end < r->begin)
    394                 *++keep = *r;
    395             else if (keep->end < r->end)
    396                 keep->end = r->end;
    397         }
    398 
    399         ranges_count = keep + 1 - ranges;
     376      ranges[ranges_count++] = range;
     377    }
     378
     379  if (ranges_count > 0) /* sort and merge */
     380    {
     381      struct tr_ipv4_range * r;
     382      struct tr_ipv4_range * keep = ranges;
     383      const struct tr_ipv4_range * end;
     384
     385      /* sort */
     386      qsort (ranges, ranges_count, sizeof (struct tr_ipv4_range),
     387             compareAddressRangesByFirstAddress);
     388
     389      /* merge */
     390      for (r=ranges+1, end=ranges+ranges_count; r!=end; ++r) {
     391        if (keep->end < r->begin)
     392          *++keep = *r;
     393        else if (keep->end < r->end)
     394          keep->end = r->end;
     395      }
     396
     397      ranges_count = keep + 1 - ranges;
    400398
    401399#ifndef NDEBUG
    402         /* sanity checks: make sure the rules are sorted
    403          * in ascending order and don't overlap */
    404         {
    405             size_t i;
    406 
    407             for (i=0; i<ranges_count; ++i)
    408                 assert (ranges[i].begin <= ranges[i].end);
    409 
    410             for (i=1; i<ranges_count; ++i)
    411                 assert (ranges[i-1].end < ranges[i].begin);
    412         }
     400      /* sanity checks: make sure the rules are sorted
     401       * in ascending order and don't overlap */
     402      {
     403        size_t i;
     404
     405        for (i=0; i<ranges_count; ++i)
     406          assert (ranges[i].begin <= ranges[i].end);
     407
     408        for (i=1; i<ranges_count; ++i)
     409          assert (ranges[i-1].end < ranges[i].begin);
     410      }
    413411#endif
    414412    }
    415413
    416     if (fwrite (ranges, sizeof (struct tr_ipv4_range), ranges_count, out) != ranges_count)
    417         tr_err (_("Couldn't save file \"%1$s\": %2$s"), b->filename, tr_strerror (errno));
    418     else {
    419         char * base = tr_basename (b->filename);
    420         tr_inf (_("Blocklist \"%s\" updated with %zu entries"), base, ranges_count);
    421         tr_free (base);
    422     }
    423 
    424     tr_free (ranges);
    425     fclose (out);
    426     fclose (in);
    427 
    428     blocklistLoad (b);
    429 
    430     return ranges_count;
    431 }
     414  if (fwrite (ranges, sizeof (struct tr_ipv4_range), ranges_count, out) != ranges_count)
     415    {
     416      tr_err (_("Couldn't save file \"%1$s\": %2$s"), b->filename, tr_strerror (errno));
     417    }
     418  else
     419    {
     420      char * base = tr_basename (b->filename);
     421      tr_inf (_("Blocklist \"%s\" updated with %zu entries"), base, ranges_count);
     422      tr_free (base);
     423    }
     424
     425  tr_free (ranges);
     426  fclose (out);
     427  fclose (in);
     428
     429  blocklistLoad (b);
     430
     431  return ranges_count;
     432}
Note: See TracChangeset for help on using the changeset viewer.