Changeset 10635

Timestamp:

May 8, 2010, 8:42:45 AM (12 years ago)

Author:

charles

Message:

(trunk) #3060 "Local Peer Discovery" -- in the code, rename LDS as LPD for Local Peer Discovery

Location:

trunk

Files:

• Transmission.xcodeproj/project.pbxproj (modified) (5 diffs)
• daemon/daemon.c (modified) (2 diffs)
• daemon/remote.c (modified) (3 diffs)
• daemon/transmission-remote.1 (modified) (1 diff)
• doc/rpc-spec.txt (modified) (1 diff)
• gtk/main.c (modified) (1 diff)
• gtk/tr-prefs.c (modified) (1 diff)
• libtransmission/Makefile.am (modified) (2 diffs)
• libtransmission/announcer.c (modified) (6 diffs)
• libtransmission/peer-mgr.c (modified) (1 diff)
• libtransmission/rpcimpl.c (modified) (2 diffs)
• libtransmission/session.c (modified) (7 diffs)
• libtransmission/session.h (modified) (2 diffs)
• libtransmission/torrent.c (modified) (1 diff)
• libtransmission/torrent.h (modified) (2 diffs)
• libtransmission/tr-lpd.c (moved) (moved from trunk/libtransmission/tr-lds.c) (33 diffs)
• libtransmission/tr-lpd.h (moved) (moved from trunk/libtransmission/tr-lds.h) (2 diffs)
• libtransmission/transmission.h (modified) (3 diffs)
• qt/prefs-dialog.cc (modified) (1 diff)
• qt/prefs.cc (modified) (1 diff)
• qt/prefs.h (modified) (1 diff)
• qt/session.cc (modified) (1 diff)

trunk/Transmission.xcodeproj/project.pbxproj

@@ -105 +105 @@
                 A21FBBAB0EDA78C300BC3C51 /* bandwidth.h in Headers */ = {isa = PBXBuildFile; fileRef = A21FBBA90EDA78C300BC3C51 /* bandwidth.h */; };
                 A21FBBAC0EDA78C300BC3C51 /* bandwidth.c in Sources */ = {isa = PBXBuildFile; fileRef = A21FBBAA0EDA78C300BC3C51 /* bandwidth.c */; };
-                A220EC5B118C8A060022B4BE /* tr-lds.c in Sources */ = {isa = PBXBuildFile; fileRef = A220EC59118C8A060022B4BE /* tr-lds.c */; };
-                A220EC5C118C8A060022B4BE /* tr-lds.h in Headers */ = {isa = PBXBuildFile; fileRef = A220EC5A118C8A060022B4BE /* tr-lds.h */; };
+                A220EC5B118C8A060022B4BE /* tr-lpd.c in Sources */ = {isa = PBXBuildFile; fileRef = A220EC59118C8A060022B4BE /* tr-lpd.c */; };
+                A220EC5C118C8A060022B4BE /* tr-lpd.h in Headers */ = {isa = PBXBuildFile; fileRef = A220EC5A118C8A060022B4BE /* tr-lpd.h */; };
                 A22180980D148A71007D09ED /* GroupsPrefsController.m in Sources */ = {isa = PBXBuildFile; fileRef = A22180970D148A71007D09ED /* GroupsPrefsController.m */; };
                 A221DCC8104B3660008A642D /* Quartz.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = A221DCC7104B3660008A642D /* Quartz.framework */; };
@@ -547 +547 @@
                 A21FBBA90EDA78C300BC3C51 /* bandwidth.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = bandwidth.h; path = libtransmission/bandwidth.h; sourceTree = "<group>"; };
                 A21FBBAA0EDA78C300BC3C51 /* bandwidth.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = bandwidth.c; path = libtransmission/bandwidth.c; sourceTree = "<group>"; };
-                A220EC59118C8A060022B4BE /* tr-lds.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = "tr-lds.c"; path = "libtransmission/tr-lds.c"; sourceTree = "<group>"; };
-                A220EC5A118C8A060022B4BE /* tr-lds.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "tr-lds.h"; path = "libtransmission/tr-lds.h"; sourceTree = "<group>"; };
+                A220EC59118C8A060022B4BE /* tr-lpd.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; name = "tr-lpd.c"; path = "libtransmission/tr-lpd.c"; sourceTree = "<group>"; };
+                A220EC5A118C8A060022B4BE /* tr-lpd.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = "tr-lpd.h"; path = "libtransmission/tr-lpd.h"; sourceTree = "<group>"; };
                 A22180960D148A71007D09ED /* GroupsPrefsController.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = GroupsPrefsController.h; path = macosx/GroupsPrefsController.h; sourceTree = "<group>"; };
                 A22180970D148A71007D09ED /* GroupsPrefsController.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; name = GroupsPrefsController.m; path = macosx/GroupsPrefsController.m; sourceTree = "<group>"; };
@@ -1213 +1213 @@
                                 A22CFCA60FC24ED80009BD3E /* tr-dht.c */,
                                 A22CFCA70FC24ED80009BD3E /* tr-dht.h */,
-                                A220EC59118C8A060022B4BE /* tr-lds.c */,
-                                A220EC5A118C8A060022B4BE /* tr-lds.h */,
+                                A220EC59118C8A060022B4BE /* tr-lpd.c */,
+                                A220EC5A118C8A060022B4BE /* tr-lpd.h */,
                                 A2AAB65B0DE0CF6200E04DDA /* rpcimpl.c */,
                                 A2AAB6590DE0CF6200E04DDA /* rpcimpl.h */,
@@ -1570 +1570 @@
                                 A209EE5D1144B51E002B02D1 /* history.h in Headers */,
                                 A247A443114C701800547DFC /* InfoViewController.h in Headers */,
-                                A220EC5C118C8A060022B4BE /* tr-lds.h in Headers */,
+                                A220EC5C118C8A060022B4BE /* tr-lpd.h in Headers */,
                         );
                         runOnlyForDeploymentPostprocessing = 0;
@@ -2041 +2041 @@
                                 4D80185910BBC0B0008A4AF2 /* magnet.c in Sources */,
                                 A209EE5C1144B51E002B02D1 /* history.c in Sources */,
-                                A220EC5B118C8A060022B4BE /* tr-lds.c in Sources */,
+                                A220EC5B118C8A060022B4BE /* tr-lpd.c in Sources */,
                         );
                         runOnlyForDeploymentPostprocessing = 0;

trunk/daemon/daemon.c

