D:/opendownloadmanager/ODM-1.x/Bittorrent/libtorrent-0.12/include/libtorrent/session_settings.hpp

Go to the documentation of this file.

/*

Copyright (c) 2003, Arvid Norberg
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in
      the documentation and/or other materials provided with the distribution.
    * Neither the name of the author nor the names of its
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

*/

#ifndef TORRENT_SESSION_SETTINGS_HPP_INCLUDED
#define TORRENT_SESSION_SETTINGS_HPP_INCLUDED

#include "libtorrent/version.hpp"

namespace libtorrent
{

        struct TORRENT_EXPORT session_settings
        {
                session_settings(std::string const& user_agent_ = "libtorrent/"
                        LIBTORRENT_VERSION)
                        : proxy_port(0)
                        , user_agent(user_agent_)
                        , tracker_completion_timeout(60)
                        , tracker_receive_timeout(20)
                        , stop_tracker_timeout(10)
                        , tracker_maximum_response_length(1024*1024)
                        , piece_timeout(120)
                        , request_queue_time(3.f)
                        , max_allowed_in_request_queue(250)
                        , max_out_request_queue(200)
                        , whole_pieces_threshold(20)
                        , peer_timeout(120)
                        , urlseed_timeout(20)
                        , urlseed_pipeline_size(5)
                        , file_pool_size(40)
                        , allow_multiple_connections_per_ip(false)
#ifndef TORRENT_DISABLE_DHT
                        , use_dht_as_fallback(true)
#endif
                {}

                std::string proxy_ip;
                int proxy_port;
                std::string proxy_login;
                std::string proxy_password;

                // this is the user agent that will be sent to the tracker
                // when doing requests. It is used to identify the client.
                // It cannot contain \r or \n
                std::string user_agent;

                // the number of seconds to wait until giving up on a
                // tracker request if it hasn't finished
                int tracker_completion_timeout;
                
                // the number of seconds where no data is received
                // from the tracker until it should be considered
                // as timed out
                int tracker_receive_timeout;

                // the time to wait when sending a stopped message
                // before considering a tracker to have timed out.
                // this is usually shorter, to make the client quit
                // faster
                int stop_tracker_timeout;

                // if the content-length is greater than this value
                // the tracker connection will be aborted
                int tracker_maximum_response_length;

                // the number of seconds from a request is sent until
                // it times out if no piece response is returned.
                int piece_timeout;

                // the length of the request queue given in the number
                // of seconds it should take for the other end to send
                // all the pieces. i.e. the actual number of requests
                // depends on the download rate and this number.
                float request_queue_time;
                
                // the number of outstanding block requests a peer is
                // allowed to queue up in the client. If a peer sends
                // more requests than this (before the first one has
                // been sent) the last request will be dropped.
                // the higher this is, the faster upload speeds the
                // client can get to a single peer.
                int max_allowed_in_request_queue;
                
                // the maximum number of outstanding requests to
                // send to a peer. This limit takes precedence over
                // request_queue_time.
                int max_out_request_queue;

                // if a whole piece can be downloaded in this number
                // of seconds, or less, the peer_connection will prefer
                // to request whole pieces at a time from this peer.
                // The benefit of this is to better utilize disk caches by
                // doing localized accesses and also to make it easier
                // to identify bad peers if a piece fails the hash check.
                int whole_pieces_threshold;
                
                // the number of seconds to wait for any activity on
                // the peer wire before closing the connectiong due
                // to time out.
                int peer_timeout;
                
                // same as peer_timeout, but only applies to url-seeds.
                // this is usually set lower, because web servers are
                // expected to be more reliable.
                int urlseed_timeout;
                
                // controls the pipelining size of url-seeds
                int urlseed_pipeline_size;
                
                // sets the upper limit on the total number of files this
                // session will keep open. The reason why files are
                // left open at all is that some anti virus software
                // hooks on every file close, and scans the file for
                // viruses. deferring the closing of the files will
                // be the difference between a usable system and
                // a completely hogged down system. Most operating
                // systems also has a limit on the total number of
                // file descriptors a process may have open. It is
                // usually a good idea to find this limit and set the
                // number of connections and the number of files
                // limits so their sum is slightly below it.
                int file_pool_size;
                
                // false to not allow multiple connections from the same
                // IP address. true will allow it.
                bool allow_multiple_connections_per_ip;

#ifndef TORRENT_DISABLE_DHT
                // while this is true, the dht will note be used unless the
                // tracker is online
                bool use_dht_as_fallback;
#endif
        };
        
#ifndef TORRENT_DISABLE_DHT
        struct dht_settings
        {
                dht_settings()
                        : max_peers_reply(50)
                        , search_branching(5)
                        , service_port(6881)
                        , max_fail_count(20)
                {}
                
                // the maximum number of peers to send in a
                // reply to get_peers
                int max_peers_reply;

                // the number of simultanous "connections" when
                // searching the DHT.
                int search_branching;
                
                // the listen port for the dht. This is a UDP port.
                int service_port;
                
                // the maximum number of times a node can fail
                // in a row before it is removed from the table.
                int max_fail_count;
        };
#endif

}

#endif

---