source: trunk/libtransmission/peer-msgs.c @ 5329

Last change on this file since 5329 was 5329, checked in by charles, 14 years ago

fix bug that caused very large torrents to crash Transmission

  • Property svn:keywords set to Date Rev Author Id
File size: 56.4 KB
Line 
1/*
2 * This file Copyright (C) 2007 Charles Kerr <charles@rebelbase.com>
3 *
4 * This file is licensed by the GPL version 2.  Works owned by the
5 * Transmission project are granted a special exemption to clause 2(b)
6 * so that the bulk of its code can remain under the MIT license.
7 * This exemption does not extend to derived works not owned by
8 * the Transmission project.
9 *
10 * $Id: peer-msgs.c 5329 2008-03-22 18:10:59Z charles $
11 */
12
13#include <assert.h>
14#include <errno.h>
15#include <stdio.h>
16#include <stdlib.h>
17#include <string.h>
18#include <libgen.h> /* basename */
19
20#include <event.h>
21
22#include "transmission.h"
23#include "bencode.h"
24#include "completion.h"
25#include "inout.h"
26#include "peer-io.h"
27#include "peer-mgr.h"
28#include "peer-mgr-private.h"
29#include "peer-msgs.h"
30#include "ratecontrol.h"
31#include "stats.h"
32#include "torrent.h"
33#include "trevent.h"
34#include "utils.h"
35
36/**
37***
38**/
39
40enum
41{
42    BT_CHOKE                = 0,
43    BT_UNCHOKE              = 1,
44    BT_INTERESTED           = 2,
45    BT_NOT_INTERESTED       = 3,
46    BT_HAVE                 = 4,
47    BT_BITFIELD             = 5,
48    BT_REQUEST              = 6,
49    BT_PIECE                = 7,
50    BT_CANCEL               = 8,
51    BT_PORT                 = 9,
52    BT_SUGGEST              = 13,
53    BT_HAVE_ALL             = 14,
54    BT_HAVE_NONE            = 15,
55    BT_REJECT               = 16,
56    BT_ALLOWED_FAST         = 17,
57    BT_LTEP                 = 20,
58
59    LTEP_HANDSHAKE          = 0,
60
61    TR_LTEP_PEX             = 1,
62
63    MIN_CHOKE_PERIOD_SEC    = (10),
64
65    /* idle seconds before we send a keepalive */
66    KEEPALIVE_INTERVAL_SECS = 90,
67
68    PEX_INTERVAL            = (60 * 1000), /* msec between sendPex() calls */
69    PEER_PULSE_INTERVAL     = (100),       /* msec between pulse() calls */
70    RATE_PULSE_INTERVAL     = (250),       /* msec between ratePulse() calls */
71
72    MAX_QUEUE_SIZE          = (100),
73    MAX_OUTBUF_SIZE         = (1024),
74     
75    /* (fast peers) max number of pieces we fast-allow to another peer */
76    MAX_FAST_ALLOWED_COUNT   = 10,
77
78    /* (fast peers) max threshold for allowing fast-pieces requests */
79    MAX_FAST_ALLOWED_THRESHOLD = 10,
80
81    /* how long an unsent request can stay queued before it's returned
82       back to the peer-mgr's pool of requests */
83    QUEUED_REQUEST_TTL_SECS = 20,
84
85    /* how long a sent request can stay queued before it's returned
86       back to the peer-mgr's pool of requests */
87    SENT_REQUEST_TTL_SECS = 120
88};
89
90/**
91***  REQUEST MANAGEMENT
92**/
93
94enum
95{
96    AWAITING_BT_LENGTH,
97    AWAITING_BT_ID,
98    AWAITING_BT_MESSAGE,
99    AWAITING_BT_PIECE
100};
101
102struct peer_request
103{
104    uint32_t index;
105    uint32_t offset;
106    uint32_t length;
107    time_t time_requested;
108};
109
110static int
111compareRequest( const void * va, const void * vb )
112{
113    int i;
114    const struct peer_request * a = va;
115    const struct peer_request * b = vb;
116    if(( i = tr_compareUint32( a->index, b->index ))) return i;
117    if(( i = tr_compareUint32( a->offset, b->offset ))) return i;
118    if(( i = tr_compareUint32( a->length, b->length ))) return i;
119    return 0;
120}
121
122struct request_list
123{
124    uint16_t count;
125    uint16_t max;
126    struct peer_request * requests;
127};
128
129static const struct request_list REQUEST_LIST_INIT = { 0, 0, NULL };
130
131static void
132reqListReserve( struct request_list * list, uint16_t max )
133{
134    if( list->max < max )
135    {
136        list->max = max;
137        list->requests = tr_renew( struct peer_request,
138                                   list->requests,
139                                   list->max );
140    }
141}
142
143static void
144reqListClear( struct request_list * list )
145{
146    tr_free( list->requests );
147    *list = REQUEST_LIST_INIT;
148}
149
150static void
151reqListCopy( struct request_list * dest, const struct request_list * src )
152{
153    dest->count = src->count;
154    dest->max = src->max;
155    dest->requests = tr_new( struct peer_request, dest->max );
156    memcpy( dest->requests, src->requests, sizeof( struct peer_request ) * dest->count );
157}
158
159static void
160reqListRemoveOne( struct request_list * list, int i )
161{
162    assert( 0<=i && i<list->count );
163
164    memmove( &list->requests[i],
165             &list->requests[i+1],
166             sizeof( struct peer_request ) * ( --list->count - i ) );
167}
168
169static void
170reqListAppend( struct request_list * list, const struct peer_request * req )
171{
172    if( ++list->count >= list->max )
173        reqListReserve( list, list->max + 8 );
174
175    list->requests[list->count-1] = *req;
176}
177
178static tr_errno
179reqListPop( struct request_list * list, struct peer_request * setme )
180{
181    tr_errno err;
182
183    if( !list->count )
184        err = TR_ERROR;
185    else {
186        *setme = list->requests[0];
187        reqListRemoveOne( list, 0 );
188        err = TR_OK;
189    }
190
191    return err;
192}
193
194static int
195reqListFind( struct request_list * list, const struct peer_request * key )
196{
197    uint16_t i;
198    for( i=0; i<list->count; ++i )
199        if( !compareRequest( key, list->requests+i ) )
200            return i;
201    return -1;
202}
203
204static tr_errno
205reqListRemove( struct request_list * list, const struct peer_request * key )
206{
207    tr_errno err;
208    const int i = reqListFind( list, key );
209
210    if( i < 0 )
211        err = TR_ERROR;
212    else {
213        err = TR_OK;
214        reqListRemoveOne( list, i );
215    }
216
217    return err;
218}
219
220/**
221***
222**/
223
224/* this is raw, unchanged data from the peer regarding
225 * the current message that it's sending us. */
226struct tr_incoming
227{
228    uint8_t id;
229    uint32_t length; /* includes the +1 for id length */
230    struct peer_request blockReq; /* metadata for incoming blocks */
231    struct evbuffer * block; /* piece data for incoming blocks */
232};
233
234struct tr_peermsgs
235{
236    unsigned int peerSentBitfield         : 1;
237    unsigned int peerSupportsPex          : 1;
238    unsigned int clientSentLtepHandshake  : 1;
239    unsigned int peerSentLtepHandshake    : 1;
240    unsigned int sendingBlock             : 1;
241   
242    uint8_t state;
243    uint8_t ut_pex_id;
244    uint16_t pexCount;
245    uint16_t maxActiveRequests;
246    uint16_t minActiveRequests;
247
248    tr_peer * info;
249
250    tr_handle * handle;
251    tr_torrent * torrent;
252    tr_peerIo * io;
253
254    tr_publisher_t * publisher;
255
256    struct evbuffer * outBlock;    /* buffer of the current piece message */
257    struct evbuffer * outMessages; /* buffer of all the non-piece messages */
258
259    struct request_list peerAskedFor;
260    struct request_list peerAskedForFast;
261    struct request_list clientAskedFor;
262    struct request_list clientWillAskFor;
263
264    tr_timer * rateTimer;
265    tr_timer * pulseTimer;
266    tr_timer * pexTimer;
267
268    time_t clientSentPexAt;
269    time_t clientSentAnythingAt;
270   
271    tr_bitfield * peerAllowedPieces;
272
273    struct tr_incoming incoming; 
274
275    tr_pex * pex;
276};
277
278/**
279***
280**/
281
282static void
283myDebug( const char * file, int line,
284         const struct tr_peermsgs * msgs,
285         const char * fmt, ... )
286{
287    FILE * fp = tr_getLog( );
288    if( fp != NULL )
289    {
290        va_list args;
291        char timestr[64];
292        struct evbuffer * buf = evbuffer_new( );
293        char * myfile = tr_strdup( file );
294
295        evbuffer_add_printf( buf, "[%s] %s - %s [%s]: ",
296                             tr_getLogTimeStr( timestr, sizeof(timestr) ),
297                             msgs->torrent->info.name,
298                             tr_peerIoGetAddrStr( msgs->io ),
299                             msgs->info->client );
300        va_start( args, fmt );
301        evbuffer_add_vprintf( buf, fmt, args );
302        va_end( args );
303        evbuffer_add_printf( buf, " (%s:%d)\n", basename(myfile), line );
304        fwrite( EVBUFFER_DATA(buf), 1, EVBUFFER_LENGTH(buf), fp );
305
306        tr_free( myfile );
307        evbuffer_free( buf );
308    }
309}
310
311#define dbgmsg(msgs, fmt...) myDebug(__FILE__, __LINE__, msgs, ##fmt )
312
313/**
314***
315**/
316
317static void
318protocolSendRequest( tr_peermsgs * msgs, const struct peer_request * req )
319{
320    tr_peerIo * io = msgs->io;
321    struct evbuffer * out = msgs->outMessages;
322
323    dbgmsg( msgs, "requesting %u:%u->%u", req->index, req->offset, req->length );
324    tr_peerIoWriteUint32( io, out, sizeof(uint8_t) + 3*sizeof(uint32_t) );
325    tr_peerIoWriteUint8 ( io, out, BT_REQUEST );
326    tr_peerIoWriteUint32( io, out, req->index );
327    tr_peerIoWriteUint32( io, out, req->offset );
328    tr_peerIoWriteUint32( io, out, req->length );
329}
330
331static void
332protocolSendCancel( tr_peermsgs * msgs, const struct peer_request * req )
333{
334    tr_peerIo * io = msgs->io;
335    struct evbuffer * out = msgs->outMessages;
336
337    dbgmsg( msgs, "cancelling %u:%u->%u", req->index, req->offset, req->length );
338    tr_peerIoWriteUint32( io, out, sizeof(uint8_t) + 3*sizeof(uint32_t) );
339    tr_peerIoWriteUint8 ( io, out, BT_CANCEL );
340    tr_peerIoWriteUint32( io, out, req->index );
341    tr_peerIoWriteUint32( io, out, req->offset );
342    tr_peerIoWriteUint32( io, out, req->length );
343}
344
345static void
346protocolSendHave( tr_peermsgs * msgs, uint32_t index )
347{
348    tr_peerIo * io = msgs->io;
349    struct evbuffer * out = msgs->outMessages;
350
351    dbgmsg( msgs, "sending Have %u", index );
352    tr_peerIoWriteUint32( io, out, sizeof(uint8_t) + sizeof(uint32_t) );
353    tr_peerIoWriteUint8 ( io, out, BT_HAVE );
354    tr_peerIoWriteUint32( io, out, index );
355}
356
357static void
358protocolSendChoke( tr_peermsgs * msgs, int choke )
359{
360    tr_peerIo * io = msgs->io;
361    struct evbuffer * out = msgs->outMessages;
362
363    dbgmsg( msgs, "sending %s", (choke ? "Choke" : "Unchoke") );
364    tr_peerIoWriteUint32( io, out, sizeof(uint8_t) );
365    tr_peerIoWriteUint8 ( io, out, choke ? BT_CHOKE : BT_UNCHOKE );
366}
367
368/**
369***  EVENTS
370**/
371
372static const tr_peermsgs_event blankEvent = { 0, 0, 0, 0, 0.0f, 0 };
373
374static void
375publish( tr_peermsgs * msgs, tr_peermsgs_event * e )
376{
377    tr_publisherPublish( msgs->publisher, msgs->info, e );
378}
379
380static void
381fireError( tr_peermsgs * msgs, tr_errno err )
382{
383    tr_peermsgs_event e = blankEvent;
384    e.eventType = TR_PEERMSG_ERROR;
385    e.err = err;
386    publish( msgs, &e );
387}
388
389static void
390fireNeedReq( tr_peermsgs * msgs )
391{
392    tr_peermsgs_event e = blankEvent;
393    e.eventType = TR_PEERMSG_NEED_REQ;
394    publish( msgs, &e );
395}
396
397static void
398firePeerProgress( tr_peermsgs * msgs )
399{
400    tr_peermsgs_event e = blankEvent;
401    e.eventType = TR_PEERMSG_PEER_PROGRESS;
402    e.progress = msgs->info->progress;
403    publish( msgs, &e );
404}
405
406static void
407fireClientHave( tr_peermsgs * msgs, uint32_t pieceIndex )
408{
409    tr_peermsgs_event e = blankEvent;
410    e.eventType = TR_PEERMSG_CLIENT_HAVE;
411    e.pieceIndex = pieceIndex;
412    publish( msgs, &e );
413}
414
415static void
416fireGotBlock( tr_peermsgs * msgs, const struct peer_request * req )
417{
418    tr_peermsgs_event e = blankEvent;
419    e.eventType = TR_PEERMSG_CLIENT_BLOCK;
420    e.pieceIndex = req->index;
421    e.offset = req->offset;
422    e.length = req->length;
423    publish( msgs, &e );
424}
425
426static void
427firePieceData( tr_peermsgs * msgs )
428{
429    tr_peermsgs_event e = blankEvent;
430    e.eventType = TR_PEERMSG_PIECE_DATA;
431    publish( msgs, &e );
432}
433
434static void
435fireCancelledReq( tr_peermsgs * msgs, const struct peer_request * req )
436{
437    tr_peermsgs_event e = blankEvent;
438    e.eventType = TR_PEERMSG_CANCEL;
439    e.pieceIndex = req->index;
440    e.offset = req->offset;
441    e.length = req->length;
442    publish( msgs, &e );
443}
444
445/**
446***  INTEREST
447**/
448
449static int
450isPieceInteresting( const tr_peermsgs   * peer,
451                    int                   piece )
452{
453    const tr_torrent * torrent = peer->torrent;
454
455    return ( ( !torrent->info.pieces[piece].dnd )               /* we want it */
456          && ( !tr_cpPieceIsComplete( torrent->completion, piece ) ) /* !have */
457          && ( tr_bitfieldHas( peer->info->have, piece ) ) );  /* peer has it */
458}
459
460/* "interested" means we'll ask for piece data if they unchoke us */
461static int
462isPeerInteresting( const tr_peermsgs * msgs )
463{
464    tr_piece_index_t i;
465    const tr_torrent * torrent;
466    const tr_bitfield * bitfield;
467    const int clientIsSeed = tr_torrentIsSeed( msgs->torrent );
468
469    if( clientIsSeed )
470        return FALSE;
471
472    torrent = msgs->torrent;
473    bitfield = tr_cpPieceBitfield( torrent->completion );
474
475    if( !msgs->info->have )
476        return TRUE;
477
478    assert( bitfield->len == msgs->info->have->len );
479    for( i=0; i<torrent->info.pieceCount; ++i )
480        if( isPieceInteresting( msgs, i ) )
481            return TRUE;
482
483    return FALSE;
484}
485
486static void
487sendInterest( tr_peermsgs * msgs, int weAreInterested )
488{
489    assert( msgs != NULL );
490    assert( weAreInterested==0 || weAreInterested==1 );
491
492    msgs->info->clientIsInterested = weAreInterested;
493    dbgmsg( msgs, "Sending %s",
494            weAreInterested ? "Interested" : "Not Interested");
495
496    tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) );
497    tr_peerIoWriteUint8 ( msgs->io, msgs->outMessages,
498                   weAreInterested ? BT_INTERESTED : BT_NOT_INTERESTED );
499}
500
501static void
502updateInterest( tr_peermsgs * msgs )
503{
504    const int i = isPeerInteresting( msgs );
505    if( i != msgs->info->clientIsInterested )
506        sendInterest( msgs, i );
507    if( i )
508        fireNeedReq( msgs );
509}
510
511static void
512cancelAllRequestsToClientExceptFast( tr_peermsgs * msgs )
513{
514    reqListClear( &msgs->peerAskedFor );
515}
516
517void
518tr_peerMsgsSetChoke( tr_peermsgs * msgs, int choke )
519{
520    const time_t fibrillationTime = time(NULL) - MIN_CHOKE_PERIOD_SEC;
521
522    assert( msgs != NULL );
523    assert( msgs->info != NULL );
524    assert( choke==0 || choke==1 );
525
526    if( msgs->info->chokeChangedAt > fibrillationTime )
527    {
528        dbgmsg( msgs, "Not changing choke to %d to avoid fibrillation", choke );
529    }
530    else if( msgs->info->peerIsChoked != choke )
531    {
532        msgs->info->peerIsChoked = choke;
533        if( choke )
534            cancelAllRequestsToClientExceptFast( msgs );
535        protocolSendChoke( msgs, choke );
536        msgs->info->chokeChangedAt = time( NULL );
537    }
538}
539
540/**
541***
542**/
543
544void
545tr_peerMsgsHave( tr_peermsgs * msgs,
546                 uint32_t      index )
547{
548    protocolSendHave( msgs, index );
549
550    /* since we have more pieces now, we might not be interested in this peer */
551    updateInterest( msgs );
552}
553#if 0
554static void
555sendFastSuggest( tr_peermsgs * msgs,
556                 uint32_t      pieceIndex )
557{
558    assert( msgs != NULL );
559   
560    if( tr_peerIoSupportsFEXT( msgs->io ) )
561    {
562        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) + sizeof(uint32_t) );
563        tr_peerIoWriteUint8( msgs->io, msgs->outMessages, BT_SUGGEST );
564        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, pieceIndex );
565    }
566}
567#endif
568static void
569sendFastHave( tr_peermsgs * msgs, int all )
570{
571    assert( msgs != NULL );
572   
573    if( tr_peerIoSupportsFEXT( msgs->io ) )
574    {
575        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) );
576        tr_peerIoWriteUint8( msgs->io, msgs->outMessages, ( all ? BT_HAVE_ALL
577                                                                : BT_HAVE_NONE ) );
578        updateInterest( msgs );
579    }
580}
581
582static void
583sendFastReject( tr_peermsgs * msgs,
584                uint32_t      pieceIndex,
585                uint32_t      offset,
586                uint32_t      length )
587{
588    assert( msgs != NULL );
589
590    if( tr_peerIoSupportsFEXT( msgs->io ) )
591    {
592        const uint32_t len = sizeof(uint8_t) + 3 * sizeof(uint32_t);
593        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, len );
594        tr_peerIoWriteUint8( msgs->io, msgs->outMessages, BT_REJECT );
595        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, pieceIndex );
596        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, offset );
597        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, length );
598    }
599}
600
601static tr_bitfield*
602getPeerAllowedPieces( tr_peermsgs * msgs )
603{
604    if( !msgs->peerAllowedPieces && tr_peerIoSupportsFEXT( msgs->io ) )
605    {
606        msgs->peerAllowedPieces = tr_peerMgrGenerateAllowedSet(
607            MAX_FAST_ALLOWED_COUNT,
608            msgs->torrent->info.pieceCount,
609            msgs->torrent->info.hash,
610            tr_peerIoGetAddress( msgs->io, NULL ) );
611    }
612
613    return msgs->peerAllowedPieces;
614}
615
616static void
617sendFastAllowed( tr_peermsgs * msgs,
618                 uint32_t      pieceIndex)
619{
620    assert( msgs != NULL );
621   
622    if( tr_peerIoSupportsFEXT( msgs->io ) )
623    {
624        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, sizeof(uint8_t) + sizeof(uint32_t) );
625        tr_peerIoWriteUint8( msgs->io, msgs->outMessages, BT_ALLOWED_FAST );
626        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, pieceIndex );
627    }
628}
629
630static void
631sendFastAllowedSet( tr_peermsgs * msgs )
632{
633    tr_piece_index_t i = 0;
634
635    while (i <= msgs->torrent->info.pieceCount )
636    {
637        if ( tr_bitfieldHas( getPeerAllowedPieces( msgs ), i) )
638            sendFastAllowed( msgs, i );
639        i++;
640    }
641}
642
643static void
644maybeSendFastAllowedSet( tr_peermsgs * msgs )
645{
646    if( tr_bitfieldCountTrueBits( msgs->info->have ) <= MAX_FAST_ALLOWED_THRESHOLD )
647        sendFastAllowedSet( msgs );
648}
649
650
651/**
652***
653**/
654
655static int
656reqIsValid( const tr_peermsgs   * msgs,
657            uint32_t              index,
658            uint32_t              offset,
659            uint32_t              length )
660{
661    return tr_torrentReqIsValid( msgs->torrent, index, offset, length );
662}
663
664static int
665requestIsValid( const tr_peermsgs * msgs, const struct peer_request * req )
666{
667    return reqIsValid( msgs, req->index, req->offset, req->length );
668}
669
670static void
671expireOldRequests( tr_peermsgs * msgs )
672{
673    int i;
674    time_t oldestAllowed;
675    struct request_list tmp = REQUEST_LIST_INIT;
676
677    /* cancel requests that have been queued for too long */
678    oldestAllowed = time( NULL ) - QUEUED_REQUEST_TTL_SECS;
679    reqListCopy( &tmp, &msgs->clientWillAskFor );
680    for( i=0; i<tmp.count; ++i ) {
681        const struct peer_request * req = &tmp.requests[i];
682        if( req->time_requested < oldestAllowed )
683            tr_peerMsgsCancel( msgs, req->index, req->offset, req->length );
684    }
685    reqListClear( &tmp );
686
687    /* cancel requests that were sent too long ago */
688    oldestAllowed = time( NULL ) - SENT_REQUEST_TTL_SECS;
689    reqListCopy( &tmp, &msgs->clientAskedFor );
690    for( i=0; i<tmp.count; ++i ) {
691        const struct peer_request * req = &tmp.requests[i];
692        if( req->time_requested < oldestAllowed )
693            tr_peerMsgsCancel( msgs, req->index, req->offset, req->length );
694    }
695    reqListClear( &tmp );
696}
697
698static void
699pumpRequestQueue( tr_peermsgs * msgs )
700{
701    const int max = msgs->maxActiveRequests;
702    const int min = msgs->minActiveRequests;
703    const time_t now = time( NULL );
704    int sent = 0;
705    int count = msgs->clientAskedFor.count;
706    struct peer_request req;
707
708    if( count > min )
709        return;
710    if( msgs->info->clientIsChoked )
711        return;
712
713    while( ( count < max ) && !reqListPop( &msgs->clientWillAskFor, &req ) )
714    {
715        assert( requestIsValid( msgs, &req ) );
716        assert( tr_bitfieldHas( msgs->info->have, req.index ) );
717
718        protocolSendRequest( msgs, &req );
719        req.time_requested = now;
720        reqListAppend( &msgs->clientAskedFor, &req );
721
722        ++count;
723        ++sent;
724    }
725
726    if( sent )
727        dbgmsg( msgs, "pump sent %d requests, now have %d active and %d queued",
728                sent,
729                msgs->clientAskedFor.count,
730                msgs->clientWillAskFor.count );
731
732    if( count < max )
733        fireNeedReq( msgs );
734}
735
736static int
737pulse( void * vmsgs );
738
739int
740tr_peerMsgsAddRequest( tr_peermsgs * msgs,
741                       uint32_t      index, 
742                       uint32_t      offset, 
743                       uint32_t      length )
744{
745    const int req_max = msgs->maxActiveRequests;
746    struct peer_request req;
747
748    assert( msgs != NULL );
749    assert( msgs->torrent != NULL );
750    assert( reqIsValid( msgs, index, offset, length ) );
751
752    /**
753    ***  Reasons to decline the request
754    **/
755
756    /* don't send requests to choked clients */
757    if( msgs->info->clientIsChoked ) {
758        dbgmsg( msgs, "declining request because they're choking us" );
759        return TR_ADDREQ_CLIENT_CHOKED;
760    }
761
762    /* peer doesn't have this piece */
763    if( !tr_bitfieldHas( msgs->info->have, index ) )
764        return TR_ADDREQ_MISSING;
765
766    /* peer's queue is full */
767    if( msgs->clientWillAskFor.count >= req_max ) {
768        dbgmsg( msgs, "declining request because we're full" );
769        return TR_ADDREQ_FULL;
770    }
771
772    /* have we already asked for this piece? */
773    req.index = index;
774    req.offset = offset;
775    req.length = length;
776    if( reqListFind( &msgs->clientAskedFor, &req ) != -1 ) {
777        dbgmsg( msgs, "declining because it's a duplicate" );
778        return TR_ADDREQ_DUPLICATE;
779    }
780    if( reqListFind( &msgs->clientWillAskFor, &req ) != -1 ) {
781        dbgmsg( msgs, "declining because it's a duplicate" );
782        return TR_ADDREQ_DUPLICATE;
783    }
784
785    /**
786    ***  Accept this request
787    **/
788
789    dbgmsg( msgs, "added req for piece %d, offset %d", (int)index, (int)offset );
790    req.time_requested = time( NULL );
791    reqListAppend( &msgs->clientWillAskFor, &req );
792    return TR_ADDREQ_OK;
793}
794
795static void
796cancelAllRequestsToPeer( tr_peermsgs * msgs )
797{
798    int i;
799    struct request_list a = msgs->clientWillAskFor;
800    struct request_list b = msgs->clientAskedFor;
801
802    msgs->clientAskedFor = REQUEST_LIST_INIT;
803    msgs->clientWillAskFor = REQUEST_LIST_INIT;
804
805    for( i=0; i<a.count; ++i )
806        fireCancelledReq( msgs, &a.requests[i] );
807
808    for( i=0; i<b.count; ++i ) {
809        fireCancelledReq( msgs, &b.requests[i] );
810        protocolSendCancel( msgs, &b.requests[i] );
811    }
812
813    reqListClear( &a );
814    reqListClear( &b );
815}
816
817void
818tr_peerMsgsCancel( tr_peermsgs * msgs,
819                   uint32_t      pieceIndex,
820                   uint32_t      offset,
821                   uint32_t      length )
822{
823    struct peer_request req;
824
825    assert( msgs != NULL );
826    assert( length > 0 );
827
828    /* have we asked the peer for this piece? */
829    req.index = pieceIndex;
830    req.offset = offset;
831    req.length = length;
832
833    /* if it's only in the queue and hasn't been sent yet, free it */
834    if( !reqListRemove( &msgs->clientWillAskFor, &req ) )
835        fireCancelledReq( msgs, &req );
836
837    /* if it's already been sent, send a cancel message too */
838    if( !reqListRemove( &msgs->clientAskedFor, &req ) ) {
839        protocolSendCancel( msgs, &req );
840        fireCancelledReq( msgs, &req );
841    }
842}
843
844/**
845***
846**/
847
848static void
849sendLtepHandshake( tr_peermsgs * msgs )
850{
851    tr_benc val, *m;
852    char * buf;
853    int len;
854    int pex;
855    const char * v = TR_NAME " " USERAGENT_PREFIX;
856    const int port = tr_getPublicPort( msgs->handle );
857    struct evbuffer * outbuf;
858
859    if( msgs->clientSentLtepHandshake )
860        return;
861
862    outbuf = evbuffer_new( );
863    dbgmsg( msgs, "sending an ltep handshake" );
864    msgs->clientSentLtepHandshake = 1;
865
866    /* decide if we want to advertise pex support */
867    if( !tr_torrentAllowsPex( msgs->torrent ) )
868        pex = 0;
869    else if( msgs->peerSentLtepHandshake )
870        pex = msgs->peerSupportsPex ? 1 : 0;
871    else
872        pex = 1;
873
874    tr_bencInit( &val, TYPE_DICT );
875    tr_bencDictReserve( &val, 4 );
876    tr_bencInitInt( tr_bencDictAdd( &val, "e" ), 1 );
877    m  = tr_bencDictAdd( &val, "m" );
878    tr_bencInit( m, TYPE_DICT );
879    if( pex ) {
880        tr_bencDictReserve( m, 1 );
881        tr_bencInitInt( tr_bencDictAdd( m, "ut_pex" ), TR_LTEP_PEX );
882    }
883    if( port > 0 )
884        tr_bencInitInt( tr_bencDictAdd( &val, "p" ), port );
885    tr_bencInitStr( tr_bencDictAdd( &val, "v" ), v, 0, 1 );
886    buf = tr_bencSave( &val, &len );
887
888    tr_peerIoWriteUint32( msgs->io, outbuf, 2*sizeof(uint8_t) + len );
889    tr_peerIoWriteUint8 ( msgs->io, outbuf, BT_LTEP );
890    tr_peerIoWriteUint8 ( msgs->io, outbuf, LTEP_HANDSHAKE );
891    tr_peerIoWriteBytes ( msgs->io, outbuf, buf, len );
892
893    tr_peerIoWriteBuf( msgs->io, outbuf );
894
895#if 0
896    dbgmsg( msgs, "here is the ltep handshake we sent:" );
897    tr_bencPrint( &val );
898    dbgmsg( msgs, "here is the ltep handshake we read [%s]:", tr_bencSave( &val, NULL ) );
899#endif
900
901    /* cleanup */
902    tr_bencFree( &val );
903    tr_free( buf );
904    evbuffer_free( outbuf );
905}
906
907static void
908parseLtepHandshake( tr_peermsgs * msgs, int len, struct evbuffer * inbuf )
909{
910    tr_benc val, * sub;
911    uint8_t * tmp = tr_new( uint8_t, len );
912
913    tr_peerIoReadBytes( msgs->io, inbuf, tmp, len );
914    msgs->peerSentLtepHandshake = 1;
915
916    if( tr_bencLoad( tmp, len, &val, NULL ) || val.type!=TYPE_DICT ) {
917        dbgmsg( msgs, "GET  extended-handshake, couldn't get dictionary" );
918        tr_free( tmp );
919        return;
920    }
921
922#if 0
923    dbgmsg( msgs, "here is the ltep handshake we read:" );
924    tr_bencPrint( &val );
925    dbgmsg( msgs, "here is the ltep handshake we read [%s]:", tr_bencSave( &val, NULL ) );
926#endif
927
928    /* does the peer prefer encrypted connections? */
929    if(( sub = tr_bencDictFindType( &val, "e", TYPE_INT )))
930        msgs->info->encryption_preference = sub->val.i
931                                      ? ENCRYPTION_PREFERENCE_YES
932                                      : ENCRYPTION_PREFERENCE_NO;
933
934    /* check supported messages for utorrent pex */
935    msgs->peerSupportsPex = 0;
936    if(( sub = tr_bencDictFindType( &val, "m", TYPE_DICT ))) {
937        if(( sub = tr_bencDictFindType( sub, "ut_pex", TYPE_INT ))) {
938            msgs->ut_pex_id = (uint8_t) sub->val.i;
939            msgs->peerSupportsPex = msgs->ut_pex_id == 0 ? 0 : 1;
940            dbgmsg( msgs, "msgs->ut_pex is %d", (int)msgs->ut_pex_id );
941        }
942    }
943
944    /* get peer's listening port */
945    if(( sub = tr_bencDictFindType( &val, "p", TYPE_INT ))) {
946        msgs->info->port = htons( (uint16_t)sub->val.i );
947        dbgmsg( msgs, "msgs->port is now %hu", msgs->info->port );
948    }
949
950    tr_bencFree( &val );
951    tr_free( tmp );
952}
953
954static void
955parseUtPex( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
956{
957    int loaded = 0;
958    uint8_t * tmp = tr_new( uint8_t, msglen );
959    tr_benc val, *sub;
960    const tr_torrent * tor = msgs->torrent;
961    tr_peerIoReadBytes( msgs->io, inbuf, tmp, msglen );
962
963    if( tr_torrentAllowsPex( tor )
964        && (( loaded = !tr_bencLoad( tmp, msglen, &val, NULL )))
965        && (( sub = tr_bencDictFindType( &val, "added", TYPE_STR ))))
966    {
967        const int n = sub->val.s.i / 6 ;
968        if( n )
969            tr_tordbg( tor, _( "Got %d peers from peer exchange" ), n );
970        tr_peerMgrAddPeers( msgs->handle->peerMgr,
971                            tor->info.hash,
972                            TR_PEER_FROM_PEX,
973                            (uint8_t*)sub->val.s.s, n );
974    }
975
976    if( loaded )
977        tr_bencFree( &val );
978    tr_free( tmp );
979}
980
981static void
982sendPex( tr_peermsgs * msgs );
983
984static void
985parseLtep( tr_peermsgs * msgs, int msglen, struct evbuffer * inbuf )
986{
987    uint8_t ltep_msgid;
988
989    tr_peerIoReadUint8( msgs->io, inbuf, &ltep_msgid );
990    msglen--;
991
992    if( ltep_msgid == LTEP_HANDSHAKE )
993    {
994        dbgmsg( msgs, "got ltep handshake" );
995        parseLtepHandshake( msgs, msglen, inbuf );
996        if( tr_peerIoSupportsLTEP( msgs->io ) )
997        {
998            sendLtepHandshake( msgs );
999            sendPex( msgs );
1000        }
1001    }
1002    else if( ltep_msgid == TR_LTEP_PEX )
1003    {
1004        dbgmsg( msgs, "got ut pex" );
1005        msgs->peerSupportsPex = 1;
1006        parseUtPex( msgs, msglen, inbuf );
1007    }
1008    else
1009    {
1010        dbgmsg( msgs, "skipping unknown ltep message (%d)", (int)ltep_msgid );
1011        evbuffer_drain( inbuf, msglen );
1012    }
1013}
1014
1015static int
1016readBtLength( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
1017{
1018    uint32_t len;
1019
1020    if( inlen < sizeof(len) )
1021        return READ_MORE;
1022
1023    tr_peerIoReadUint32( msgs->io, inbuf, &len );
1024
1025    if( len == 0 ) /* peer sent us a keepalive message */
1026        dbgmsg( msgs, "got KeepAlive" );
1027    else {
1028        msgs->incoming.length = len;
1029        msgs->state = AWAITING_BT_ID;
1030    }
1031
1032    return READ_AGAIN;
1033}
1034
1035static int
1036readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen );
1037
1038static int
1039readBtId( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
1040{
1041    uint8_t id;
1042
1043    if( inlen < sizeof(uint8_t) )
1044        return READ_MORE;
1045
1046    tr_peerIoReadUint8( msgs->io, inbuf, &id );
1047    msgs->incoming.id = id;
1048
1049    if( id==BT_PIECE )
1050    {
1051        msgs->state = AWAITING_BT_PIECE;
1052        return READ_AGAIN;
1053    }
1054    else if( msgs->incoming.length != 1 )
1055    {
1056        msgs->state = AWAITING_BT_MESSAGE;
1057        return READ_AGAIN;
1058    }
1059    else return readBtMessage( msgs, inbuf, inlen-1 );
1060}
1061
1062static void
1063updatePeerProgress( tr_peermsgs * msgs )
1064{
1065    msgs->info->progress = tr_bitfieldCountTrueBits( msgs->info->have )
1066                         / (float)msgs->torrent->info.pieceCount;
1067    dbgmsg( msgs, "peer progress is %f", msgs->info->progress );
1068    updateInterest( msgs );
1069    firePeerProgress( msgs );
1070}
1071
1072static int
1073clientCanSendFastBlock( const tr_peermsgs * msgs UNUSED )
1074{
1075    /* don't send a fast piece if peer has MAX_FAST_ALLOWED_THRESHOLD pieces */
1076    if( tr_bitfieldCountTrueBits( msgs->info->have ) > MAX_FAST_ALLOWED_THRESHOLD )
1077        return FALSE;
1078   
1079    /* ...or if we don't have ourself enough pieces */
1080    if( tr_bitfieldCountTrueBits( tr_cpPieceBitfield( msgs->torrent->completion ) ) < MAX_FAST_ALLOWED_THRESHOLD )
1081        return FALSE;
1082
1083    /* Maybe a bandwidth limit ? */
1084    return TRUE;
1085}
1086
1087static void
1088peerMadeRequest( tr_peermsgs * msgs, const struct peer_request * req )
1089{
1090    const int reqIsValid = requestIsValid( msgs, req );
1091    const int clientHasPiece = reqIsValid && tr_cpPieceIsComplete( msgs->torrent->completion, req->index );
1092    const int peerIsChoked = msgs->info->peerIsChoked;
1093    const int peerIsFast = tr_peerIoSupportsFEXT( msgs->io );
1094    const int pieceIsFast = reqIsValid && tr_bitfieldHas( getPeerAllowedPieces( msgs ), req->index );
1095    const int canSendFast = clientCanSendFastBlock( msgs );
1096
1097    if( !reqIsValid ) /* bad request */
1098    {
1099        dbgmsg( msgs, "rejecting an invalid request." );
1100        sendFastReject( msgs, req->index, req->offset, req->length );
1101    }
1102    else if( !clientHasPiece ) /* we don't have it */
1103    {
1104        dbgmsg( msgs, "rejecting request for a piece we don't have." );
1105        sendFastReject( msgs, req->index, req->offset, req->length );
1106    }
1107    else if( peerIsChoked && !peerIsFast ) /* doesn't he know he's choked? */
1108    {
1109        tr_peerMsgsSetChoke( msgs, 1 );
1110        sendFastReject( msgs, req->index, req->offset, req->length );
1111    }
1112    else if( peerIsChoked && peerIsFast && ( !pieceIsFast || !canSendFast ) )
1113    {
1114        sendFastReject( msgs, req->index, req->offset, req->length );
1115    }
1116    else /* YAY */
1117    {
1118        if( peerIsFast && pieceIsFast )
1119            reqListAppend( &msgs->peerAskedForFast, req );
1120        else
1121            reqListAppend( &msgs->peerAskedFor, req );
1122    }
1123}
1124
1125static int
1126messageLengthIsCorrect( const tr_peermsgs * msg, uint8_t id, uint32_t len )
1127{
1128    switch( id )
1129    {
1130        case BT_CHOKE:
1131        case BT_UNCHOKE:
1132        case BT_INTERESTED:
1133        case BT_NOT_INTERESTED:
1134        case BT_HAVE_ALL:
1135        case BT_HAVE_NONE:
1136            return len==1;
1137
1138        case BT_HAVE:
1139        case BT_SUGGEST:
1140        case BT_ALLOWED_FAST:
1141            return len==5;
1142
1143        case BT_BITFIELD:
1144            return len == (msg->torrent->info.pieceCount+7u)/8u + 1u;
1145       
1146        case BT_REQUEST:
1147        case BT_CANCEL:
1148        case BT_REJECT:
1149            return len==13;
1150
1151        case BT_PIECE:
1152            return len>9 && len<=16393;
1153
1154        case BT_PORT:
1155            return len==3;
1156
1157        case BT_LTEP:
1158            return len >= 2;
1159
1160        default:
1161            return FALSE;
1162    }
1163}
1164
1165static int
1166clientGotBlock( tr_peermsgs * msgs, const uint8_t * block, const struct peer_request * req );
1167
1168static void
1169clientGotBytes( tr_peermsgs * msgs, uint32_t byteCount )
1170{
1171    const time_t now = time( NULL );
1172    tr_torrent * tor = msgs->torrent;
1173    tor->activityDate = tr_date( );
1174    tor->downloadedCur += byteCount;
1175    msgs->info->pieceDataActivityDate = now;
1176    msgs->info->credit += (int)(byteCount * SWIFT_REPAYMENT_RATIO);
1177    tr_rcTransferred( msgs->info->rcToClient, byteCount );
1178    tr_rcTransferred( tor->download, byteCount );
1179    tr_rcTransferred( tor->handle->download, byteCount );
1180    tr_statsAddDownloaded( msgs->handle, byteCount );
1181    firePieceData( msgs );
1182}
1183
1184static int
1185readBtPiece( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
1186{
1187    struct peer_request * req = &msgs->incoming.blockReq;
1188    assert( EVBUFFER_LENGTH(inbuf) >= inlen );
1189    dbgmsg( msgs, "In readBtPiece" );
1190
1191    if( !req->length )
1192    {
1193        if( inlen < 8 )
1194            return READ_MORE;
1195
1196        tr_peerIoReadUint32( msgs->io, inbuf, &req->index );
1197        tr_peerIoReadUint32( msgs->io, inbuf, &req->offset );
1198        req->length = msgs->incoming.length - 9;
1199        dbgmsg( msgs, "got incoming block header %u:%u->%u", req->index, req->offset, req->length );
1200        return READ_AGAIN;
1201    }
1202    else
1203    {
1204        int err;
1205
1206        /* read in another chunk of data */
1207        const size_t nLeft = req->length - EVBUFFER_LENGTH(msgs->incoming.block);
1208        size_t n = MIN( nLeft, inlen );
1209        uint8_t * buf = tr_new( uint8_t, n );
1210        assert( EVBUFFER_LENGTH(inbuf) >= n );
1211        tr_peerIoReadBytes( msgs->io, inbuf, buf, n );
1212        evbuffer_add( msgs->incoming.block, buf, n );
1213        clientGotBytes( msgs, n );
1214        tr_free( buf );
1215        dbgmsg( msgs, "got %d bytes for block %u:%u->%u ... %d remain",
1216               (int)n, req->index, req->offset, req->length,
1217               (int)( req->length - EVBUFFER_LENGTH(msgs->incoming.block) ) );
1218        if( EVBUFFER_LENGTH(msgs->incoming.block) < req->length )
1219            return READ_MORE;
1220
1221        /* we've got the whole block ... process it */
1222        err = clientGotBlock( msgs, EVBUFFER_DATA(msgs->incoming.block), req );
1223
1224        /* cleanup */
1225        evbuffer_drain( msgs->incoming.block, EVBUFFER_LENGTH(msgs->incoming.block) );
1226        req->length = 0;
1227        msgs->state = AWAITING_BT_LENGTH;
1228        if( !err )
1229            return READ_AGAIN;
1230        else {
1231            fireError( msgs, err );
1232            return READ_DONE;
1233        }
1234    }
1235}
1236
1237static int
1238readBtMessage( tr_peermsgs * msgs, struct evbuffer * inbuf, size_t inlen )
1239{
1240    uint32_t ui32;
1241    uint32_t msglen = msgs->incoming.length;
1242    const uint8_t id = msgs->incoming.id;
1243    const size_t startBufLen = EVBUFFER_LENGTH( inbuf );
1244
1245    --msglen; /* id length */
1246
1247    if( inlen < msglen )
1248        return READ_MORE;
1249
1250    dbgmsg( msgs, "got BT id %d, len %d, buffer size is %d", (int)id, (int)msglen, (int)inlen );
1251
1252    if( !messageLengthIsCorrect( msgs, id, msglen+1 ) )
1253    {
1254        dbgmsg( msgs, "bad packet - BT message #%d with a length of %d", (int)id, (int)msglen );
1255        fireError( msgs, TR_ERROR );
1256        return READ_DONE;
1257    }
1258
1259    switch( id )
1260    {
1261        case BT_CHOKE:
1262            dbgmsg( msgs, "got Choke" );
1263            msgs->info->clientIsChoked = 1;
1264            cancelAllRequestsToPeer( msgs );
1265            cancelAllRequestsToClientExceptFast( msgs );
1266            break;
1267
1268        case BT_UNCHOKE:
1269            dbgmsg( msgs, "got Unchoke" );
1270            msgs->info->clientIsChoked = 0;
1271            fireNeedReq( msgs );
1272            break;
1273
1274        case BT_INTERESTED:
1275            dbgmsg( msgs, "got Interested" );
1276            msgs->info->peerIsInterested = 1;
1277            tr_peerMsgsSetChoke( msgs, 0 );
1278            break;
1279
1280        case BT_NOT_INTERESTED:
1281            dbgmsg( msgs, "got Not Interested" );
1282            msgs->info->peerIsInterested = 0;
1283            break;
1284           
1285        case BT_HAVE:
1286            tr_peerIoReadUint32( msgs->io, inbuf, &ui32 );
1287            dbgmsg( msgs, "got Have: %u", ui32 );
1288            if( tr_bitfieldAdd( msgs->info->have, ui32 ) )
1289                fireError( msgs, TR_ERROR_PEER_MESSAGE );
1290            updatePeerProgress( msgs );
1291            tr_rcTransferred( msgs->torrent->swarmspeed, msgs->torrent->info.pieceSize );
1292            break;
1293
1294        case BT_BITFIELD: {
1295            const int clientIsSeed = tr_torrentIsSeed( msgs->torrent );
1296            dbgmsg( msgs, "got a bitfield" );
1297            msgs->peerSentBitfield = 1;
1298            tr_peerIoReadBytes( msgs->io, inbuf, msgs->info->have->bits, msglen );
1299            updatePeerProgress( msgs );
1300            maybeSendFastAllowedSet( msgs );
1301            tr_peerMsgsSetChoke( msgs, !clientIsSeed || (msgs->info->progress<1.0) );
1302            fireNeedReq( msgs );
1303            break;
1304        }
1305
1306        case BT_REQUEST: {
1307            struct peer_request r;
1308            tr_peerIoReadUint32( msgs->io, inbuf, &r.index );
1309            tr_peerIoReadUint32( msgs->io, inbuf, &r.offset );
1310            tr_peerIoReadUint32( msgs->io, inbuf, &r.length );
1311            dbgmsg( msgs, "got Request: %u:%u->%u", r.index, r.offset, r.length );
1312            peerMadeRequest( msgs, &r );
1313            break;
1314        }
1315
1316        case BT_CANCEL: {
1317            struct peer_request r;
1318            tr_peerIoReadUint32( msgs->io, inbuf, &r.index );
1319            tr_peerIoReadUint32( msgs->io, inbuf, &r.offset );
1320            tr_peerIoReadUint32( msgs->io, inbuf, &r.length );
1321            dbgmsg( msgs, "got a Cancel %u:%u->%u", r.index, r.offset, r.length );
1322            reqListRemove( &msgs->peerAskedForFast, &r );
1323            reqListRemove( &msgs->peerAskedFor, &r );
1324            break;
1325        }
1326
1327        case BT_PIECE:
1328            assert( 0 ); /* handled elsewhere! */
1329            break;
1330       
1331        case BT_PORT:
1332            dbgmsg( msgs, "Got a BT_PORT" );
1333            tr_peerIoReadUint16( msgs->io, inbuf, &msgs->info->port );
1334            break;
1335           
1336        case BT_SUGGEST: {
1337            dbgmsg( msgs, "Got a BT_SUGGEST" );
1338            tr_peerIoReadUint32( msgs->io, inbuf, &ui32 );
1339            /* we don't do anything with this yet */
1340            break;
1341        }
1342           
1343        case BT_HAVE_ALL:
1344            dbgmsg( msgs, "Got a BT_HAVE_ALL" );
1345            tr_bitfieldAddRange( msgs->info->have, 0, msgs->torrent->info.pieceCount );
1346            updatePeerProgress( msgs );
1347            maybeSendFastAllowedSet( msgs );
1348            break;
1349       
1350       
1351        case BT_HAVE_NONE:
1352            dbgmsg( msgs, "Got a BT_HAVE_NONE" );
1353            tr_bitfieldClear( msgs->info->have );
1354            updatePeerProgress( msgs );
1355            maybeSendFastAllowedSet( msgs );
1356            break;
1357       
1358        case BT_REJECT: {
1359            struct peer_request r;
1360            dbgmsg( msgs, "Got a BT_REJECT" );
1361            tr_peerIoReadUint32( msgs->io, inbuf, &r.index );
1362            tr_peerIoReadUint32( msgs->io, inbuf, &r.offset );
1363            tr_peerIoReadUint32( msgs->io, inbuf, &r.length );
1364            reqListRemove( &msgs->clientAskedFor, &r );
1365            break;
1366        }
1367
1368        case BT_ALLOWED_FAST: {
1369            dbgmsg( msgs, "Got a BT_ALLOWED_FAST" );
1370            tr_peerIoReadUint32( msgs->io, inbuf, &ui32 );
1371            /* we don't do anything with this yet */
1372            break;
1373        }
1374
1375        case BT_LTEP:
1376            dbgmsg( msgs, "Got a BT_LTEP" );
1377            parseLtep( msgs, msglen, inbuf );
1378            break;
1379
1380        default:
1381            dbgmsg( msgs, "peer sent us an UNKNOWN: %d", (int)id );
1382            tr_peerIoDrain( msgs->io, inbuf, msglen );
1383            break;
1384    }
1385
1386    assert( msglen + 1 == msgs->incoming.length );
1387    assert( EVBUFFER_LENGTH(inbuf) == startBufLen - msglen );
1388
1389    msgs->state = AWAITING_BT_LENGTH;
1390    return READ_AGAIN;
1391}
1392
1393static void
1394peerGotBytes( tr_peermsgs * msgs, uint32_t byteCount )
1395{
1396    const time_t now = time( NULL );
1397    tr_torrent * tor = msgs->torrent;
1398    tor->activityDate = tr_date( );
1399    tor->uploadedCur += byteCount;
1400    msgs->info->pieceDataActivityDate = now;
1401    msgs->info->credit -= byteCount;
1402    tr_rcTransferred( msgs->info->rcToPeer, byteCount );
1403    tr_rcTransferred( tor->upload, byteCount );
1404    tr_rcTransferred( tor->handle->upload, byteCount );
1405    tr_statsAddUploaded( msgs->handle, byteCount );
1406    firePieceData( msgs );
1407}
1408
1409static size_t
1410getDownloadMax( const tr_peermsgs * msgs )
1411{
1412    static const size_t maxval = ~0;
1413    const tr_torrent * tor = msgs->torrent;
1414
1415    if( tor->downloadLimitMode == TR_SPEEDLIMIT_GLOBAL )
1416        return tor->handle->useDownloadLimit
1417            ? tr_rcBytesLeft( tor->handle->download ) : maxval;
1418
1419    if( tor->downloadLimitMode == TR_SPEEDLIMIT_SINGLE )
1420        return tr_rcBytesLeft( tor->download );
1421
1422    return maxval;
1423}
1424
1425static void
1426decrementDownloadedCount( tr_peermsgs * msgs, uint32_t byteCount )
1427{
1428    tr_torrent * tor = msgs->torrent;
1429    tor->downloadedCur -= MIN( tor->downloadedCur, byteCount );
1430}
1431
1432static void
1433reassignBytesToCorrupt( tr_peermsgs * msgs, uint32_t byteCount )
1434{
1435    tr_torrent * tor = msgs->torrent;
1436
1437    tor->corruptCur += byteCount;
1438
1439    decrementDownloadedCount( msgs, byteCount );
1440}
1441
1442static void
1443gotBadPiece( tr_peermsgs * msgs, tr_piece_index_t pieceIndex )
1444{
1445    const uint32_t byteCount =
1446        tr_torPieceCountBytes( msgs->torrent, pieceIndex );
1447    reassignBytesToCorrupt( msgs, byteCount );
1448}
1449
1450static void
1451clientGotUnwantedBlock( tr_peermsgs * msgs, const struct peer_request * req )
1452{
1453    decrementDownloadedCount( msgs, req->length );
1454}
1455
1456static void
1457addPeerToBlamefield( tr_peermsgs * msgs, uint32_t index )
1458{
1459    if( !msgs->info->blame )
1460         msgs->info->blame = tr_bitfieldNew( msgs->torrent->info.pieceCount );
1461    tr_bitfieldAdd( msgs->info->blame, index );
1462}
1463
1464static tr_errno
1465clientGotBlock( tr_peermsgs                * msgs,
1466                const uint8_t              * data,
1467                const struct peer_request  * req )
1468{
1469    int err;
1470    tr_torrent * tor = msgs->torrent;
1471    const tr_block_index_t block = _tr_block( tor, req->index, req->offset );
1472
1473    assert( msgs != NULL );
1474    assert( req != NULL );
1475
1476    if( req->length != tr_torBlockCountBytes( msgs->torrent, block ) )
1477    {
1478        dbgmsg( msgs, "wrong block size -- expected %u, got %d",
1479                tr_torBlockCountBytes( msgs->torrent, block ), req->length );
1480        return TR_ERROR;
1481    }
1482
1483    /* save the block */
1484    dbgmsg( msgs, "got block %u:%u->%u", req->index, req->offset, req->length );
1485
1486    /**
1487    *** Remove the block from our `we asked for this' list
1488    **/
1489
1490    if( reqListRemove( &msgs->clientAskedFor, req ) )
1491    {
1492        clientGotUnwantedBlock( msgs, req );
1493        dbgmsg( msgs, "we didn't ask for this message..." );
1494        return 0;
1495    }
1496
1497    dbgmsg( msgs, "peer has %d more blocks we've asked for",
1498                  msgs->clientAskedFor.count );
1499
1500    /**
1501    *** Error checks
1502    **/
1503
1504    if( tr_cpBlockIsComplete( tor->completion, block ) ) {
1505        dbgmsg( msgs, "we have this block already..." );
1506        clientGotUnwantedBlock( msgs, req );
1507        return 0;
1508    }
1509
1510    /**
1511    ***  Save the block
1512    **/
1513
1514    msgs->info->peerSentPieceDataAt = time( NULL );
1515    if(( err = tr_ioWrite( tor, req->index, req->offset, req->length, data )))
1516        return err;
1517
1518    tr_cpBlockAdd( tor->completion, block );
1519
1520    addPeerToBlamefield( msgs, req->index );
1521
1522    fireGotBlock( msgs, req );
1523
1524    /**
1525    ***  Handle if this was the last block in the piece
1526    **/
1527
1528    if( tr_cpPieceIsComplete( tor->completion, req->index ) )
1529    {
1530        const tr_errno err = tr_ioTestPiece( tor, req->index );
1531
1532        if( err )
1533            tr_torerr( tor, _( "Piece %lu, which was just downloaded, failed its checksum test: %s" ),
1534                       (unsigned long)req->index,
1535                       tr_errorString( err ) );
1536
1537        tr_torrentSetHasPiece( tor, req->index, !err );
1538        tr_torrentSetPieceChecked( tor, req->index, TRUE );
1539        tr_peerMgrSetBlame( tor->handle->peerMgr, tor->info.hash, req->index, !err );
1540
1541        if( !err )
1542            fireClientHave( msgs, req->index );
1543        else
1544            gotBadPiece( msgs, req->index );
1545    }
1546
1547    return 0;
1548}
1549
1550static void
1551didWrite( struct bufferevent * evin UNUSED, void * vmsgs )
1552{
1553    pulse( vmsgs );
1554}
1555
1556static ReadState
1557canRead( struct bufferevent * evin, void * vmsgs )
1558{
1559    ReadState ret;
1560    tr_peermsgs * msgs = vmsgs;
1561    struct evbuffer * in = EVBUFFER_INPUT ( evin );
1562    const size_t inlen = EVBUFFER_LENGTH( in );
1563
1564    if( !inlen )
1565    {
1566        ret = READ_DONE;
1567    }
1568    else if( msgs->state == AWAITING_BT_PIECE )
1569    {
1570        const size_t downloadMax = getDownloadMax( msgs );
1571        const size_t n = MIN( inlen, downloadMax );
1572        ret = n ? readBtPiece( msgs, in, n ) : READ_DONE;
1573    }
1574    else switch( msgs->state )
1575    {
1576        case AWAITING_BT_LENGTH:  ret = readBtLength ( msgs, in, inlen ); break;
1577        case AWAITING_BT_ID:      ret = readBtId     ( msgs, in, inlen ); break;
1578        case AWAITING_BT_MESSAGE: ret = readBtMessage( msgs, in, inlen ); break;
1579        default:                  assert( 0 );
1580    }
1581
1582    return ret;
1583}
1584
1585static void
1586sendKeepalive( tr_peermsgs * msgs )
1587{
1588    dbgmsg( msgs, "sending a keepalive message" );
1589    tr_peerIoWriteUint32( msgs->io, msgs->outMessages, 0 );
1590}
1591
1592/**
1593***
1594**/
1595
1596static int
1597isSwiftEnabled( const tr_peermsgs * msgs )
1598{
1599    /* rationale: SWIFT is good for getting rid of deadbeats, but most
1600     * private trackers have ratios where you _want_ to feed deadbeats
1601     * as much as possible.  So we disable SWIFT on private torrents */
1602    return SWIFT_ENABLED
1603        && !tr_torrentIsSeed( msgs->torrent )
1604        && !tr_torrentIsPrivate( msgs->torrent );
1605}
1606
1607static size_t
1608getUploadMax( const tr_peermsgs * msgs )
1609{
1610    static const size_t maxval = ~0;
1611    const tr_torrent * tor = msgs->torrent;
1612    const int useSwift = isSwiftEnabled( msgs );
1613    const size_t swiftLeft = msgs->info->credit;
1614    size_t speedLeft;
1615    size_t bufLeft;
1616    size_t ret;
1617
1618    if( tor->uploadLimitMode == TR_SPEEDLIMIT_GLOBAL )
1619        speedLeft = tor->handle->useUploadLimit ? tr_rcBytesLeft( tor->handle->upload ) : maxval;
1620    else if( tor->uploadLimitMode == TR_SPEEDLIMIT_SINGLE )
1621        speedLeft = tr_rcBytesLeft( tor->upload );
1622    else
1623        speedLeft = ~0;
1624
1625    bufLeft = MAX_OUTBUF_SIZE - tr_peerIoWriteBytesWaiting( msgs->io );
1626    ret = MIN( speedLeft, bufLeft );
1627    if( useSwift)
1628        ret = MIN( ret, swiftLeft );
1629    return ret;
1630}
1631
1632static int
1633ratePulse( void * vmsgs )
1634{
1635    tr_peermsgs * msgs = (tr_peermsgs *) vmsgs;
1636    msgs->info->rateToClient = tr_rcRate( msgs->info->rcToClient );
1637    msgs->info->rateToPeer = tr_rcRate( msgs->info->rcToPeer );
1638    msgs->maxActiveRequests = MIN( 4 + (int)(msgs->info->rateToClient/4), MAX_QUEUE_SIZE );
1639    msgs->minActiveRequests = msgs->maxActiveRequests / 3;
1640    return TRUE;
1641}
1642
1643static tr_errno
1644popNextRequest( tr_peermsgs * msgs, struct peer_request * setme )
1645{
1646    if( !reqListPop( &msgs->peerAskedForFast, setme ) )
1647        return 0;
1648    if( !reqListPop( &msgs->peerAskedFor, setme ) )
1649        return 0;
1650
1651    return TR_ERROR;
1652}
1653
1654static int
1655pulse( void * vmsgs )
1656{
1657    const time_t now = time( NULL );
1658    tr_peermsgs * msgs = vmsgs;
1659
1660    tr_peerIoTryRead( msgs->io );
1661    pumpRequestQueue( msgs );
1662    expireOldRequests( msgs );
1663
1664    if( msgs->sendingBlock )
1665    {
1666        const size_t uploadMax = getUploadMax( msgs );
1667        size_t len = EVBUFFER_LENGTH( msgs->outBlock );
1668        const size_t outlen = MIN( len, uploadMax );
1669
1670        assert( len );
1671
1672        if( outlen )
1673        {
1674            tr_peerIoWrite( msgs->io, EVBUFFER_DATA( msgs->outBlock ), outlen );
1675            evbuffer_drain( msgs->outBlock, outlen );
1676            peerGotBytes( msgs, outlen );
1677
1678            len -= outlen;
1679            msgs->clientSentAnythingAt = now;
1680            msgs->sendingBlock = len!=0;
1681
1682            dbgmsg( msgs, "wrote %d bytes; %d left in block", (int)outlen, (int)len );
1683        }
1684        else dbgmsg( msgs, "stalled writing block... uploadMax %lu, outlen %lu", uploadMax, outlen );
1685    }
1686
1687    if( !msgs->sendingBlock )
1688    {
1689        struct peer_request req;
1690
1691        if(( EVBUFFER_LENGTH( msgs->outMessages ) ))
1692        {
1693            dbgmsg( msgs, "flushing outMessages..." );
1694            tr_peerIoWriteBuf( msgs->io, msgs->outMessages );
1695            msgs->clientSentAnythingAt = now;
1696        }
1697        else if( !EVBUFFER_LENGTH( msgs->outBlock )
1698            && !popNextRequest( msgs, &req )
1699            && requestIsValid( msgs, &req )
1700            && tr_cpPieceIsComplete( msgs->torrent->completion, req.index ) )
1701        {
1702            uint8_t * buf = tr_new( uint8_t, req.length );
1703
1704            if( !tr_ioRead( msgs->torrent, req.index, req.offset, req.length, buf ) )
1705            {
1706                tr_peerIo * io = msgs->io;
1707                struct evbuffer * out = msgs->outBlock;
1708
1709                dbgmsg( msgs, "sending block %u:%u->%u", req.index, req.offset, req.length );
1710                tr_peerIoWriteUint32( io, out, sizeof(uint8_t) + 2*sizeof(uint32_t) + req.length );
1711                tr_peerIoWriteUint8 ( io, out, BT_PIECE );
1712                tr_peerIoWriteUint32( io, out, req.index );
1713                tr_peerIoWriteUint32( io, out, req.offset );
1714                tr_peerIoWriteBytes ( io, out, buf, req.length );
1715                msgs->sendingBlock = 1;
1716            }
1717
1718            tr_free( buf );
1719        }
1720        else if( ( now - msgs->clientSentAnythingAt ) > KEEPALIVE_INTERVAL_SECS )
1721        {
1722            sendKeepalive( msgs );
1723        }
1724    }
1725
1726    return TRUE; /* loop forever */
1727}
1728
1729static void
1730gotError( struct bufferevent * evbuf UNUSED, short what, void * vmsgs )
1731{
1732    if( what & EVBUFFER_TIMEOUT )
1733        dbgmsg( vmsgs, "libevent got a timeout, what=%hd", what );
1734    if( what & ( EVBUFFER_EOF | EVBUFFER_ERROR ) )
1735        dbgmsg( vmsgs, "libevent got an error! what=%hd, errno=%d (%s)",
1736                what, errno, tr_strerror(errno) );
1737    fireError( vmsgs, TR_ERROR );
1738}
1739
1740static void
1741sendBitfield( tr_peermsgs * msgs )
1742{
1743    const tr_bitfield * bitfield = tr_cpPieceBitfield( msgs->torrent->completion );
1744    struct evbuffer * out = msgs->outMessages;
1745
1746    dbgmsg( msgs, "sending peer a bitfield message" );
1747    tr_peerIoWriteUint32( msgs->io, out, sizeof(uint8_t) + bitfield->len );
1748    tr_peerIoWriteUint8 ( msgs->io, out, BT_BITFIELD );
1749    tr_peerIoWriteBytes ( msgs->io, out, bitfield->bits, bitfield->len );
1750}
1751
1752/**
1753***
1754**/
1755
1756/* some peers give us error messages if we send
1757   more than this many peers in a single pex message */
1758#define MAX_PEX_DIFFS 200
1759
1760typedef struct
1761{
1762    tr_pex * added;
1763    tr_pex * dropped;
1764    tr_pex * elements;
1765    int addedCount;
1766    int droppedCount;
1767    int elementCount;
1768    int diffCount;
1769}
1770PexDiffs;
1771
1772static void
1773pexAddedCb( void * vpex, void * userData )
1774{
1775    PexDiffs * diffs = (PexDiffs *) userData;
1776    tr_pex * pex = (tr_pex *) vpex;
1777    if( diffs->diffCount < MAX_PEX_DIFFS )
1778    {
1779        diffs->diffCount++;
1780        diffs->added[diffs->addedCount++] = *pex;
1781        diffs->elements[diffs->elementCount++] = *pex;
1782    }
1783}
1784
1785static void
1786pexRemovedCb( void * vpex, void * userData )
1787{
1788    PexDiffs * diffs = (PexDiffs *) userData;
1789    tr_pex * pex = (tr_pex *) vpex;
1790    if( diffs->diffCount < MAX_PEX_DIFFS )
1791    {
1792        diffs->diffCount++;
1793        diffs->dropped[diffs->droppedCount++] = *pex;
1794    }
1795}
1796
1797static void
1798pexElementCb( void * vpex, void * userData )
1799{
1800    PexDiffs * diffs = (PexDiffs *) userData;
1801    tr_pex * pex = (tr_pex *) vpex;
1802    if( diffs->diffCount < MAX_PEX_DIFFS )
1803    {
1804        diffs->diffCount++;
1805        diffs->elements[diffs->elementCount++] = *pex;
1806    }
1807}
1808
1809static void
1810sendPex( tr_peermsgs * msgs )
1811{
1812    if( msgs->peerSupportsPex && tr_torrentAllowsPex( msgs->torrent ) )
1813    {
1814        int i;
1815        tr_pex * newPex = NULL;
1816        const int newCount = tr_peerMgrGetPeers( msgs->handle->peerMgr, msgs->torrent->info.hash, &newPex );
1817        PexDiffs diffs;
1818        tr_benc val, *added, *dropped, *flags;
1819        uint8_t *tmp, *walk;
1820        char * benc;
1821        int bencLen;
1822
1823        /* build the diffs */
1824        diffs.added = tr_new( tr_pex, newCount );
1825        diffs.addedCount = 0;
1826        diffs.dropped = tr_new( tr_pex, msgs->pexCount );
1827        diffs.droppedCount = 0;
1828        diffs.elements = tr_new( tr_pex, newCount + msgs->pexCount );
1829        diffs.elementCount = 0;
1830        diffs.diffCount = 0;
1831        tr_set_compare( msgs->pex, msgs->pexCount,
1832                        newPex, newCount,
1833                        tr_pexCompare, sizeof(tr_pex),
1834                        pexRemovedCb, pexAddedCb, pexElementCb, &diffs );
1835        dbgmsg( msgs, "pex: old peer count %d, new peer count %d, added %d, removed %d", msgs->pexCount, newCount, diffs.addedCount, diffs.droppedCount );
1836
1837        /* update peer */
1838        tr_free( msgs->pex );
1839        msgs->pex = diffs.elements;
1840        msgs->pexCount = diffs.elementCount;
1841
1842        /* build the pex payload */
1843        tr_bencInit( &val, TYPE_DICT );
1844        tr_bencDictReserve( &val, 3 );
1845
1846        /* "added" */
1847        added = tr_bencDictAdd( &val, "added" );
1848        tmp = walk = tr_new( uint8_t, diffs.addedCount * 6 );
1849        for( i=0; i<diffs.addedCount; ++i ) {
1850            memcpy( walk, &diffs.added[i].in_addr, 4 ); walk += 4;
1851            memcpy( walk, &diffs.added[i].port, 2 ); walk += 2;
1852        }
1853        assert( ( walk - tmp ) == diffs.addedCount * 6 );
1854        tr_bencInitStr( added, tmp, walk-tmp, FALSE );
1855
1856        /* "added.f" */
1857        flags = tr_bencDictAdd( &val, "added.f" );
1858        tmp = walk = tr_new( uint8_t, diffs.addedCount );
1859        for( i=0; i<diffs.addedCount; ++i )
1860            *walk++ = diffs.added[i].flags;
1861        assert( ( walk - tmp ) == diffs.addedCount );
1862        tr_bencInitStr( flags, tmp, walk-tmp, FALSE );
1863
1864        /* "dropped" */
1865        dropped = tr_bencDictAdd( &val, "dropped" );
1866        tmp = walk = tr_new( uint8_t, diffs.droppedCount * 6 );
1867        for( i=0; i<diffs.droppedCount; ++i ) {
1868            memcpy( walk, &diffs.dropped[i].in_addr, 4 ); walk += 4;
1869            memcpy( walk, &diffs.dropped[i].port, 2 ); walk += 2;
1870        }
1871        assert( ( walk - tmp ) == diffs.droppedCount * 6 );
1872        tr_bencInitStr( dropped, tmp, walk-tmp, FALSE );
1873
1874        /* write the pex message */
1875        benc = tr_bencSave( &val, &bencLen );
1876        tr_peerIoWriteUint32( msgs->io, msgs->outMessages, 2*sizeof(uint8_t) + bencLen );
1877        tr_peerIoWriteUint8 ( msgs->io, msgs->outMessages, BT_LTEP );
1878        tr_peerIoWriteUint8 ( msgs->io, msgs->outMessages, msgs->ut_pex_id );
1879        tr_peerIoWriteBytes ( msgs->io, msgs->outMessages, benc, bencLen );
1880
1881        /* cleanup */
1882        tr_free( benc );
1883        tr_bencFree( &val );
1884        tr_free( diffs.added );
1885        tr_free( diffs.dropped );
1886        tr_free( newPex );
1887
1888        msgs->clientSentPexAt = time( NULL );
1889    }
1890}
1891
1892static int
1893pexPulse( void * vpeer )
1894{
1895    sendPex( vpeer );
1896    return TRUE;
1897}
1898
1899/**
1900***
1901**/
1902
1903tr_peermsgs*
1904tr_peerMsgsNew( struct tr_torrent * torrent,
1905                struct tr_peer    * info,
1906                tr_delivery_func    func,
1907                void              * userData,
1908                tr_publisher_tag  * setme )
1909{
1910    tr_peermsgs * m;
1911
1912    assert( info != NULL );
1913    assert( info->io != NULL );
1914
1915    m = tr_new0( tr_peermsgs, 1 );
1916    m->publisher = tr_publisherNew( );
1917    m->info = info;
1918    m->handle = torrent->handle;
1919    m->torrent = torrent;
1920    m->io = info->io;
1921    m->info->clientIsChoked = 1;
1922    m->info->peerIsChoked = 1;
1923    m->info->clientIsInterested = 0;
1924    m->info->peerIsInterested = 0;
1925    m->info->have = tr_bitfieldNew( torrent->info.pieceCount );
1926    m->state = AWAITING_BT_LENGTH;
1927    m->pulseTimer = tr_timerNew( m->handle, pulse, m, PEER_PULSE_INTERVAL );
1928    m->rateTimer = tr_timerNew( m->handle, ratePulse, m, RATE_PULSE_INTERVAL );
1929    m->pexTimer = tr_timerNew( m->handle, pexPulse, m, PEX_INTERVAL );
1930    m->outMessages = evbuffer_new( );
1931    m->incoming.block = evbuffer_new( );
1932    m->outBlock = evbuffer_new( );
1933    m->peerAllowedPieces = NULL;
1934    m->peerAskedFor = REQUEST_LIST_INIT;
1935    m->peerAskedForFast = REQUEST_LIST_INIT;
1936    m->clientAskedFor = REQUEST_LIST_INIT;
1937    m->clientWillAskFor = REQUEST_LIST_INIT;
1938    *setme = tr_publisherSubscribe( m->publisher, func, userData );
1939
1940    if ( tr_peerIoSupportsLTEP( m->io ) )
1941        sendLtepHandshake( m );
1942
1943    /* bitfield/have-all/have-none must preceed other non-handshake messages... */
1944    if ( !tr_peerIoSupportsFEXT( m->io ) )
1945        sendBitfield( m );
1946    else {
1947        /* This peer is fastpeer-enabled, send it have-all or have-none if appropriate */
1948        float completion = tr_cpPercentComplete( m->torrent->completion );
1949        if ( completion == 0.0f ) {
1950            sendFastHave( m, 0 );
1951        } else if ( completion == 1.0f ) {
1952            sendFastHave( m, 1 );
1953        } else {
1954            sendBitfield( m );
1955        }
1956    }
1957   
1958    tr_peerIoSetTimeoutSecs( m->io, 150 ); /* timeout after N seconds of inactivity */
1959    tr_peerIoSetIOFuncs( m->io, canRead, didWrite, gotError, m );
1960    ratePulse( m );
1961
1962    return m;
1963}
1964
1965void
1966tr_peerMsgsFree( tr_peermsgs* msgs )
1967{
1968    if( msgs != NULL )
1969    {
1970        tr_timerFree( &msgs->pulseTimer );
1971        tr_timerFree( &msgs->rateTimer );
1972        tr_timerFree( &msgs->pexTimer );
1973        tr_publisherFree( &msgs->publisher );
1974        reqListClear( &msgs->clientWillAskFor );
1975        reqListClear( &msgs->clientAskedFor );
1976        reqListClear( &msgs->peerAskedForFast );
1977        reqListClear( &msgs->peerAskedFor );
1978        tr_bitfieldFree( msgs->peerAllowedPieces );
1979        evbuffer_free( msgs->incoming.block );
1980        evbuffer_free( msgs->outMessages );
1981        evbuffer_free( msgs->outBlock );
1982        tr_free( msgs->pex );
1983
1984        memset( msgs, ~0, sizeof( tr_peermsgs ) );
1985        tr_free( msgs );
1986    }
1987}
1988
1989tr_publisher_tag
1990tr_peerMsgsSubscribe( tr_peermsgs       * peer,
1991                      tr_delivery_func    func,
1992                      void              * userData )
1993{
1994    return tr_publisherSubscribe( peer->publisher, func, userData );
1995}
1996
1997void
1998tr_peerMsgsUnsubscribe( tr_peermsgs       * peer,
1999                        tr_publisher_tag    tag )
2000{
2001    tr_publisherUnsubscribe( peer->publisher, tag );
2002}
Note: See TracBrowser for help on using the repository browser.