Changeset 292


Ignore:
Timestamp:
09/15/07 13:05:14 (12 years ago)
Author:
Eoin
Message:

Not borked anymore.

Files:
7 edited

Legend:

Unmodified
Added
Removed
  • res/Halite.rc

    r290 r292  
    22#include "resource.h" 
    33#include "afxres.h" 
     4 
    45#include "../src/halTorrent.cpp" 
     6#include "../src/halTorrentInternal.hpp" 
    57 
    68STRINGTABLE  
     
    517519        HAL_TORRENT_STOPPED             "Stopped" 
    518520        HAL_TORRENT_PAUSED              "Paused" 
     521        HAL_TORRENT_STOPPING    "Stopping" 
     522        HAL_TORRENT_PAUSING             "Pausing" 
    519523        HAL_TORRENT_METADATA    "Downloading Metadata" 
    520524END 
     
    593597    HAL_EVENT_XMLEXP              "Xml Exception (%1%) with %2%." 
    594598        LBT_EVENT_TORRENT_FINISHED    "Torrent %1% finished." 
     599        LBT_EVENT_TORRENT_PAUSED      "Torrent %1% paused." 
    595600    HAL_EVENT_TORRENTEXP          "Torrent (%1%) exception caught; %2% from %3%." 
    596601    HAL_EVENT_INVTORRENT          "Invalid torrent (%1%) from %2%." 
  • res/resource.h

    r290 r292  
    209209#define HAL_EVENT_PEER                  40034 
    210210#define HAL_EVENT_TRACKER               40035 
    211 #define HAL_PEER_INTERESTING            40037 
    212 #define HAL_PEER_CHOKED                 40038 
    213 #define HAL_PEER_REMOTE_INTERESTING     40039 
    214 #define HAL_PEER_REMOTE_CHOKED          40040 
    215 #define HAL_PEER_SUPPORT_EXTENSIONS     40041 
    216 #define HAL_PEER_LOCAL_CONNECTION       40042 
    217 #define HAL_PEER_HANDSHAKE              40043 
    218 #define HAL_PEER_CONNECTING             40044 
    219 #define HAL_PEER_QUEUED                 40045 
    220 #define HAL_PEER_RC4_ENCRYPTED          40046 
    221 #define HAL_PEER_PLAINTEXT_ENCRYPTED    40047 
    222 #define HAL_TORRENT_QUEUED_CHECKING     40050 
    223 #define HAL_TORRENT_CHECKING_FILES      40051 
    224 #define HAL_TORRENT_CONNECTING          40052 
    225 #define HAL_TORRENT_DOWNLOADING         40053 
    226 #define HAL_TORRENT_FINISHED            40054 
    227 #define HAL_TORRENT_SEEDING             40055 
    228 #define HAL_TORRENT_ALLOCATING          40056 
    229 #define HAL_TORRENT_QUEUED              40057 
    230 #define HAL_TORRENT_STOPPED             40058 
    231211#define HAL_TORRENT_PAUSED              40059 
    232212#define HAL_TORRENT_METADATA            40060 
  • src/HaliteListView.cpp

    r291 r292  
    163163} 
    164164 
    165  
    166165//LRESULT HaliteListViewCtrl::OnDeleteItem(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/) 
    167166//{ 
  • src/halConfig.cpp

    r268 r292  
    2929        { 
    3030                ProgressDialog progDlg(L"Loading IP filters...", bind( 
    31                         &BitTorrent::ensure_ip_filter_on, &bittorrent(), _1)); 
     31                        &BitTorrent::ensureIpFilterOn, &bittorrent(), _1)); 
    3232                progDlg.DoModal(); 
    3333        } 
    3434        else 
    35                 bittorrent().ensure_ip_filter_off(); 
     35                bittorrent().ensureIpFilterOff(); 
    3636        } 
    3737        catch(const std::exception& e) 
     
    4545        if (enablePe) 
    4646        { 
    47                 bittorrent().ensure_pe_on(peEncLevel, peConInPolicy, peConOutPolicy, pePerferRc4); 
     47                bittorrent().ensurePeOn(peEncLevel, peConInPolicy, peConOutPolicy, pePerferRc4); 
    4848        } 
    4949        else 
    50                 bittorrent().ensure_pe_off(); 
     50                bittorrent().ensurePeOff(); 
    5151        } 
    5252        catch(const std::exception& e) 
     
    9494        if (enableDHT) 
    9595        { 
    96                 if (!bittorrent().ensure_dht_on()) 
     96                if (!bittorrent().ensureDhtOn()) 
    9797                { 
    98                         bittorrent().ensure_dht_off(); 
     98                        bittorrent().ensureDhtOff(); 
    9999                         
    100100                        hal::event().post(boost::shared_ptr<hal::EventDetail>( 
     
    103103        } 
    104104        else 
    105                 bittorrent().ensure_dht_off(); 
     105                bittorrent().ensureDhtOff(); 
    106106} 
    107107 
  • src/halTorrent.cpp

    r291 r292  
    1717#define HAL_TRACKER_ALERT                                                       80007 
    1818#define HAL_TRACKER_REPLY_ALERT                                         80008 
     19#define LBT_EVENT_TORRENT_PAUSED                                        80009 
    1920 
    2021#ifndef RC_INVOKED 
     
    332333                                new EventGeneral(Event::info, a.timestamp(), 
    333334                                        wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_FINISHED))  
    334                                                 % get(a.handle).filename()) 
     335                                                % get(a.handle).name()) 
    335336                        )       );                       
     337                } 
     338                 
     339                void operator()(lbt::torrent_paused_alert const& a) const 
     340                { 
     341                        event().post(shared_ptr<EventDetail>( 
     342                                new EventGeneral(Event::info, a.timestamp(), 
     343                                        wformat(hal::app().res_wstr(LBT_EVENT_TORRENT_PAUSED))  
     344                                                % get(a.handle).name()) 
     345                        )       );       
     346 
     347                        get(a.handle).completedPause(); 
    336348                } 
    337349                 
     
    429441                        BitTorrent_impl& bit_impl_; 
    430442                         
    431                         TorrentInternal& get(lbt::torrent_handle h) const { return bit_impl_.getTorrent(h); } 
     443                        TorrentInternal& get(lbt::torrent_handle h) const  
     444                        {  
     445                                return bit_impl_.theTorrents.get(from_utf8_safe(h.get_torrent_info().name()));  
     446                        } 
    432447                 
    433448                } handler(*this); 
     
    440455                        lbt::handle_alert< 
    441456                                lbt::torrent_finished_alert, 
     457                                lbt::torrent_paused_alert, 
    442458                                lbt::peer_error_alert, 
    443459                                lbt::peer_ban_alert, 
     
    554570                        if (ifs) 
    555571                        { 
     572                                TorrentMap torrents; 
    556573                                boost::archive::xml_wiarchive ia(ifs);   
    557574                                ia >> make_nvp("torrents", torrents); 
     
    598615        bool keepChecking_; 
    599616         
    600         TorrentMap torrents; 
     617//      TorrentMap torrents; 
    601618        TorrentManager theTorrents; 
    602619         
    603         TorrentInternal& getTorrent(lbt::torrent_handle h) 
     620/*      TorrentInternal& getTorrent(lbt::torrent_handle h) 
    604621        { 
    605622                TorrentMap::iterator i = torrents.find(h.get_torrent_info().name()); 
     
    610627                throw lbt::invalid_handle(); 
    611628        } 
    612          
     629*/       
    613630        const wpath workingDirectory; 
    614631         
     
    669686        if (!pimpl->theSession.is_listening()) 
    670687        { 
    671                 bool result = pimpl->theSession.listen_on(range); 
    672                  
    673                 return result;   
     688                return pimpl->theSession.listen_on(range); 
    674689        } 
    675690        else 
     
    694709void BitTorrent::stopListening() 
    695710{ 
    696         ensure_dht_off(); 
     711        ensureDhtOff(); 
    697712        pimpl->theSession.listen_on(make_pair(0, 0)); 
    698713} 
    699714 
    700 bool BitTorrent::ensure_dht_on() 
     715bool BitTorrent::ensureDhtOn() 
    701716{ 
    702717        if (!pimpl->dht_on_) 
     
    713728} 
    714729 
    715 void BitTorrent::ensure_dht_off() 
     730void BitTorrent::ensureDhtOff() 
    716731{ 
    717732        if (pimpl->dht_on_) 
     
    804819} 
    805820 
    806 void BitTorrent::ensure_ip_filter_on(progressCallback fn) 
     821void BitTorrent::ensureIpFilterOn(progressCallback fn) 
    807822{ 
    808823        if (!pimpl->ip_filter_loaded_) 
     
    820835} 
    821836 
    822 void BitTorrent::ensure_ip_filter_off() 
     837void BitTorrent::ensureIpFilterOff() 
    823838{ 
    824839        pimpl->theSession.set_ip_filter(lbt::ip_filter()); 
     
    827842 
    828843#ifndef TORRENT_DISABLE_ENCRYPTION       
    829 void BitTorrent::ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4) 
     844void BitTorrent::ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4) 
    830845{ 
    831846        lbt::pe_settings pe; 
     
    893908} 
    894909 
    895 void BitTorrent::ensure_pe_off() 
     910void BitTorrent::ensurePeOff() 
    896911{ 
    897912        lbt::pe_settings pe; 
     
    12601275                                        break; 
    12611276                                case TorrentDetail::torrent_paused: 
     1277                                case TorrentDetail::torrent_pausing: 
    12621278                                        (*i).torrent.addToSession(true); 
    12631279                                        break; 
     
    12981314        wpath resumeDir=pimpl->workingDirectory/L"resume"; 
    12991315         
    1300         if (!pimpl->torrents.empty() && !exists(resumeDir)) 
     1316        if (!exists(resumeDir)) 
    13011317                create_directory(resumeDir); 
    13021318 
     
    13141330         
    13151331        // Ok this polling loop here is a bit curde, but a blocking wait is actually appropiate. 
    1316         lbt::session_status status = pimpl->theSession.status();         
    1317         while (status.download_rate > 0 || status.upload_rate > 0) 
    1318         { 
     1332        for (bool allPaused = true; !allPaused; ) 
     1333        { 
     1334                for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end();  
     1335                                i != e; ++i) 
     1336                        allPaused &= (TorrentDetail::torrent_paused == (*i).torrent.state()); 
     1337                 
    13191338                Sleep(200); 
    1320                 status = pimpl->theSession.status(); 
    13211339        } 
    13221340         
     
    13241342                new EventInfo(L"Torrents stopped."))); 
    13251343                 
    1326         for (TorrentMap::const_iterator i=pimpl->torrents.begin(), e=pimpl->torrents.end(); i != e; ++i) 
    1327         { 
    1328                 if ((*i).second.inSession()) 
    1329                 { 
    1330                         lbt::entry resumedata = (*i).second.handle().write_resume_data(); 
    1331                         pimpl->theSession.remove_torrent((*i).second.handle()); 
    1332                          
    1333                         bool halencode_result = halencode(resumeDir/from_utf8((*i).first), resumedata); 
     1344        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end();  
     1345                i != e; ++i) 
     1346        { 
     1347                if ((*i).torrent.inSession()) 
     1348                { 
     1349                        lbt::entry resumedata = (*i).torrent.handle().write_resume_data(); 
     1350                        pimpl->theSession.remove_torrent((*i).torrent.handle()); 
     1351                         
     1352                        bool halencode_result = halencode(resumeDir/(*i).torrent.filename(), resumedata); 
    13341353                        assert(halencode_result); 
    13351354                } 
     
    14031422} 
    14041423 
    1405 void BitTorrent::getAllPeerDetails(string filename, PeerDetails& peerContainer) 
    1406 { 
    1407         try { 
    1408          
    1409         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1410          
    1411         if (i != pimpl->torrents.end()) 
    1412                 (*i).second.getPeerDetails(peerContainer); 
     1424void BitTorrent::getAllPeerDetails(const std::string& filename, PeerDetails& peerContainer) 
     1425{ 
     1426        getAllPeerDetails(from_utf8_safe(filename), peerContainer); 
     1427} 
     1428 
     1429void BitTorrent::getAllPeerDetails(const std::wstring& filename, PeerDetails& peerContainer) 
     1430{ 
     1431        try { 
     1432         
     1433        pimpl->theTorrents.get(filename).getPeerDetails(peerContainer); 
    14131434         
    14141435        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllPeerDetails") 
    14151436} 
    14161437 
    1417 void BitTorrent::getAllFileDetails(string filename, FileDetails& fileDetails) 
    1418 { 
    1419         try { 
    1420          
    1421         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1422          
    1423         if (i != pimpl->torrents.end()) 
    1424                 (*i).second.getFileDetails(fileDetails); 
     1438void BitTorrent::getAllFileDetails(const std::string& filename, FileDetails& fileDetails) 
     1439{ 
     1440        getAllFileDetails(from_utf8_safe(filename), fileDetails); 
     1441} 
     1442 
     1443void BitTorrent::getAllFileDetails(const std::wstring& filename, FileDetails& fileDetails) 
     1444{ 
     1445        try { 
     1446         
     1447        pimpl->theTorrents.get(filename).getFileDetails(fileDetails); 
    14251448         
    14261449        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getAllFileDetails") 
     
    16151638        try { 
    16161639         
    1617         for (TorrentMap::iterator iter = pimpl->torrents.begin();  
    1618                 iter != pimpl->torrents.end(); ++iter) 
     1640        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); 
     1641                i != e; ++i) 
    16191642        {                
    1620                 if ((*iter).second.inSession()) 
    1621                         (*iter).second.pause(); 
     1643                if ((*i).torrent.inSession()) 
     1644                        (*i).torrent.pause(); 
    16221645        } 
    16231646         
     
    16291652        try { 
    16301653         
    1631         for (TorrentMap::iterator iter = pimpl->torrents.begin();  
    1632                 iter != pimpl->torrents.end(); ++iter) 
    1633         { 
    1634                 if ((*iter).second.inSession() && iter->second.state() == TorrentDetail::torrent_paused) 
    1635                         (*iter).second.resume(); 
     1654        for (TorrentManager::torrentByName::iterator i=pimpl->theTorrents.begin(), e=pimpl->theTorrents.end(); 
     1655                i != e; ++i) 
     1656        { 
     1657                if ((*i).torrent.inSession() && (*i).torrent.state() == TorrentDetail::torrent_paused) 
     1658                        (*i).torrent.resume(); 
    16361659        } 
    16371660         
     
    16391662} 
    16401663 
    1641 void BitTorrent::setTorrentLimit(string filename, int maxConn, int maxUpload) 
    1642 { 
    1643         try { 
    1644          
    1645         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1646          
    1647         if (i != pimpl->torrents.end()) 
    1648         { 
    1649                 (*i).second.setConnectionLimit(maxConn, maxUpload); 
    1650         } 
     1664void BitTorrent::setTorrentLimit(const std::string& filename, int maxConn, int maxUpload) 
     1665{ 
     1666        setTorrentLimit(hal::from_utf8_safe(filename), maxConn, maxUpload); 
     1667} 
     1668 
     1669void BitTorrent::setTorrentLimit(const std::wstring& filename, int maxConn, int maxUpload) 
     1670{ 
     1671        try { 
     1672         
     1673        pimpl->theTorrents.get(filename).setConnectionLimit(maxConn, maxUpload); 
    16511674         
    16521675        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "setTorrentLimit") 
    16531676} 
    16541677 
    1655 void BitTorrent::setTorrentRatio(string filename, float ratio) 
    1656 { 
    1657         try { 
    1658          
    1659         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1660          
    1661         if (i != pimpl->torrents.end()) 
    1662         { 
    1663                 (*i).second.setRatio(ratio); 
    1664         } 
     1678void BitTorrent::setTorrentRatio(const std::string& filename, float ratio) 
     1679{ 
     1680        setTorrentRatio(hal::from_utf8_safe(filename), ratio); 
     1681} 
     1682 
     1683void BitTorrent::setTorrentRatio(const std::wstring& filename, float ratio) 
     1684{ 
     1685        try { 
     1686         
     1687        pimpl->theTorrents.get(filename).setRatio(ratio); 
    16651688         
    16661689        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "setTorrentRatio") 
    16671690} 
    16681691 
    1669 float BitTorrent::getTorrentRatio(string filename) 
    1670 { 
    1671         try { 
    1672          
    1673         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1674          
    1675         if (i != pimpl->torrents.end()) 
    1676         { 
    1677                 return (*i).second.getRatio(); 
    1678         } 
     1692float BitTorrent::getTorrentRatio(const std::string& filename) 
     1693{ 
     1694        return getTorrentRatio(hal::from_utf8_safe(filename)); 
     1695} 
     1696 
     1697float BitTorrent::getTorrentRatio(const std::wstring& filename) 
     1698{ 
     1699        try { 
     1700         
     1701        return pimpl->theTorrents.get(filename).getRatio(); 
    16791702         
    16801703        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getTorrentRatio") 
     
    16831706} 
    16841707 
    1685 void BitTorrent::setTorrentSpeed(string filename, float download, float upload) 
    1686 { 
    1687         try { 
    1688          
    1689         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1690          
    1691         if (i != pimpl->torrents.end()) 
    1692         { 
    1693                 (*i).second.setTransferSpeed(download, upload); 
    1694         } 
     1708void BitTorrent::setTorrentSpeed(const std::string& filename, float download, float upload) 
     1709{ 
     1710        setTorrentSpeed(hal::from_utf8_safe(filename), download, upload); 
     1711} 
     1712 
     1713void BitTorrent::setTorrentSpeed(const std::wstring& filename, float download, float upload) 
     1714{ 
     1715        try { 
     1716         
     1717        pimpl->theTorrents.get(filename).setTransferSpeed(download, upload); 
    16951718         
    16961719        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "setTorrentSpeed") 
    16971720} 
    16981721 
    1699 pair<int, int> BitTorrent::getTorrentLimit(string filename) 
    1700 { 
    1701         try { 
    1702          
    1703         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1704          
    1705         if (i != pimpl->torrents.end()) 
    1706         { 
    1707                 return (*i).second.getConnectionLimit(); 
    1708         } 
     1722pair<int, int> BitTorrent::getTorrentLimit(const std::string& filename) 
     1723{ 
     1724        return getTorrentLimit(from_utf8_safe(filename)); 
     1725} 
     1726 
     1727pair<int, int> BitTorrent::getTorrentLimit(const std::wstring& filename) 
     1728{ 
     1729        try { 
     1730         
     1731        return pimpl->theTorrents.get(filename).getConnectionLimit(); 
    17091732         
    17101733        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getTorrentLimit") 
     
    17131736} 
    17141737 
    1715 pair<float, float> BitTorrent::getTorrentSpeed(string filename) 
    1716 { 
    1717         try { 
    1718          
    1719         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1720          
    1721         if (i != pimpl->torrents.end()) 
    1722         { 
    1723                 return (*i).second.getTransferSpeed(); 
    1724         } 
     1738pair<float, float> BitTorrent::getTorrentSpeed(const std::string& filename) 
     1739{ 
     1740        return getTorrentSpeed(from_utf8_safe(filename)); 
     1741} 
     1742 
     1743pair<float, float> BitTorrent::getTorrentSpeed(const std::wstring& filename) 
     1744{ 
     1745        try { 
     1746         
     1747        return pimpl->theTorrents.get(filename).getTransferSpeed(); 
    17251748         
    17261749        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getTorrentSpeed") 
     
    17291752} 
    17301753 
    1731 void BitTorrent::setTorrentFilePriorities(std::string filename,  
     1754void BitTorrent::setTorrentFilePriorities(const std::string& filename,  
    17321755        std::vector<int> fileIndices, int priority) 
    17331756{ 
    1734         try { 
    1735          
    1736         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1737          
    1738         if (i != pimpl->torrents.end()) 
    1739         { 
    1740                 (*i).second.setFilePriorities(fileIndices, priority); 
    1741         } 
     1757        setTorrentFilePriorities(from_utf8_safe(filename), fileIndices, priority); 
     1758} 
     1759 
     1760void BitTorrent::setTorrentFilePriorities(const std::wstring& filename,  
     1761        std::vector<int> fileIndices, int priority) 
     1762{ 
     1763        try { 
     1764         
     1765        pimpl->theTorrents.get(filename).setFilePriorities(fileIndices, priority); 
    17421766         
    17431767        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "setTorrentFilePriorities") 
    17441768} 
    17451769 
    1746 void BitTorrent::setTorrentTrackers(std::string filename,  
     1770void BitTorrent::setTorrentTrackers(const std::string& filename,  
    17471771        const std::vector<TrackerDetail>& trackers) 
    17481772{ 
    1749         try { 
    1750          
    1751         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1752          
    1753         if (i != pimpl->torrents.end()) 
    1754         { 
    1755                 (*i).second.setTrackers(trackers); 
    1756         } 
     1773        setTorrentTrackers(from_utf8_safe(filename), trackers); 
     1774} 
     1775 
     1776void BitTorrent::setTorrentTrackers(const std::wstring& filename,  
     1777        const std::vector<TrackerDetail>& trackers) 
     1778{ 
     1779        try { 
     1780         
     1781        pimpl->theTorrents.get(filename).setTrackers(trackers); 
    17571782         
    17581783        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "setTorrentTrackers") 
    17591784} 
    17601785 
    1761 void BitTorrent::resetTorrentTrackers(std::string filename) 
    1762 { 
    1763         try { 
    1764          
    1765         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1766          
    1767         if (i != pimpl->torrents.end()) 
    1768         { 
    1769                 (*i).second.resetTrackers(); 
    1770         } 
     1786void BitTorrent::resetTorrentTrackers(const std::string& filename) 
     1787{ 
     1788        resetTorrentTrackers(from_utf8_safe(filename)); 
     1789} 
     1790 
     1791void BitTorrent::resetTorrentTrackers(const std::wstring& filename) 
     1792{ 
     1793        try { 
     1794         
     1795        pimpl->theTorrents.get(filename).resetTrackers(); 
    17711796         
    17721797        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "resetTorrentTrackers") 
    17731798} 
    17741799 
    1775 std::vector<TrackerDetail> BitTorrent::getTorrentTrackers(std::string filename) 
    1776 { 
    1777         try { 
    1778          
    1779         TorrentMap::iterator i = pimpl->torrents.find(filename); 
    1780          
    1781         if (i != pimpl->torrents.end()) 
    1782         { 
    1783                 return (*i).second.getTrackers(); 
    1784         } 
     1800std::vector<TrackerDetail> BitTorrent::getTorrentTrackers(const std::string& filename) 
     1801{ 
     1802        return getTorrentTrackers(from_utf8_safe(filename)); 
     1803} 
     1804 
     1805std::vector<TrackerDetail> BitTorrent::getTorrentTrackers(const std::wstring& filename) 
     1806{ 
     1807        try { 
     1808         
     1809        return pimpl->theTorrents.get(filename).getTrackers(); 
    17851810         
    17861811        } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "getTorrentTrackers") 
     
    18071832}; 
    18081833 
    1809 #endif 
     1834#endif // RC_INVOKED 
  • src/halTorrent.hpp

    r291 r292  
    168168                torrent_active = 0, 
    169169                torrent_paused, 
    170                 torrent_stopped 
     170                torrent_stopped, 
     171                torrent_pausing, 
     172                torrent_stopping 
    171173        }; 
    172174         
     
    340342{ 
    341343public:  
    342  
    343344        void shutDownSession(); 
    344345        void saveTorrentData(); 
     
    348349        void stopListening(); 
    349350         
    350         bool ensure_dht_on(); 
    351         void ensure_dht_off(); 
    352          
    353         void ensure_ip_filter_on(progressCallback fn); 
    354         void ensure_ip_filter_off(); 
     351        bool ensureDhtOn(); 
     352        void ensureDhtOff(); 
     353         
     354        void ensurePeOn(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4); 
     355        void ensurePeOff(); 
     356         
     357        void ensureIpFilterOn(progressCallback fn); 
     358        void ensureIpFilterOff(); 
     359         
    355360        void ip_v4_filter_block(asio::ip::address_v4 first, asio::ip::address_v4 last); 
    356361        void ip_v6_filter_block(asio::ip::address_v6 first, asio::ip::address_v6 last); 
     
    359364        void clearIpFilter(); 
    360365         
    361         void ensure_pe_on(int enc_level, int in_enc_policy, int out_enc_policy, bool prefer_rc4); 
    362         void ensure_pe_off(); 
    363366         
    364367        void setSessionHalfOpenLimit(int halfConn); 
     
    372375        void setTorrentDefaults(int maxConn, int maxUpload, float download, float upload);       
    373376        void newTorrent(boost::filesystem::wpath filename, boost::filesystem::wpath files); 
    374         void addTorrent(boost::filesystem::wpath file, wpath saveDirectory, bool startPaused=false, bool compactStorage=false); 
    375          
    376         void setTorrentRatio(std::string, float ratio); 
    377         float getTorrentRatio(std::string); 
    378          
    379         void getAllPeerDetails(std::string filename, PeerDetails& peerContainer); 
    380         void getAllFileDetails(std::string filename, FileDetails& fileDetails); 
     377        void addTorrent(boost::filesystem::wpath file, wpath saveDirectory,  
     378                bool startPaused=false, bool compactStorage=false); 
     379         
     380        void setTorrentRatio(const std::string&, float ratio); 
     381        void setTorrentRatio(const std::wstring&, float ratio); 
     382        float getTorrentRatio(const std::string&); 
     383        float getTorrentRatio(const std::wstring&); 
     384         
     385        void getAllPeerDetails(const std::string& filename, PeerDetails& peerContainer); 
     386        void getAllPeerDetails(const std::wstring& filename, PeerDetails& peerContainer); 
     387        void getAllFileDetails(const std::string& filename, FileDetails& fileDetails); 
     388        void getAllFileDetails(const std::wstring& filename, FileDetails& fileDetails); 
    381389         
    382390        void resumeAll(); 
     
    410418        std::pair<std::wstring, std::wstring> getTorrentLogin(const std::wstring&  filename); 
    411419         
    412         void setTorrentLimit(std::string filename, int maxConn, int maxUpload); 
    413         void setTorrentSpeed(std::string filename, float download, float upload); 
    414         pair<int, int> getTorrentLimit(std::string filename); 
    415         pair<float, float> getTorrentSpeed(std::string filename); 
    416          
    417         void setTorrentTrackers(std::string filename, const std::vector<TrackerDetail>& trackers); 
    418         void resetTorrentTrackers(std::string filename); 
    419         std::vector<TrackerDetail> getTorrentTrackers(std::string filename); 
    420          
    421         void setTorrentFilePriorities(std::string filename, std::vector<int> fileIndices, int priority); 
     420        void setTorrentLimit(const std::string& filename, int maxConn, int maxUpload); 
     421        void setTorrentLimit(const std::wstring& filename, int maxConn, int maxUpload); 
     422        void setTorrentSpeed(const std::string& filename, float download, float upload); 
     423        void setTorrentSpeed(const std::wstring& filename, float download, float upload); 
     424        pair<int, int> getTorrentLimit(const std::string& filename); 
     425        pair<int, int> getTorrentLimit(const std::wstring& filename); 
     426        pair<float, float> getTorrentSpeed(const std::string& filename); 
     427        pair<float, float> getTorrentSpeed(const std::wstring& filename); 
     428         
     429        void setTorrentTrackers(const std::string& filename, const std::vector<TrackerDetail>& trackers); 
     430        void setTorrentTrackers(const std::wstring& filename, const std::vector<TrackerDetail>& trackers); 
     431        void resetTorrentTrackers(const std::string& filename); 
     432        void resetTorrentTrackers(const std::wstring& filename); 
     433        std::vector<TrackerDetail> getTorrentTrackers(const std::string& filename); 
     434        std::vector<TrackerDetail> getTorrentTrackers(const std::wstring& filename); 
     435         
     436        void setTorrentFilePriorities(const std::string& filename, std::vector<int> fileIndices, int priority); 
     437        void setTorrentFilePriorities(const std::wstring& filename, std::vector<int> fileIndices, int priority); 
    422438 
    423439        void startEventReceiver(); 
     
    432448 
    433449        const TorrentDetails& torrentDetails(); 
    434 //      const TorrentDetails& getTorrentDetails(std::string selected, std::set<std::string> allSelected);        
    435450        const TorrentDetails& updateTorrentDetails(const std::wstring& focused, const std::set<std::wstring>& selected); 
    436451         
  • src/halTorrentInternal.hpp

    r291 r292  
    66 
    77#pragma once 
     8 
     9#define HAL_PEER_INTERESTING            40037 
     10#define HAL_PEER_CHOKED                 40038 
     11#define HAL_PEER_REMOTE_INTERESTING     40039 
     12#define HAL_PEER_REMOTE_CHOKED          40040 
     13#define HAL_PEER_SUPPORT_EXTENSIONS     40041 
     14#define HAL_PEER_LOCAL_CONNECTION       40042 
     15#define HAL_PEER_HANDSHAKE              40043 
     16#define HAL_PEER_CONNECTING             40044 
     17#define HAL_PEER_QUEUED                 40045 
     18#define HAL_PEER_RC4_ENCRYPTED          40046 
     19#define HAL_PEER_PLAINTEXT_ENCRYPTED    40047 
     20#define HAL_TORRENT_QUEUED_CHECKING     40050 
     21#define HAL_TORRENT_CHECKING_FILES      40051 
     22#define HAL_TORRENT_CONNECTING          40052 
     23#define HAL_TORRENT_DOWNLOADING         40053 
     24#define HAL_TORRENT_FINISHED            40054 
     25#define HAL_TORRENT_SEEDING             40055 
     26#define HAL_TORRENT_ALLOCATING          40056 
     27#define HAL_TORRENT_QUEUED              40057 
     28#define HAL_TORRENT_STOPPED             40058 
     29#define HAL_TORRENT_PAUSED              40059 
     30#define HAL_TORRENT_STOPPING            50000 
     31#define HAL_TORRENT_PAUSING             50001 
     32 
     33#ifndef RC_INVOKED 
    834 
    935#include <boost/multi_index_container.hpp> 
     
    271297                {        
    272298                        addToSession(true); 
    273                         assert(inSession());                     
     299                        assert(inSession()); 
     300                        state_ = TorrentDetail::torrent_paused;  
    274301                } 
    275302                else 
     
    277304                        assert(inSession()); 
    278305                        handle_.pause(); 
     306                        state_ = TorrentDetail::torrent_pausing;         
    279307                }        
    280                  
    281                 state_ = TorrentDetail::torrent_paused;                  
     308                                 
    282309                assert(handle_.is_paused()); 
    283310        } 
     
    293320                state_ = TorrentDetail::torrent_stopped; 
    294321                assert(!inSession());                    
     322        } 
     323         
     324        void completedPause() 
     325        { 
     326                if (TorrentDetail::torrent_pausing == state_ && inSession()) 
     327                { 
     328                        state_ = TorrentDetail::torrent_paused;  
     329                        assert(handle_.is_paused()); 
     330                } 
    295331        } 
    296332         
     
    712748         
    713749public: 
    714          
    715750        typedef TorrentMultiIndex::index<byFilename>::type torrentByFilename; 
    716751        typedef TorrentMultiIndex::index<byName>::type torrentByName; 
     
    834869        wstring state; 
    835870         
    836         if (state_ == TorrentDetail::torrent_paused) 
     871        switch (state_) 
     872        { 
     873        case TorrentDetail::torrent_paused: 
    837874                state = app().res_wstr(HAL_TORRENT_PAUSED); 
    838         else if (state_ == TorrentDetail::torrent_stopped) 
     875                break; 
     876                 
     877        case TorrentDetail::torrent_pausing: 
     878                state = app().res_wstr(HAL_TORRENT_PAUSING); 
     879                break; 
     880                 
     881        case TorrentDetail::torrent_stopped: 
    839882                state = app().res_wstr(HAL_TORRENT_STOPPED); 
    840         else 
    841         { 
     883                break; 
     884                 
     885        case TorrentDetail::torrent_stopping: 
     886                state = app().res_wstr(HAL_TORRENT_STOPPING); 
     887                break; 
     888                 
     889        default: 
    842890                switch (statusMemory_.state) 
    843891                { 
     
    937985} 
    938986 
    939 } //namespace hal 
     987} // namespace hal 
     988 
     989#endif // RC_INVOKED 
     990 
Note: See TracChangeset for help on using the changeset viewer.