@@ -86 +86 @@
     { 'o', "dht", "Enable distributed hash tables (DHT)", "o", 0, NULL },
     { 'O', "no-dht", "Disable distributed hash tables (DHT)", "O", 0, NULL },
-    { 'z', "lds", "Enable local peer discovery (LDS)", "z", 0, NULL },
-    { 'Z', "no-lds", "Disable local peer discovery (LDS)", "Z", 0, NULL },
+    { 'z', "lds", "Enable local peer discovery (LPD)", "z", 0, NULL },
+    { 'Z', "no-lds", "Disable local peer discovery (LPD)", "Z", 0, NULL },
     { 'P', "peerport", "Port for incoming peers (Default: " TR_DEFAULT_PEER_PORT_STR ")", "P", 1, "<port>" },
     { 'm', "portmap", "Enable portmapping via NAT-PMP or UPnP", "m", 0, NULL },
@@ -409 +409 @@
                       tr_bencDictAddBool( &settings, TR_PREFS_KEY_RATIO_ENABLED, FALSE );
                       break;
-            case 'z': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LDS_ENABLED, TRUE );
-                      break;
-            case 'Z': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LDS_ENABLED, FALSE );
+            case 'z': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, TRUE );
+                      break;
+            case 'Z': tr_bencDictAddBool( &settings, TR_PREFS_KEY_LPD_ENABLED, FALSE );
                       break;
             default:  showUsage( );

trunk/daemon/remote.c

@@ -256 +256 @@
     { 'x', "pex",                   "Enable peer exchange (PEX)", "x",  0, NULL },
     { 'X', "no-pex",                "Disable peer exchange (PEX)", "X",  0, NULL },
-    { 'z', "lds",                   "Enable local peer discovery (LDS)", "z",  0, NULL },
-    { 'Z', "no-lds",                "Disable local peer discovery (LDS)", "Z",  0, NULL },
+    { 'z', "lds",                   "Enable local peer discovery (LPD)", "z",  0, NULL },
+    { 'Z', "no-lds",                "Disable local peer discovery (LPD)", "Z",  0, NULL },
     { 940, "peer-info",             "List the current torrent(s)' peers", "pi",  0, NULL },
     {   0, NULL,                    NULL, NULL, 0, NULL }
@@ -1344 +1344 @@
         if( tr_bencDictFindBool( args, TR_PREFS_KEY_DHT_ENABLED, &boolVal ) )
             printf( "  Distributed hash table enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
-        if( tr_bencDictFindBool( args, TR_PREFS_KEY_LDS_ENABLED, &boolVal ) )
+        if( tr_bencDictFindBool( args, TR_PREFS_KEY_LPD_ENABLED, &boolVal ) )
             printf( "  Local peer discovery enabled: %s\n", ( boolVal ? "Yes" : "No" ) );
         if( tr_bencDictFindBool( args, TR_PREFS_KEY_PEX_ENABLED, &boolVal ) )
@@ -1824 +1824 @@
                 case 'X': tr_bencDictAddBool( args, TR_PREFS_KEY_PEX_ENABLED, FALSE );
                           break;
-                case 'z': tr_bencDictAddBool( args, TR_PREFS_KEY_LDS_ENABLED, TRUE );
-                          break;
-                case 'Z': tr_bencDictAddBool( args, TR_PREFS_KEY_LDS_ENABLED, FALSE );
+                case 'z': tr_bencDictAddBool( args, TR_PREFS_KEY_LPD_ENABLED, TRUE );
+                          break;
+                case 'Z': tr_bencDictAddBool( args, TR_PREFS_KEY_LPD_ENABLED, FALSE );
                           break;
                 case 953: tr_bencDictAddReal( args, "seedRatioLimit", atof(optarg) );

trunk/daemon/transmission-remote.1

@@ -249 +249 @@
 Disable peer exchange (PEX).
 .It Fl z Fl -lds
-Enable local peer discovery (LDS).
+Enable local peer discovery (LPD).
 .It Fl Z Fl -no-lds
-Disable local peer discovery (LDS).
+Disable local peer discovery (LPD).
 .It Fl pi Fl -peer-info
 List the current torrent's connected peers.

trunk/doc/rpc-spec.txt

@@ -406 +406 @@
    "incomplete-dir"              | string     path for incomplete torrents, when enabled
    "incomplete-dir-enabled"      | boolean    true means keep torrents in incomplete-dir until done
-   "lds-enabled"                 | boolean    true means allow lds in public torrents
+   "lpd-enabled"                 | boolean    true means allow Local Peer Discovery in public torrents
    "peer-limit-global"           | number     maximum global number of peers
    "peer-limit-per-torrent"      | number     maximum global number of peers

trunk/gtk/main.c

@@ -1222 +1222 @@
         tr_sessionSetDHTEnabled( tr, pref_flag_get( key ) );
     }
-    else if( !strcmp( key, TR_PREFS_KEY_LDS_ENABLED ) )
-    {
-        tr_sessionSetLDSEnabled( tr, pref_flag_get( key ) );
+    else if( !strcmp( key, TR_PREFS_KEY_LPD_ENABLED ) )
+    {
+        tr_sessionSetLPDEnabled( tr, pref_flag_get( key ) );
     }
     else if( !strcmp( key, TR_PREFS_KEY_RPC_PORT ) )

trunk/gtk/tr-prefs.c

@@ -555 +555 @@
     hig_workarea_add_wide_control( t, &row, w );
 
-    s = _( "Use LDS to find local peers" );
-    w = new_check_button( s, TR_PREFS_KEY_LDS_ENABLED, core );
-    s = _( "LDS is a tool for finding peers on your local network." );
+    s = _( "Use Local Peer Discovery to find more peers" );
+    w = new_check_button( s, TR_PREFS_KEY_LPD_ENABLED, core );
+    s = _( "LPD is a tool for finding peers on your local network." );
     gtr_widget_set_tooltip_text( w, s );
     hig_workarea_add_wide_control( t, &row, w );

trunk/libtransmission/Makefile.am

@@ -56 +56 @@
     torrent-magnet.c \
     tr-dht.c \
-    tr-lds.c \
+    tr-lpd.c \
     tr-getopt.c \
     trevent.c \
@@ -109 +109 @@
     transmission.h \
     tr-dht.h \
-    tr-lds.h \
+    tr-lpd.h \
     trevent.h \
     upnp.h \

trunk/libtransmission/announcer.c

@@ -25 +25 @@
 #include "session.h"
 #include "tr-dht.h"
-#include "tr-lds.h"
+#include "tr-lpd.h"
 #include "torrent.h"
 #include "utils.h"
@@ -70 +70 @@
 
     /* this is an upper limit for the frequency of LDS announces */
-    LDS_HOUSEKEEPING_INTERVAL_SECS = 30
+    LPD_HOUSEKEEPING_INTERVAL_SECS = 30
 
 };
