* Fixed a buffer overflow when writting to the output buffer. This

would in some rare occasions cause memory to be corrupted. leading to
a crash.

* Added option for setting the http proxy and proccess's umask.

* Save the total uploaded for downloads between sessions.

* Moved from sigc++ to my own lightweight slot class for the task
scheduler. This saves some 5-600kb when compiled with debugging
symbols, 1-200kb without.


git-svn-id: svn://rakshasa.no/libtorrent/trunk/libtorrent@605 e378c898-3ddf-0310-93e7-cc216c733640

Author: rakshasa

BUGS

@@ -1,6 +1,3 @@
 FIXME LATER:
 
-Caught exception: "DownloadWrapper::resume_save() called with wrong state"
-
-
-"Connection read fd(40) state(5) "PeerConnectionBase::read_chunk() tried to read a piece but is not in throttle list""
+Caught exception from libtorrent: Connection write fd(68,0,6) "ProtocolBuffer tried to write beyond scope of the buffer"

Makefile.am

@@ -13,6 +13,7 @@ EXTRA_DIST= \
         rak/algorithm.h \
 	rak/error_number.h \
         rak/functional.h \
+        rak/functional_fun.h \
 	rak/ranges.h \
 	rak/string_manip.h \
 	rak/timer.h \

TODO

@@ -13,11 +13,11 @@ Display leechers/seeders.
 Make sure storage error is correctly displayed, rather than being
 hidden.
 
-Make the vfat workaround configurable.
+Make the vfat workaround configurable. Also add note to the wiki.
 
-* Move block download done to DownloadWrapper.
+Different min peers for seeding and leeching modes?
 
-* Move finished delay signal out into downloadwrapper.
+Store data on which side inititalized the connection.
 
 
 === For the next API change ===
@@ -35,13 +35,6 @@ those regions.
 ===
 
 
-=== Delegator refactoring ===
-
-Seperate out DelegatorSelect, rewrite it and use slots.
-
-======
-
-
 === Hash Resume save ===
 
 [R] could you add a trigger for Download::hash_resume_save when a torrent 
@@ -104,35 +97,17 @@ function that chokes all and doesn't allow new unchokes.
 
 Move download initializiation stuff into Manager.
 
-Replace download_remove's info_hash thingie with Download.
-
-Use partial sort, or nth_element.
-
 Rename most things to remote/local or something. up/down is too
 confusing. Atleast add it to some of the function names.
 
-Rewrite throttle code, consider not updating when unlimited. Do an
-update when putting them into unlimited mode.
-
-Optimize interested, seperate return values for requesting where we
-are still interested downloading from others and when we're not
-interested anymore.
-
 Would be nice to refactor requester, it should own the bitfield in some way?
 
-Wait when receiving resource tmp unavailable. Currently need to close
-the connection.
-
 delegator's priorities are reset on DownloadMain::open? Make the
 priority thing work right, don't use a seperate function for updating
 them.
 
 Consider asking for read-ahead for fast peers.
 
-File priority might not like sequential requesting.
-
-Cache the number of unchoked peers.
-
 Unaligned 58.6.0.92     0.0
 
 Do move of session torrent so we don't end up with incomplete torrent
@@ -144,20 +119,11 @@ they don't give rw perm or resize?
 Clearer display of which torrents are stopped, make it into a seperate
 column.
 
-Move stuff into rak.
-
-Slot in torrent/Peer for incoming, so we can use SocketAddress
-internally?
-
 Re-add slot for removing incoming connections from available list? If
 so, remove the check in connect_peers.
 
 Move endgame detection to delegator?
 
-Make sure rtorrent's http downloading times out.
-
-Different min peers for seeding and leeching modes?
-
 Rename TrackerControl?
 
 Remove get_ for certain class of accesses, also make them pointers to
@@ -198,11 +164,6 @@ Add filter for ip address, and peer id. These must be seperate as ip
 happens before handshake, but peer id is done after handshake or
 before connecting.
 
-Make the tries adjuster into a setting.
-
-Doesn't force in some cases when the system is overloaded and you got
-small hash chunks.
-
 Fix hash checking slowness on overworked boxens. Possibly mark the
 mmap'ed area as sequential. Add options to the man page.
 
@@ -219,67 +180,24 @@ downloads at all times.
 Use a seperate function for checking the hash status when doing
 download starts.
 
