mirror
/
transmission
mirror of https://github.com/transmission/transmission
1
0
Fork 0
Code Issues Releases Wiki Activity

unify the daemon and gtk client's config files so that you can easily swap back and forth between clients and keep the same torrents and preferences.

This commit is contained in:
Charles Kerr 2008-06-12 16:25:36 +00:00
parent e64c608f2d
commit effb78d674
13 changed files with 347 additions and 258 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

215
daemon/daemon.c
View File

@ -36,50 +36,98 @@ static char myConfigFilename[MAX_PATH_LENGTH];
#define KEY_BLOCKLIST "blocklist-enabled"
#define KEY_DOWNLOAD_DIR "download-dir"
#define KEY_ENCRYPTION "encryption"
#define KEY_PEER_LIMIT "peer-limit"
#define KEY_PEER_LIMIT "max-peers-global"
#define KEY_PEER_PORT "peer-port"
#define KEY_PORT_FORWARDING "port-forwarding-enabled"
#define KEY_PEX_ENABLED "pex-enabled"
#define KEY_AUTH_REQUIRED "rpc-auth-required"
#define KEY_AUTH_REQUIRED "rpc-authentication-required"
#define KEY_USERNAME "rpc-username"
#define KEY_PASSWORD "rpc-password"
#define KEY_ACL "rpc-acl"
#define KEY_ACL "rpc-access-control-list"
#define KEY_RPC_PORT "rpc-port"
#define KEY_DSPEED "speed-limit-down"
#define KEY_DSPEED_ENABLED "speed-limit-down-enabled"
#define KEY_USPEED "speed-limit-up"
#define KEY_USPEED_ENABLED "speed-limit-up-enabled"
#define KEY_DSPEED "download-limit"
#define KEY_DSPEED_ENABLED "download-limit-enabled"
#define KEY_USPEED "upload-limit"
#define KEY_USPEED_ENABLED "upload-limit-enabled"
#define CONFIG_FILE "session.json"
#define CONFIG_FILE "settings.json"
const char * encryption_str[3] = { "tolerated", "preferred", "required" };
/***
**** Config File
***/
static void
replaceInt( tr_benc * dict, const char * key, int64_t value )
{
tr_bencDictRemove( dict, key );
tr_bencDictAddInt( dict, key, value );
}
static void
replaceStr( tr_benc * dict, const char * key, const char* value )
{
tr_bencDictRemove( dict, key );
tr_bencDictAddStr( dict, key, value );
}
static void
saveState( tr_session * s )
{
tr_benc d;
tr_bencInitDict( &d, 16 );
tr_bencDictAddInt( &d, KEY_BLOCKLIST, tr_blocklistIsEnabled( s ) );
tr_bencDictAddStr( &d, KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
tr_bencDictAddInt( &d, KEY_PEER_LIMIT, tr_sessionGetPeerLimit( s ) );
tr_bencDictAddInt( &d, KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
tr_bencDictAddInt( &d, KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
tr_bencDictAddInt( &d, KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
tr_bencDictAddStr( &d, KEY_USERNAME, tr_sessionGetRPCUsername( s ) );
tr_bencDictAddStr( &d, KEY_PASSWORD, tr_sessionGetRPCPassword( s ) );
tr_bencDictAddStr( &d, KEY_ACL, tr_sessionGetRPCACL( s ) );
tr_bencDictAddInt( &d, KEY_RPC_PORT, tr_sessionGetRPCPort( s ) );
tr_bencDictAddInt( &d, KEY_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled( s ) );
tr_bencDictAddInt( &d, KEY_DSPEED, tr_sessionGetSpeedLimit( s, TR_DOWN ) );
tr_bencDictAddInt( &d, KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
tr_bencDictAddInt( &d, KEY_USPEED, tr_sessionGetSpeedLimit( s, TR_UP ) );
tr_bencDictAddInt( &d, KEY_USPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
tr_bencDictAddStr( &d, KEY_ENCRYPTION, encryption_str[tr_sessionGetEncryption( s )] );
if( tr_bencLoadJSONFile( myConfigFilename, &d ) )
tr_bencInitDict( &d, 16 );
replaceInt( &d, KEY_BLOCKLIST, tr_blocklistIsEnabled( s ) );
replaceStr( &d, KEY_DOWNLOAD_DIR, tr_sessionGetDownloadDir( s ) );
replaceInt( &d, KEY_PEER_LIMIT, tr_sessionGetPeerLimit( s ) );
replaceInt( &d, KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
replaceInt( &d, KEY_PORT_FORWARDING, tr_sessionIsPortForwardingEnabled( s ) );
replaceInt( &d, KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
replaceStr( &d, KEY_USERNAME, tr_sessionGetRPCUsername( s ) );
replaceStr( &d, KEY_PASSWORD, tr_sessionGetRPCPassword( s ) );
replaceStr( &d, KEY_ACL, tr_sessionGetRPCACL( s ) );
replaceInt( &d, KEY_RPC_PORT, tr_sessionGetRPCPort( s ) );
replaceInt( &d, KEY_AUTH_REQUIRED, tr_sessionIsRPCPasswordEnabled( s ) );
replaceInt( &d, KEY_DSPEED, tr_sessionGetSpeedLimit( s, TR_DOWN ) );
replaceInt( &d, KEY_DSPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_DOWN ) );
replaceInt( &d, KEY_USPEED, tr_sessionGetSpeedLimit( s, TR_UP ) );
fprintf( stderr, "session says its speed upload speed limit is %d\n", tr_sessionGetSpeedLimit( s, TR_UP ) );
replaceInt( &d, KEY_USPEED_ENABLED, tr_sessionIsSpeedLimitEnabled( s, TR_UP ) );
replaceInt( &d, KEY_ENCRYPTION, tr_sessionGetEncryption( s ) );
tr_bencSaveJSONFile( myConfigFilename, &d );
tr_bencFree( &d );
tr_ninf( MY_NAME, "saved \"%s\"", myConfigFilename );
}
static void
getConfigInt( tr_benc * dict,
const char * key,
int * setme,
int defaultVal )
{
if( *setme < 0 ) {
int64_t i;
if( tr_bencDictFindInt( dict, key, &i ) )
*setme = i;
else
*setme = defaultVal;
}
}
static void
getConfigStr( tr_benc * dict,
const char * key,
const char ** setme,
const char * defaultVal )
{
if( !*setme ) {
const char * s;
if( tr_bencDictFindStr( dict, key, &s ) )
*setme = s;
else
*setme = defaultVal;
}
}
/**
* @param port port number, or -1 if not set in the command line
* @param auth TRUE, FALSE, or -1 if not set on the command line
@ -92,41 +140,17 @@ session_init( const char * configDir, const char * downloadDir,
int blocklistEnabled )
{
char mycwd[MAX_PATH_LENGTH];
tr_benc state;
int have_state;
int64_t i;
int64_t peer_port = TR_DEFAULT_PORT;
int64_t peers = TR_DEFAULT_GLOBAL_PEER_LIMIT;
int64_t pex_enabled = TR_DEFAULT_PEX_ENABLED;
int64_t fwd_enabled = TR_DEFAULT_PORT_FORWARDING_ENABLED;
int64_t up_limit = 100;
int64_t up_limited = FALSE;
int64_t down_limit = 100;
int64_t down_limited = FALSE;
int encryption = TR_ENCRYPTION_PREFERRED;
tr_benc state, *dict = NULL;
int peerPort=-1, peers=-1;
int pexEnabled = -1;
int fwdEnabled = -1;
int upLimit=-1, upLimited=-1, downLimit=-1, downLimited=-1;
int encryption = -1;
tr_ctor * ctor;
tr_torrent ** torrents;
if(( have_state = !tr_bencLoadJSONFile( myConfigFilename, &state )))
{
const char * str;
tr_ninf( MY_NAME, "loading settings from \"%s\"", myConfigFilename );
tr_bencDictFindInt( &state, KEY_PEER_LIMIT, &peers );
tr_bencDictFindInt( &state, KEY_PEX_ENABLED, &pex_enabled );
tr_bencDictFindInt( &state, KEY_PEER_PORT, &peer_port );
tr_bencDictFindInt( &state, KEY_PORT_FORWARDING, &fwd_enabled );
tr_bencDictFindInt( &state, KEY_DSPEED, &down_limit );
tr_bencDictFindInt( &state, KEY_DSPEED_ENABLED, &down_limited );
tr_bencDictFindInt( &state, KEY_USPEED, &up_limit );
tr_bencDictFindInt( &state, KEY_USPEED_ENABLED, &up_limited );
if( tr_bencDictFindStr( &state, KEY_ENCRYPTION, &str ) ) {
if( !strcmp( str, "required" ) )
encryption = TR_ENCRYPTION_REQUIRED;
else if( !strcmp( str, "tolerated" ) )
encryption = TR_PLAINTEXT_PREFERRED;
}
}
if( !tr_bencLoadJSONFile( myConfigFilename, &state ) )
dict = &state;
/***
**** Decide on which values to pass into tr_sessionInitFull().
@ -135,56 +159,23 @@ session_init( const char * configDir, const char * downloadDir,
**** If neither of those can be found, the TR_DEFAULT fields are used .
***/
/* authorization */
if( authRequired < 0 ) {
if( have_state && tr_bencDictFindInt( &state, KEY_AUTH_REQUIRED, &i ) )
authRequired = i;
if( authRequired < 0 )
authRequired = FALSE;
}
/* username */
if( !username )
tr_bencDictFindStr( &state, KEY_USERNAME, &username );
/* password */
if( !password )
tr_bencDictFindStr( &state, KEY_PASSWORD, &password );
/* acl */
if( !acl ) {
if( have_state )
tr_bencDictFindStr( &state, KEY_ACL, &acl );
if( !acl )
acl = TR_DEFAULT_RPC_ACL;
}
/* rpc port */
if( rpcPort < 0 ) {
if( have_state && tr_bencDictFindInt( &state, KEY_RPC_PORT, &i ) )
rpcPort = i;
if( rpcPort < 0 )
rpcPort = TR_DEFAULT_RPC_PORT;
}
/* blocklist */
if( blocklistEnabled < 0 ) {
if( have_state && tr_bencDictFindInt( &state, KEY_BLOCKLIST, &i ) )
blocklistEnabled = i;
if( blocklistEnabled < 0 )
blocklistEnabled = TR_DEFAULT_BLOCKLIST_ENABLED;
}
/* download dir */
if( !downloadDir ) {
if( have_state )
tr_bencDictFindStr( &state, KEY_DOWNLOAD_DIR, &downloadDir );
if( !downloadDir ) {
getcwd( mycwd, sizeof( mycwd ) );
downloadDir = mycwd;
}
}
getcwd( mycwd, sizeof( mycwd ) );
getConfigStr( dict, KEY_DOWNLOAD_DIR, &downloadDir, mycwd );
getConfigInt( dict, KEY_PEX_ENABLED, &pexEnabled, TR_DEFAULT_PEX_ENABLED );
getConfigInt( dict, KEY_PORT_FORWARDING, &fwdEnabled, TR_DEFAULT_PORT_FORWARDING_ENABLED );
getConfigInt( dict, KEY_PEER_PORT, &peerPort, TR_DEFAULT_PORT );
getConfigInt( dict, KEY_DSPEED, &downLimit, 100 );
getConfigInt( dict, KEY_DSPEED_ENABLED, &downLimited, FALSE );
getConfigInt( dict, KEY_USPEED, &upLimit, 100 );
getConfigInt( dict, KEY_USPEED_ENABLED, &upLimited, FALSE );
getConfigInt( dict, KEY_PEER_LIMIT, &peers, TR_DEFAULT_GLOBAL_PEER_LIMIT );
getConfigInt( dict, KEY_BLOCKLIST, &blocklistEnabled, TR_DEFAULT_BLOCKLIST_ENABLED );
getConfigInt( dict, KEY_RPC_PORT, &rpcPort, TR_DEFAULT_RPC_PORT );
getConfigStr( dict, KEY_ACL, &acl, TR_DEFAULT_RPC_ACL );
getConfigInt( dict, KEY_AUTH_REQUIRED, &authRequired, FALSE );
getConfigStr( dict, KEY_USERNAME, &username, NULL );
getConfigStr( dict, KEY_PASSWORD, &password, NULL );
getConfigInt( dict, KEY_ENCRYPTION, &encryption, TR_ENCRYPTION_PREFERRED );
/***
****
@ -192,10 +183,10 @@ session_init( const char * configDir, const char * downloadDir,
/* start the session */
mySession = tr_sessionInitFull( configDir, "daemon", downloadDir,
pex_enabled, fwd_enabled, peer_port,
pexEnabled, fwdEnabled, peerPort,
encryption,
up_limit, up_limited,
down_limit, down_limited,
upLimited, upLimit,
downLimited, downLimit,
peers,
TR_MSG_INF, 0,
blocklistEnabled,
@ -218,7 +209,7 @@ session_init( const char * configDir, const char * downloadDir,
tr_free( torrents );
tr_ctorFree( ctor );
if( have_state )
if( dict )
tr_bencFree( &state );
}

3
gtk/actions.c
View File

@ -207,7 +207,7 @@ actions_init( GtkUIManager * ui_manager, gpointer callback_user_data )
{
int i, n;
int active;
char * match;
const char * match;
const int n_entries = G_N_ELEMENTS( entries );
GtkActionGroup * action_group;
@ -254,7 +254,6 @@ actions_init( GtkUIManager * ui_manager, gpointer callback_user_data )
gtk_ui_manager_insert_action_group( ui_manager, action_group, 0 );
g_object_unref (G_OBJECT(action_group));
g_free( match );
}
/****

6
gtk/add-dialog.c
View File

@ -290,7 +290,7 @@ addDialog( GtkWindow * parent,
{
GtkWidget * w;
GtkWidget * c;
char * folder;
const char * folder;
w = gtk_file_chooser_dialog_new( _( "Add a Torrent" ), parent,
GTK_FILE_CHOOSER_ACTION_OPEN,
@ -305,10 +305,8 @@ addDialog( GtkWindow * parent,
addTorrentFilters( GTK_FILE_CHOOSER( w ) );
g_signal_connect( w, "response", G_CALLBACK(onAddDialogResponse), core );
if(( folder = pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER ))) {
if(( folder = pref_string_get( PREF_KEY_OPEN_DIALOG_FOLDER )))
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER( w ), folder );
g_free( folder );
}
c = gtk_check_button_new_with_mnemonic( _( "Display _options dialog" ) );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( c ), pref_flag_get( PREF_KEY_OPTIONS_PROMPT ) );

242
gtk/conf.c
View File

@ -51,9 +51,9 @@ cf_init(const char *dir, char **errstr)
if( errstr != NULL )
*errstr = NULL;
gl_confdir = g_build_filename( dir, "gtk", NULL );
gl_confdir = g_strdup( dir );
if( mkdir_p(gl_confdir, 0755 ) )
if( mkdir_p( gl_confdir, 0755 ) )
return TRUE;
if( errstr != NULL )
@ -122,64 +122,76 @@ cf_lock( char ** errstr )
return didLock;
}
char*
cf_sockname( void )
{
assert( gl_confdir != NULL );
return g_build_filename( gl_confdir, "socket", NULL );
}
/***
****
**** Preferences
****
***/
#define GROUP "general"
static char*
getPrefsFilename( void )
{
assert( gl_confdir != NULL );
return g_build_filename( gl_confdir, "prefs.ini", NULL );
return g_build_filename( gl_confdir, "settings.json", NULL );
}
static GKeyFile*
getPrefsKeyFile( void )
static tr_benc*
getPrefs( void )
{
static GKeyFile * myKeyFile = NULL;
static tr_benc dict;
static gboolean loaded = FALSE;
if( myKeyFile == NULL )
if( !loaded )
{
char * filename = getPrefsFilename( );
myKeyFile = g_key_file_new( );
g_key_file_load_from_file( myKeyFile, filename, 0, NULL );
if( tr_bencLoadJSONFile( filename, &dict ) )
tr_bencInitDict( &dict, 100 );
g_free( filename );
loaded = TRUE;
}
return myKeyFile;
return &dict;
}
/***
****
***/
int
pref_int_get( const char * key ) {
return g_key_file_get_integer( getPrefsKeyFile( ), GROUP, key, NULL );
pref_int_get( const char * key )
{
int64_t i;
tr_bencDictFindInt( getPrefs( ), key, &i );
return i;
}
void
pref_int_set( const char * key, int value ) {
g_key_file_set_integer( getPrefsKeyFile( ), GROUP, key, value );
pref_int_set( const char * key, int value )
{
tr_benc * d = getPrefs( );
tr_bencDictRemove( d, key );
tr_bencDictAddInt( d, key, value );
}
void
pref_int_set_default( const char * key, int value ) {
if( !g_key_file_has_key( getPrefsKeyFile( ), GROUP, key, NULL ) )
pref_int_set_default( const char * key, int value )
{
if( !tr_bencDictFind( getPrefs( ), key ) )
pref_int_set( key, value );
}
/***
****
***/
gboolean
pref_flag_get ( const char * key ) {
return g_key_file_get_boolean( getPrefsKeyFile( ), GROUP, key, NULL );
pref_flag_get ( const char * key )
{
int64_t i;
tr_bencDictFindInt( getPrefs( ), key, &i );
return i != 0;
}
gboolean
pref_flag_eval( pref_flag_t val, const char * key ) {
pref_flag_eval( pref_flag_t val, const char * key )
{
switch( val ) {
case PREF_FLAG_TRUE: return TRUE;
case PREF_FLAG_FALSE: return FALSE;
@ -187,54 +199,56 @@ pref_flag_eval( pref_flag_t val, const char * key ) {
}
}
void
pref_flag_set( const char * key, gboolean value ) {
g_key_file_set_boolean( getPrefsKeyFile( ), GROUP, key, value );
pref_flag_set( const char * key, gboolean value )
{
pref_int_set( key, value!=0 );
}
void
pref_flag_set_default( const char * key, gboolean value ) {
if( !g_key_file_has_key( getPrefsKeyFile( ), GROUP, key, NULL ) )
pref_flag_set( key, value );
pref_flag_set_default( const char * key, gboolean value )
{
pref_int_set_default( key, value!=0 );
}
char*
pref_string_get( const char * key ) {
return g_key_file_get_string( getPrefsKeyFile( ), GROUP, key, NULL );
/***
****
***/
const char*
pref_string_get( const char * key )
{
const char * str = NULL;
tr_bencDictFindStr( getPrefs( ), key, &str );
return str;
}
void
pref_string_set( const char * key, const char * value ) {
g_key_file_set_string( getPrefsKeyFile( ), GROUP, key, value );
pref_string_set( const char * key, const char * value )
{
tr_benc * d = getPrefs( );
tr_bencDictRemove( d, key );
tr_bencDictAddStr( d, key, value );
}
void
pref_string_set_default( const char * key, const char * value ) {
if( !g_key_file_has_key( getPrefsKeyFile( ), GROUP, key, NULL ) )
pref_string_set_default( const char * key, const char * value )
{
if( !tr_bencDictFind( getPrefs( ), key ) )
pref_string_set( key, value );
}
/***
****
***/
void
pref_save(char **errstr)
pref_save( void )
{
gsize datalen;
GError * err = NULL;
char * data;
char * filename;
char * path;
char * filename = getPrefsFilename( );
char * path = g_path_get_dirname( filename );
filename = getPrefsFilename( );
path = g_path_get_dirname( filename );
mkdir_p( path, 0755 );
tr_bencSaveJSONFile( filename, getPrefs( ) );
data = g_key_file_to_data( getPrefsKeyFile(), &datalen, &err );
if( !err ) {
GIOChannel * out = g_io_channel_new_file( filename, "w+", &err );
g_io_channel_write_chars( out, data, datalen, NULL, &err );
g_io_channel_unref( out );
}
if( errstr != NULL )
*errstr = err ? g_strdup( err->message ) : NULL;
g_clear_error( &err );
g_free( data );
g_free( path );
g_free( filename );
}
@ -257,19 +271,26 @@ tr_file_set_contents( const char * filename, const void * out, size_t len, GErro
#endif
static char*
getCompat08PrefsFilename( void )
getCompat080PrefsFilename( void )
{
assert( gl_confdir != NULL );
return g_build_filename( g_get_home_dir(), ".transmission", "gtk", "prefs", NULL );
}
static char*
getCompat09PrefsFilename( void )
getCompat090PrefsFilename( void )
{
assert( gl_confdir != NULL );
return g_build_filename( g_get_home_dir(), ".transmission", "gtk", "prefs.ini", NULL );
}
static char*
getCompat121PrefsFilename( void )
{
assert( gl_confdir != NULL );
return g_build_filename( gl_confdir, "prefs.ini", NULL );
}
static void
translate_08_to_09( const char* oldfile, const char* newfile )
{
@ -321,22 +342,95 @@ translate_08_to_09( const char* oldfile, const char* newfile )
g_free( contents );
}
static void
translate_keyfile_to_json( const char * old_file, const char * new_file )
{
tr_benc dict;
GKeyFile * keyfile;
gchar ** keys;
gsize i;
gsize length;
static struct pref_entry {
const char* oldkey;
const char* newkey;
} renamed[] = {
{ "default-download-directory", "download-dir" },
{ "listening-port", "peer-port" },
{ "nat-traversal-enabled", "port-forwarding-enabled" },
{ "encrypted-connections-only", "encryption" }
};
keyfile = g_key_file_new( );
g_key_file_load_from_file( keyfile, old_file, 0, NULL );
length = 0;
keys = g_key_file_get_keys( keyfile, "general", &length, NULL );
tr_bencInitDict( &dict, length );
for( i=0; i<length; ++i )
{
guint j;
const char * key = keys[i];
gchar * val = g_key_file_get_value( keyfile, "general", key, NULL );
for( j=0; j<G_N_ELEMENTS(renamed); ++j )
if( !strcmp( renamed[j].oldkey, key ) )
key = renamed[j].newkey;
if( !strcmp(val,"true") || !strcmp(val,"false") )
tr_bencDictAddInt( &dict, key, !strcmp(val,"true") );
else {
char * end;
long l;
errno = 0;
l = strtol( val, &end, 10 );
if( !errno && end && !*end )
tr_bencDictAddInt( &dict, key, l );
else
tr_bencDictAddStr( &dict, key, val );
}
g_free( val );
}
g_key_file_free( keyfile );
tr_bencSaveJSONFile( new_file, &dict );
tr_bencFree( &dict );
}
void
cf_check_older_configs( void )
{
char * cfn = getPrefsFilename( );
char * cfn08 = getCompat08PrefsFilename( );
char * cfn09 = getCompat09PrefsFilename( );
char * filename = getPrefsFilename( );
if( !g_file_test( cfn, G_FILE_TEST_IS_REGULAR )
&& g_file_test( cfn09, G_FILE_TEST_IS_REGULAR ) )
g_rename( cfn09, cfn );
if( !g_file_test( filename, G_FILE_TEST_IS_REGULAR ) )
{
char * key1 = getCompat121PrefsFilename( );
char * key2 = getCompat090PrefsFilename( );
char * benc = getCompat080PrefsFilename( );
if( !g_file_test( cfn, G_FILE_TEST_IS_REGULAR )
&& g_file_test( cfn08, G_FILE_TEST_IS_REGULAR ) )
translate_08_to_09( cfn08, cfn );
if( g_file_test( key1, G_FILE_TEST_IS_REGULAR ) )
{
translate_keyfile_to_json( key1, filename );
}
else if( g_file_test( key2, G_FILE_TEST_IS_REGULAR ) )
{
translate_keyfile_to_json( key2, filename );
}
else if( g_file_test( benc, G_FILE_TEST_IS_REGULAR ) )
{
char * tmpfile;
int fd = g_file_open_tmp( "transmission-prefs-XXXXXX", &tmpfile, NULL );
if( fd != -1 ) close( fd );
translate_08_to_09( benc, tmpfile );
translate_keyfile_to_json( tmpfile, filename );
unlink( tmpfile );
}
g_free( cfn09 );
g_free( cfn08 );
g_free( cfn );
g_free( benc );
g_free( key2 );
g_free( key1 );
}
g_free( filename );
}

22
gtk/conf.h
View File

@ -29,19 +29,19 @@
#ifndef TG_CONF_H
#define TG_CONF_H
int pref_int_get ( const char * key );
void pref_int_set ( const char * key, int value );
void pref_int_set_default ( const char * key, int value );
int pref_int_get ( const char * key );
void pref_int_set ( const char * key, int value );
void pref_int_set_default ( const char * key, int value );
gboolean pref_flag_get ( const char * key );
void pref_flag_set ( const char * key, gboolean value );
void pref_flag_set_default ( const char * key, gboolean value );
gboolean pref_flag_get ( const char * key );
void pref_flag_set ( const char * key, gboolean value );
void pref_flag_set_default ( const char * key, gboolean value );
char* pref_string_get ( const char * key );
void pref_string_set ( const char * key, const char * value );
void pref_string_set_default ( const char * key, const char * value );
const char* pref_string_get ( const char * key );
void pref_string_set ( const char * key, const char * value );
void pref_string_set_default ( const char * key, const char * value );
void pref_save ( char **errstr );
void pref_save ( void );
/**
***
@ -67,8 +67,6 @@ gboolean
cf_init(const char *confdir, char **errstr);
gboolean
cf_lock(char **errstr);
char *
cf_sockname(void);
void
cf_check_older_configs(void);

34
gtk/main.c
View File

@ -412,11 +412,9 @@ main( int argc, char ** argv )
"gtk",
pref_string_get( PREF_KEY_DOWNLOAD_DIR ),
pref_flag_get( PREF_KEY_PEX ),
pref_flag_get( PREF_KEY_NAT ),
pref_flag_get( PREF_KEY_PORT_FORWARDING ),
pref_int_get( PREF_KEY_PORT ),
pref_flag_get( PREF_KEY_ENCRYPTED_ONLY )
? TR_ENCRYPTION_REQUIRED
: TR_ENCRYPTION_PREFERRED,
pref_int_get( PREF_KEY_ENCRYPTION ),
pref_flag_get( PREF_KEY_UL_LIMIT_ENABLED ),
pref_int_get( PREF_KEY_UL_LIMIT ),
pref_flag_get( PREF_KEY_DL_LIMIT_ENABLED ),
@ -887,11 +885,11 @@ prefschanged( TrCore * core UNUSED, const char * key, gpointer data )
struct cbdata * cbdata = data;
tr_handle * tr = tr_core_handle( cbdata->core );
if( !strcmp( key, PREF_KEY_ENCRYPTED_ONLY ) )
if( !strcmp( key, PREF_KEY_ENCRYPTION ) )
{
const gboolean crypto_only = pref_flag_get( key );
tr_sessionSetEncryption( tr, crypto_only ? TR_ENCRYPTION_REQUIRED
: TR_ENCRYPTION_PREFERRED );
const int encryption = pref_int_get( key );
g_message( "setting encryption to %d", encryption );
tr_sessionSetEncryption( tr, encryption );
}
else if( !strcmp( key, PREF_KEY_PORT ) )
{
@ -928,7 +926,7 @@ prefschanged( TrCore * core UNUSED, const char * key, gpointer data )
const int limit = pref_int_get( key );
tr_sessionSetSpeedLimit( tr, TR_UP, limit );
}
else if( !strcmp( key, PREF_KEY_NAT ) )
else if( !strcmp( key, PREF_KEY_PORT_FORWARDING ) )
{
const gboolean enabled = pref_flag_get( key );
tr_sessionSetPortForwardingEnabled( tr, enabled );
@ -953,21 +951,18 @@ prefschanged( TrCore * core UNUSED, const char * key, gpointer data )
else if( !strcmp( key, PREF_KEY_RPC_ACL ) )
{
char * err = NULL;
char * s = pref_string_get( key );
const char * s = pref_string_get( key );
tr_sessionSetRPCACL( tr, s, &err );
g_free( s );
}
else if( !strcmp( key, PREF_KEY_RPC_USERNAME ) )
{
char * s = pref_string_get( key );
const char * s = pref_string_get( key );
tr_sessionSetRPCUsername( tr, s );
g_free( s );
}
else if( !strcmp( key, PREF_KEY_RPC_PASSWORD ) )
{
char * s = pref_string_get( key );
const char * s = pref_string_get( key );
tr_sessionSetRPCPassword( tr, s );
g_free( s );
}
else if( !strcmp( key, PREF_KEY_RPC_AUTH_ENABLED ) )
{
@ -976,9 +971,8 @@ prefschanged( TrCore * core UNUSED, const char * key, gpointer data )
}
else if( !strcmp( key, PREF_KEY_PROXY_SERVER ) )
{
char * s = pref_string_get( key );
const char * s = pref_string_get( key );
tr_sessionSetProxy( tr, s );
g_free( s );
}
else if( !strcmp( key, PREF_KEY_PROXY_TYPE ) )
{
@ -997,15 +991,13 @@ prefschanged( TrCore * core UNUSED, const char * key, gpointer data )
}
else if( !strcmp( key, PREF_KEY_PROXY_USERNAME ) )
{
char * s = pref_string_get( key );
const char * s = pref_string_get( key );
tr_sessionSetProxyUsername( tr, s );
g_free( s );
}
else if( !strcmp( key, PREF_KEY_PROXY_PASSWORD ) )
{
char * s = pref_string_get( key );
const char * s = pref_string_get( key );
tr_sessionSetProxyPassword( tr, s );
g_free( s );
}
}

13
gtk/tr-core.c
View File

@ -125,7 +125,7 @@ tr_core_dispose( GObject * obj )
{
GObjectClass * parent;
pref_save( NULL );
pref_save( );
core->priv = NULL;
parent = g_type_class_peek( g_type_parent( TR_CORE_TYPE ) );
@ -386,9 +386,8 @@ tr_core_apply_defaults( tr_ctor * ctor )
pref_int_get( PREF_KEY_MAX_PEERS_PER_TORRENT ) );
if( tr_ctorGetDownloadDir( ctor, TR_FORCE, NULL ) ) {
char * path = pref_string_get( PREF_KEY_DOWNLOAD_DIR );
const char * path = pref_string_get( PREF_KEY_DOWNLOAD_DIR );
tr_ctorSetDownloadDir( ctor, TR_FORCE, path );
g_free( path );
}
}
@ -493,10 +492,9 @@ prefsChanged( TrCore * core, const char * key, gpointer data UNUSED )
if( !strcmp( key, PREF_KEY_SORT_MODE ) ||
!strcmp( key, PREF_KEY_SORT_REVERSED ) )
{
char * mode = pref_string_get( PREF_KEY_SORT_MODE );
const char * mode = pref_string_get( PREF_KEY_SORT_MODE );
gboolean isReversed = pref_flag_get( PREF_KEY_SORT_REVERSED );
setSort( core, mode, isReversed );
g_free( mode );
}
else if( !strcmp( key, PREF_KEY_MAX_PEERS_GLOBAL ) )
{
@ -1027,20 +1025,19 @@ tr_core_set_hibernation_allowed( TrCore * core, gboolean allowed )
static void
commitPrefsChange( TrCore * core, const char * key )
{
pref_save( NULL );
pref_save( );
g_signal_emit( core, TR_CORE_GET_CLASS(core)->prefsig, 0, key );
}
void
tr_core_set_pref( TrCore * self, const char * key, const char * newval )
{
char * oldval = pref_string_get( key );
const char * oldval = pref_string_get( key );
if( tr_strcmp( oldval, newval ) )
{
pref_string_set( key, newval );
commitPrefsChange( self, key );
}
g_free( oldval );
}
void

31
gtk/tr-prefs.c
View File

@ -93,10 +93,10 @@ tr_prefs_init_global( void )
pref_int_set_default ( PREF_KEY_PORT, TR_DEFAULT_PORT );
pref_flag_set_default ( PREF_KEY_NAT, TRUE );
pref_flag_set_default ( PREF_KEY_PORT_FORWARDING, TRUE );
pref_flag_set_default ( PREF_KEY_PEX, TR_DEFAULT_PEX_ENABLED );
pref_flag_set_default ( PREF_KEY_ASKQUIT, TRUE );
pref_flag_set_default ( PREF_KEY_ENCRYPTED_ONLY, FALSE );
pref_flag_set_default ( PREF_KEY_ENCRYPTION, TR_ENCRYPTION_PREFERRED );
pref_int_set_default ( PREF_KEY_MSGLEVEL, TR_MSG_INF );
@ -118,7 +118,7 @@ tr_prefs_init_global( void )
pref_string_set_default( PREF_KEY_RPC_PASSWORD, pw );
pref_flag_set_default ( PREF_KEY_RPC_AUTH_ENABLED, FALSE );
pref_save( NULL );
pref_save( );
}
/**
@ -191,12 +191,11 @@ static GtkWidget*
new_entry( const char * key, gpointer core )
{
GtkWidget * w = gtk_entry_new( );
char * value = pref_string_get( key );
const char * value = pref_string_get( key );
if( value )
gtk_entry_set_text( GTK_ENTRY( w ), value );
g_object_set_data_full( G_OBJECT(w), PREF_KEY, g_strdup(key), g_free );
g_signal_connect( w, "changed", G_CALLBACK(entry_changed_cb), core );
g_free( value );
return w;
}
@ -214,11 +213,10 @@ new_path_chooser_button( const char * key, gpointer core )
{
GtkWidget * w = gtk_file_chooser_button_new( NULL,
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER );
char * path = pref_string_get( key );
const char * path = pref_string_get( key );
g_object_set_data_full( G_OBJECT(w), PREF_KEY, g_strdup(key), g_free );
g_signal_connect( w, "selection-changed", G_CALLBACK(chosen_cb), core );
gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(w), path );
g_free( path );
return w;
}
@ -496,6 +494,15 @@ onUpdateBlocklistCB( GtkButton * w, gpointer gdata )
tr_webRun( handle, url, NULL, got_blocklist, data );
}
static void
onEncryptionToggled( GtkToggleButton * w, gpointer core )
{
const int val = gtk_toggle_button_get_active( w )
? TR_ENCRYPTION_REQUIRED
: TR_ENCRYPTION_PREFERRED;
tr_core_set_pref_int( TR_CORE( core ), PREF_KEY_ENCRYPTION, val );
}
static GtkWidget*
peerPage( GObject * core, gboolean * alive )
{
@ -530,7 +537,10 @@ peerPage( GObject * core, gboolean * alive )
hig_workarea_add_wide_control( t, &row, h );
s = _("_Ignore unencrypted peers");
w = new_check_button( s, PREF_KEY_ENCRYPTED_ONLY, core );
w = gtk_check_button_new_with_mnemonic( s );
gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON(w),
pref_int_get(PREF_KEY_ENCRYPTION)==TR_ENCRYPTION_REQUIRED );
g_signal_connect( w, "toggled", G_CALLBACK(onEncryptionToggled), core );
hig_workarea_add_wide_control( t, &row, w );
s = _("Use peer e_xchange");
@ -810,7 +820,7 @@ remotePage( GObject * core )
/* access control list */
{
char * val = pref_string_get( PREF_KEY_RPC_ACL );
const char * val = pref_string_get( PREF_KEY_RPC_ACL );
GtkTreeModel * m = acl_tree_model_new( val );
GtkTreeViewColumn * c;
GtkCellRenderer * r;
@ -852,7 +862,6 @@ remotePage( GObject * core )
w = hig_workarea_add_row( t, &row, s, w, NULL );
gtk_misc_set_alignment( GTK_MISC( w ), 0.0f, 0.1f );
page->widgets = g_slist_append( page->widgets, w );
g_free( val );
/* permission column */
m = allow_deny_model_new( );
@ -971,7 +980,7 @@ networkPage( GObject * core )
hig_workarea_add_section_title (t, &row, _( "Router" ) );
s = _("Use port _forwarding from my router" );
w = new_check_button( s, PREF_KEY_NAT, core );
w = new_check_button( s, PREF_KEY_PORT_FORWARDING, core );
hig_workarea_add_wide_control( t, &row, w );
hig_workarea_add_section_divider( t, &row );

8
gtk/tr-prefs.h
View File

@ -25,7 +25,7 @@ GtkWidget * tr_prefs_dialog_new( GObject * core, GtkWindow * parent );
#define PREF_KEY_UL_LIMIT_ENABLED "upload-limit-enabled"
#define PREF_KEY_UL_LIMIT "upload-limit"
#define PREF_KEY_OPTIONS_PROMPT "show-options-window"
#define PREF_KEY_DOWNLOAD_DIR "default-download-directory"
#define PREF_KEY_DOWNLOAD_DIR "download-dir"
#define PREF_KEY_OPEN_DIALOG_FOLDER "open-dialog-folder"
#define PREF_KEY_ALLOW_HIBERNATION "allow-hibernation"
#define PREF_KEY_DIR_WATCH "watch-folder"
@ -34,11 +34,11 @@ GtkWidget * tr_prefs_dialog_new( GObject * core, GtkWindow * parent );
#define PREF_KEY_START "start-added-torrents"
#define PREF_KEY_TRASH_ORIGINAL "trash-original-torrent-files"
#define PREF_KEY_PEER_SOCKET_TOS "peer-socket-tos"
#define PREF_KEY_PORT "listening-port"
#define PREF_KEY_NAT "nat-traversal-enabled"
#define PREF_KEY_PORT "peer-port"
#define PREF_KEY_PORT_FORWARDING "port-forwarding-enabled"
#define PREF_KEY_PEX "pex-enabled"
#define PREF_KEY_ASKQUIT "prompt-before-exit"
#define PREF_KEY_ENCRYPTED_ONLY "encrypted-connections-only"
#define PREF_KEY_ENCRYPTION "encryption"
#define PREF_KEY_MSGLEVEL "debug-message-level"
#define PREF_KEY_SORT_MODE "sort-mode"
#define PREF_KEY_SORT_REVERSED "sort-reversed"

6
gtk/tr-window.c
View File

@ -413,7 +413,7 @@ tr_window_new( GtkUIManager * ui_manager, TrCore * core )
{
int i, n;
int status_stats_mode;
char * pch;
const char * pch;
PrivateData * p;
GtkWidget *vbox, *w, *self, *h, *c, *s, *image, *menu;
GtkWindow *win;
@ -510,7 +510,6 @@ tr_window_new( GtkUIManager * ui_manager, TrCore * core )
gtk_menu_shell_append( GTK_MENU_SHELL(menu), w );
gtk_widget_show( w );
}
g_free( pch );
/* status */
h = p->status = gtk_hbox_new( FALSE, GUI_PAD );
@ -606,7 +605,7 @@ updateTorrentCount( PrivateData * p )
static void
updateStats( PrivateData * p )
{
char * pch;
const char * pch;
char up[32], down[32], ratio[32], buf[128];
struct tr_session_stats stats;
tr_handle * handle = tr_core_handle( p->core );
@ -638,7 +637,6 @@ updateStats( PrivateData * p )
tr_strlratio( ratio, stats.ratio, sizeof( ratio ) );
g_snprintf( buf, sizeof(buf), _("Ratio: %s"), ratio );
}
g_free( pch );
gtk_label_set_text( GTK_LABEL( p->stats_lb ), buf );
}

2
libtransmission/bencode.h
View File

@ -53,8 +53,6 @@ typedef struct tr_benc
} val;
} tr_benc;
const tr_benc BENC_INIT;
/* backwards compatability */
typedef tr_benc benc_val_t;

21
libtransmission/stats.c
View File

@ -29,7 +29,7 @@ struct tr_stats_handle
};
static char*
getFilename( const tr_handle * handle, char * buf, size_t buflen )
getOldFilename( const tr_handle * handle, char * buf, size_t buflen )
{
tr_buildPath( buf, buflen, tr_sessionGetConfigDir(handle),
"stats.benc",
@ -37,14 +37,29 @@ getFilename( const tr_handle * handle, char * buf, size_t buflen )
return buf;
}
static char*
getFilename( const tr_handle * handle, char * buf, size_t buflen )
{
tr_buildPath( buf, buflen, tr_sessionGetConfigDir(handle),
"stats.json",
NULL );
return buf;
}
static void
loadCumulativeStats( const tr_handle * handle, tr_session_stats * setme )
{
int loaded = FALSE;
char filename[MAX_PATH_LENGTH];
tr_benc top;
getFilename( handle, filename, sizeof(filename) );
if( !tr_bencLoadFile( filename, &top ) )
loaded = !tr_bencLoadJSONFile( filename, &top );
if( !loaded ) {
getOldFilename( handle, filename, sizeof(filename) );
loaded = !tr_bencLoadFile( filename, &top );
}
if( loaded )
{
int64_t i;
@ -78,7 +93,7 @@ saveCumulativeStats( const tr_handle * handle, const tr_session_stats * s )
getFilename( handle, filename, sizeof(filename) );
tr_deepLog( __FILE__, __LINE__, NULL, "Saving stats to \"%s\"", filename );
tr_bencSaveFile( filename, &top );
tr_bencSaveJSONFile( filename, &top );
tr_bencFree( &top );
}

2
libtransmission/torrent.c
View File

@ -1554,7 +1554,7 @@ tr_torrentSetAnnounceList( tr_torrent * tor,
const tr_tracker_info * trackers,
int trackerCount )
{
tr_benc metainfo = BENC_INIT;
tr_benc metainfo;
/* save to the .torrent file */
if( !tr_bencLoadFile( tor->info.torrent, &metainfo ) )