@@ -207 +207 @@
     struct event * upkeepTimer;
     int slotsAvailable;
-    time_t ldsHouseKeepingAt;
+    time_t lpdHouseKeepingAt;
 }
 tr_announcer;
@@ -255 +255 @@
 
     const time_t relaxUntil =
-        calcRescheduleWithJitter( LDS_HOUSEKEEPING_INTERVAL_SECS / 3 );
+        calcRescheduleWithJitter( LPD_HOUSEKEEPING_INTERVAL_SECS / 3 );
 
     assert( tr_isSession( session ) );
@@ -264 +264 @@
     a->session = session;
     a->slotsAvailable = MAX_CONCURRENT_TASKS;
-    a->ldsHouseKeepingAt = relaxUntil;
+    a->lpdHouseKeepingAt = relaxUntil;
     a->upkeepTimer = tr_new0( struct event, 1 );
     evtimer_set( a->upkeepTimer, onUpkeepTimer, a );
@@ -1908 +1908 @@
 
     /* Local Peer Discovery */
-    if( announcer->ldsHouseKeepingAt <= now )
-    {
-        tr_ldsAnnounceMore( now, LDS_HOUSEKEEPING_INTERVAL_SECS );
+    if( announcer->lpdHouseKeepingAt <= now )
+    {
+        tr_lpdAnnounceMore( now, LPD_HOUSEKEEPING_INTERVAL_SECS );
 
         /* reschedule more LDS announces for ( the future + jitter ) */
-        announcer->ldsHouseKeepingAt =
-            calcRescheduleWithJitter( LDS_HOUSEKEEPING_INTERVAL_SECS );
+        announcer->lpdHouseKeepingAt =
+            calcRescheduleWithJitter( LPD_HOUSEKEEPING_INTERVAL_SECS );
     }
 }

trunk/libtransmission/peer-mgr.c

@@ -1509 +1509 @@
         case TR_PEER_FROM_PEX      : return 60 * 60 * 2;
         case TR_PEER_FROM_RESUME   : return 60 * 60;
-        case TR_PEER_FROM_LDS      : return 10 * 60;
+        case TR_PEER_FROM_LPD      : return 10 * 60;
         default                    : return 60 * 60;
     }

trunk/libtransmission/rpcimpl.c

@@ -1215 +1215 @@
     if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_DHT_ENABLED, &boolVal ) )
         tr_sessionSetDHTEnabled( session, boolVal );
-    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_LDS_ENABLED, &boolVal ) )
-        tr_sessionSetLDSEnabled( session, boolVal );
+    if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_LPD_ENABLED, &boolVal ) )
+        tr_sessionSetLPDEnabled( session, boolVal );
     if( tr_bencDictFindBool( args_in, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, &boolVal ) )
         tr_sessionSetPeerPortRandomOnStart( session, boolVal );
@@ -1329 +1329 @@
     tr_bencDictAddBool( d, TR_PREFS_KEY_PEX_ENABLED, tr_sessionIsPexEnabled( s ) );
     tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED, tr_sessionIsDHTEnabled( s ) );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_LDS_ENABLED, tr_sessionIsLDSEnabled( s ) );
+    tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED, tr_sessionIsLPDEnabled( s ) );
     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT, tr_sessionGetPeerPort( s ) );
     tr_bencDictAddInt ( d, TR_PREFS_KEY_PEER_PORT_RANDOM_ON_START, tr_sessionGetPeerPortRandomOnStart( s ) );

trunk/libtransmission/session.c

@@ -43 +43 @@
 #include "torrent.h"
 #include "tr-dht.h"
-#include "tr-lds.h"
+#include "tr-lpd.h"
 #include "trevent.h"
 #include "utils.h"
@@ -246 +246 @@
     tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        FALSE );
     tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,              TRUE );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_LDS_ENABLED,              FALSE );
+    tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED,              FALSE );
     tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,             tr_getDefaultDownloadDir( ) );
     tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED,                   100 );
@@ -309 +309 @@
     tr_bencDictAddBool( d, TR_PREFS_KEY_BLOCKLIST_ENABLED,        tr_blocklistIsEnabled( s ) );
     tr_bencDictAddBool( d, TR_PREFS_KEY_DHT_ENABLED,              s->isDHTEnabled );
-    tr_bencDictAddBool( d, TR_PREFS_KEY_LDS_ENABLED,              s->isLDSEnabled );
+    tr_bencDictAddBool( d, TR_PREFS_KEY_LPD_ENABLED,              s->isLPDEnabled );
     tr_bencDictAddStr ( d, TR_PREFS_KEY_DOWNLOAD_DIR,             s->downloadDir );
     tr_bencDictAddInt ( d, TR_PREFS_KEY_DSPEED,                   tr_sessionGetSpeedLimit( s, TR_DOWN ) );
@@ -629 +629 @@
     }
 
-    if( session->isLDSEnabled )
-    {
-        if( tr_ldsInit( session, &session->public_ipv4->addr ) )
-            tr_ninf( "LDS", "Local Peer Discovery active" );
-    }
-    else
-        tr_ndbg( "LDS", "Local Peer Discovery disabled" );
+    if( !session->isLPDEnabled )
+        tr_ndbg( "LPD", _( "Local Peer Discovery disabled" ) );
+    else if( tr_lpdInit( session, &session->public_ipv4->addr ) )
+        tr_ninf( "LPD", _( "Local Peer Discovery active" ) );
 
     /* cleanup */
@@ -679 +676 @@
     if( tr_bencDictFindBool( settings, TR_PREFS_KEY_DHT_ENABLED, &boolVal ) )
         tr_sessionSetDHTEnabled( session, boolVal );
-    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_LDS_ENABLED, &boolVal ) )
-        tr_sessionSetLDSEnabled( session, boolVal );
+    if( tr_bencDictFindBool( settings, TR_PREFS_KEY_LPD_ENABLED, &boolVal ) )
+        tr_sessionSetLPDEnabled( session, boolVal );
     if( tr_bencDictFindInt( settings, TR_PREFS_KEY_ENCRYPTION, &i ) )
         tr_sessionSetEncryption( session, i );