-Possibly do sync before/after checking hash. Don't sync complete
-chunks as they were synced at the time of hash checking? Read the list
-of dirty chunks from the delegator. Need to fix the problem of corrupt
-downloads due to lack of diskspace.
-
-Ponder race condition on lazy hash checking, do new data get written
-before we start checking?
-
-The handling of hash fails isn't good enough...
-
-Directory validation needs to be lazy?
-
-Disable read/write_chunk exceptions.
-
-Don't allow many handshakes from the same ip?
-
-Create a std::list'ish thing that contains the current downloads, and
-expose it to the client. Will make DownloadManager 'redundant'. Don't fix?
-
-
 
 *** STUFF I MIGHT DO SOME DAY ***
 
-SMALL TODO STUFF I HAVEN'T BOTHERED DOING YET:
-
 After 25 seconds, choke a peer if no requests have been received?
 
-Add average, max and total to rates. Will this be controlled by
-choke/unchoke?
-
 Add a snub factor. The more you upload without getting back, the
 higher it goes. Add a start buffer.
 
 Add config for how often we unchoke unknown peers vs good uploaders
 
-Each throttle can have it's own rules to decide the priority it gets.
-
-Switch to a proper type for file offset/length and chunk length. A
-proper type for chunk index.
-
 std::isalpha in escape string
 
-Store data on which side inititalized the connection.
-
 torrent::Http::call_cleanup to delete the factory created object?
 
 If we get conflicting prot flags in get_chunk, we might go into cycle
 of re-allocating. Do a union instead.
 
 
-LONG TERM:
-
-Make a collection of stuff in utils that can be shared between apps.
-
-
-TIMER RELATED
-
-Throttle update needs to be off when no throttle is on. Make sure it
-doesn't bork with using up allocated bytes.
-
-
 DELEGATOR STUFF
 
 Proper canceling of pieces in sendHave, unless only one can download a
@@ -292,10 +210,6 @@ Don't be so aggressive at selecting stalled pieces.
 
 AFTER API REDESIGN:
 
-Add the option to not throw non-critical exceptions. This lets the
-client be ignorant of errors while creating stuff. (Make some kind of
-C friendly layer ontop)
-
 Consider ways of optimizing bitfield memory usage. A bitfield with all
 set shouldn't change ever... And do a count on number of set bits?
 
@@ -326,7 +240,4 @@ disallow for open torrents?
 
 Move mkdir stuff out of Path?
 
-Cleanup HashQueue, seperate out nodes etc.  * Make it a private list.
-* Don't pass Chunk in SlotDone.
-
 Lock file in session directory.

rak/functional.h

