Changeset 1231


Ignore:
Timestamp:
Dec 16, 2006, 1:00:05 AM (15 years ago)
Author:
livings124
Message:

handle redirect of url's

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/multitracker/libtransmission/tracker.c

    r1223 r1231  
    4646   
    4747    tr_announce_list_ptr_t ** trackerAnnounceListPtr;
    48    
     48
     49#define TC_CHANGE_NO        0
     50#define TC_CHANGE_NEXT      1
     51#define TC_CHANGE_REDIRECT  2
    4952    int            shouldChangeAnnounce;
    5053    int            announceTier;
    5154    int            announceTierLast;
     55   
     56    char         * redirectAddress;
     57    int            redirectAddressLen;
     58    char         * redirectScrapeAddress;
     59    int            redirectScrapeAddressLen;
    5260
    5361    char           started;
     
    104112
    105113    tc->started        = 1;
     114   
     115    tc->shouldChangeAnnounce = TC_CHANGE_NO;
     116    tc->redirectAddress = NULL;
    106117
    107118    tc->interval       = 300;
     
    189200   
    190201    tc->shouldChangeAnnounce = tc->announceTier + 1 < inf->trackerTiers
    191                                 || tc->announceTierLast + 1 < inf->trackerList[tc->announceTier].count;
     202                                || tc->announceTierLast + 1 < inf->trackerList[tc->announceTier].count
     203                                ? TC_CHANGE_NEXT : TC_CHANGE_NO;
    192204}
    193205
     
    198210   
    199211    /* Last tracker failed, try next */
    200     if( tc->shouldChangeAnnounce )
     212    if( tc->shouldChangeAnnounce != TC_CHANGE_NO )
    201213    {
    202214        return 1;
     
    271283
    272284    /* in process of changing tracker or scrape not supported */
    273     if( tc->shouldChangeAnnounce || !tc->trackerCanScrape )
     285    if( tc->shouldChangeAnnounce != TC_CHANGE_NO || !tc->trackerCanScrape )
    274286    {
    275287        return 0;
     
    298310    tr_info_t    * inf = &tor->info;
    299311    const char   * data;
    300     int            len, i;
     312    char         * address, * announce;
     313    int            len, i, port;
    301314    tr_announce_list_ptr_t * announcePtr, * prevAnnouncePtr;
    302315
     
    305318        tc->randOffset = tr_rand( 60000 );
    306319       
    307         if( tc->shouldChangeAnnounce )
    308         {
    309             tr_inf( "Tracker: failed to connect to %s, trying next", tc->trackerAddress );
     320        if( tr_fdSocketWillCreate( tor->fdlimit, 1 ) )
     321        {
     322            return;
     323        }
     324        tc->dateTry = tr_date();
     325       
     326        if( tc->shouldChangeAnnounce == TC_CHANGE_REDIRECT )
     327        {
     328            /* Use redirected address */
     329            if( !tr_httpParseUrl( tc->redirectAddress, tc->redirectAddressLen,
     330                                     &address, &port, &announce ) )
     331            {
     332                tc->http = tr_httpClient( TR_HTTP_GET, address, port, announce );
     333               
     334                free( address );
     335                free( announce );
     336            }
    310337           
    311             if( tc->announceTierLast + 1 < inf->trackerList[tc->announceTier].count )
     338            tc->shouldChangeAnnounce = TC_CHANGE_NO;
     339           
     340            free( tc->redirectAddress );
     341            tc->redirectAddress = NULL;
     342        }
     343        else
     344        {
     345            if( tc->shouldChangeAnnounce == TC_CHANGE_NEXT )
    312346            {
    313                 prevAnnouncePtr = tc->trackerAnnounceListPtr[tc->announceTier];
    314                 announcePtr = prevAnnouncePtr->nextItem;
    315                 for( i = 0; i < tc->announceTierLast; i++ )
     347                tr_inf( "Tracker: failed to connect to %s, trying next", tc->trackerAddress );
     348               
     349                if( tc->announceTierLast + 1 < inf->trackerList[tc->announceTier].count )
    316350                {
    317                     prevAnnouncePtr = announcePtr;
    318                     announcePtr = announcePtr->nextItem;
     351                    prevAnnouncePtr = tc->trackerAnnounceListPtr[tc->announceTier];
     352                    announcePtr = prevAnnouncePtr->nextItem;
     353                    for( i = 0; i < tc->announceTierLast; i++ )
     354                    {
     355                        prevAnnouncePtr = announcePtr;
     356                        announcePtr = announcePtr->nextItem;
     357                    }
     358                   
     359                    /* Move address to front of tier in announce list */
     360                    prevAnnouncePtr->nextItem = announcePtr->nextItem;
     361                    announcePtr->nextItem =  tc->trackerAnnounceListPtr[tc->announceTier];
     362                    tc->trackerAnnounceListPtr[tc->announceTier] = announcePtr;
     363                   
     364                    tc->announceTierLast++;
     365                }
     366                else
     367                {
     368                    tc->announceTierLast = 0;
     369                    tc->announceTier++;
    319370                }
    320371               
    321                 /* Move address to front of tier in announce list */
    322                 prevAnnouncePtr->nextItem = announcePtr->nextItem;
    323                 announcePtr->nextItem =  tc->trackerAnnounceListPtr[tc->announceTier];
    324                 tc->trackerAnnounceListPtr[tc->announceTier] = announcePtr;
    325                
    326                 tc->announceTierLast++;
     372                tr_inf( "Tracker: tracker address set to %s", tc->trackerAnnounceListPtr[tc->announceTier]->item->address );
     373                setAnnounce( tc, tc->trackerAnnounceListPtr[tc->announceTier] );
     374                tc->shouldChangeAnnounce = TC_CHANGE_NO;
    327375            }
    328376            else
    329377            {
     378                if( tc->announceTier != 0 )
     379                {
     380                    setAnnounce( tc, tc->trackerAnnounceListPtr[0] );
     381                    tc->announceTier = 0;
     382                }
    330383                tc->announceTierLast = 0;
    331                 tc->announceTier++;
    332384            }
    333385           
    334             tr_inf( "Tracker: tracker address set to %s", tc->trackerAnnounceListPtr[tc->announceTier]->item->address );
    335             setAnnounce( tc, tc->trackerAnnounceListPtr[tc->announceTier] );
    336             tc->shouldChangeAnnounce = 0;
    337         }
    338         else
    339         {
    340             if( tc->announceTier != 0 )
    341             {
    342                 setAnnounce( tc, tc->trackerAnnounceListPtr[0] );
    343                 tc->announceTier = 0;
    344             }
    345             tc->announceTierLast = 0;
    346         }
    347        
    348         if( tr_fdSocketWillCreate( tor->fdlimit, 1 ) )
    349         {
    350             return;
    351         }
    352         tc->dateTry = tr_date();
    353         tc->http = getQuery( tc );
    354 
    355         tr_inf( "Tracker: connecting to %s:%d (%s)",
    356                 tc->trackerAddress, tc->trackerPort,
    357                 tc->started ? "sending 'started'" :
    358                 ( tc->completed ? "sending 'completed'" :
    359                   ( tc->stopped ? "sending 'stopped'" :
    360                     ( 0 < tc->newPort ? "sending 'stopped' to change port" :
    361                       "getting peers" ) ) ) );
     386            tc->http = getQuery( tc );
     387
     388            tr_inf( "Tracker: connecting to %s:%d (%s)",
     389                    tc->trackerAddress, tc->trackerPort,
     390                    tc->started ? "sending 'started'" :
     391                    ( tc->completed ? "sending 'completed'" :
     392                      ( tc->stopped ? "sending 'stopped'" :
     393                        ( 0 < tc->newPort ? "sending 'stopped' to change port" :
     394                          "getting peers" ) ) ) );
     395        }
    362396    }
    363397
     
    374408               
    375409                failureAnnouncing( tc );
    376                 if ( tc->shouldChangeAnnounce )
    377                 {
    378                     tr_trackerPulse( tc );
    379                 }
    380                
    381                 return;
    382 
    383             case TR_OK:
    384                 readAnswer( tc, data, len );
    385                 killHttp( &tc->http, tor->fdlimit );
    386                
    387                 /* Something happened to need to try next address */
    388                 if ( tc->shouldChangeAnnounce )
     410                if ( tc->shouldChangeAnnounce != TC_CHANGE_NO )
    389411                {
    390412                    tr_trackerPulse( tc );
     
    393415               
    394416                break;
     417
     418            case TR_OK:
     419                readAnswer( tc, data, len );
     420                killHttp( &tc->http, tor->fdlimit );
     421               
     422                /* Something happened to need to try next address */
     423                if ( tc->shouldChangeAnnounce != TC_CHANGE_NO )
     424                {
     425                    tr_trackerPulse( tc );
     426                    return;
     427                }
     428               
     429                break;
    395430        }
    396431    }
     
    403438        }
    404439        tc->dateScrape = tr_date();
    405         tc->httpScrape = getScrapeQuery( tc );
    406         tr_inf( "Scrape: sent http request to %s:%d", tc->trackerAddress, tc->trackerPort );
     440       
     441        if ( tc->redirectScrapeAddress != NULL )
     442        {
     443            /* Use redirected address */
     444            if( !tr_httpParseUrl( tc->redirectScrapeAddress, tc->redirectScrapeAddressLen,
     445                                     &address, &port, &announce ) )
     446            {
     447                tc->httpScrape = tr_httpClient( TR_HTTP_GET, address, port, announce );
     448               
     449                free( address );
     450                free( announce );
     451            }
     452           
     453            free( tc->redirectScrapeAddress );
     454            tc->redirectScrapeAddress = NULL;
     455        }
     456        else
     457        {
     458            tc->httpScrape = getScrapeQuery( tc );
     459            tr_inf( "Scrape: sent HTTP request to %s:%d%s", tc->trackerAddress, tc->trackerPort, tc->trackerScrape );
     460        }
    407461    }
    408462
     
    422476                readScrapeAnswer( tc, data, len );
    423477                killHttp( &tc->httpScrape, tor->fdlimit );
    424                
    425478                break;
    426479        }
     
    568621        return;
    569622    }
     623   
     624    if( code == 301 || code == 302 )
     625    {
     626        tr_err( "Tracker: HTTP status code: %i", code );
     627       
     628        tr_http_header_t hdr[] = { { "Location", NULL, 0 }, { NULL, NULL, 0 } };
     629       
     630        tr_httpParse( data, len, hdr );
     631       
     632        char * address = calloc( sizeof( char ), hdr->len+1 );
     633        snprintf( address, hdr->len+1, "%s", hdr->data );
     634       
     635        tr_err( "Tracker: redirected URL: %s", address );
     636       
     637        tc->shouldChangeAnnounce = TC_CHANGE_REDIRECT;
     638        tc->redirectAddress = address;
     639        tc->redirectAddressLen = len;
     640       
     641        return;
     642    }
    570643
    571644    if( !TR_HTTP_STATUS_OK( code ) )
     
    819892        return;
    820893    }
     894   
     895    if( code == 301 || code == 302 )
     896    {
     897        tr_err( "Scrape: HTTP status code: %i", code );
     898       
     899        tr_http_header_t hdr[] = { { "Location", NULL, 0 }, { NULL, NULL, 0 } };
     900       
     901        tr_httpParse( data, len, hdr );
     902       
     903        char * address = calloc( sizeof( char ), hdr->len+1 );
     904        snprintf( address, hdr->len+1, "%s", hdr->data );
     905       
     906        tr_err( "Scrape: redirected URL: %s", address );
     907       
     908        /* Needs a new scrape */
     909        tc->dateScrape = 0;
     910       
     911        tc->redirectScrapeAddress = address;
     912        tc->redirectScrapeAddressLen = len;
     913       
     914        return;
     915    }
    821916
    822917    if( !TR_HTTP_STATUS_OK( code ) )
Note: See TracChangeset for help on using the changeset viewer.