@@ -1565 +1562 @@
     free_incoming_peer_port( session );
 
-    if( session->isLDSEnabled )
-        tr_ldsUninit( session );
+    if( session->isLPDEnabled )
+        tr_lpdUninit( session );
 
     if( session->isDHTEnabled )
@@ -1803 +1800 @@
 
 void
-tr_sessionSetLDSEnabled( tr_session * session,
+tr_sessionSetLPDEnabled( tr_session * session,
                          tr_bool      enabled )
 {
     assert( tr_isSession( session ) );
 
-    session->isLDSEnabled = ( enabled != 0 );
-}
-
-tr_bool
-tr_sessionIsLDSEnabled( const tr_session * session )
-{
-    assert( tr_isSession( session ) );
-
-    return session->isLDSEnabled;
-}
-
-tr_bool
-tr_sessionAllowsLDS( const tr_session * session )
-{
-    return tr_sessionIsLDSEnabled( session );
+    session->isLPDEnabled = ( enabled != 0 );
+}
+
+tr_bool
+tr_sessionIsLPDEnabled( const tr_session * session )
+{
+    assert( tr_isSession( session ) );
+
+    return session->isLPDEnabled;
+}
+
+tr_bool
+tr_sessionAllowsLPD( const tr_session * session )
+{
+    return tr_sessionIsLPDEnabled( session );
 }
 

trunk/libtransmission/session.h

@@ -85 +85 @@
     tr_bool                      isPexEnabled;
     tr_bool                      isDHTEnabled;
-    tr_bool                      isLDSEnabled;
+    tr_bool                      isLPDEnabled;
     tr_bool                      isBlocklistEnabled;
     tr_bool                      isProxyEnabled;
@@ -181 +181 @@
 tr_bool      tr_sessionAllowsDHT( const tr_session * session );
 
-tr_bool      tr_sessionAllowsLDS( const tr_session * session );
+tr_bool      tr_sessionAllowsLPD( const tr_session * session );
 
 const char * tr_sessionFindTorrentFile( const tr_session * session,

trunk/libtransmission/torrent.c

@@ -1401 +1401 @@
         tor->dhtAnnounceAt = now + tr_cryptoWeakRandInt( 20 );
         tor->dhtAnnounce6At = now + tr_cryptoWeakRandInt( 20 );
-        tor->ldsAnnounceAt = now;
+        tor->lpdAnnounceAt = now;
         tr_peerMgrStartTorrent( tor );
     }

trunk/libtransmission/torrent.h

@@ -201 +201 @@
     tr_bool                    dhtAnnounce6InProgress;
     
-    time_t                     ldsAnnounceAt;
+    time_t                     lpdAnnounceAt;
 
     uint64_t                   downloadedCur;
@@ -335 +335 @@
 }
 
-static inline tr_bool tr_torrentAllowsLDS( const tr_torrent * tor )
+static inline tr_bool tr_torrentAllowsLPD( const tr_torrent * tor )
 {
     return ( tor != NULL )
-        && ( tr_sessionAllowsLDS( tor->session ) )
+        && ( tr_sessionAllowsLPD( tor->session ) )
         && ( !tr_torrentIsPrivate( tor ) );
 }

trunk/libtransmission/tr-lpd.c

@@ -45 +45 @@
 #include "session.h"
 #include "torrent.h" /* tr_torrentFindFromHash() */
-#include "tr-lds.h"
+#include "tr-lpd.h"
 #include "utils.h"
 #include "version.h"
@@ -51 +51 @@
 /**
 * @brief Local Peer Discovery
-* @file tr-lds.c
-*
-* This module implements the Local Peer Discovery (LDS) protocol as supported by the
-* uTorrent client application.  A typical LDS datagram is 119 bytes long.
+* @file tr-lpd.c
+*
+* This module implements the Local Peer Discovery (LPD) protocol as supported by the
+* uTorrent client application.  A typical LPD datagram is 119 bytes long.
 *
 * $Id$
@@ -61 +61 @@
 static void event_callback( int, short, void* );
 
-static int lds_socket; /**<separate multicast receive socket */
-static int lds_socket2; /**<and multicast send socket */
-static struct event lds_event;
-static tr_port lds_port;
-
-static tr_torrent* lds_torStaticType UNUSED; /* just a helper for static type analysis */
+static int lpd_socket; /**<separate multicast receive socket */
+static int lpd_socket2; /**<and multicast send socket */
+static struct event lpd_event;
+static tr_port lpd_port;
+
+static tr_torrent* lpd_torStaticType UNUSED; /* just a helper for static type analysis */
 static tr_session* session;
 
-enum { lds_maxDatagramLength = 200 }; /**<the size an LDS datagram must not exceed */
-const char lds_mcastGroup[] = "239.192.152.143"; /**<LDS multicast group */
-const int lds_mcastPort = 6771; /**<LDS source and destination UPD port */
-static struct sockaddr_in lds_mcastAddr; /**<initialized from the above constants in tr_ldsInit */
+enum { lpd_maxDatagramLength = 200 }; /**<the size an LPD datagram must not exceed */
+const char lpd_mcastGroup[] = "239.192.152.143"; /**<LPD multicast group */
+const int lpd_mcastPort = 6771; /**<LPD source and destination UPD port */
+static struct sockaddr_in lpd_mcastAddr; /**<initialized from the above constants in tr_lpdInit */
 
 /**
 * @brief Protocol-related information carried by a Local Peer Discovery packet */
-struct lds_protocolVersion
+struct lpd_protocolVersion
 {
     int major, minor;
 };
 