@@ -349,12 +349,12 @@ bind2nd(const Operation& op, const Type& val) {
 // of using a seperate functor for that.
 
 template <typename Object, typename Ret>
-class mem_fn0 {
+class mem_fun0 {
 public:
   typedef Ret (Object::*Function)();
 
-  mem_fn0() : m_object(NULL) {}
-  mem_fn0(Object* o, Function f) : m_object(o), m_function(f) {}
+  mem_fun0() : m_object(NULL) {}
+  mem_fun0(Object* o, Function f) : m_object(o), m_function(f) {}
 
   bool is_valid() const { return m_object; }
 
@@ -366,12 +366,12 @@ class mem_fn0 {
 };
 
 template <typename Object, typename Ret>
-class const_mem_fn0 {
+class const_mem_fun0 {
 public:
   typedef Ret (Object::*Function)() const;
 
-  const_mem_fn0() : m_object(NULL) {}
-  const_mem_fn0(Object* o, Function f) : m_object(o), m_function(f) {}
+  const_mem_fun0() : m_object(NULL) {}
+  const_mem_fun0(Object* o, Function f) : m_object(o), m_function(f) {}
 
   bool is_valid() const { return m_object; }
 
@@ -383,12 +383,12 @@ class const_mem_fn0 {
 };
 
 template <typename Object, typename Ret, typename Arg1>
-class mem_fn1 {
+class mem_fun1 {
 public:
   typedef Ret (Object::*Function)(Arg1);
 
-  mem_fn1() : m_object(NULL) {}
-  mem_fn1(Object* o, Function f) : m_object(o), m_function(f) {}
+  mem_fun1() : m_object(NULL) {}
+  mem_fun1(Object* o, Function f) : m_object(o), m_function(f) {}
 
   bool is_valid() const { return m_object; }
 
@@ -400,12 +400,12 @@ class mem_fn1 {
 };
 
 template <typename Object, typename Ret, typename Arg1>
-class const_mem_fn1 {
+class const_mem_fun1 {
 public:
   typedef Ret (Object::*Function)(Arg1) const;
 
-  const_mem_fn1() : m_object(NULL) {}
-  const_mem_fn1(Object* o, Function f) : m_object(o), m_function(f) {}
+  const_mem_fun1() : m_object(NULL) {}
+  const_mem_fun1(Object* o, Function f) : m_object(o), m_function(f) {}
 
   bool is_valid() const { return m_object; }
 
@@ -417,12 +417,12 @@ class const_mem_fn1 {
 };
 
 template <typename Object, typename Ret, typename Arg1, typename Arg2>
-class mem_fn2 : public std::binary_function<Arg1, Arg2, Ret> {
+class mem_fun2 : public std::binary_function<Arg1, Arg2, Ret> {
 public:
   typedef Ret (Object::*Function)(Arg1, Arg2);
 
-  mem_fn2() : m_object(NULL) {}
-  mem_fn2(Object* o, Function f) : m_object(o), m_function(f) {}
+  mem_fun2() : m_object(NULL) {}
+  mem_fun2(Object* o, Function f) : m_object(o), m_function(f) {}
 
   bool is_valid() const { return m_object; }
 
@@ -434,12 +434,12 @@ class mem_fn2 : public std::binary_function<Arg1, Arg2, Ret> {
 };
 
 template <typename Object, typename Ret, typename Arg1, typename Arg2, typename Arg3>
-class mem_fn3 {
+class mem_fun3 {
 public:
   typedef Ret (Object::*Function)(Arg1, Arg2, Arg3);
 
-  mem_fn3() : m_object(NULL) {}
-  mem_fn3(Object* o, Function f) : m_object(o), m_function(f) {}
+  mem_fun3() : m_object(NULL) {}
+  mem_fun3(Object* o, Function f) : m_object(o), m_function(f) {}
 
   bool is_valid() const { return m_object; }
 
@@ -451,39 +451,39 @@ class mem_fn3 {
 };
 
 template <typename Object, typename Ret>
-inline mem_fn0<Object, Ret>
-make_mem_fn(Object* o, Ret (Object::*f)()) {
- return mem_fn0<Object, Ret>(o, f);
+inline mem_fun0<Object, Ret>
+make_mem_fun(Object* o, Ret (Object::*f)()) {
+ return mem_fun0<Object, Ret>(o, f);
 }
 
 template <typename Object, typename Ret>
-inline const_mem_fn0<Object, Ret>
-make_mem_fn(Object* o, Ret (Object::*f)() const) {
- return const_mem_fn0<Object, Ret>(o, f);
+inline const_mem_fun0<Object, Ret>
+make_mem_fun(Object* o, Ret (Object::*f)() const) {
+ return const_mem_fun0<Object, Ret>(o, f);
 }
 
 template <typename Object, typename Ret, typename Arg1>
-inline mem_fn1<Object, Ret, Arg1>
-make_mem_fn(Object* o, Ret (Object::*f)(Arg1)) {
- return mem_fn1<Object, Ret, Arg1>(o, f);
+inline mem_fun1<Object, Ret, Arg1>
+make_mem_fun(Object* o, Ret (Object::*f)(Arg1)) {
+ return mem_fun1<Object, Ret, Arg1>(o, f);
 }
 
 template <typename Object, typename Ret, typename Arg1>
-inline const_mem_fn1<Object, Ret, Arg1>
-make_mem_fn(Object* o, Ret (Object::*f)(Arg1) const) {
- return const_mem_fn1<Object, Ret, Arg1>(o, f);
+inline const_mem_fun1<Object, Ret, Arg1>
+make_mem_fun(Object* o, Ret (Object::*f)(Arg1) const) {
+ return const_mem_fun1<Object, Ret, Arg1>(o, f);
 }
 
 template <typename Object, typename Ret, typename Arg1, typename Arg2>
-inline mem_fn2<Object, Ret, Arg1, Arg2>
-make_mem_fn(Object* o, Ret (Object::*f)(Arg1, Arg2)) {
- return mem_fn2<Object, Ret, Arg1, Arg2>(o, f);
+inline mem_fun2<Object, Ret, Arg1, Arg2>
+make_mem_fun(Object* o, Ret (Object::*f)(Arg1, Arg2)) {
+ return mem_fun2<Object, Ret, Arg1, Arg2>(o, f);
 }
 
 template <typename Object, typename Ret, typename Arg1, typename Arg2, typename Arg3>
-inline mem_fn3<Object, Ret, Arg1, Arg2, Arg3>
-make_mem_fn(Object* o, Ret (Object::*f)(Arg1, Arg2, Arg3)) {
- return mem_fn3<Object, Ret, Arg1, Arg2, Arg3>(o, f);
+inline mem_fun3<Object, Ret, Arg1, Arg2, Arg3>
+make_mem_fun(Object* o, Ret (Object::*f)(Arg1, Arg2, Arg3)) {
+ return mem_fun3<Object, Ret, Arg1, Arg2, Arg3>(o, f);
 }
 
 }