Changeset 5517


Ignore:
Timestamp:
04/05/08 20:12:11 (8 years ago)
Author:
charles
Message:

#684: Use XDG basedir spec for configuration and cache files in $HOME

Location:
trunk
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • trunk/cli/transmissioncli.c

    r5448 r5517  
    141141
    142142    /* Initialize libtransmission */
    143     h = tr_initFull( "cli",
     143    h = tr_initFull( tr_getDefaultConfigDir(),
     144                     "cli",                   /* tag */
    144145                     1,                       /* pex enabled */
    145146                     natTraversal,            /* nat enabled */
  • trunk/daemon/misc.c

    r5455 r5517  
    8080confpath( char * buf, size_t len, const char * file, enum confpathtype type )
    8181{
    82     strlcpy( buf, tr_getPrefsDirectory(), len );
     82    strlcpy( buf, tr_getDefaultConfigDir(), len );
    8383
    8484    switch( type )
  • trunk/daemon/torrents.c

    r5506 r5517  
    110110
    111111    gl_base   = base;
    112     gl_handle = tr_init( "daemon" );
     112    gl_handle = tr_init( tr_getDefaultConfigDir(), "daemon" );
    113113
    114114    confpath( gl_state, sizeof gl_state, CONF_FILE_STATE, 0 );
  • trunk/gtk/conf.c

    r5455 r5517  
    259259{
    260260    assert( gl_confdir != NULL );
    261     return g_build_filename( gl_confdir, "prefs", NULL );
     261    return g_build_filename( g_get_home_dir(), ".transmission", "gtk", "prefs", NULL );
     262}
     263
     264static char*
     265getCompat09PrefsFilename( void )
     266{
     267    assert( gl_confdir != NULL );
     268    return g_build_filename( g_get_home_dir(), ".transmission", "gtk", "prefs.ini", NULL );
    262269}
    263270
     
    318325    char * cfn = getPrefsFilename( );
    319326    char * cfn08 = getCompat08PrefsFilename( );
     327    char * cfn09 = getCompat09PrefsFilename( );
     328
     329    if( !g_file_test( cfn,   G_FILE_TEST_IS_REGULAR )
     330      && g_file_test( cfn09, G_FILE_TEST_IS_REGULAR ) )
     331      g_rename( cfn09, cfn );
    320332
    321333    if( !g_file_test( cfn,   G_FILE_TEST_IS_REGULAR )
     
    323335        translate_08_to_09( cfn08, cfn );
    324336
     337    g_free( cfn09 );
    325338    g_free( cfn08 );
    326339    g_free( cfn );
  • trunk/gtk/main.c

    r5496 r5517  
    273273    gboolean startminimized = FALSE;
    274274    char * domain = "transmission";
     275    const char * configDir = tr_getDefaultConfigDir( );
     276
    275277    GOptionEntry entries[] = {
    276278        { "paused", 'p', 0, G_OPTION_ARG_NONE, &startpaused,
     
    306308    tr_notify_init( );
    307309
    308     didinit = cf_init( tr_getPrefsDirectory(), NULL ); /* must come before actions_init */
     310    didinit = cf_init( configDir, NULL ); /* must come before actions_init */
    309311    tr_prefs_init_global( );
    310312    myUIManager = gtk_ui_manager_new ();
     
    318320    setupsighandlers( ); /* set up handlers for fatal signals */
    319321
    320     if( ( didinit || cf_init( tr_getPrefsDirectory(), &err ) ) &&
     322    if( ( didinit || cf_init( configDir, &err ) ) &&
    321323        ( didlock || cf_lock( &err ) ) )
    322324    {
  • trunk/gtk/tr-core.c

    r5476 r5517  
    450450
    451451
    452     h = tr_initFull( "gtk",
     452    h = tr_initFull( tr_getDefaultConfigDir( ),
     453                     "gtk",
    453454                     pref_flag_get( PREF_KEY_PEX ),
    454455                     pref_flag_get( PREF_KEY_NAT ),
  • trunk/libtransmission/fastresume.c

    r5455 r5517  
    124124fastResumeFileName( char * buf, size_t buflen, const tr_torrent * tor, int tag )
    125125{
    126     const char * cacheDir = tr_getCacheDirectory ();
     126    const char * cacheDir = tr_getResumeDir( tor->handle );
    127127    const char * hash = tor->info.hashString;
    128128
     
    604604    uint8_t * ret = NULL;
    605605    char path[MAX_PATH_LENGTH];
    606     const char * cacheDir = tr_getCacheDirectory ();
     606    const char * cacheDir = tr_getResumeDir( tor->handle );
    607607    const char * hash = tor->info.hashString;
    608608
     
    715715{
    716716    char path[MAX_PATH_LENGTH];
    717     const char * cacheDir = tr_getCacheDirectory ();
     717    const char * cacheDir = tr_getResumeDir( tor->handle );
    718718    const char * hash = tor->info.hashString;
    719719
  • trunk/libtransmission/internal.h

    r5516 r5517  
    7272    char                     * tag;
    7373
     74    char                     * configDir;
     75    char                     * torrentDir;
     76    char                     * resumeDir;
     77
    7478    struct tr_ratecontrol    * upload;
    7579    struct tr_ratecontrol    * download;
  • trunk/libtransmission/metainfo.c

    r5506 r5517  
    126126
    127127static void
    128 savedname( char * name, size_t len, const char * hash, const char * tag )
    129 {
    130     const char * torDir = tr_getTorrentsDirectory ();
    131 
    132     if( tag == NULL )
     128savedname( const tr_handle * handle,
     129           char            * name,
     130           size_t            len,
     131           const char      * hash )
     132{
     133    const char * torDir = tr_getTorrentDir( handle );
     134
     135    if( !handle->tag )
    133136    {
    134137        tr_buildPath( name, len, torDir, hash, NULL );
     
    137140    {
    138141        char base[1024];
    139         snprintf( base, sizeof(base), "%s-%s", hash, tag );
     142        snprintf( base, sizeof(base), "%s-%s", hash, handle->tag );
    140143        tr_buildPath( name, len, torDir, base, NULL );
    141144    }
     
    144147
    145148int
    146 tr_metainfoParse( tr_info * inf, const tr_benc * meta_in, const char * tag )
     149tr_metainfoParse( const tr_handle  * handle,
     150                  tr_info          * inf,
     151                  const tr_benc    * meta_in )
    147152{
    148153    tr_piece_index_t i;
     
    168173
    169174    tr_sha1_to_hex( inf->hashString, inf->hash );
    170     savedname( buf, sizeof( buf ), inf->hashString, tag );
     175    savedname( handle, buf, sizeof( buf ), inf->hashString );
    171176    tr_free( inf->torrent );
    172177    inf->torrent = tr_strdup( buf );
     
    564569
    565570void
    566 tr_metainfoRemoveSaved( const char * hashString, const char * tag )
     571tr_metainfoRemoveSaved( const tr_handle * handle,
     572                        const char      * hashString )
    567573{
    568574    char file[MAX_PATH_LENGTH];
    569     savedname( file, sizeof file, hashString, tag );
     575    savedname( handle, file, sizeof file, hashString );
    570576    unlink( file );
    571577}
     
    573579/* Save a copy of the torrent file in the saved torrent directory */
    574580int
    575 tr_metainfoSave( const char * hash, const char * tag,
    576                  const uint8_t * buf, size_t buflen )
     581tr_metainfoSave( const tr_handle  * handle,
     582                 const char       * hash,
     583                 const uint8_t    * buf,
     584                 size_t             buflen )
    577585{
    578586    char   path[MAX_PATH_LENGTH];
    579587    FILE * file;
    580588
    581     savedname( path, sizeof path, hash, tag );
     589    savedname( handle, path, sizeof path, hash );
    582590    file = fopen( path, "wb+" );
    583591    if( !file )
  • trunk/libtransmission/metainfo.h

    r5127 r5517  
    3030struct tr_benc;
    3131
    32 int tr_metainfoParse( tr_info *, const struct tr_benc *, const char * tag );
     32int tr_metainfoParse( const tr_handle       * handle,
     33                      tr_info               * info,
     34                      const struct tr_benc  * benc );
     35
    3336void tr_metainfoFree( tr_info * inf );
    34 void tr_metainfoRemoveSaved( const char * hashString, const char * tag );
    3537
    36 int tr_metainfoSave( const char *hashString, const char * tag, const uint8_t * metainfo, size_t len );
     38void tr_metainfoRemoveSaved( const tr_handle  * handle,
     39                             const char       * hashString );
     40
     41int tr_metainfoSave( const tr_handle  * handle,
     42                     const char       * hashString,
     43                     const uint8_t    * metainfo,
     44                     size_t             len );
    3745
    3846#endif
  • trunk/libtransmission/platform.c

    r5171 r5517  
    285285
    286286static const char *
    287 tr_getHomeDirectory( void )
    288 {
    289     static char buf[MAX_PATH_LENGTH];
    290     static int init = 0;
    291     const char * envHome;
    292 
    293     if( init )
    294         return buf;
    295 
    296     envHome = getenv( "HOME" );
    297     if( envHome )
    298         snprintf( buf, sizeof(buf), "%s", envHome );
    299     else {
     287getHomeDir( void )
     288{
     289    static char * home = NULL;
     290
     291    if( !home )
     292    {
     293        home = tr_strdup( getenv( "HOME" ) );
     294
     295        if( !home )
     296        {
    300297#ifdef WIN32
    301         SHGetFolderPath( NULL, CSIDL_PROFILE, NULL, 0, buf );
     298            SHGetFolderPath( NULL, CSIDL_PROFILE, NULL, 0, buf );
    302299#elif defined(__BEOS__) || defined(__AMIGAOS4__)
    303         *buf = '\0';
    304 #else
    305         struct passwd * pw = getpwuid( getuid() );
    306         endpwent();
    307         if( pw != NULL )
    308             snprintf( buf, sizeof(buf), "%s", pw->pw_dir );
    309 #endif
    310     }
    311 
    312     init = 1;
    313     return buf;
    314 }
    315 
    316 
    317 static void
    318 tr_migrateResume( const char *oldDirectory, const char *newDirectory )
    319 {
    320     DIR * dirh = opendir( oldDirectory );
    321 
    322     if( dirh != NULL )
    323     {
    324         struct dirent * dirp;
    325 
    326         while( ( dirp = readdir( dirh ) ) )
    327         {
    328             if( !strncmp( "resume.", dirp->d_name, 7 ) )
    329             {
    330                 char o[MAX_PATH_LENGTH];
    331                 char n[MAX_PATH_LENGTH];
    332                 tr_buildPath( o, sizeof(o), oldDirectory, dirp->d_name, NULL );
    333                 tr_buildPath( n, sizeof(n), newDirectory, dirp->d_name, NULL );
    334                 rename( o, n );
    335             }
     300            home = tr_strdup( "" );
     301#else
     302            struct passwd * pw = getpwuid( getuid() );
     303            endpwent( );
     304            if( pw )
     305                home = tr_strdup( pw->pw_dir );
     306#endif
    336307        }
    337308
    338         closedir( dirh );
    339     }
    340 }
    341 
    342 const char *
    343 tr_getPrefsDirectory( void )
    344 {
    345     static char   buf[MAX_PATH_LENGTH];
    346     static int    init = 0;
    347     const char * trhome;
    348 
    349     if( init )
    350         return buf;
    351 
    352     trhome = getenv( "TRANSMISSION_HOME" );
    353     if( trhome != NULL )
    354     {
    355         strlcpy( buf, trhome, sizeof( buf ) );
    356     }
    357     else
    358     {
     309        if( !home )
     310            home = tr_strdup( "" );
     311    }
     312
     313    return home;
     314}
     315
     316static const char *
     317getOldConfigDir( void )
     318{
     319    static char * path = NULL;
     320
     321    if( !path )
     322    {
     323        char buf[MAX_PATH_LENGTH];
    359324#ifdef __BEOS__
    360325        find_directory( B_USER_SETTINGS_DIRECTORY,
     
    363328        strcat( buf, "/Transmission" );
    364329#elif defined( SYS_DARWIN )
    365         tr_buildPath ( buf, sizeof( buf ),
    366                        tr_getHomeDirectory( ),
    367                        "Library",
    368                        "Application Support",
    369                        "Transmission",
    370                        NULL );
     330        tr_buildPath ( buf, sizeof( buf ), getHomeDir( ),
     331                       "Library", "Application Support",
     332                       "Transmission", NULL );
    371333#elif defined(__AMIGAOS4__)
    372334        strlcpy( buf, "PROGDIR:.transmission", sizeof( buf ) );
     
    375337        SHGetFolderPath( NULL, CSIDL_APPDATA, NULL, 0, appdata );
    376338        tr_buildPath( buf, sizeof(buf),
    377                       appdata,
    378                       "Transmission",
    379                       NULL );
    380 #else
    381         tr_buildPath ( buf, sizeof(buf), tr_getHomeDirectory( ), ".transmission", NULL );
    382 #endif
    383     }
    384 
     339                      appdata, "Transmission", NULL );
     340#else
     341        tr_buildPath ( buf, sizeof(buf),
     342                       getHomeDir( ), ".transmission", NULL );
     343#endif
     344        path = tr_strdup( buf );
     345    }
     346
     347    return path;
     348}
     349
     350static const char *
     351getOldTorrentsDir( void )
     352{
     353    static char * path = NULL;
     354
     355    if( !path )
     356    {
     357        char buf[MAX_PATH_LENGTH];
     358        const char * p = getOldConfigDir();
     359#if defined(__BEOS__) || defined(WIN32) || defined(SYS_DARWIN)
     360        tr_buildPath( buf, sizeof( buf ), p, "Torrents", NULL );
     361#else
     362        tr_buildPath( buf, sizeof( buf ), p, "torrents", NULL );
     363#endif
     364
     365        path = tr_strdup( buf );
     366    }
     367
     368    return path;
     369}
     370static const char *
     371getOldCacheDir( void )
     372{
     373    static char * path = NULL;
     374
     375    if( !path )
     376    {
     377        char buf[MAX_PATH_LENGTH];
     378        const char * p = getOldConfigDir( );
     379#if defined(__BEOS__) || defined(WIN32)
     380        tr_buildPath( buf, sizeof( buf ), p, "Cache", NULL );
     381#elif defined( SYS_DARWIN )
     382        tr_buildPath( buf, sizeof( buf ), getHomeDir(),
     383                      "Library", "Caches", "Transmission", NULL );
     384#else
     385        tr_buildPath( buf, sizeof( buf ), p, "cache", NULL );
     386#endif
     387        path = tr_strdup( buf );
     388    }
     389
     390    return path;
     391}
     392
     393static void
     394moveFiles( const char * oldDir, const char * newDir )
     395{
     396    if( oldDir && newDir && strcmp( oldDir, newDir ) )
     397    {
     398        DIR * dirh = opendir( oldDir );
     399        if( dirh )
     400        {
     401            int count = 0;
     402            struct dirent * dirp;
     403            while(( dirp = readdir( dirh )))
     404            {
     405                if( strcmp( dirp->d_name, "." ) && strcmp( dirp->d_name, ".." ) )
     406                {
     407                    char o[MAX_PATH_LENGTH];
     408                    char n[MAX_PATH_LENGTH];
     409                    tr_buildPath( o, sizeof(o), oldDir, dirp->d_name, NULL );
     410                    tr_buildPath( n, sizeof(n), newDir, dirp->d_name, NULL );
     411                    rename( o, n );
     412                    ++count;
     413                }
     414            }
     415            tr_inf( _( "Migrated %1$d files from \"%2$s\" to \"%3$s\"" ),
     416                    count, oldDir, newDir );
     417            closedir( dirh );
     418        }
     419    }
     420}
     421
     422static void
     423migrateFiles( const tr_handle * handle )
     424{
     425    static int migrated = FALSE;
     426
     427    if( !migrated )
     428    {
     429        const char * oldDir;
     430        const char * newDir;
     431        migrated = TRUE;
     432
     433        oldDir = getOldTorrentsDir( );
     434        newDir = tr_getTorrentDir( handle );
     435        moveFiles( oldDir, newDir );
     436
     437        oldDir = getOldCacheDir( );
     438        newDir = tr_getResumeDir( handle );
     439        moveFiles( oldDir, newDir );
     440    }
     441}
     442
     443#ifdef SYS_DARWIN
     444#define RESUME_SUBDIR  "Resume"
     445#define TORRENT_SUBDIR "Torrents"
     446#else
     447#define RESUME_SUBDIR  "resume"
     448#define TORRENT_SUBDIR "torrents"
     449#endif
     450
     451void
     452tr_setConfigDir( tr_handle * handle, const char * configDir )
     453{
     454    char buf[MAX_PATH_LENGTH];
     455
     456    handle->configDir = tr_strdup( configDir );
     457
     458    tr_buildPath( buf, sizeof( buf ), configDir, RESUME_SUBDIR, NULL );
    385459    tr_mkdirp( buf, 0777 );
    386     init = 1;
    387 
    388 #ifdef SYS_DARWIN
    389     char old[MAX_PATH_LENGTH];
    390     tr_buildPath ( old, sizeof(old),
    391                    tr_getHomeDirectory(), ".transmission", NULL );
    392     tr_migrateResume( old, buf );
    393     rmdir( old );
    394 #endif
    395 
    396     return buf;
     460    handle->resumeDir = tr_strdup( buf );
     461
     462    tr_buildPath( buf, sizeof( buf ), configDir, TORRENT_SUBDIR, NULL );
     463    tr_mkdirp( buf, 0777 );
     464    handle->torrentDir = tr_strdup( buf );
     465
     466    migrateFiles( handle );
    397467}
    398468
    399469const char *
    400 tr_getCacheDirectory( void )
    401 {
    402     static char buf[MAX_PATH_LENGTH];
    403     static int  init = 0;
    404     static const size_t buflen = sizeof(buf);
    405     const char * p;
    406 
    407     if( init )
    408         return buf;
    409 
    410     p = tr_getPrefsDirectory();
    411 #if defined(__BEOS__) || defined(WIN32)
    412     tr_buildPath( buf, buflen, p, "Cache", NULL );
    413 #elif defined( SYS_DARWIN )
    414     tr_buildPath( buf, buflen, tr_getHomeDirectory(),
    415                   "Library", "Caches", "Transmission", NULL );
    416 #else
    417     tr_buildPath( buf, buflen, p, "cache", NULL );
    418 #endif
    419 
    420     tr_mkdirp( buf, 0777 );
    421     init = 1;
    422 
    423     if( strcmp( p, buf ) )
    424         tr_migrateResume( p, buf );
    425 
    426     return buf;
    427 }
     470tr_getConfigDir( const tr_handle * handle )
     471{
     472    return handle->configDir;
     473}
     474
    428475
    429476const char *
    430 tr_getTorrentsDirectory( void )
    431 {
    432     static char buf[MAX_PATH_LENGTH];
    433     static int  init = 0;
    434     static const size_t buflen = sizeof(buf);
    435     const char * p;
    436 
    437     if( init )
    438         return buf;
    439 
    440     p = tr_getPrefsDirectory ();
    441 
    442 #if defined(__BEOS__) || defined(WIN32)
    443     tr_buildPath( buf, buflen, p, "Torrents", NULL );
    444 #elif defined( SYS_DARWIN )
    445     tr_buildPath( buf, buflen, p, "Torrents", NULL );
    446 #else
    447     tr_buildPath( buf, buflen, p, "torrents", NULL );
    448 #endif
    449 
    450     tr_mkdirp( buf, 0777 );
    451     init = 1;
    452     return buf;
     477tr_getTorrentDir( const tr_handle * handle )
     478{
     479    return handle->torrentDir;
     480}
     481
     482const char *
     483tr_getResumeDir( const tr_handle * handle )
     484{
     485    return handle->resumeDir;
     486}
     487
     488const char*
     489tr_getDefaultConfigDir( void )
     490{
     491    static char * s = NULL;
     492
     493    if( !s )
     494    {
     495        char path[MAX_PATH_LENGTH];
     496
     497        if(( s = getenv( "TRANSMISSION_HOME" )))
     498        {
     499            snprintf( path, sizeof( path ), s );
     500        }
     501        else
     502        {
     503#ifdef DARWIN
     504            tr_buildPath( path, sizeof( path ),
     505                          getHomeDir( ), "Library", "Application Support",
     506                          "Transmission", NULL );
     507#elif defined(WIN32)
     508            char appdata[MAX_PATH_LENGTH];
     509            SHGetFolderPath( NULL, CSIDL_APPDATA, NULL, 0, appdata );
     510            tr_buildPath( path, sizeof( path ),
     511                          appdata, "Transmission", NULL );
     512#else
     513            if(( s = getenv( "XDG_CONFIG_HOME" )))
     514                tr_buildPath( path, sizeof( path ),
     515                              s, "transmission", NULL );
     516            else
     517                tr_buildPath( path, sizeof( path ),
     518                              getHomeDir(), ".config", "transmission", NULL );
     519#endif
     520        }
     521
     522        s = tr_strdup( path );
     523    }
     524
     525    return s;
    453526}
    454527
  • trunk/libtransmission/platform.h

    r5167 r5517  
    3636typedef struct tr_thread tr_thread;
    3737
    38 const char * tr_getCacheDirectory( void );
    39 const char * tr_getTorrentsDirectory( void );
     38struct tr_handle;
     39
     40void tr_setConfigDir  ( struct tr_handle * handle,
     41                        const char       * configDir );
     42
     43const char * tr_getResumeDir  ( const struct tr_handle * );
     44
     45const char * tr_getTorrentDir ( const struct tr_handle * );
    4046
    4147tr_thread*   tr_threadNew  ( void (*func)(void *), void * arg, const char * name );
  • trunk/libtransmission/stats.c

    r5498 r5517  
    1515#include "transmission.h"
    1616#include "bencode.h"
    17 #include "platform.h" /* tr_getPrefsDirectory */
     17#include "platform.h" /* tr_getConfigDir() */
    1818#include "utils.h" /* tr_buildPath */
    1919
     
    6060
    6161static char*
    62 getFilename( char * buf, size_t buflen )
    63 {
    64     tr_buildPath( buf, buflen, tr_getPrefsDirectory(), "stats.benc", NULL );
     62getFilename( const tr_handle * handle, char * buf, size_t buflen )
     63{
     64    tr_buildPath( buf, buflen, tr_getConfigDir(handle), "stats.benc", NULL );
    6565    return buf;
    6666}
    6767
    6868static void
    69 loadCumulativeStats( tr_session_stats * setme )
     69loadCumulativeStats( const tr_handle * handle, tr_session_stats * setme )
    7070{
    7171    size_t len;
     
    7373    char filename[MAX_PATH_LENGTH];
    7474
    75     getFilename( filename, sizeof(filename) );
     75    getFilename( handle, filename, sizeof(filename) );
    7676    content = tr_loadFile( filename, &len );
    7777    if( content != NULL )
     
    8282
    8383static void
    84 saveCumulativeStats( const tr_session_stats * stats )
     84saveCumulativeStats( const tr_handle * handle, const tr_session_stats * stats )
    8585{
    8686    FILE * fp;
     
    9898
    9999    str = tr_bencSave( &top, &len );
    100     getFilename( filename, sizeof(filename) );
     100    getFilename( handle, filename, sizeof(filename) );
    101101    fp = fopen( filename, "wb+" );
    102102    fwrite( str, 1, len, fp );
     
    115115{
    116116    struct tr_stats_handle * stats = tr_new0( struct tr_stats_handle, 1 );
    117     loadCumulativeStats( &stats->old );
     117    loadCumulativeStats( handle, &stats->old );
    118118    stats->single.sessionCount = 1;
    119119    stats->startTime = time( NULL );
     
    126126    tr_session_stats cumulative;
    127127    tr_getCumulativeSessionStats( handle, &cumulative );
    128     saveCumulativeStats( &cumulative );
     128    saveCumulativeStats( handle, &cumulative );
    129129
    130130    tr_free( handle->sessionStats );
  • trunk/libtransmission/torrent-ctor.c

    r5127 r5517  
    132132    if( err && ( ctor->handle->tag != NULL ) ) {
    133133        snprintf( basename, sizeof(basename), "%s-%s", hashString, ctor->handle->tag );
    134         tr_buildPath( filename, sizeof(filename), tr_getTorrentsDirectory(), basename, NULL );
     134        tr_buildPath( filename, sizeof(filename), tr_getTorrentDir( ctor->handle ), basename, NULL );
    135135        err = tr_ctorSetMetainfoFromFile( ctor, filename );
    136136    }
    137137
    138138    if( err ) {
    139         tr_buildPath( filename, sizeof(filename), tr_getTorrentsDirectory(), hashString, NULL );
     139        tr_buildPath( filename, sizeof(filename), tr_getTorrentDir( ctor->handle ), hashString, NULL );
    140140        err = tr_ctorSetMetainfoFromFile( ctor, filename );
    141141    }
  • trunk/libtransmission/torrent.c

    r5475 r5517  
    384384            int len;
    385385            uint8_t * text = (uint8_t*) tr_bencSave( val, &len );
    386             tr_metainfoSave( tor->info.hashString,
    387                              tor->handle->tag,
     386            tr_metainfoSave( tor->handle,
     387                             tor->info.hashString,
    388388                             text, len );
    389389            tr_free( text );
     
    425425        return TR_EINVALID;
    426426
    427     err = tr_metainfoParse( setmeInfo, metainfo, handle->tag );
     427    err = tr_metainfoParse( handle, setmeInfo, metainfo );
    428428    doFree = !err && ( setmeInfo == &tmp );
    429429
     
    827827tr_torrentRemoveSaved( tr_torrent * tor )
    828828{
    829     tr_metainfoRemoveSaved( tor->info.hashString, tor->handle->tag );
     829    tr_metainfoRemoveSaved( tor->handle, tor->info.hashString );
    830830
    831831    tr_fastResumeRemove( tor );
  • trunk/libtransmission/transmission.c

    r5516 r5517  
    115115
    116116tr_handle *
    117 tr_initFull( const char * tag,
     117tr_initFull( const char * configDir,
     118             const char * tag,
    118119             int          isPexEnabled,
    119120             int          isNatEnabled,
     
    138139#endif
    139140
     141    if( configDir == NULL )
     142        configDir = tr_getDefaultConfigDir( );
     143
    140144    tr_msgInit( );
    141145    tr_setMessageLevel( messageLevel );
     
    146150    h->isPexEnabled = isPexEnabled ? 1 : 0;
    147151    h->encryptionMode = encryptionMode;
     152    h->configDir = tr_strdup( configDir );
     153
     154    tr_setConfigDir( h, configDir );
    148155
    149156    tr_netInit(); /* must go before tr_eventInit */
     
    182189
    183190    /* initialize the blocklist */
    184     tr_buildPath( filename, sizeof( filename ), tr_getPrefsDirectory(), "blocklists", NULL );
     191    tr_buildPath( filename, sizeof( filename ), h->configDir, "blocklists", NULL );
    185192    tr_mkdirp( filename, 0777 );
    186     tr_buildPath( filename, sizeof( filename ), tr_getPrefsDirectory(), "blocklists", "level1.bin", NULL );
     193    tr_buildPath( filename, sizeof( filename ), h->configDir, "blocklists", "level1.bin", NULL );
    187194    h->blocklist = _tr_blocklistNew( filename, isBlocklistEnabled );
    188195
     
    192199}
    193200
    194 tr_handle * tr_init( const char * tag )
    195 {
    196     return tr_initFull( tag,
     201tr_handle *
     202tr_init( const char * configDir,
     203         const char * tag )
     204{
     205    return tr_initFull( configDir,
     206                        tag,
    197207                        TRUE, /* pex enabled */
    198208                        FALSE, /* nat enabled */
     
    434444    struct stat sb;
    435445    DIR * odir = NULL;
    436     const char * dirname = tr_getTorrentsDirectory( );
     446    const char * dirname = tr_getTorrentDir( h );
    437447    tr_torrent ** torrents;
    438448    tr_list *l=NULL, *list=NULL;
  • trunk/libtransmission/transmission.h

    r5516 r5517  
    7777typedef struct tr_handle tr_handle;
    7878
    79 tr_handle * tr_initFull( const char * tag,
     79const char* tr_getDefaultConfigDir( void );
     80
     81tr_handle * tr_initFull( const char * configDir,
     82                         const char * tag,
    8083                         int          isPexEnabled,
    8184                         int          isNatEnabled,
     
    9497 * Like tr_initFull() but with default values supplied.
    9598 */
    96 tr_handle * tr_init( const char * tag );
     99tr_handle * tr_init( const char * configDir,
     100                     const char * tag );
    97101
    98102/**
     
    148152 * preferences. The string belongs to libtransmission, do not free it.
    149153 **********************************************************************/
    150 const char * tr_getPrefsDirectory( void );
     154const char * tr_getConfigDir( const tr_handle * );
    151155
    152156
     
    502506
    503507/**
    504  *  Load all the torrents in tr_getTorrentsDirectory().
     508 *  Load all the torrents in tr_getTorrentDir().
    505509 *  This can be used at startup to kickstart all the torrents
    506510 *  from the previous session.
     
    650654 ***********************************************************************
    651655 * delete's Transmission's copy of the torrent's metadata from
    652  * tr_getTorrentsDirectory().
     656 * tr_getTorrentDir().
    653657 **********************************************************************/
    654658void tr_torrentRemoveSaved( tr_torrent * );
Note: See TracChangeset for help on using the changeset viewer.