Changeset 10800


Ignore:
Timestamp:
Jun 19, 2010, 2:33:10 PM (12 years ago)
Author:
charles
Message:

(trunk) #3256 "libtransmission/publish.[ch] should be replaced" -- apply publish.diff for 2.10

Location:
trunk/libtransmission
Files:
2 deleted
12 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/Makefile.am

    r10798 r10800  
    4545    port-forwarding.c \
    4646    ptrarray.c \
    47     publish.c \
    4847    ratecontrol.c \
    4948    resume.c \
     
    9796    port-forwarding.h \
    9897    ptrarray.h \
    99     publish.h \
    10098    ratecontrol.h \
    10199    resume.h \
  • trunk/libtransmission/announcer.c

    r10741 r10800  
    2222#include "net.h"
    2323#include "ptrarray.h"
    24 #include "publish.h"
    2524#include "session.h"
    2625#include "tr-dht.h"
     
    531530{
    532531    tr_ptrArray tiers;
    533     tr_publisher publisher;
     532    tr_tracker_callback * callback;
     533    void * callbackData;
    534534}
    535535tr_torrent_tiers;
     
    540540    tr_torrent_tiers * tiers = tr_new0( tr_torrent_tiers, 1 );
    541541    tiers->tiers = TR_PTR_ARRAY_INIT;
    542     tiers->publisher = TR_PUBLISHER_INIT;
    543542    return tiers;
    544543}
     
    547546tiersFree( tr_torrent_tiers * tiers )
    548547{
    549     tr_publisherDestruct( &tiers->publisher );
    550548    tr_ptrArrayDestruct( &tiers->tiers, tierFree );
    551549    tr_free( tiers );
     
    594592        event.text = msg;
    595593        event.tracker = tier->currentTracker ? tier->currentTracker->announce : NULL;
    596         tr_publisherPublish( &tiers->publisher, tier, &event );
     594
     595        if( tiers->callback != NULL )
     596            tiers->callback( tier->tor, &event, tiers->callbackData );
    597597    }
    598598}
     
    641641    e.compactLen = compactLen;
    642642
    643     tr_publisherPublish( &tier->tor->tiers->publisher, tier, &e );
     643    if( tier->tor->tiers->callback != NULL )
     644        tier->tor->tiers->callback( tier->tor, &e, NULL );
    644645
    645646    return compactLen / 6;
     
    845846
    846847tr_torrent_tiers *
    847 tr_announcerAddTorrent( tr_announcer * announcer, tr_torrent * tor )
     848tr_announcerAddTorrent( tr_announcer * announcer, tr_torrent * tor,
     849                        tr_tracker_callback * callback, void * callbackData )
    848850{
    849851    tr_torrent_tiers * tiers;
     
    853855
    854856    tiers = tiersNew( );
     857    tiers->callback = callback;
     858    tiers->callbackData = callbackData;
    855859
    856860    addTorrentToTier( announcer, tiers, tor );
     
    928932    /* cleanup */
    929933    tr_ptrArrayDestruct( &oldTiers, tierFree );
    930 }
    931 
    932 tr_publisher_tag
    933 tr_announcerSubscribe( struct tr_torrent_tiers   * tiers,
    934                        tr_delivery_func            func,
    935                        void                      * userData )
    936 {
    937     return tr_publisherSubscribe( &tiers->publisher, func, userData );
    938 }
    939 
    940 void
    941 tr_announcerUnsubscribe( struct tr_torrent_tiers  * tiers,
    942                          tr_publisher_tag           tag )
    943 {
    944     if( tiers )
    945         tr_publisherUnsubscribe( &tiers->publisher, tag );
    946934}
    947935
  • trunk/libtransmission/announcer.h

    r10664 r10800  
    1919
    2020#include "transmission.h"
    21 #include "publish.h"
    2221
    2322struct tr_announcer;
     
    5655tr_tracker_event;
    5756
     57typedef void tr_tracker_callback ( tr_torrent              * tor,
     58                                   const tr_tracker_event  * event,
     59                                   void                    * client_data );
     60
    5861/**
    5962***  Session ctor/dtor
     
    6871**/
    6972
    70 struct tr_torrent_tiers * tr_announcerAddTorrent( struct tr_announcer  *,
    71                                                   tr_torrent           * );
     73struct tr_torrent_tiers * tr_announcerAddTorrent( struct tr_announcer *,
     74                                                  tr_torrent          * torrent,
     75                                                  tr_tracker_callback * cb,
     76                                                  void                * cbdata );
    7277
    7378tr_bool tr_announcerHasBacklog( const struct tr_announcer * );
    7479
    7580void tr_announcerResetTorrent( struct tr_announcer*, tr_torrent* );
    76 
    77 tr_publisher_tag tr_announcerSubscribe( struct tr_torrent_tiers  * tiers,
    78                                         tr_delivery_func           func,
    79                                         void                     * userData );
    80 
    81 void tr_announcerUnsubscribe( struct tr_torrent_tiers  * tiers,
    82                               tr_publisher_tag           tag );
    8381
    8482void tr_announcerRemoveTorrent( struct tr_announcer * ,
  • trunk/libtransmission/peer-common.h

    r10694 r10800  
    8585tr_peer_event;
    8686
     87struct tr_peer;
     88
     89typedef void tr_peer_callback( struct tr_peer      * peer,
     90                              const tr_peer_event  * event,
     91                              void                 * client_data );
     92
    8793#ifdef WIN32
    8894 #define EMSGSIZE WSAEMSGSIZE
  • trunk/libtransmission/peer-mgr.c

    r10798 r10800  
    393393
    394394    if( peer->msgs != NULL )
    395     {
    396         tr_peerMsgsUnsubscribe( peer->msgs, peer->msgsTag );
    397395        tr_peerMsgsFree( peer->msgs );
    398     }
    399396
    400397    tr_peerIoClear( peer->io );
     
    458455}
    459456
    460 static void peerCallbackFunc( void * vpeer, void * vevent, void * vt );
     457static void peerCallbackFunc( tr_peer *, const tr_peer_event *, void * );
    461458
    462459static Torrent*
     
    13391336
    13401337static void
    1341 peerCallbackFunc( void * vpeer, void * vevent, void * vt )
    1342 {
    1343     tr_peer * peer = vpeer; /* may be NULL if peer is a webseed */
     1338peerCallbackFunc( tr_peer * peer, const tr_peer_event * e, void * vt )
     1339{
    13441340    Torrent * t = vt;
    1345     const tr_peer_event * e = vevent;
    13461341
    13471342    torrentLock( t );
     
    17071702                                                                balanced by our unref in peerDestructor()  */
    17081703                tr_peerIoSetParent( peer->io, t->tor->bandwidth );
    1709                 tr_peerMsgsNew( t->tor, peer, peerCallbackFunc, t, &peer->msgsTag );
     1704                tr_peerMsgsNew( t->tor, peer, peerCallbackFunc, t );
    17101705
    17111706                success = TRUE;
  • trunk/libtransmission/peer-mgr.h

    r10751 r10800  
    2929#include "net.h"
    3030#include "peer-common.h" /* struct peer_request */
    31 #include "publish.h" /* tr_publisher_tag */
    3231
    3332/**
     
    125124
    126125    struct tr_peermsgs     * msgs;
    127     tr_publisher_tag         msgsTag;
    128126}
    129127tr_peer;
  • trunk/libtransmission/peer-msgs.c

    r10798 r10800  
    202202    tr_torrent *           torrent;
    203203
    204     tr_publisher           publisher;
     204    tr_peer_callback      * callback;
     205    void                  * callbackData;
    205206
    206207    struct evbuffer *      outMessages; /* all the non-piece messages */
     
    471472    assert( msgs->peer->msgs == msgs );
    472473
    473     tr_publisherPublish( &msgs->publisher, msgs->peer, e );
     474    if( msgs->callback != NULL )
     475        msgs->callback( msgs->peer, e, msgs->callbackData );
    474476}
    475477
     
    23162318
    23172319tr_peermsgs*
    2318 tr_peerMsgsNew( struct tr_torrent * torrent,
    2319                 struct tr_peer    * peer,
    2320                 tr_delivery_func    func,
    2321                 void              * userData,
    2322                 tr_publisher_tag  * setme )
     2320tr_peerMsgsNew( struct tr_torrent    * torrent,
     2321                struct tr_peer       * peer,
     2322                tr_peer_callback     * callback,
     2323                void                 * callbackData )
    23232324{
    23242325    tr_peermsgs * m;
     
    23282329
    23292330    m = tr_new0( tr_peermsgs, 1 );
    2330     m->publisher = TR_PUBLISHER_INIT;
     2331    m->callback = callback;
     2332    m->callbackData = callbackData;
    23312333    m->peer = peer;
    23322334    m->torrent = torrent;
     
    23442346    peer->msgs = m;
    23452347
    2346     *setme = tr_publisherSubscribe( &m->publisher, func, userData );
    2347 
    23482348    if( tr_peerIoSupportsLTEP( peer->io ) )
    23492349        sendLtepHandshake( m );
     
    23722372    {
    23732373        evtimer_del( &msgs->pexTimer );
    2374         tr_publisherDestruct( &msgs->publisher );
    23752374
    23762375        evbuffer_free( msgs->incoming.block );
     
    23832382    }
    23842383}
    2385 
    2386 void
    2387 tr_peerMsgsUnsubscribe( tr_peermsgs *    peer,
    2388                         tr_publisher_tag tag )
    2389 {
    2390     tr_publisherUnsubscribe( &peer->publisher, tag );
    2391 }
  • trunk/libtransmission/peer-msgs.h

    r10332 r10800  
    2020#include <inttypes.h>
    2121#include "peer-common.h"
    22 #include "publish.h"
    2322
    2423struct tr_torrent;
     
    3332typedef struct tr_peermsgs tr_peermsgs;
    3433
    35 tr_peermsgs* tr_peerMsgsNew( struct tr_torrent * torrent,
    36                              struct tr_peer *    peer,
    37                              tr_delivery_func    func,
    38                              void *              user,
    39                              tr_publisher_tag *  setme );
    40 
     34tr_peermsgs* tr_peerMsgsNew( struct tr_torrent    * torrent,
     35                             struct tr_peer       * peer,
     36                             tr_peer_callback     * callback,
     37                             void                 * callback_data );
    4138
    4239void         tr_peerMsgsSetChoke( tr_peermsgs *, int doChoke );
     
    5653void         tr_peerMsgsFree( tr_peermsgs* );
    5754
    58 void         tr_peerMsgsUnsubscribe( tr_peermsgs      * peer,
    59                                      tr_publisher_tag   tag );
    60 
    6155size_t       tr_generateAllowedSet( tr_piece_index_t  * setmePieces,
    6256                                    size_t              desiredSetSize,
  • trunk/libtransmission/torrent.c

    r10798 r10800  
    361361
    362362static void
    363 onTrackerResponse( void * tracker UNUSED,
    364                    void * vevent,
    365                    void * user_data )
    366 {
    367     tr_torrent * tor = user_data;
    368     tr_tracker_event * event = vevent;
    369 
     363onTrackerResponse( tr_torrent * tor, const tr_tracker_event * event, void * unused UNUSED )
     364{
    370365    switch( event->messageType )
    371366    {
     
    728723    }
    729724
    730     tor->tiers = tr_announcerAddTorrent( tor->session->announcer, tor );
    731     tor->tiersSubscription = tr_announcerSubscribe( tor->tiers, onTrackerResponse, tor );
     725    tor->tiers = tr_announcerAddTorrent( tor->session->announcer, tor, onTrackerResponse, NULL );
    732726
    733727    if( doStart )
     
    13151309    tr_cpDestruct( &tor->completion );
    13161310
    1317     tr_announcerUnsubscribe( tor->tiers, tor->tiersSubscription );
    13181311    tr_announcerRemoveTorrent( session->announcer, tor );
    13191312
  • trunk/libtransmission/torrent.h

    r10774 r10800  
    195195
    196196    struct tr_torrent_tiers  * tiers;
    197     struct tr_publisher_tag  * tiersSubscription;
    198197
    199198    time_t                     dhtAnnounceAt;
  • trunk/libtransmission/webseed.c

    r10500 r10800  
    3232    char              * url;
    3333
    34     tr_delivery_func  * callback;
    35     void *              callback_userdata;
     34    tr_peer_callback  * callback;
     35    void              * callback_data;
    3636
    3737    tr_piece_index_t    pieceIndex;
     
    5353
    5454static void
    55 publish( tr_webseed *    w,
    56          tr_peer_event * e )
    57 {
    58     if( w->callback )
    59         w->callback( NULL, e, w->callback_userdata );
     55publish( tr_webseed * w, tr_peer_event * e )
     56{
     57    if( w->callback != NULL )
     58        w->callback( NULL, e, w->callback_data );
    6059}
    6160
     
    237236tr_webseed*
    238237tr_webseedNew( struct tr_torrent * torrent,
    239                const char *        url,
    240                tr_delivery_func    callback,
    241                void *              callback_userdata )
     238               const char        * url,
     239               tr_peer_callback  * callback,
     240               void              * callback_data )
    242241{
    243242    tr_webseed * w = tr_new0( tr_webseed, 1 );
     
    248247    w->url = tr_strdup( url );
    249248    w->callback = callback;
    250     w->callback_userdata = callback_userdata;
     249    w->callback_data = callback_data;
    251250    tr_rcConstruct( &w->rateDown );
    252 /*fprintf( stderr, "w->callback_userdata is %p\n", w->callback_userdata );*/
    253251    return w;
    254252}
  • trunk/libtransmission/webseed.h

    r9868 r10800  
    2121
    2222#include "peer-common.h"
    23 #include "publish.h"
    2423
    2524tr_webseed* tr_webseedNew( struct tr_torrent * torrent,
    26                            const char *        url,
    27                            tr_delivery_func    delivery_func,
    28                            void *              delivery_userdata );
     25                           const char        * url,
     26                           tr_peer_callback  * callback,
     27                           void              * callback_data );
    2928
    3029void        tr_webseedFree( tr_webseed * );
Note: See TracChangeset for help on using the changeset viewer.