Ignore:
Timestamp:
Jan 21, 2013, 9:14:14 PM (8 years ago)
Author:
jordan
Message:

(libT) #4632 'custom blocklist generates 2x # of rules': add a fix, which causes r13825's test to pass

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/session.c

    r13824 r13826  
    612612    tr_runInEventThread (session, tr_sessionInitImpl, &data);
    613613    while (!data.done)
    614         tr_wait_msec (100);
     614        tr_wait_msec (50);
    615615
    616616    return session;
     
    728728
    729729    tr_webInit (session);
     730    while (session->web == NULL)
     731      tr_wait_msec (50);
    730732
    731733    tr_sessionSet (session, &settings);
     
    18441846        dbgmsg ("waiting on port unmap (%p) or announcer (%p)... now %zu deadline %zu",
    18451847                session->shared, session->announcer, (size_t)time (NULL), (size_t)deadline);
    1846         tr_wait_msec (100);
     1848        tr_wait_msec (50);
    18471849    }
    18481850
     
    18551857        static bool forced = false;
    18561858        dbgmsg ("waiting for libtransmission thread to finish... now %zu deadline %zu", (size_t)time (NULL), (size_t)deadline);
    1857         tr_wait_msec (500);
     1859        tr_wait_msec (100);
    18581860        if (deadlineReached (deadline) && !forced)
    18591861        {
     
    21842186loadBlocklists (tr_session * session)
    21852187{
    2186     int         binCount = 0;
    2187     int         newCount = 0;
    2188     struct stat sb;
    2189     char      * dirname;
    2190     DIR *       odir = NULL;
    2191     tr_list *   list = NULL;
    2192     const bool  isEnabled = session->isBlocklistEnabled;
    2193 
    2194     /* walk through the directory and find blocklists */
    2195     dirname = tr_buildPath (session->configDir, "blocklists", NULL);
    2196     if (!stat (dirname,
    2197                &sb) && S_ISDIR (sb.st_mode)
    2198       && ((odir = opendir (dirname))))
     2188  DIR * odir;
     2189  char * dirname;
     2190  struct dirent * d;
     2191  tr_list * blocklists = NULL;
     2192  tr_ptrArray loadme = TR_PTR_ARRAY_INIT;
     2193  const bool isEnabled = session->isBlocklistEnabled;
     2194
     2195  /* walk the blocklist directory... */
     2196  dirname = tr_buildPath (session->configDir, "blocklists", NULL);
     2197  odir = opendir (dirname);
     2198  while ((d = readdir (odir)))
    21992199    {
    2200         struct dirent *d;
    2201         for (d = readdir (odir); d; d = readdir (odir))
     2200      char * path;
     2201      char * load = NULL;
     2202 
     2203      if (!d->d_name || (d->d_name[0]=='.')) /* ignore dotfiles */
     2204        continue;
     2205
     2206      path = tr_buildPath (dirname, d->d_name, NULL);
     2207
     2208      if (tr_stringEndsWith (path, ".bin"))
    22022209        {
    2203             char * filename;
    2204 
    2205             if (!d->d_name || d->d_name[0] == '.') /* skip dotfiles, ., and ..
    2206                                                       */
    2207                 continue;
    2208 
    2209             filename = tr_buildPath (dirname, d->d_name, NULL);
    2210 
    2211             if (tr_stringEndsWith (filename, ".bin"))
     2210          load = tr_strdup (path);
     2211        }
     2212      else
     2213        {
     2214          char * binname;
     2215          char * basename;
     2216          time_t path_mtime = 0;
     2217          time_t binname_mtime = 0;
     2218
     2219          basename = tr_basename (d->d_name);
     2220          binname = tr_strdup_printf ("%s" TR_PATH_DELIMITER_STR "%s.bin", dirname, basename);
     2221
     2222          if (!tr_fileExists (binname, &binname_mtime)) /* create it */
    22122223            {
    2213                 /* if we don't already have this blocklist, add it */
    2214                 if (!tr_list_find (list, filename,
    2215                                  (TrListCompareFunc)strcmp))
     2224              tr_blocklistFile * b = tr_blocklistFileNew (binname, isEnabled);
     2225              const int n = tr_blocklistFileSetContent (b, path);
     2226              if (n > 0)
     2227                load = tr_strdup (binname);
     2228
     2229              tr_blocklistFileFree (b);
     2230            }
     2231          else if (tr_fileExists(path,&path_mtime) && (path_mtime>=binname_mtime)) /* update it */
     2232            {
     2233              char * old;
     2234              tr_blocklistFile * b;
     2235
     2236              old = tr_strdup_printf ("%s.old", binname);
     2237              remove (old);
     2238              rename (binname, old);
     2239              b = tr_blocklistFileNew (binname, isEnabled);
     2240              if (tr_blocklistFileSetContent (b, path) > 0)
    22162241                {
    2217                     tr_list_append (&list,
    2218                                    tr_blocklistFileNew (filename, isEnabled));
    2219                     ++binCount;
     2242                  remove (old);
    22202243                }
     2244              else
     2245                {
     2246                  remove (binname);
     2247                  rename (old, binname);
     2248                }
     2249
     2250              tr_blocklistFileFree (b);
     2251              tr_free (old);
    22212252            }
    2222             else
    2223             {
    2224                 /* strip out the file suffix, if there is one, and add ".bin"
    2225                   instead */
    2226                 tr_blocklistFile * b;
    2227                 const char *   dot = strrchr (d->d_name, '.');
    2228                 const int      len = dot ? dot - d->d_name
    2229                                          : (int)strlen (d->d_name);
    2230                 char         * tmp = tr_strdup_printf (
    2231                                         "%s" TR_PATH_DELIMITER_STR "%*.*s.bin",
    2232                                         dirname, len, len, d->d_name);
    2233                 b = tr_blocklistFileNew (tmp, isEnabled);
    2234                 tr_blocklistFileSetContent (b, filename);
    2235                 tr_list_append (&list, b);
    2236                 ++newCount;
    2237                 tr_free (tmp);
    2238             }
    2239 
    2240             tr_free (filename);
     2253
     2254          tr_free (basename);
     2255          tr_free (binname);
    22412256        }
    22422257
    2243         closedir (odir);
    2244     }
    2245 
    2246     session->blocklists = list;
    2247 
    2248     if (binCount)
    2249         tr_dbg ("Found %d blocklists in \"%s\"", binCount, dirname);
    2250     if (newCount)
    2251         tr_dbg ("Found %d new blocklists in \"%s\"", newCount, dirname);
    2252 
    2253     tr_free (dirname);
     2258      if (load != NULL)
     2259        {
     2260          if (tr_ptrArrayFindSorted (&loadme, load, (PtrArrayCompareFunc)strcmp) == NULL)
     2261            tr_ptrArrayInsertSorted (&loadme, load, (PtrArrayCompareFunc)strcmp);
     2262          else
     2263            tr_free (load);
     2264        }
     2265
     2266      tr_free (path);
     2267    }
     2268
     2269  if (!tr_ptrArrayEmpty (&loadme))
     2270    {
     2271      int i;
     2272      const int n = tr_ptrArraySize (&loadme);
     2273      const char ** paths = (const char **) tr_ptrArrayBase (&loadme);
     2274
     2275      for (i=0; i<n; ++i)
     2276        tr_list_append (&blocklists, tr_blocklistFileNew (paths[i], isEnabled));
     2277    }
     2278
     2279  /* cleanup */
     2280  closedir (odir);
     2281  tr_free (dirname);
     2282  tr_ptrArrayDestruct (&loadme, (PtrArrayForeachFunc)tr_free);
     2283  session->blocklists = blocklists;
    22542284}
    22552285
Note: See TracChangeset for help on using the changeset viewer.