Ticket #252: ipv6-phase-1.diff

File ipv6-phase-1.diff, 43.0 KB (added by jhujhiti, 12 years ago)

Phase 1, mark 2

  • libtransmission/peer-io.c

     
    1919#ifdef WIN32
    2020 #include <winsock2.h>
    2121#else
    22  #include <netinet/in.h> /* struct in_addr */
    2322 #include <arpa/inet.h> /* inet_ntoa */
    2423#endif
    2524
     
    9796
    9897    tr_session             * session;
    9998
    100     struct in_addr           in_addr;
     99    tr_address               addr;
    101100    struct tr_iobuf        * iobuf;
    102101    tr_list                * output_datatypes; /* struct tr_datatype */
    103102
     
    238237}
    239238
    240239static tr_peerIo*
    241 tr_peerIoNew( tr_session *          session,
    242               const struct in_addr * in_addr,
    243               uint16_t               port,
    244               const uint8_t *        torrentHash,
    245               int                    isIncoming,
    246               int                    socket )
     240tr_peerIoNew( tr_session       * session,
     241              const tr_address * addr,
     242              uint16_t           port,
     243              const uint8_t *    torrentHash,
     244              int                isIncoming,
     245              int                socket )
    247246{
    248247    tr_peerIo * io;
    249248
     
    254253    io->magicNumber = MAGIC_NUMBER;
    255254    io->crypto = tr_cryptoNew( torrentHash, isIncoming );
    256255    io->session = session;
    257     io->in_addr = *in_addr;
     256    io->addr = *addr;
    258257    io->port = port;
    259258    io->socket = socket;
    260259    io->isIncoming = isIncoming != 0;
     
    266265}
    267266
    268267tr_peerIo*
    269 tr_peerIoNewIncoming( tr_session *          session,
    270                       const struct in_addr * in_addr,
    271                       uint16_t               port,
    272                       int                    socket )
     268tr_peerIoNewIncoming( tr_session       * session,
     269                      const tr_address * addr,
     270                      uint16_t           port,
     271                      int                socket )
    273272{
    274273    assert( session );
    275     assert( in_addr );
     274    assert( addr );
    276275    assert( socket >= 0 );
    277276
    278     return tr_peerIoNew( session, in_addr, port,
     277    return tr_peerIoNew( session, addr, port,
    279278                         NULL, 1,
    280279                         socket );
    281280}
    282281
    283282tr_peerIo*
    284 tr_peerIoNewOutgoing( tr_session *          session,
    285                       const struct in_addr * in_addr,
    286                       int                    port,
    287                       const uint8_t *        torrentHash )
     283tr_peerIoNewOutgoing( tr_session       * session,
     284                      const tr_address * addr,
     285                      int                port,
     286                      const uint8_t    * torrentHash )
    288287{
    289288    int socket;
    290289
    291290    assert( session );
    292     assert( in_addr );
     291    assert( addr );
    293292    assert( port >= 0 );
    294293    assert( torrentHash );
    295294
    296     socket = tr_netOpenTCP( session, in_addr, port );
     295    socket = tr_netOpenTCP( session, addr, port );
    297296
    298297    return socket < 0
    299298           ? NULL
    300            : tr_peerIoNew( session, in_addr, port, torrentHash, 0, socket );
     299           : tr_peerIoNew( session, addr, port, torrentHash, 0, socket );
    301300}
    302301
    303302static void
     
    336335    return io->session;
    337336}
    338337
    339 const struct in_addr*
     338const tr_address*
    340339tr_peerIoGetAddress( const tr_peerIo * io,
    341                            uint16_t * port )
     340                           uint16_t  * port )
    342341{
    343342    assert( isPeerIo( io ) );
    344343
    345344    if( port )
    346345        *port = io->port;
    347346
    348     return &io->in_addr;
     347    return &io->addr;
    349348}
    350349
    351350const char*
    352 tr_peerIoAddrStr( const struct in_addr * addr,
    353                   uint16_t               port )
     351tr_peerIoAddrStr( const tr_address * addr,
     352                  uint16_t           port )
    354353{
    355354    static char buf[512];
    356355
    357     tr_snprintf( buf, sizeof( buf ), "%s:%u", inet_ntoa( *addr ),
    358                 ntohs( port ) );
     356    if( addr->type == TR_AF_INET )
     357        tr_snprintf( buf, sizeof( buf ), "%s:%u", tr_ntop_non_ts( addr ),
     358                    ntohs( port ) );
     359    else
     360        tr_snprintf( buf, sizeof( buf ), "[%s]:%u", tr_ntop_non_ts( addr ),
     361                    ntohs( port ) );
    359362    return buf;
    360363}
    361364
    362365const char*
    363366tr_peerIoGetAddrStr( const tr_peerIo * io )
    364367{
    365     return tr_peerIoAddrStr( &io->in_addr, io->port );
     368    return tr_peerIoAddrStr( &io->addr, io->port );
    366369}
    367370
    368371static void
     
    401404    if( io->socket >= 0 )
    402405        tr_netClose( io->socket );
    403406
    404     io->socket = tr_netOpenTCP( io->session, &io->in_addr, io->port );
     407    io->socket = tr_netOpenTCP( io->session, &io->addr, io->port );
    405408
    406409    if( io->socket >= 0 )
    407410    {
  • libtransmission/peer-msgs.c

     
    17591759    diffs->elements[diffs->elementCount++] = *pex;
    17601760}
    17611761
     1762/* TODO: ipv6 pex */
    17621763static void
    17631764sendPex( tr_peermsgs * msgs )
    17641765{
     
    18061807            /* "added" */
    18071808            tmp = walk = tr_new( uint8_t, diffs.addedCount * 6 );
    18081809            for( i = 0; i < diffs.addedCount; ++i ) {
    1809                 memcpy( walk, &diffs.added[i].in_addr, 4 ); walk += 4;
     1810                memcpy( walk, &diffs.added[i].addr.addr, 4 ); walk += 4;
    18101811                memcpy( walk, &diffs.added[i].port, 2 ); walk += 2;
    18111812            }
    18121813            assert( ( walk - tmp ) == diffs.addedCount * 6 );
     
    18241825            /* "dropped" */
    18251826            tmp = walk = tr_new( uint8_t, diffs.droppedCount * 6 );
    18261827            for( i = 0; i < diffs.droppedCount; ++i ) {
    1827                 memcpy( walk, &diffs.dropped[i].in_addr, 4 ); walk += 4;
     1828                memcpy( walk, &diffs.dropped[i].addr.addr, 4 ); walk += 4;
    18281829                memcpy( walk, &diffs.dropped[i].port, 2 ); walk += 2;
    18291830            }
    18301831            assert( ( walk - tmp ) == diffs.droppedCount * 6 );
  • libtransmission/peer-io.h

     
    2121***
    2222**/
    2323
    24 struct in_addr;
    2524struct evbuffer;
    2625struct tr_bandwidth;
    2726struct tr_crypto;
     
    3231***
    3332**/
    3433
    35 tr_peerIo*           tr_peerIoNewOutgoing( struct tr_handle     * session,
    36                                            const struct in_addr * addr,
    37                                            int                    port,
    38                                            const  uint8_t       * torrentHash );
     34tr_peerIo*           tr_peerIoNewOutgoing( struct tr_handle * session,
     35                                           const tr_address * addr,
     36                                           int                port,
     37                                           const  uint8_t   * torrentHash );
    3938
    40 tr_peerIo*           tr_peerIoNewIncoming( struct tr_handle     * session,
    41                                            const struct in_addr * addr,
    42                                            uint16_t               port,
    43                                            int                    socket );
     39tr_peerIo*           tr_peerIoNewIncoming( struct tr_handle * session,
     40                                           const tr_address * addr,
     41                                           uint16_t           port,
     42                                           int                socket );
    4443
    4544void                 tr_peerIoFree( tr_peerIo * io );
    4645
     
    5958***
    6059**/
    6160
    62 const char*          tr_peerIoAddrStr( const struct in_addr * addr,
    63                                        uint16_t               port );
     61const char*          tr_peerIoAddrStr( const tr_address * addr,
     62                                       uint16_t           port );
    6463
    6564const char*          tr_peerIoGetAddrStr( const tr_peerIo * io );
    6665
    67 const struct in_addr*tr_peerIoGetAddress( const tr_peerIo * io,
     66const tr_address *   tr_peerIoGetAddress( const tr_peerIo * io,
    6867                                                uint16_t * port );
    6968
    7069const uint8_t*       tr_peerIoGetTorrentHash( tr_peerIo * io );
  • libtransmission/peer-mgr.c

     
    9595 * into this list for new ones. */
    9696struct peer_atom
    9797{
    98     uint8_t           from;
    99     uint8_t           flags; /* these match the added_f flags */
    100     uint8_t           myflags; /* flags that aren't defined in added_f */
    101     uint16_t          port;
    102     uint16_t          numFails;
    103     struct in_addr    addr;
    104     time_t            time; /* when the peer's connection status last changed */
    105     time_t            piece_data_time;
     98    uint8_t    from;
     99    uint8_t    flags; /* these match the added_f flags */
     100    uint8_t    myflags; /* flags that aren't defined in added_f */
     101    uint16_t   port;
     102    uint16_t   numFails;
     103    tr_address addr;
     104    time_t     time; /* when the peer's connection status last changed */
     105    time_t     piece_data_time;
    106106};
    107107
    108108typedef struct
     
    184184**/
    185185
    186186static int
    187 compareAddresses( const struct in_addr * a,
    188                   const struct in_addr * b )
    189 {
    190     if( a->s_addr != b->s_addr )
    191         return a->s_addr < b->s_addr ? -1 : 1;
    192 
    193     return 0;
    194 }
    195 
    196 static int
    197187handshakeCompareToAddr( const void * va,
    198188                        const void * vb )
    199189{
    200190    const tr_handshake * a = va;
    201191
    202     return compareAddresses( tr_handshakeGetAddr( a, NULL ), vb );
     192    return tr_compareAddresses( tr_handshakeGetAddr( a, NULL ), vb );
    203193}
    204194
    205195static int
     
    210200}
    211201
    212202static tr_handshake*
    213 getExistingHandshake( tr_ptrArray *          handshakes,
    214                       const struct in_addr * in_addr )
     203getExistingHandshake( tr_ptrArray      * handshakes,
     204                      const tr_address * addr )
    215205{
    216206    return tr_ptrArrayFindSorted( handshakes,
    217                                   in_addr,
     207                                  addr,
    218208                                  handshakeCompareToAddr );
    219209}
    220210
     
    224214{
    225215    const struct peer_atom * a = va;
    226216
    227     return compareAddresses( &a->addr, vb );
     217    return tr_compareAddresses( &a->addr, vb );
    228218}
    229219
    230220static int
     
    276266    const tr_peer * a = va;
    277267    const tr_peer * b = vb;
    278268
    279     return compareAddresses( &a->in_addr, &b->in_addr );
     269    return tr_compareAddresses( &a->addr, &b->addr );
    280270}
    281271
    282272static int
     
    285275{
    286276    const tr_peer * a = va;
    287277
    288     return compareAddresses( &a->in_addr, vb );
     278    return tr_compareAddresses( &a->addr, vb );
    289279}
    290280
    291281static tr_peer*
    292 getExistingPeer( Torrent *              torrent,
    293                  const struct in_addr * in_addr )
     282getExistingPeer( Torrent          * torrent,
     283                 const tr_address * addr )
    294284{
    295285    assert( torrentIsLocked( torrent ) );
    296     assert( in_addr );
     286    assert( addr );
    297287
    298288    return tr_ptrArrayFindSorted( torrent->peers,
    299                                   in_addr,
     289                                  addr,
    300290                                  peerCompareToAddr );
    301291}
    302292
    303293static struct peer_atom*
    304 getExistingAtom( const                  Torrent * t,
    305                  const struct in_addr * addr )
     294getExistingAtom( const Torrent    * t,
     295                 const tr_address * addr )
    306296{
    307297    assert( torrentIsLocked( t ) );
    308298    return tr_ptrArrayFindSorted( t->pool, addr, comparePeerAtomToAddress );
    309299}
    310300
    311301static int
    312 peerIsInUse( const Torrent *        ct,
    313              const struct in_addr * addr )
     302peerIsInUse( const Torrent    * ct,
     303             const tr_address * addr )
    314304{
    315305    Torrent * t = (Torrent*) ct;
    316306
     
    322312}
    323313
    324314static tr_peer*
    325 peerConstructor( tr_torrent * tor, const struct in_addr * in_addr )
     315peerConstructor( tr_torrent * tor, const tr_address * addr )
    326316{
    327317    tr_peer * p;
    328318
    329319    p = tr_new0( tr_peer, 1 );
    330     memcpy( &p->in_addr, in_addr, sizeof( struct in_addr ) );
     320    memcpy( &p->addr, addr, sizeof( tr_address ) );
    331321    p->bandwidth = tr_bandwidthNew( tor->session, tor->bandwidth );
    332322    return p;
    333323}
    334324
    335325static tr_peer*
    336 getPeer( Torrent *              torrent,
    337          const struct in_addr * in_addr )
     326getPeer( Torrent          * torrent,
     327         const tr_address * addr )
    338328{
    339329    tr_peer * peer;
    340330
    341331    assert( torrentIsLocked( torrent ) );
    342332
    343     peer = getExistingPeer( torrent, in_addr );
     333    peer = getExistingPeer( torrent, addr );
    344334
    345335    if( peer == NULL )
    346336    {
    347         peer = peerConstructor( torrent->tor, in_addr );
     337        peer = peerConstructor( torrent->tor, addr );
    348338        tr_ptrArrayInsertSorted( torrent->peers, peer, peerCompare );
    349339    }
    350340
     
    380370
    381371    assert( torrentIsLocked( t ) );
    382372
    383     atom = getExistingAtom( t, &peer->in_addr );
     373    atom = getExistingAtom( t, &peer->addr );
    384374    assert( atom );
    385375    atom->time = time( NULL );
    386376
     
    530520***/
    531521
    532522int
    533 tr_peerMgrPeerIsSeed( const tr_peerMgr *     mgr,
    534                       const uint8_t *        torrentHash,
    535                       const struct in_addr * addr )
     523tr_peerMgrPeerIsSeed( const tr_peerMgr * mgr,
     524                      const uint8_t    * torrentHash,
     525                      const tr_address * addr )
    536526{
    537527    int                      isSeed = FALSE;
    538528    const Torrent *          t = NULL;
     
    905895           tr_peer * peer )
    906896{
    907897    tordbg( t, "increasing peer %s strike count to %d",
    908             tr_peerIoAddrStr( &peer->in_addr,
     898            tr_peerIoAddrStr( &peer->addr,
    909899                              peer->port ), peer->strikes + 1 );
    910900
    911901    if( ++peer->strikes >= MAX_BAD_PIECES_PER_PEER )
    912902    {
    913         struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     903        struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    914904        atom->myflags |= MYFLAG_BANNED;
    915905        peer->doPurge = 1;
    916906        tordbg( t, "banning peer %s",
     
    975965
    976966            /* update our atom */
    977967            if( peer ) {
    978                 struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
     968                struct peer_atom * a = getExistingAtom( t, &peer->addr );
    979969                a->piece_data_time = now;
    980970            }
    981971
     
    1004994
    1005995            /* update our atom */
    1006996            if( peer ) {
    1007                 struct peer_atom * a = getExistingAtom( t, &peer->in_addr );
     997                struct peer_atom * a = getExistingAtom( t, &peer->addr );
    1008998                a->piece_data_time = now;
    1009999            }
    10101000
     
    10151005        {
    10161006            if( peer )
    10171007            {
    1018                 struct peer_atom * atom = getExistingAtom( t,
    1019                                                            &peer->in_addr );
     1008                struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    10201009                const int          peerIsSeed = e->progress >= 1.0;
    10211010                if( peerIsSeed )
    10221011                {
     
    11111100}
    11121101
    11131102static void
    1114 ensureAtomExists( Torrent *              t,
    1115                   const struct in_addr * addr,
    1116                   uint16_t               port,
    1117                   uint8_t                flags,
    1118                   uint8_t                from )
     1103ensureAtomExists( Torrent          * t,
     1104                  const tr_address * addr,
     1105                  uint16_t           port,
     1106                  uint8_t            flags,
     1107                  uint8_t            from )
    11191108{
    11201109    if( getExistingAtom( t, addr ) == NULL )
    11211110    {
     
    11521141                   const uint8_t * peer_id,
    11531142                   void *          vmanager )
    11541143{
    1155     int                    ok = isConnected;
    1156     int                    success = FALSE;
    1157     uint16_t               port;
    1158     const struct in_addr * addr;
    1159     tr_peerMgr *           manager = (tr_peerMgr*) vmanager;
    1160     Torrent *              t;
    1161     tr_handshake *         ours;
     1144    int                ok = isConnected;
     1145    int                success = FALSE;
     1146    uint16_t           port;
     1147    const tr_address * addr;
     1148    tr_peerMgr *       manager = (tr_peerMgr*) vmanager;
     1149    Torrent *          t;
     1150    tr_handshake *     ours;
    11621151
    11631152    assert( io );
    11641153    assert( isConnected == 0 || isConnected == 1 );
     
    12531242}
    12541243
    12551244void
    1256 tr_peerMgrAddIncoming( tr_peerMgr *     manager,
    1257                        struct in_addr * addr,
    1258                        uint16_t         port,
    1259                        int              socket )
     1245tr_peerMgrAddIncoming( tr_peerMgr * manager,
     1246                       tr_address * addr,
     1247                       uint16_t     port,
     1248                       int          socket )
    12601249{
    12611250    managerLock( manager );
    12621251
    12631252    if( tr_sessionIsAddressBlocked( manager->session, addr ) )
    12641253    {
    12651254        tr_dbg( "Banned IP address \"%s\" tried to connect to us",
    1266                inet_ntoa( *addr ) );
     1255               tr_ntop_non_ts( addr ) );
    12671256        tr_netClose( socket );
    12681257    }
    12691258    else if( getExistingHandshake( manager->incomingHandshakes, addr ) )
     
    13001289    managerLock( manager );
    13011290
    13021291    t = getExistingTorrent( manager, torrentHash );
    1303     if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->in_addr ) )
    1304         ensureAtomExists( t, &pex->in_addr, pex->port, pex->flags, from );
     1292    if( !tr_sessionIsAddressBlocked( t->manager->session, &pex->addr ) )
     1293        ensureAtomExists( t, &pex->addr, pex->port, pex->flags, from );
    13051294
    13061295    managerUnlock( manager );
    13071296}
     
    13201309
    13211310    for( i = 0; i < n; ++i )
    13221311    {
    1323         memcpy( &pex[i].in_addr, walk, 4 ); walk += 4;
     1312        pex[i].addr.type = TR_AF_INET;
     1313        memcpy( &pex[i].addr.addr, walk, 4 ); walk += 4;
    13241314        memcpy( &pex[i].port, walk, 2 ); walk += 2;
    13251315        if( added_f && ( n == added_f_len ) )
    13261316            pex[i].flags = added_f[i];
     
    13571347                tordbg(
    13581348                    t,
    13591349                    "peer %s contributed to corrupt piece (%d); now has %d strikes",
    1360                     tr_peerIoAddrStr( &peer->in_addr, peer->port ),
     1350                    tr_peerIoAddrStr( &peer->addr, peer->port ),
    13611351                    pieceIndex, (int)peer->strikes + 1 );
    13621352                addStrike( t, peer );
    13631353            }
     
    13711361{
    13721362    const tr_pex * a = va;
    13731363    const tr_pex * b = vb;
    1374     int            i =
    1375         memcmp( &a->in_addr, &b->in_addr, sizeof( struct in_addr ) );
     1364    int            i = tr_compareAddresses( &a->addr, &b->addr );
    13761365
    13771366    if( i ) return i;
    13781367    if( a->port < b->port ) return -1;
     
    14201409        for( i = 0; i < peerCount; ++i, ++walk )
    14211410        {
    14221411            const tr_peer * peer = peers[i];
    1423             walk->in_addr = peer->in_addr;
     1412            walk->addr = peer->addr;
    14241413            walk->port = peer->port;
    14251414            walk->flags = 0;
    14261415            if( peerPrefersCrypto( peer ) ) walk->flags |= ADDED_F_ENCRYPTION_FLAG;
     
    16581647    for( i = 0; i < size; ++i )
    16591648    {
    16601649        const tr_peer *          peer = peers[i];
    1661         const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     1650        const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    16621651
    16631652        if( peer->io == NULL ) /* not connected */
    16641653            continue;
     
    17461735    {
    17471736        char *                   pch;
    17481737        const tr_peer *          peer = peers[i];
    1749         const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     1738        const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    17501739        tr_peer_stat *           stat = ret + i;
    17511740
    1752         tr_netNtop( &peer->in_addr, stat->addr, sizeof( stat->addr ) );
     1741        tr_ntop( &peer->addr, stat->addr, sizeof( stat->addr ) );
    17531742        tr_strlcpy( stat->client, ( peer->client ? peer->client : "" ),
    17541743                   sizeof( stat->client ) );
    17551744        stat->port               = ntohs( peer->port );
     
    19451934{
    19461935    const tr_torrent *       tor = t->tor;
    19471936    const time_t             now = time( NULL );
    1948     const struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     1937    const struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    19491938
    19501939    /* if it's marked for purging, close it */
    19511940    if( peer->doPurge )
     
    22072196        for( i = 0; i < nBad; ++i )
    22082197        {
    22092198            tr_peer *          peer = connections[i];
    2210             struct peer_atom * atom = getExistingAtom( t, &peer->in_addr );
     2199            struct peer_atom * atom = getExistingAtom( t, &peer->addr );
    22112200            if( peer->pieceDataActivityDate )
    22122201                atom->numFails = 0;
    22132202            else
  • libtransmission/peer-mgr.h

     
    2121
    2222#ifdef WIN32
    2323 #include <winsock2.h> /* struct in_addr */
    24 #else
    25  #include <netinet/in.h> /* struct in_addr */
    2624#endif
    2725
    28 struct in_addr;
     26#include "net.h"
     27
    2928struct tr_handle;
    3029struct tr_peer_stat;
    3130struct tr_torrent;
     
    4241
    4342typedef struct tr_pex
    4443{
    45     struct in_addr in_addr;
    46     uint16_t    port;
    47     uint8_t     flags;
     44    tr_address addr;
     45    uint16_t   port;
     46    uint8_t    flags;
    4847}
    4948tr_pex;
    5049
     
    5453
    5554void tr_peerMgrFree( tr_peerMgr * manager );
    5655
    57 int tr_peerMgrPeerIsSeed( const tr_peerMgr      * mgr,
    58                           const uint8_t         * torrentHash,
    59                           const struct in_addr  * addr );
     56int tr_peerMgrPeerIsSeed( const tr_peerMgr  * mgr,
     57                          const uint8_t     * torrentHash,
     58                          const tr_address  * addr );
    6059
    61 void tr_peerMgrAddIncoming( tr_peerMgr     * manager,
    62                             struct in_addr * addr,
    63                             uint16_t         port,
    64                             int              socket );
     60void tr_peerMgrAddIncoming( tr_peerMgr * manager,
     61                            tr_address * addr,
     62                            uint16_t     port,
     63                            int          socket );
    6564
    6665tr_pex * tr_peerMgrCompactToPex( const void    * compact,
    6766                                 size_t          compactLen,
  • libtransmission/blocklist.c

     
    3131#include "transmission.h"
    3232#include "platform.h"
    3333#include "blocklist.h"
    34 #include "net.h" /* tr_netResolve() */
     34#include "net.h"
    3535#include "utils.h"
    3636
    3737/***
     
    198198}
    199199
    200200int
    201 _tr_blocklistHasAddress( tr_blocklist *        b,
    202                          const struct in_addr * addr )
     201_tr_blocklistHasAddress( tr_blocklist     * b,
     202                         const tr_address * addr )
    203203{
    204204    uint32_t                   needle;
    205205    const struct tr_ip_range * range;
     
    211211    if( !b->rules )
    212212        return 0;
    213213
    214     needle = ntohl( addr->s_addr );
     214    needle = ntohl( addr->addr.addr4.s_addr );
    215215
    216216    range = bsearch( &needle,
    217217                     b->rules,
     
    259259    {
    260260        char *             rangeBegin;
    261261        char *             rangeEnd;
    262         struct in_addr     in_addr;
     262        tr_address         addr;
    263263        struct tr_ip_range range;
    264264
    265265        rangeBegin = strrchr( line, ':' );
     
    270270        if( !rangeEnd ){ free( line ); continue; }
    271271        *rangeEnd++ = '\0';
    272272
    273         if( tr_netResolve( rangeBegin, &in_addr ) )
     273        if( !tr_pton( rangeBegin, &addr ) )
    274274            tr_err( "blocklist skipped invalid address [%s]\n", rangeBegin );
    275         range.begin = ntohl( in_addr.s_addr );
     275        range.begin = ntohl( addr.addr.addr4.s_addr );
    276276
    277         if( tr_netResolve( rangeEnd, &in_addr ) )
     277        if( !tr_pton( rangeEnd, &addr ) )
    278278            tr_err( "blocklist skipped invalid address [%s]\n", rangeEnd );
    279         range.end = ntohl( in_addr.s_addr );
     279        range.end = ntohl( addr.addr.addr4.s_addr );
    280280
    281281        free( line );
    282282
  • libtransmission/blocklist.h

     
    1717#ifndef TR_BLOCKLIST_H
    1818#define TR_BLOCKLIST_H
    1919
    20 struct in_addr;
     20#include "net.h" /* NEW INCLDUE */
     21
    2122typedef struct tr_blocklist tr_blocklist;
    2223
    2324tr_blocklist* _tr_blocklistNew( const char * filename,
     
    3637void          _tr_blocklistSetEnabled(             tr_blocklist *,
    3738                                               int isEnabled );
    3839
    39 int           _tr_blocklistHasAddress(
    40               tr_blocklist *,
    41     const struct
    42     in_addr * addr );
     40int           _tr_blocklistHasAddress( tr_blocklist *,
     41                                       const tr_address * addr );
    4342
    4443int           _tr_blocklistSetContent(
    4544                 tr_blocklist *,
  • libtransmission/port-forwarding.c

     
    114114    {
    115115        int socket;
    116116        errno = 0;
    117         socket = tr_netBindTCP( s->publicPort );
     117        /* TODO: this is where we want to listen on another socket */
     118        socket = tr_netBindTCP( &tr_inaddr_any, s->publicPort );
    118119        if( socket >= 0 )
    119120        {
    120121            tr_ninf( getKey( ),
     
    138139
    139140    for( ; ; ) /* check for new incoming peer connections */
    140141    {
    141         int            socket;
    142         uint16_t       port;
    143         struct in_addr addr;
     142        int        socket;
     143        uint16_t   port;
     144        tr_address addr;
    144145
    145146        if( s->bindSocket < 0 )
    146147            break;
  • libtransmission/handshake.c

     
    11961196    return handshake->io;
    11971197}
    11981198
    1199 const struct in_addr *
     1199const tr_address *
    12001200tr_handshakeGetAddr( const struct tr_handshake * handshake,
    12011201                                                 uint16_t * port )
    12021202{
  • libtransmission/fdlimit.c

     
    471471}
    472472
    473473int
    474 tr_fdSocketAccept( int              b,
    475                    struct in_addr * addr,
    476                    tr_port_t *      port )
     474tr_fdSocketAccept( int          b,
     475                   tr_address * addr,
     476                   tr_port_t  * port )
    477477{
    478     int                s = -1;
    479     unsigned int       len;
    480     struct sockaddr_in sock;
     478    int                     s = -1;
     479    unsigned int            len;
     480    struct sockaddr_storage sock;
    481481
    482482    assert( addr );
    483483    assert( port );
     
    485485    tr_lockLock( gFd->lock );
    486486    if( gFd->socketCount < getSocketMax( gFd ) )
    487487    {
    488         len = sizeof( sock );
     488        len = sizeof( struct sockaddr );
    489489        s = accept( b, (struct sockaddr *) &sock, &len );
    490490    }
    491491    if( s > -1 )
    492492    {
    493         *addr = sock.sin_addr;
    494         *port = sock.sin_port;
     493        /* "The ss_family field of the sockaddr_storage structure will always
     494         * align with the family field of any protocol-specific structure." */
     495        if( sock.ss_family == AF_INET )
     496        {
     497            struct sockaddr_in * sock4 = (struct sockaddr_in *)&sock;
     498            addr->type = TR_AF_INET;
     499            addr->addr.addr4.s_addr = sock4->sin_addr.s_addr;
     500            *port = sock4->sin_port;
     501        }
     502        else
     503        {
     504            struct sockaddr_in6 * sock6 = (struct sockaddr_in6 *)&sock;
     505            addr->type = TR_AF_INET6;
     506            memcpy( &addr->addr, &sock6->sin6_addr,
     507                   sizeof( struct sockaddr_in6 ) );
     508            *port = sock6->sin6_port;
     509        }
    495510        ++gFd->socketCount;
    496511    }
    497512    tr_lockUnlock( gFd->lock );
  • libtransmission/handshake.h

     
    1919
    2020#include "transmission.h"
    2121
    22 struct in_addr;
    2322struct tr_peerIo;
    2423typedef struct tr_handshake tr_handshake;
    2524
     
    3534                                        handshakeDoneCB    doneCB,
    3635                                        void *             doneUserData );
    3736
    38 const struct in_addr * tr_handshakeGetAddr(
     37const tr_address * tr_handshakeGetAddr(
    3938    const struct tr_handshake * handshake,
    4039                                uint16_t
    4140    *                           setme_port );
  • libtransmission/fdlimit.h

     
    8787 **********************************************************************/
    8888int      tr_fdSocketCreate( int type );
    8989
    90 int      tr_fdSocketAccept( int              b,
    91                             struct in_addr * addr,
    92                             tr_port_t *      port );
     90int      tr_fdSocketAccept( int          b,
     91                            tr_address * addr,
     92                            tr_port_t  * port );
    9393
    9494void     tr_fdSocketClose( int s );
    9595
  • libtransmission/peer-mgr-private.h

     
    2121
    2222#ifdef WIN32
    2323 #include <winsock2.h> /* struct in_addr */
    24 #else
    25  #include <netinet/in.h> /* struct in_addr */
    2624#endif
    2725
    2826#include "publish.h" /* tr_publisher_tag */
     
    5250
    5351    uint8_t                  encryption_preference;
    5452    uint16_t                 port;
    55     struct in_addr           in_addr;
     53    tr_address               addr;
    5654    struct tr_peerIo       * io;
    5755
    5856    struct tr_bitfield     * blame;
  • libtransmission/transmission.h

     
    4949 #define PRIu32 "lu"
    5050#endif
    5151#include <time.h> /* time_t */
     52#include <netinet/in.h> /* INET6_ADDRSTRLEN */
    5253
    5354#define SHA_DIGEST_LENGTH 20
    5455
     
    10611062    uint8_t      from;
    10621063    uint16_t     port;
    10631064
    1064     char         addr[16];
     1065    char         addr[INET6_ADDRSTRLEN];
    10651066    char         client[80];
    10661067    char         flagStr[32];
    10671068
  • libtransmission/resume.c

     
    6161****
    6262***/
    6363
     64/* TODO: fast resume is done with pex */
    6465static void
    6566savePeers( tr_benc *          dict,
    6667           const tr_torrent * tor )
  • libtransmission/session.c

     
    799799}
    800800
    801801int
    802 tr_sessionIsAddressBlocked( const tr_session *     session,
    803                             const struct in_addr * addr )
     802tr_sessionIsAddressBlocked( const tr_session * session,
     803                            const tr_address * addr )
    804804{
    805805    tr_list * l;
    806806
  • libtransmission/net.c

     
    4747#include "platform.h"
    4848#include "utils.h"
    4949
     50const tr_address tr_in6addr_any = { TR_AF_INET6, { IN6ADDR_ANY_INIT } };
     51const tr_address tr_inaddr_any = { TR_AF_INET,
     52    { { { { INADDR_ANY, 0x00, 0x00, 0x00 } } } } };
    5053
    5154void
    5255tr_netInit( void )
     
    6366    }
    6467}
    6568
    66 /***********************************************************************
    67  * DNS resolution
    68  *
    69  * Synchronous "resolution": only works with character strings
    70  * representing numbers expressed in the Internet standard `.' notation.
    71  * Returns a non-zero value if an error occurs.
    72  **********************************************************************/
     69const char *
     70tr_ntop( const tr_address * src,
     71         char * dst,
     72         int size )
     73{
     74    if( src->type == TR_AF_INET )
     75        return inet_ntop( AF_INET, &src->addr, dst, size );
     76    else
     77        return inet_ntop( AF_INET6, &src->addr, dst, size );
     78}
     79
     80/*
     81 * Non-threadsafe version of tr_ntop, which uses a static memory area for a buffer.
     82 * This function is suitable to be called from libTransmission's networking code,
     83 * which is single-threaded.
     84 */
     85const char *
     86tr_ntop_non_ts( const tr_address * src )
     87{
     88    static char buf[INET6_ADDRSTRLEN];
     89    return tr_ntop( src, buf, sizeof( buf ) );
     90}
     91
     92tr_address *
     93tr_pton( const char * src,
     94         tr_address * dst )
     95{
     96    int retval = inet_pton( AF_INET, src, &dst->addr );
     97    if( retval < 0 )
     98        return NULL;
     99    else if( retval == 0 )
     100        retval = inet_pton( AF_INET6, src, &dst->addr );
     101    else
     102    {
     103        dst->type = TR_AF_INET;
     104        return dst;
     105    }
     106   
     107    if( retval < 1 )
     108        return NULL;
     109    dst->type = TR_AF_INET6;
     110    return dst;
     111}
     112
     113/*
     114 * Compare two tr_address structures.
     115 * Returns:
     116 * <0 if a < b
     117 * >0 if a > b
     118 * 0  if a == b
     119 */
    73120int
    74 tr_netResolve( const char *     address,
    75                struct in_addr * addr )
     121tr_compareAddresses( const tr_address * a,
     122                     const tr_address * b)
    76123{
    77     addr->s_addr = inet_addr( address );
    78     return addr->s_addr == 0xFFFFFFFF;
     124    int retval;
     125    int addrlen;
     126    /* IPv6 addresses are always "greater than" IPv4 */
     127    if( a->type == TR_AF_INET && b->type == TR_AF_INET6 )
     128        return 1;
     129    if( a->type == TR_AF_INET6 && b->type == TR_AF_INET )
     130        return -1;
     131   
     132    if( a->type == TR_AF_INET )
     133        addrlen = sizeof( struct in_addr );
     134    else
     135        addrlen = sizeof( struct in6_addr );
     136   
     137    retval = memcmp( &a->addr, &b->addr, addrlen );
     138    if( retval == 0 )
     139        return 0;
     140   
     141    return retval;
    79142}
    80143
    81144/***********************************************************************
     
    136199#endif
    137200}
    138201
     202static void
     203setup_sockaddr( const tr_address        * addr,
     204                tr_port_t                 port,
     205                struct sockaddr_storage * sockaddr)
     206{
     207    struct sockaddr_in  sock4;
     208    struct sockaddr_in6 sock6;
     209    if( addr->type == TR_AF_INET )
     210    {
     211        memset( &sock4, 0, sizeof( sock4 ) );
     212        sock4.sin_family      = AF_INET;
     213        sock4.sin_addr.s_addr = addr->addr.addr4.s_addr;
     214        sock4.sin_port        = port;
     215        memcpy( sockaddr, &sock4, sizeof( sock4 ) );
     216    }
     217    else
     218    {
     219        memset( &sock6, 0, sizeof( sock6 ) );
     220        sock6.sin6_family = AF_INET6;
     221        sock6.sin6_port = port;
     222        memcpy( &sock6.sin6_addr, &addr->addr, sizeof( struct in6_addr ) );
     223        memcpy( sockaddr, &sock6, sizeof( sock6 ) );
     224    }
     225}
     226
    139227int
    140 tr_netOpenTCP( tr_session            * session,
    141                const struct in_addr  * addr,
    142                tr_port_t               port )
     228tr_netOpenTCP( tr_session        * session,
     229               const tr_address  * addr,
     230               tr_port_t           port )
    143231{
    144     int                s;
    145     struct sockaddr_in sock;
    146     const int          type = SOCK_STREAM;
     232    int                     s;
     233    struct sockaddr_storage sock;
     234    const int               type = SOCK_STREAM;
    147235
    148236    if( ( s = createSocket( type ) ) < 0 )
    149237        return -1;
    150238
    151239    setSndBuf( session, s );
    152240
    153     memset( &sock, 0, sizeof( sock ) );
    154     sock.sin_family      = AF_INET;
    155     sock.sin_addr.s_addr = addr->s_addr;
    156     sock.sin_port        = port;
     241    setup_sockaddr( addr, port, &sock );
    157242
    158243    if( ( connect( s, (struct sockaddr *) &sock,
    159                   sizeof( struct sockaddr_in ) ) < 0 )
     244                  sizeof( struct sockaddr ) ) < 0 )
    160245#ifdef WIN32
    161246      && ( sockerrno != WSAEWOULDBLOCK )
    162247#endif
     
    164249    {
    165250        tr_err( _(
    166251                   "Couldn't connect socket %d to %s, port %d (errno %d - %s)" ),
    167                s, inet_ntoa( *addr ), port,
     252               s, tr_ntop_non_ts( addr ), port,
    168253               sockerrno, tr_strerror( sockerrno ) );
    169254        tr_netClose( s );
    170255        s = -1;
     
    177262}
    178263
    179264int
    180 tr_netBindTCP( int port )
     265tr_netBindTCP( const tr_address * addr,
     266               int port )
    181267{
    182     int                s;
    183     struct sockaddr_in sock;
    184     const int          type = SOCK_STREAM;
     268    int                     s;
     269    struct sockaddr_storage sock;
     270    const int               type = SOCK_STREAM;
    185271
    186272#if defined( SO_REUSEADDR ) || defined( SO_REUSEPORT )
    187273    int                optval;
     
    194280    optval = 1;
    195281    setsockopt( s, SOL_SOCKET, SO_REUSEADDR, (char*)&optval, sizeof( optval ) );
    196282#endif
     283   
     284    setup_sockaddr( addr, htons( port ), &sock );
    197285
    198     memset( &sock, 0, sizeof( sock ) );
    199     sock.sin_family      = AF_INET;
    200     sock.sin_addr.s_addr = INADDR_ANY;
    201     sock.sin_port        = htons( port );
    202 
    203286    if( bind( s, (struct sockaddr *) &sock,
    204              sizeof( struct sockaddr_in ) ) )
     287             sizeof( struct sockaddr ) ) )
    205288    {
    206         tr_err( _( "Couldn't bind port %d: %s" ), port,
    207                tr_strerror( sockerrno ) );
     289        tr_err( _( "Couldn't bind port %d on %s: %s" ), port,
     290               tr_ntop_non_ts( addr ), tr_strerror( sockerrno ) );
    208291        tr_netClose( s );
    209292        return -1;
    210293    }
    211294
    212     tr_dbg(  "Bound socket %d to port %d", s, port );
     295    tr_dbg(  "Bound socket %d to port %d on %s", s, port,
     296           tr_ntop_non_ts( addr ) );
    213297    return s;
    214298}
    215299
    216300int
    217 tr_netAccept( tr_session      * session,
    218               int               b,
    219               struct in_addr * addr,
    220               tr_port_t       * port )
     301tr_netAccept( tr_session * session,
     302              int          b,
     303              tr_address * addr,
     304              tr_port_t  * port )
    221305{
    222306    int fd = makeSocketNonBlocking( tr_fdSocketAccept( b, addr, port ) );
    223307    setSndBuf( session, fd );
     
    229313{
    230314    tr_fdSocketClose( s );
    231315}
    232 
    233 void
    234 tr_netNtop( const struct in_addr * addr,
    235             char *                 buf,
    236             int                    len )
    237 {
    238     const uint8_t * cast;
    239 
    240     cast = (const uint8_t *)addr;
    241     tr_snprintf( buf, len, "%hhu.%hhu.%hhu.%hhu",
    242                  cast[0], cast[1], cast[2], cast[3] );
    243 }
    244 
  • libtransmission/session.h

     
    3939 #endif
    4040#endif
    4141
     42#include "net.h"
    4243
     44
    4345typedef enum { TR_NET_OK, TR_NET_ERROR, TR_NET_WAIT } tr_tristate_t;
    4446
    4547uint8_t*       tr_peerIdNew( void );
     
    121123                                       const char * hashString,
    122124                                       const char * filename );
    123125
    124 struct in_addr;
     126int          tr_sessionIsAddressBlocked( const tr_session * session,
     127                                         const tr_address * addr );
    125128
    126 int          tr_sessionIsAddressBlocked( const tr_session *     session,
    127                                          const struct in_addr * addr );
    128129
    129 
    130130void         tr_globalLock( tr_session * );
    131131
    132132void         tr_globalUnlock( tr_session * );
  • libtransmission/net.h

     
    6060 #define sockerrno errno
    6161#endif
    6262
    63 struct in_addr;
    64 struct sockaddr_in;
    6563struct tr_session;
    6664
    67 /***********************************************************************
    68  * DNS resolution
    69  **********************************************************************/
    70 int  tr_netResolve( const  char *,
    71                     struct in_addr * );
     65#define TR_AF_INET  0
     66#define TR_AF_INET6 1
    7267
     68typedef struct tr_address {
     69    unsigned short type : 1;
     70    union {
     71        /* The order here is important for tr_in{,6}addr_any initialization,
     72         * since we can't use C99 designated initializers */
     73        struct in6_addr addr6;
     74        struct in_addr  addr4;
     75    } addr;
     76} tr_address;
    7377
     78extern const tr_address tr_inaddr_any;
     79extern const tr_address tr_in6addr_any;
     80
     81const char *tr_ntop( const tr_address * src,
     82                     char * dst,
     83                     int size );
     84const char *tr_ntop_non_ts( const tr_address * src );
     85tr_address *tr_pton( const char * src,
     86                     tr_address * dst );
     87int tr_compareAddresses( const tr_address * a,
     88                         const tr_address * b);
     89
     90
    7491/***********************************************************************
    7592 * Sockets
    7693 **********************************************************************/
    77 int  tr_netOpenTCP( struct tr_handle     * session,
    78                     const struct in_addr * addr,
    79                     tr_port_t              port );
     94int  tr_netOpenTCP( struct tr_handle * session,
     95                    const tr_address * addr,
     96                    tr_port_t          port );
    8097
    81 int  tr_netBindTCP( int port );
     98int  tr_netBindTCP( const tr_address * addr,
     99                    int                port );
    82100
    83 int  tr_netAccept( struct tr_handle  * session,
    84                    int                 bound,
    85                    struct in_addr    * setme_addr,
    86                    tr_port_t         * setme_port );
     101int  tr_netAccept( struct tr_handle * session,
     102                   int                bound,
     103                   tr_address       * setme_addr,
     104                   tr_port_t        * setme_port );
    87105
    88106int  tr_netSetTOS( int s,
    89107                   int tos );
    90108
    91109void tr_netClose( int s );
    92110
    93 void tr_netNtop( const struct in_addr * addr,
    94                  char *                 buf,
    95                  int                    len );
    96 
    97111void tr_netInit( void );
    98112
    99113#endif /* _TR_NET_H_ */
  • libtransmission/tracker.c

     
    280280parseOldPeers( tr_benc * bePeers,
    281281               size_t *  byteCount )
    282282{
     283    /* TODO: wtf */
    283284    int       i;
    284285    uint8_t * compact, *walk;
    285286    const int peerCount = bePeers->val.l.count;
     
    290291
    291292    for( i = 0, walk = compact; i < peerCount; ++i )
    292293    {
    293         const char *   s;
    294         int64_t        itmp;
    295         struct in_addr addr;
    296         tr_port_t      port;
    297         tr_benc *      peer = &bePeers->val.l.vals[i];
     294        const char * s;
     295        int64_t      itmp;
     296        tr_address  addr;
     297        tr_port_t    port;
     298        tr_benc *    peer = &bePeers->val.l.vals[i];
    298299
    299         if( !tr_bencDictFindStr( peer, "ip",
    300                                  &s ) || tr_netResolve( s, &addr ) )
    301             continue;
     300        if( tr_bencDictFindStr( peer, "ip", &s ) )
     301        {
     302            if( tr_pton( s, &addr ) == NULL )
     303                continue;
     304            if( addr.type != TR_AF_INET )
     305                continue;
     306        }
    302307
    303         memcpy( walk, &addr, 4 );
     308        memcpy( walk, &addr.addr.addr4.s_addr, 4 );
    304309        walk += 4;
    305310
    306311        if( !tr_bencDictFindInt( peer, "port",
  • Transmission.xcodeproj/project.pbxproj

     
    22392239                                GCC_VERSION = 4.2;
    22402240                                GCC_WARN_ABOUT_MISSING_NEWLINE = NO;
    22412241                                GCC_WARN_ABOUT_RETURN_TYPE = NO;
     2242                                GCC_WARN_INITIALIZER_NOT_FULLY_BRACKETED = YES;
     2243                                GCC_WARN_PEDANTIC = NO;
    22422244                                GCC_WARN_PROTOTYPE_CONVERSION = NO;
    22432245                                GCC_WARN_SHADOW = NO;
    22442246                                GCC_WARN_SIGN_COMPARE = NO;