btpeer :: core bittorrent client functionality implemented in C++

00001 
00006 /*
00007 Copyright (C) 2005  Anders Hedstrom
00008 
00009 This program is free software; you can redistribute it and/or
00010 modify it under the terms of the GNU General Public License
00011 as published by the Free Software Foundation; either version 2
00012 of the License, or (at your option) any later version.
00013 
00014 This program is distributed in the hope that it will be useful,
00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017 GNU General Public License for more details.
00018 
00019 You should have received a copy of the GNU General Public License
00020 along with this program; if not, write to the Free Software
00021 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
00022 */
00023 #ifdef _WIN32
00024 #pragma warning(disable:4786)
00025 #endif
00026 #include <ISocketHandler.h>
00027 
00028 #include "Session.h"
00029 #include "PeerHandler.h"
00030 #include "pSocket.h"
00031 #include "Piece.h"
00032 #include "Peer.h"
00033 
00034 #ifdef _DEBUG
00035 #define DEB(x) x
00036 #else
00037 #define DEB(x)
00038 #endif
00039 
00040 
00041 
00042 Peer::Peer(ISocketHandler& h,const std::string& hash,const std::string& ip,const std::string& id,port_t port)
00043 :m_handler(h)
00044 ,m_hash(hash)
00045 ,m_ip(ip)
00046 ,m_id(id)
00047 ,m_port(port)
00048 ,m_bitmap(NULL)
00049 ,m_bitmap_size(0)
00050 ,m_choke(true)
00051 ,m_interested(false)
00052 ,m_t_choke(0)
00053 ,m_tried(false)
00054 ,m_failed(false)
00055 {
00056 DEB(    printf("%s:%d\n", ip.c_str(), port);)
00057         Session *sess = static_cast<PeerHandler&>(Handler()).GetSession(hash);
00058         if (sess)
00059         {
00060                 size_t n = sess -> GetNumberOfPieces();
00061                 m_bitmap = new bitmap_t(n);
00062                 m_bitmap_size = m_bitmap -> GetBitmapSize();
00063         }
00064 }
00065 
00066 
00067 Peer::~Peer()
00068 {
00069         if (m_bitmap)
00070                 delete m_bitmap;
00071         while (m_requests.size())
00072         {
00073                 request_v::iterator it = m_requests.begin();
00074                 Request *r = *it;
00075                 delete r;
00076                 m_requests.erase(it);
00077         }
00078 }
00079 
00080 
00081 bool Peer::Connected()
00082 {
00083         pSocket *p = PeerSocket();
00084         return p ? static_cast<PeerHandler&>(Handler()).Connected(this) && p -> CTS() : false;
00085 }
00086 
00087 
00088 pSocket *Peer::PeerSocket()
00089 {
00090         return static_cast<PeerHandler&>(Handler()).PeerSocket(this);
00091 }
00092 
00093 
00094 void Peer::set(size_t piece)
00095 {
00096         if (m_bitmap)
00097                 m_bitmap -> set(piece);
00098 }
00099 
00100 
00101 size_t Peer::GotSlice(size_t piece,size_t offset)
00102 {
00103         for (request_v::iterator it = m_requests.begin(); it != m_requests.end(); it++)
00104         {
00105                 Request *r = *it;
00106                 if (r -> GetPiece() == piece && r -> GetOffset() == offset)
00107                 {
00108                         size_t l = r -> GetLength();
00109                         delete r;
00110                         m_requests.erase(it);
00111                         // TODO: reset request timeout here
00112                         return l;
00113                 }
00114         }
00115         // slice was not in request queue, get slice length from incomplete piece list
00116         Session *sess = static_cast<PeerHandler&>(Handler()).GetSession(m_hash);
00117         if (!sess)
00118                 return 0;
00119         Piece *p = sess -> GetIncomplete(piece);
00120         if (p)
00121                 return MIN(SLICE, p -> PieceLength() - offset);
00122         return 0;
00123 }
00124 
00125 
00126 void Peer::RefreshRequests()
00127 {
00128         for (request_v::iterator it = m_requests.begin(); it != m_requests.end(); it++)
00129         {
00130                 Request *r = *it;
00131                 r -> ResetAge();
00132         }
00133 }
00134 
00135 
00136 size_t Peer::Score(bitmap_t *bitmap)
00137 {
00138         if (!bitmap || !m_bitmap)
00139                 return 0;
00140         size_t q = 0;
00141         for (size_t i = 0; i < bitmap -> GetNumberOfPieces(); i++)
00142         {
00143                 if (bitmap -> IsSet(i) != m_bitmap -> IsSet(i))
00144                         q++;
00145         }
00146         return q;
00147 }
00148 
00149 
00150 void Peer::RequestAvailable()
00151 {
00152         Session *sess = static_cast<PeerHandler&>(Handler()).GetSession(m_hash);
00153         if (!sess)
00154                 return;
00155         sess -> RequestAvailable(this);
00156 }
00157 
00158 
00159 void Peer::RemoveRequests()
00160 {
00161         Session *sess = static_cast<PeerHandler&>(Handler()).GetSession(m_hash);
00162         if (!sess)
00163                 return;
00164         sess -> RemoveRequests(this);
00165 }
00166 
00167
Peer.cpp