-enum lds_enumTimeToLive {
-    lds_ttlSameSubnet = 1,
-    lds_ttlSameSite = 32,
-    lds_ttlSameRegion = 64,
-    lds_ttlSameContinent = 128,
-    lds_ttlUnrestricted = 255
+enum lpd_enumTimeToLive {
+    lpd_ttlSameSubnet = 1,
+    lpd_ttlSameSite = 32,
+    lpd_ttlSameRegion = 64,
+    lpd_ttlSameContinent = 128,
+    lpd_ttlUnrestricted = 255
 };
 
 enum {
-    lds_announceInterval = 4 * 60, /**<4 min announce interval per torrent */
-    lds_announceScope = lds_ttlSameSubnet /**<the maximum scope for LDS datagrams */
+    lpd_announceInterval = 4 * 60, /**<4 min announce interval per torrent */
+    lpd_announceScope = lpd_ttlSameSubnet /**<the maximum scope for LPD datagrams */
 };
 
@@ -113 +113 @@
 * @brief allow at most ten messages per second (interval average)
 * @note this constraint is only enforced once per housekeeping interval */
-enum { lds_announceCapFactor = 10 };
+enum { lpd_announceCapFactor = 10 };
 
 /**
@@ -119 +119 @@
 * @brief number of unsolicited messages during the last HK interval
 * @remark counts downwards */
-static int lds_unsolicitedMsgCounter;
+static int lpd_unsolicitedMsgCounter;
 
 /**
 * @def CRLF
-* @brief a line-feed, as understood by the LDS protocol */
+* @brief a line-feed, as understood by the LPD protocol */
 #define CRLF "\r\n"
 
@@ -145 +145 @@
 * in this case the function returns a character sequence beginning with CRLF).
 * If parameter is not NULL, the declared protocol version is returned as part of
-* the lds_protocolVersion structure.
-*/
-static const char* lds_extractHeader( const char* s, struct lds_protocolVersion* const ver )
+* the lpd_protocolVersion structure.
+*/
+static const char* lpd_extractHeader( const char* s, struct lpd_protocolVersion* const ver )
 {
     int major = -1, minor = -1;
@@ -156 +156 @@
 
     /* something might be rotten with this chunk of data */
-    if( len == 0 || len > lds_maxDatagramLength )
+    if( len == 0 || len > lpd_maxDatagramLength )
         return NULL;
 
@@ -199 +199 @@
 *   - copy back value from end to next "\r\n"
 */
-static int lds_extractParam( const char* const str, const char* const name, int n, char* const val )
+static int lpd_extractParam( const char* const str, const char* const name, int n, char* const val )
 {
     /* configure maximum length of search string here */
@@ -245 +245 @@
 /**
 * @brief Configures additional capabilities for a socket */
-static inline int lds_configureSocket( int sock, int add )
+static inline int lpd_configureSocket( int sock, int add )
 {
     /* read-modify-write socket flags */
@@ -265 +265 @@
 * and event-based message handling.
 *
-* @remark Since the LDS service does not use another protocol family yet, this code is
+* @remark Since the LPD service does not use another protocol family yet, this code is
 * IPv4 only for the time being.
 */
-int tr_ldsInit( tr_session* ss, tr_address* tr_addr UNUSED )
+int tr_lpdInit( tr_session* ss, tr_address* tr_addr UNUSED )
 {
     struct ip_mreq mcastReq;
@@ -276 +276 @@
         return -1;
 
-    assert( lds_announceInterval > 0 );
-    assert( lds_announceScope > 0 );
-
-    lds_port = tr_sessionGetPeerPort( ss );
-    if( lds_port <= 0 )
+    assert( lpd_announceInterval > 0 );
+    assert( lpd_announceScope > 0 );
+
+    lpd_port = tr_sessionGetPeerPort( ss );
+    if( lpd_port <= 0 )
         return -1;
 
-    tr_ndbg( "LDS", "Initialising Local Peer Discovery" );
+    tr_ndbg( "LPD", "Initialising Local Peer Discovery" );
 
     /* setup datagram socket (receive) */
     {
-        lds_socket = socket( PF_INET, SOCK_DGRAM, 0 );
-        if( lds_socket < 0 )
+        lpd_socket = socket( PF_INET, SOCK_DGRAM, 0 );
+        if( lpd_socket < 0 )
             goto fail;
 
         /* enable non-blocking operation */
-        if( lds_configureSocket( lds_socket, O_NONBLOCK ) < 0 )
-            goto fail;
-
-        if( setsockopt( lds_socket, SOL_SOCKET, SO_REUSEADDR,
+        if( lpd_configureSocket( lpd_socket, O_NONBLOCK ) < 0 )
+            goto fail;
+
+        if( setsockopt( lpd_socket, SOL_SOCKET, SO_REUSEADDR,
                 &opt_on, sizeof opt_on ) < 0 )
             goto fail;
 
-        memset( &lds_mcastAddr, 0, sizeof lds_mcastAddr );
-        lds_mcastAddr.sin_family = AF_INET;
-        lds_mcastAddr.sin_port = htons( lds_mcastPort );
-        if( inet_pton( lds_mcastAddr.sin_family, lds_mcastGroup,
-                &lds_mcastAddr.sin_addr ) < 0 )
-            goto fail;
-
-        if( bind( lds_socket, (struct sockaddr*) &lds_mcastAddr,
-                sizeof lds_mcastAddr ) < 0 )
-            goto fail;
-
-        /* we want to join that LDS multicast group */
+        memset( &lpd_mcastAddr, 0, sizeof lpd_mcastAddr );
+        lpd_mcastAddr.sin_family = AF_INET;
+        lpd_mcastAddr.sin_port = htons( lpd_mcastPort );
+        if( inet_pton( lpd_mcastAddr.sin_family, lpd_mcastGroup,
+                &lpd_mcastAddr.sin_addr ) < 0 )
+            goto fail;
+
+        if( bind( lpd_socket, (struct sockaddr*) &lpd_mcastAddr,
+                sizeof lpd_mcastAddr ) < 0 )
+            goto fail;
+
+        /* we want to join that LPD multicast group */
         memset( &mcastReq, 0, sizeof mcastReq );
-        mcastReq.imr_multiaddr = lds_mcastAddr.sin_addr;
+        mcastReq.imr_multiaddr = lpd_mcastAddr.sin_addr;
         mcastReq.imr_interface.s_addr = htonl( INADDR_ANY );
-        if( setsockopt( lds_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+        if( setsockopt( lpd_socket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
                 &mcastReq, sizeof mcastReq ) < 0 )
             goto fail;
 
-        if( setsockopt( lds_socket, IPPROTO_IP, IP_MULTICAST_LOOP,
+        if( setsockopt( lpd_socket, IPPROTO_IP, IP_MULTICAST_LOOP,
                 &opt_off, sizeof opt_off ) < 0 )
             goto fail;
@@ -325 +325 @@
     /* setup datagram socket (send) */
     {
-        const unsigned char scope = lds_announceScope;
-
-        lds_socket2 = socket( PF_INET, SOCK_DGRAM, 0 );
-        if( lds_socket2 < 0 )
+        const unsigned char scope = lpd_announceScope;
+
+        lpd_socket2 = socket( PF_INET, SOCK_DGRAM, 0 );
+        if( lpd_socket2 < 0 )
             goto fail;
 
         /* enable non-blocking operation */
-        if( lds_configureSocket( lds_socket2, O_NONBLOCK ) < 0 )
+        if( lpd_configureSocket( lpd_socket2, O_NONBLOCK ) < 0 )
             goto fail;
 
         /* configure outbound multicast TTL */
-        if( setsockopt( lds_socket2, IPPROTO_IP, IP_MULTICAST_TTL,
+        if( setsockopt( lpd_socket2, IPPROTO_IP, IP_MULTICAST_TTL,
                 &scope, sizeof scope ) < 0 )
             goto fail;
 
-        if( setsockopt( lds_socket2, IPPROTO_IP, IP_MULTICAST_LOOP,
+        if( setsockopt( lpd_socket2, IPPROTO_IP, IP_MULTICAST_LOOP,
                 &opt_off, sizeof opt_off ) < 0 )
             goto fail;
@@ -347 +347 @@
     session = ss;
 
-    /* Note: lds_unsolicitedMsgCounter remains 0 until the first timeout event, thus
+    /* Note: lpd_unsolicitedMsgCounter remains 0 until the first timeout event, thus
      * any announcement received during the initial interval will be discarded. */
 
-    event_set( &lds_event, lds_socket, EV_READ | EV_PERSIST, event_callback, NULL );
-    event_add( &lds_event, NULL );
-
-    tr_ndbg( "LDS", "Local Peer Discovery initialised" );
+    event_set( &lpd_event, lpd_socket, EV_READ | EV_PERSIST, event_callback, NULL );
+    event_add( &lpd_event, NULL );
+
+    tr_ndbg( "LPD", "Local Peer Discovery initialised" );
 
     return 1;
@@ -360 +360 @@
     {
         const int save = errno;
-        close( lds_socket );
-        close( lds_socket2 );
-        lds_socket = lds_socket2 = -1;
+        close( lpd_socket );
+        close( lpd_socket2 );
+        lpd_socket = lpd_socket2 = -1;
         session = NULL;
-        tr_ndbg( "LDS", "LDS initialisation failed (errno = %d)", save );
+        tr_ndbg( "LPD", "LPD initialisation failed (errno = %d)", save );
         errno = save;
     }
@@ -372 +372 @@
 }
 
-void tr_ldsUninit( tr_session* ss )
+void tr_lpdUninit( tr_session* ss )
 {
     if( session != ss )
         return;
 
-    tr_ndbg( "LDS", "Uninitialising Local Peer Discovery" );
-
-    event_del( &lds_event );
+    tr_ndbg( "LPD", "Uninitialising Local Peer Discovery" );
+
+    event_del( &lpd_event );
 
     /* just shut down, we won't remember any former nodes */
-    EVUTIL_CLOSESOCKET( lds_socket );
-    EVUTIL_CLOSESOCKET( lds_socket2 );
-    tr_ndbg( "LDS", "Done uninitialising Local Peer Discovery" );
+    EVUTIL_CLOSESOCKET( lpd_socket );
+    EVUTIL_CLOSESOCKET( lpd_socket2 );
+    tr_ndbg( "LPD", "Done uninitialising Local Peer Discovery" );
 
     session = NULL;
 }
 
-tr_bool tr_ldsEnabled( const tr_session* ss )
+tr_bool tr_lpdEnabled( const tr_session* ss )
 {
     return ss && ( ss == session );
@@ -399 +399 @@
 * @brief Performs some (internal) software consistency checks at compile time.
 * @remark Declared inline for the compiler not to allege us of feeding unused
-* functions. In any other respect, lds_consistencyCheck is an orphaned function.
-*/
-static inline void lds_consistencyCheck( void )
+* functions. In any other respect, lpd_consistencyCheck is an orphaned function.
+*/
+static inline void lpd_consistencyCheck( void )
 {
     /* if the following check fails, the definition of a hash string has changed
-     * without our knowledge; revise string handling in functions tr_ldsSendAnnounce
-     * and tr_ldsConsiderAnnounce. However, the code is designed to function as long
+     * without our knowledge; revise string handling in functions tr_lpdSendAnnounce
+     * and tr_lpdConsiderAnnounce. However, the code is designed to function as long
      * as interfaces to the rest of the lib remain compatible with char* strings. */
-    STATIC_ASSERT( sizeof(lds_torStaticType->info.hashString[0]) == sizeof(char) );
+    STATIC_ASSERT( sizeof(lpd_torStaticType->info.hashString[0]) == sizeof(char) );
 }
 /**
@@ -414 +414 @@
 
 /**
-* @defgroup LdsProto LDS announcement processing
+* @defgroup LdsProto LPD announcement processing
 * @{
 */
@@ -424 +424 @@
 * @return Returns TRUE on success
 *
-* Send a query for torrent t out to the LDS multicast group (or the LAN, for that
+* Send a query for torrent t out to the LPD multicast group (or the LAN, for that
 * matter).  A listening client on the same network might react by adding us to his
 * peer pool for torrent t.
 */
-tr_bool tr_ldsSendAnnounce( const tr_torrent* t )
+tr_bool tr_lpdSendAnnounce( const tr_torrent* t )
 {
     const char fmt[] =
@@ -439 +439 @@
 
     char hashString[lengthof( t->info.hashString )];
-    char query[lds_maxDatagramLength + 1] = { };
+    char query[lpd_maxDatagramLength + 1] = { };
 
     if( t == NULL )
@@ -449 +449 @@
 
     /* prepare a zero-terminated announce message */
-    snprintf( query, lds_maxDatagramLength + 1, fmt, 1, 1,
-        lds_mcastGroup, lds_mcastPort, lds_port, hashString );
-
-    /* actually send the query out using [lds_socket2] */
+    snprintf( query, lpd_maxDatagramLength + 1, fmt, 1, 1,
+        lpd_mcastGroup, lpd_mcastPort, lpd_port, hashString );
+
+    /* actually send the query out using [lpd_socket2] */
     {
         const int len = strlen( query );
 
-        /* destination address info has already been set up in tr_ldsInit(),
+        /* destination address info has already been set up in tr_lpdInit(),
          * so we refrain from preparing another sockaddr_in here */
-        int res = sendto( lds_socket2, query, len, 0,
-            (const struct sockaddr*) &lds_mcastAddr, sizeof lds_mcastAddr );
+        int res = sendto( lpd_socket2, query, len, 0,
+            (const struct sockaddr*) &lpd_mcastAddr, sizeof lpd_mcastAddr );
 
         if( res != len )
@@ -465 +465 @@
     }
 
-    tr_tordbg( t, "LDS announce message away" );
+    tr_tordbg( t, "LPD announce message away" );
 
     return TRUE;
@@ -480 +480 @@
 * the peer in/out parameter.
 *
-* @note The port information gets added to the peer structure if tr_ldsConsiderAnnounce
+* @note The port information gets added to the peer structure if tr_lpdConsiderAnnounce
 * is able to extract the necessary information from the announce message.  That is, if
 * return != 0, the caller may retrieve the value from the passed structure.
 */
-static int tr_ldsConsiderAnnounce( tr_pex* peer, const char* const msg )
+static int tr_lpdConsiderAnnounce( tr_pex* peer, const char* const msg )
 {
     enum
     {
         maxValueLen = 25,
-        maxHashLen = lengthof(lds_torStaticType->info.hashString)
+        maxHashLen = lengthof(lpd_torStaticType->info.hashString)
     };
 
-    struct lds_protocolVersion ver = { -1, -1 };
+    struct lpd_protocolVersion ver = { -1, -1 };
     char value[maxValueLen] = { };
     char hashString[maxHashLen] = { };
@@ -501 +501 @@
         tr_torrent* tor = NULL;
 
-        const char* params = lds_extractHeader( msg, &ver );
+        const char* params = lpd_extractHeader( msg, &ver );
         if( params == NULL || ver.major != 1 ) /* allow messages of protocol v1 */
             return 0;
@@ -507 +507 @@
         /* save the effort to check Host, which seems to be optional anyway */
 
-        if( lds_extractParam( params, "Port", maxValueLen, value ) == 0 )
+        if( lpd_extractParam( params, "Port", maxValueLen, value ) == 0 )
             return 0;
 
@@ -517 +517 @@
         res = -1; /* signal caller side-effect to peer->port via return != 0 */
 
-        if( lds_extractParam( params, "Infohash", maxHashLen, hashString ) == 0 )
+        if( lpd_extractParam( params, "Infohash", maxHashLen, hashString ) == 0 )
             return res;
 
         tor = tr_torrentFindFromHashString( session, hashString );
 
-        if( tr_isTorrent( tor ) && tr_torrentAllowsLDS( tor ) )
+        if( tr_isTorrent( tor ) && tr_torrentAllowsLPD( tor ) )
         {
             /* we found a suitable peer, add it to the torrent */
-            tr_peerMgrAddPex( tor, TR_PEER_FROM_LDS, peer, -1 );
-            tr_tordbg( tor, "Learned %d local peer from LDS (%s:%u)",
+            tr_peerMgrAddPex( tor, TR_PEER_FROM_LPD, peer, -1 );
+            tr_tordbg( tor, "Learned %d local peer from LPD (%s:%u)",
                 1, inet_ntoa( peer->addr.addr.addr4 ), peerPort );
 
@@ -534 +534 @@
         }
         else
-            tr_ndbg( "LDS", "Cannot serve torrent #%s", hashString );
+            tr_ndbg( "LPD", "Cannot serve torrent #%s", hashString );
     }
 
@@ -544 +544 @@
 
 /**
-* @note Since it possible for tr_ldsAnnounceMore to get called from outside the LDS module,
+* @note Since it possible for tr_lpdAnnounceMore to get called from outside the LPD module,
 * the function needs to be informed of the externally employed housekeeping interval.
-* Further, by setting interval to zero (or negative) the caller may actually disable LDS
+* Further, by setting interval to zero (or negative) the caller may actually disable LPD
 * announces on a per-interval basis.
 */
-int tr_ldsAnnounceMore( const time_t now, const int interval )
+int tr_lpdAnnounceMore( const time_t now, const int interval )
 {
     tr_torrent* tor = NULL;
@@ -558 +558 @@
 
     while(( tor = tr_torrentNext( session, tor ) )
-          && tr_sessionAllowsLDS( session ) )
+          && tr_sessionAllowsLPD( session ) )
     {
         if( tr_isTorrent( tor ) )
         {
-            if( !tr_torrentAllowsLDS( tor ) || (
+            if( !tr_torrentAllowsLPD( tor ) || (
                     ( tr_torrentGetActivity( tor ) != TR_STATUS_DOWNLOAD ) &&
                     ( tr_torrentGetActivity( tor ) != TR_STATUS_SEED ) ) )
                 continue;
 
-            if( tor->ldsAnnounceAt <= now )
+            if( tor->lpdAnnounceAt <= now )
             {
-                if( tr_ldsSendAnnounce( tor ) )
+                if( tr_lpdSendAnnounce( tor ) )
                     announcesSent++;
 
-                tor->ldsAnnounceAt = now + lds_announceInterval;
+                tor->lpdAnnounceAt = now + lpd_announceInterval;
                 break; /* that's enough; for this interval */
             }
@@ -580 +580 @@
     /* perform housekeeping for the flood protection mechanism */
     {
-        const int maxAnnounceCap = interval * lds_announceCapFactor;
-
-        if( lds_unsolicitedMsgCounter < 0 )
-            tr_ninf( "LDS", "Dropped %d announces in the last interval (max. %d "
-                     "allowed)", -lds_unsolicitedMsgCounter, maxAnnounceCap );
-
-        lds_unsolicitedMsgCounter = maxAnnounceCap;
+        const int maxAnnounceCap = interval * lpd_announceCapFactor;
+
+        if( lpd_unsolicitedMsgCounter < 0 )
+            tr_ninf( "LPD", "Dropped %d announces in the last interval (max. %d "
+                     "allowed)", -lpd_unsolicitedMsgCounter, maxAnnounceCap );
+
+        lpd_unsolicitedMsgCounter = maxAnnounceCap;
     }
 
@@ -594 +594 @@
 /**
 * @brief Processing of timeout notifications and incoming data on the socket
-* @note maximum rate of read events is limited according to @a lds_maxAnnounceCap
+* @note maximum rate of read events is limited according to @a lpd_maxAnnounceCap
 * @see DoS */
 static void event_callback( int s UNUSED, short type, void* ignore UNUSED )
@@ -600 +600 @@
     assert( tr_isSession( session ) );
 
-    /* do not allow announces to be processed if LDS is disabled */
-    if( !tr_sessionAllowsLDS( session ) )
+    /* do not allow announces to be processed if LPD is disabled */
+    if( !tr_sessionAllowsLPD( session ) )
         return;
 
@@ -610 +610 @@
 
         /* be paranoid enough about zero terminating the foreign string */
-        char foreignMsg[lds_maxDatagramLength + 1] = { };
+        char foreignMsg[lpd_maxDatagramLength + 1] = { };
 
         /* process local announcement from foreign peer */
-        int res = recvfrom( lds_socket, foreignMsg, lds_maxDatagramLength,
+        int res = recvfrom( lpd_socket, foreignMsg, lpd_maxDatagramLength,
             0, (struct sockaddr*) &foreignAddr, (socklen_t*) &addrLen );
 
         /* besides, do we get flooded? then bail out! */
-        if( --lds_unsolicitedMsgCounter < 0 )
+        if( --lpd_unsolicitedMsgCounter < 0 )
             return;
 
-        if( res > 0 && res <= lds_maxDatagramLength )
+        if( res > 0 && res <= lpd_maxDatagramLength )
         {
             struct tr_pex foreignPeer =
@@ -629 +629 @@
 
             foreignPeer.addr.addr.addr4 = foreignAddr.sin_addr;
-            if( tr_ldsConsiderAnnounce( &foreignPeer, foreignMsg ) != 0 )
+            if( tr_lpdConsiderAnnounce( &foreignPeer, foreignMsg ) != 0 )
                 return; /* OK so far, no log message */
         }
 
-        tr_ndbg( "LDS", "Discarded invalid multicast message" );
-    }
-}
-
+        tr_ndbg( "LPD", "Discarded invalid multicast message" );
+    }
+}
+

trunk/libtransmission/tr-lpd.h

@@ -21 +21 @@
 */
 
-#ifndef _TR_LDS_H
-#define _TR_LDS_H
+#ifndef _TR_LPD_H
+#define _TR_LPD_H
 
 /* $Id$ */
 
-int tr_ldsInit( tr_session*, tr_address* );
-void tr_ldsUninit( tr_session* );
+int tr_lpdInit( tr_session*, tr_address* );
+void tr_lpdUninit( tr_session* );
 
-tr_bool tr_ldsEnabled( const tr_session* );
+tr_bool tr_lpdEnabled( const tr_session* );
 
-tr_bool tr_ldsSendAnnounce( const tr_torrent* );
+tr_bool tr_lpdSendAnnounce( const tr_torrent* );
 
-int tr_ldsAnnounceMore( const time_t, const int );
+int tr_lpdAnnounceMore( const time_t, const int );
 
 /**
@@ -54 +54 @@
 * @} */
 
-#endif /* _TR_LDS_H */
+#endif /* _TR_LPD_H */
 

trunk/libtransmission/transmission.h

@@ -165 +165 @@
 #define TR_PREFS_KEY_BLOCKLIST_ENABLED          "blocklist-enabled"
 #define TR_PREFS_KEY_DHT_ENABLED                "dht-enabled"
-#define TR_PREFS_KEY_LDS_ENABLED                "lds-enabled"
+#define TR_PREFS_KEY_LPD_ENABLED                "lpd-enabled"
 #define TR_PREFS_KEY_DOWNLOAD_DIR               "download-dir"
 #define TR_PREFS_KEY_ENCRYPTION                 "encryption"
@@ -593 +593 @@
 void               tr_sessionSetDHTEnabled( tr_session * session, tr_bool );
 
-tr_bool            tr_sessionIsLDSEnabled( const tr_session * session );
-
-void               tr_sessionSetLDSEnabled( tr_session * session, tr_bool enabled );
+tr_bool            tr_sessionIsLPDEnabled( const tr_session * session );
+
+void               tr_sessionSetLPDEnabled( tr_session * session, tr_bool enabled );
 
 void               tr_sessionSetLazyBitfieldEnabled( tr_session * session,
@@ -1654 +1654 @@
 {
     TR_PEER_FROM_INCOMING  = 0, /* connections made to the listening port */
-    TR_PEER_FROM_LDS,           /* peers discovered by local announcements */
+    TR_PEER_FROM_LPD,           /* peers discovered by local announcements */
     TR_PEER_FROM_TRACKER,       /* peers received from a tracker */
     TR_PEER_FROM_DHT,           /* peers learnt from the DHT */

trunk/qt/prefs-dialog.cc

@@ -478 +478 @@
     hig->addWideControl( w = checkBoxNew( tr( "Use &DHT to find more peers" ), Prefs::DHT_ENABLED ) );
     w->setToolTip( tr( "DHT is a tool for finding peers without a tracker." ) );
-    hig->addWideControl( w = checkBoxNew( tr( "Use &LDS to find local peers" ), Prefs::LDS_ENABLED ) );
-    w->setToolTip( tr( "LDS is a tool for finding peers on your local network." ) );
+    hig->addWideControl( w = checkBoxNew( tr( "Use &Local Peer Discovery to find more peers" ), Prefs::LPD_ENABLED ) );
+    w->setToolTip( tr( "LPD is a tool for finding peers on your local network." ) );
 
     hig->finish( );

trunk/qt/prefs.cc

@@ -94 +94 @@
     { PEX_ENABLED, TR_PREFS_KEY_PEX_ENABLED, QVariant::Bool },
     { DHT_ENABLED, TR_PREFS_KEY_DHT_ENABLED, QVariant::Bool },
-    { LDS_ENABLED, TR_PREFS_KEY_LDS_ENABLED, QVariant::Bool },
+    { LPD_ENABLED, TR_PREFS_KEY_LPD_ENABLED, QVariant::Bool },
     { PORT_FORWARDING, TR_PREFS_KEY_PORT_FORWARDING, QVariant::Bool },
     { PROXY_AUTH_ENABLED, TR_PREFS_KEY_PROXY_AUTH_ENABLED, QVariant::Bool },

trunk/qt/prefs.h

@@ -98 +98 @@
             PEX_ENABLED,
             DHT_ENABLED,
-            LDS_ENABLED,
+            LPD_ENABLED,
             PORT_FORWARDING,
             PROXY_AUTH_ENABLED,

trunk/qt/session.cc

@@ -142 +142 @@
         case Prefs :: INCOMPLETE_DIR:
         case Prefs :: INCOMPLETE_DIR_ENABLED:
-        case Prefs :: LDS_ENABLED:
+        case Prefs :: LPD_ENABLED:
         case Prefs :: PEER_LIMIT_GLOBAL:
         case Prefs :: PEER_LIMIT_TORRENT: