3 * the main header file for libswift, normally you should only read this one
5 * Created by Victor Grishchenko on 3/6/09.
6 * Copyright 2009-2012 TECHNISCHE UNIVERSITEIT DELFT. All rights reserved.
15 HANDSHAKE 00, channelid
16 Communicates the channel id of the sender. The
17 initial handshake packet also has the root hash
20 DATA 01, bin_32, buffer
23 ACK 02, bin_32, timestamp_32
25 Confirms successfull delivery of data. Used for
26 congestion control, as well.
29 Practical value of "hints" is to avoid overlap, mostly.
30 Hints might be lost in the network or ignored.
31 Peer might send out data without a hint.
32 Hint which was not responded (by DATA) in some RTTs
33 is considered to be ignored.
34 As peers cant pick randomly kilobyte here and there,
35 they send out "long hints" for non-base bins.
37 HASH 04, bin_32, sha1hash
38 SHA1 hash tree hashes for data verification. The
39 connection to a fresh peer starts with bootstrapping
40 him with peak hashes. Later, before sending out
41 any data, a peer sends the necessary uncle hashes.
43 PEX+/PEX- 05/06, ipv4 addr, port
44 Peer exchange messages; reports all connected and
45 disconected peers. Might has special meaning (as
46 in the case with swarm supervisors).
60 #include <event2/event.h>
61 #include <event2/event_struct.h>
62 #include <event2/buffer.h>
67 #include "availability.h"
68 #include "../kernel/mptp.h"
72 #define SWIFT_MAX_UDP_OVER_ETH_PAYLOAD (1500-20-8)
73 // Arno: Maximum size of non-DATA messages in a UDP packet we send.
74 #define SWIFT_MAX_NONDATA_DGRAM_SIZE (SWIFT_MAX_UDP_OVER_ETH_PAYLOAD-SWIFT_DEFAULT_CHUNK_SIZE-1-4)
75 // Arno: Maximum size of a UDP packet we send. Note: depends on CHUNKSIZE 8192
76 #define SWIFT_MAX_SEND_DGRAM_SIZE (SWIFT_MAX_NONDATA_DGRAM_SIZE+1+4+8192)
77 // Arno: Maximum size of a UDP packet we are willing to accept. Note: depends on CHUNKSIZE 8192
78 #define SWIFT_MAX_RECV_DGRAM_SIZE (SWIFT_MAX_SEND_DGRAM_SIZE*2)
80 #define layer2bytes(ln,cs) (uint64_t)( ((double)cs)*pow(2.0,(double)ln))
81 #define bytes2layer(bn,cs) (int)log2( ((double)bn)/((double)cs) )
83 // Arno, 2011-12-22: Enable Riccardo's VodPiecePicker
84 #define ENABLE_VOD_PIECEPICKER 1
87 /** IPv4 address, just a nice wrapping around struct sockaddr_in. */
89 struct sockaddr_mptp *addr;
90 static uint32_t LOCALHOST;
91 void set_port (uint16_t port) {
92 addr->dests[0].port = htons(port);
94 void set_port (const char* port_str) {
96 if (sscanf(port_str,"%i",&p))
99 void set_ipv4 (uint32_t ipv4) {
100 addr->dests[0].addr = htonl(ipv4);
102 void set_ipv4 (const char* ipv4_str) ;
103 //{ inet_aton(ipv4_str,&(addr.sin_addr)); }
105 addr = (struct sockaddr_mptp *)calloc(1, sizeof(struct sockaddr_mptp) + sizeof(struct mptp_dest));
111 Address(const char* ip, uint16_t port) {
116 Address(const char* ip_port);
117 Address(uint16_t port) {
119 set_ipv4((uint32_t)INADDR_ANY);
122 Address(uint32_t ipv4addr, uint16_t port) {
127 Address(const struct sockaddr_in& address) {
129 addr->dests[0].addr = address.sin_addr.s_addr;
130 addr->dests[0].port = address.sin_port;
135 uint32_t ipv4 () const { return ntohl(addr->dests[0].addr); }
136 uint16_t port () const { return ntohs(addr->dests[0].port); }
137 bool operator == (const Address& b) const {
138 return addr->count == b.addr->count &&
139 addr->dests[0].port==b.addr->dests[0].port &&
140 addr->dests[0].addr==b.addr->dests[0].addr;
142 const char* str () const {
143 // Arno, 2011-10-04: not thread safe, replace.
144 static char rs[4][32];
147 sprintf(rs[i],"%i.%i.%i.%i:%i",ipv4()>>24,(ipv4()>>16)&0xff,
148 (ipv4()>>8)&0xff,ipv4()&0xff,port());
151 const char* ipv4str () const {
152 // Arno, 2011-10-04: not thread safe, replace.
153 static char rs[4][32];
156 sprintf(rs[i],"%i.%i.%i.%i",ipv4()>>24,(ipv4()>>16)&0xff,
157 (ipv4()>>8)&0xff,ipv4()&0xff);
160 bool operator != (const Address& b) const { return !(*this==b); }
161 bool is_private() const {
163 uint32_t no = ipv4(); uint8_t no0 = no>>24,no1 = (no>>16)&0xff;
164 if (no0 == 10) return true;
165 else if (no0 == 172 && no1 >= 16 && no1 <= 31) return true;
166 else if (no0 == 192 && no1 == 168) return true;
171 // Arno, 2011-10-03: Use libevent callback functions, no on_error?
172 #define sockcb_t event_callback_fn
174 sckrwecb_t (evutil_socket_t s=0, sockcb_t mr=NULL, sockcb_t mw=NULL,
176 sock(s), may_read(mr), may_write(mw), on_error(oe) {}
177 evutil_socket_t sock;
187 #define NOW now_t::now
189 /** tintbin is basically a pair<tint,bin64_t> plus some nice operators.
190 Most frequently used in different queues (acknowledgements, requests,
195 tintbin(const tintbin& b) : time(b.time), bin(b.bin) {}
196 tintbin() : time(TINT_NEVER), bin(bin_t::NONE) {}
197 tintbin(tint time_, bin_t bin_) : time(time_), bin(bin_) {}
198 tintbin(bin_t bin_) : time(NOW), bin(bin_) {}
199 bool operator < (const tintbin& b) const
200 { return time > b.time; }
201 bool operator == (const tintbin& b) const
202 { return time==b.time && bin==b.bin; }
203 bool operator != (const tintbin& b) const
204 { return !(*this==b); }
207 typedef std::deque<tintbin> tbqueue;
208 typedef std::deque<bin_t> binqueue;
209 typedef Address Address;
211 /** A heap (priority queue) for timestamped bin numbers (tintbins). */
215 int size () const { return data_.size(); }
216 bool is_empty () const { return data_.empty(); }
218 tintbin ret = data_.front();
219 std::pop_heap(data_.begin(),data_.end());
223 void push(const tintbin& tb) {
225 push_heap(data_.begin(),data_.end());
227 const tintbin& peek() const {
228 return data_.front();
232 /** swift protocol message types; these are used on the wire. */
241 SWIFT_SIGNED_HASH = 7,
243 SWIFT_MSGTYPE_RCVD = 9,
244 SWIFT_RANDOMIZE = 10, //FRAGRAND
245 SWIFT_VERSION = 11, // Arno, 2011-10-19: TODO to match RFC-rev-03
246 SWIFT_MESSAGE_COUNT = 12
255 //class CongestionController; // Arno: Currently part of Channel. See ::NextSendTime
258 typedef void (*ProgressCallback) (int transfer, bin_t bin);
260 /** A class representing single file transfer. */
265 /** A constructor. Open/submit/retrieve a file.
266 * @param file_name the name of the file
267 * @param root_hash the root hash of the file; zero hash if the file
270 FileTransfer(const char *file_name, const Sha1Hash& root_hash=Sha1Hash::ZERO,bool force_check_diskvshash=true,bool check_netwvshash=true,uint32_t chunk_size=SWIFT_DEFAULT_CHUNK_SIZE);
272 /** Close everything. */
276 /** While we need to feed ACKs to every peer, we try (1) avoid
277 unnecessary duplication and (2) keep minimum state. Thus,
278 we use a rotating queue of bin completion events. */
279 //bin64_t RevealAck (uint64_t& offset);
280 /** Rotating queue read for channels of this transmission. */
282 int RevealChannel (int& i);
284 int RandomChannel (int own_id);
287 /** Find transfer by the root hash. */
288 static FileTransfer* Find (const Sha1Hash& hash);
289 /** Find transfer by the file descriptor. */
290 static FileTransfer* file (int fd) {
291 return fd<files.size() ? files[fd] : NULL;
294 /** The binmap for data already retrieved and checked. */
295 binmap_t& ack_out () { return file_.ack_out(); }
296 /** Piece picking strategy used by this transfer. */
297 PiecePicker& picker () { return *picker_; }
298 /** The number of channels working for this transfer. */
299 int channel_count () const { return hs_in_.size(); }
300 /** Hash tree checked file; all the hashes and data are kept here. */
301 HashTree& file() { return file_; }
302 /** File descriptor for the data file. */
303 int fd () const { return file_.file_descriptor(); }
304 /** Root SHA1 hash of the transfer (and the data file). */
305 const Sha1Hash& root_hash () const { return file_.root_hash(); }
306 /** Ric: the availability in the swarm */
307 Availability& availability() { return *availability_; }
310 /** Arno: Call when n bytes are received. */
311 void OnRecvData(int n);
312 /** Arno: Call when n bytes are sent. */
313 void OnSendData(int n);
314 /** Arno: Call when no bytes are sent due to rate limiting. */
316 /** Arno: Return current speed for the given direction in bytes/s */
317 double GetCurrentSpeed(data_direction_t ddir);
318 /** Arno: Return maximum speed for the given direction in bytes/s */
319 double GetMaxSpeed(data_direction_t ddir);
320 /** Arno: Set maximum speed for the given direction in bytes/s */
321 void SetMaxSpeed(data_direction_t ddir, double m);
322 /** Arno: Return the number of non-seeders current channeled with. */
323 uint32_t GetNumLeechers();
324 /** Arno: Return the number of seeders current channeled with. */
325 uint32_t GetNumSeeders();
326 /** Arno: Return the set of Channels for this transfer. MORESTATS */
327 std::set<Channel *> GetChannels() { return mychannels_; }
329 /** Arno: set the tracker for this transfer. Reseting it won't kill
330 * any existing connections.
332 void SetTracker(Address tracker) { tracker_ = tracker; }
334 /** Arno: (Re)Connect to tracker for this transfer, or global Channel::tracker if not set */
335 void ConnectToTracker();
337 /** Arno: Reconnect to the tracker if no established peers and
338 * exp backoff allows it.
340 void ReConnectToTrackerIfAllowed(bool hasestablishedpeers);
342 /** Arno: Return the Channel to peer "addr" that is not equal to "notc". */
343 Channel * FindChannel(const Address &addr, Channel *notc);
346 static void LibeventCleanCallback(int fd, short event, void *arg);
351 /** Piece picker strategy. */
352 PiecePicker* picker_;
354 /** Channels working for this transfer. */
355 binqueue hs_in_; // Arno, 2011-10-03: Should really be queue of channel ID (=uint32_t)
357 /** Messages we are accepting. */
363 /** Availability in the swarm */
364 Availability* availability_;
366 #define SWFT_MAX_TRANSFER_CB 8
367 ProgressCallback callbacks[SWFT_MAX_TRANSFER_CB];
368 uint8_t cb_agg[SWFT_MAX_TRANSFER_CB];
372 std::set<Channel *> mychannels_; // Arno, 2012-01-31: May be duplicate of hs_in_
373 MovingAverageSpeed cur_speed_[2];
374 double max_speed_[2];
378 struct event evclean_;
380 Address tracker_; // Tracker for this transfer
381 tint tracker_retry_interval_;
382 tint tracker_retry_time_;
385 void OnDataIn (bin_t pos);
386 // Gertjan fix: return bool
387 bool OnPexIn (const Address& addr);
389 static std::vector<FileTransfer*> files;
392 friend class Channel;
393 // Ric: maybe not really needed
394 friend class Availability;
395 friend uint64_t Size (int fdes);
396 friend bool IsComplete (int fdes);
397 friend uint64_t Complete (int fdes);
398 friend uint64_t SeqComplete (int fdes);
399 friend int Open (const char* filename, const Sha1Hash& hash, Address tracker, bool force_check_diskvshash, bool check_netwvshash, uint32_t chunk_size);
400 friend void Close (int fd) ;
401 friend void AddProgressCallback (int transfer,ProgressCallback cb,uint8_t agg);
402 friend void RemoveProgressCallback (int transfer,ProgressCallback cb);
403 friend void ExternallyRetrieved (int transfer,bin_t piece);
407 /** PiecePicker implements some strategy of choosing (picking) what
408 to request next, given the possible range of choices:
409 data acknowledged by the peer minus data already retrieved.
410 May pick sequentially, do rarest first or in some other way. */
413 virtual void Randomize (uint64_t twist) = 0;
414 /** The piece picking method itself.
415 * @param offered the data acknowledged by the peer
416 * @param max_width maximum number of packets to ask for
417 * @param expires (not used currently) when to consider request expired
418 * @return the bin number to request */
419 virtual bin_t Pick (binmap_t& offered, uint64_t max_width, tint expires) = 0;
420 virtual void LimitRange (bin_t range) = 0;
421 /** updates the playback position for streaming piece picking.
422 * @param amount amount to increment in bin unit size (1KB default) */
423 virtual void updatePlaybackPos (int amount=1) = 0;
424 virtual ~PiecePicker() {}
428 class PeerSelector { // Arno: partically unused
430 virtual void AddPeer (const Address& addr, const Sha1Hash& root) = 0;
431 virtual Address GetPeer (const Sha1Hash& for_root) = 0;
435 /* class DataStorer { // Arno: never implemented
437 DataStorer (const Sha1Hash& id, size_t size);
438 virtual size_t ReadData (bin_t pos,uint8_t** buf) = 0;
439 virtual size_t WriteData (bin_t pos, uint8_t* buf, size_t len) = 0;
443 /** swift channel's "control block"; channels loosely correspond to TCP
444 connections or FTP sessions; one channel is created for one file
445 being transferred between two peers. As we don't need buffers and
446 lots of other TCP stuff, sizeof(Channel+members) must be below 1K.
447 Normally, API users do not deal with this class. */
450 #define DGRAM_MAX_SOCK_OPEN 128
451 static int sock_count;
452 static sckrwecb_t sock_open[DGRAM_MAX_SOCK_OPEN];
455 Channel (FileTransfer* file, int socket=INVALID_SOCKET, Address peer=Address());
467 static Address tracker; // Global tracker for all transfers
468 struct event *evsend_ptr_; // Arno: timer per channel // SAFECLOSE
469 static struct event_base *evbase;
470 static struct event evrecv;
471 static const char* SEND_CONTROL_MODES[];
473 static tint epoch, start;
474 static uint64_t global_dgrams_up, global_dgrams_down, global_raw_bytes_up, global_raw_bytes_down, global_bytes_up, global_bytes_down;
475 static void CloseChannelByAddress(const Address &addr);
478 // Arno: channel is also a "singleton" class that manages all sockets
479 // for a swift process
480 static void LibeventSendCallback(int fd, short event, void *arg);
481 static void LibeventReceiveCallback(int fd, short event, void *arg);
482 static void RecvDatagram (evutil_socket_t socket); // Called by LibeventReceiveCallback
483 static int RecvFrom(evutil_socket_t sock, Address& addr, struct evbuffer *evb); // Called by RecvDatagram
484 static int SendTo(evutil_socket_t sock, const Address& addr, struct evbuffer *evb); // Called by Channel::Send()
485 static evutil_socket_t Bind(Address address, sckrwecb_t callbacks=sckrwecb_t());
486 static Address BoundAddress(evutil_socket_t sock);
487 static evutil_socket_t default_socket()
488 { return sock_count ? sock_open[0].sock : INVALID_SOCKET; }
490 /** close the port */
491 static void CloseSocket(evutil_socket_t sock);
492 static void Shutdown ();
493 /** the current time */
496 // Arno: Per instance methods
497 void Recv (struct evbuffer *evb);
498 void Send (); // Called by LibeventSendCallback
501 void OnAck (struct evbuffer *evb);
502 void OnHave (struct evbuffer *evb);
503 bin_t OnData (struct evbuffer *evb);
504 void OnHint (struct evbuffer *evb);
505 void OnHash (struct evbuffer *evb);
506 void OnPex (struct evbuffer *evb);
507 void OnHandshake (struct evbuffer *evb);
508 void OnRandomize (struct evbuffer *evb); //FRAGRAND
509 void AddHandshake (struct evbuffer *evb);
510 bin_t AddData (struct evbuffer *evb);
511 void AddAck (struct evbuffer *evb);
512 void AddHave (struct evbuffer *evb);
513 void AddHint (struct evbuffer *evb);
514 void AddUncleHashes (struct evbuffer *evb, bin_t pos);
515 void AddPeakHashes (struct evbuffer *evb);
516 void AddPex (struct evbuffer *evb);
518 void AddPexReq(struct evbuffer *evb);
519 void BackOffOnLosses (float ratio=0.5);
520 tint SwitchSendControl (int control_mode);
521 tint NextSendTime ();
522 tint KeepAliveNextSendTime ();
523 tint PingPongNextSendTime ();
524 tint CwndRateNextSendTime ();
525 tint SlowStartNextSendTime ();
526 tint AimdNextSendTime ();
527 tint LedbatNextSendTime ();
528 /** Arno: return true if this peer has complete file. May be fuzzy if Peak Hashes not in */
530 /** Arno: return (UDP) port for this channel */
531 uint16_t GetMyPort();
532 bool IsDiffSenderOrDuplicate(Address addr, uint32_t chid);
534 static int MAX_REORDERING;
537 static tint MAX_SEND_INTERVAL;
538 static tint LEDBAT_TARGET;
539 static float LEDBAT_GAIN;
540 static tint LEDBAT_DELAY_BIN;
541 static bool SELF_CONN_OK;
542 static tint MAX_POSSIBLE_RTT;
543 static tint MIN_PEX_REQUEST_INTERVAL;
544 static FILE* debug_file;
546 const std::string id_string () const;
547 /** A channel is "established" if had already sent and received packets. */
548 bool is_established () { return peer_channel_id_ && own_id_mentioned_; }
549 FileTransfer& transfer() { return *transfer_; }
550 HashTree& file () { return transfer_->file(); }
551 const Address& peer() const { return peer_; }
552 const Address& recv_peer() const { return recv_peer_; }
553 tint ack_timeout () {
554 tint dev = dev_avg_ < MIN_DEV ? MIN_DEV : dev_avg_;
555 tint tmo = rtt_avg_ + dev * 4;
556 return tmo < 30*TINT_SEC ? tmo : 30*TINT_SEC;
558 uint32_t id () const { return id_; }
561 uint64_t raw_bytes_up() { return raw_bytes_up_; }
562 uint64_t raw_bytes_down() { return raw_bytes_down_; }
563 uint64_t bytes_up() { return bytes_up_; }
564 uint64_t bytes_down() { return bytes_down_; }
566 static int DecodeID(int scrambled);
567 static int EncodeID(int unscrambled);
568 static Channel* channel(int i) {
569 return i<channels.size()?channels[i]:NULL;
571 static void CloseTransfer (FileTransfer* trans);
575 void Schedule4Close() { scheduled4close_ = true; }
576 bool IsScheduled4Close() { return scheduled4close_; }
580 /** Channel id: index in the channel array. */
582 /** Socket address of the peer. */
584 /** The UDP socket fd. */
585 evutil_socket_t socket_;
586 /** Descriptor of the file in question. */
587 FileTransfer* transfer_;
588 /** Peer channel id; zero if we are trying to open a channel. */
589 uint32_t peer_channel_id_;
590 bool own_id_mentioned_;
591 /** Peer's progress, based on acknowledgements. */
593 /** Last data received; needs to be acked immediately. */
596 /** The history of data sent and still unacknowledged. */
598 /** Timeouted data (potentially to be retransmitted). */
599 tbqueue data_out_tmo_;
601 /** Index in the history array. */
603 /** Transmit schedule: in most cases filled with the peer's hints */
605 /** Hints sent (to detect and reschedule ignored hints). */
607 uint64_t hint_out_size_;
608 /** Types of messages the peer accepts. */
611 //tint last_send_time, last_recv_time;
614 tint last_pex_request_time_;
615 tint next_pex_request_time_;
616 bool pex_request_outstanding_;
617 tbqueue reverse_pex_out_; // Arno, 2011-10-03: should really be a queue of (tint,channel id(= uint32_t)) pairs.
618 int useless_pex_count_;
619 /** Smoothed averages for RTT, RTT deviation and data interarrival periods. */
620 tint rtt_avg_, dev_avg_, dip_avg_;
621 tint last_send_time_;
622 tint last_recv_time_;
623 tint last_data_out_time_;
624 tint last_data_in_time_;
625 tint last_loss_time_;
626 tint next_send_time_;
627 /** Congestion window; TODO: int, bytes. */
630 /** Data sending interval. */
632 /** The congestion control strategy. */
634 /** Datagrams (not data) sent since last recv. */
635 int sent_since_recv_;
637 /** Arno: Fix for KEEP_ALIVE_CONTROL */
638 bool lastrecvwaskeepalive_;
639 bool lastsendwaskeepalive_;
641 /** Recent acknowlegements for data previously sent. */
642 int ack_rcvd_recent_;
643 /** Recent non-acknowlegements (losses) of data previously sent. */
644 int ack_not_rcvd_recent_;
645 /** LEDBAT one-way delay machinery */
646 tint owd_min_bins_[4];
648 tint owd_min_bin_start_;
649 tint owd_current_[4];
654 // Arno, 2011-11-28: for detailed, per-peer stats. MORESTATS
655 uint64_t raw_bytes_up_, raw_bytes_down_, bytes_up_, bytes_down_;
658 bool scheduled4close_;
659 /** Arno: Socket address of the peer where packets are received from,
660 * when an IANA private address, otherwise 0.
661 * May not be equal to peer_. 2PEERSBEHINDSAMENAT */
664 int PeerBPS() const {
665 return TINT_SEC / dip_avg_ * 1024;
667 /** Get a request for one packet from the queue of peer's requests. */
668 bin_t DequeueHint(bool *retransmitptr);
670 void TimeoutDataOut ();
671 void CleanStaleHintOut();
672 void CleanHintOut(bin_t pos);
674 void UpdateDIP(bin_t pos); // RETRANSMIT
677 static PeerSelector* peer_selector;
679 static tint last_tick;
680 //static tbheap send_queue;
682 static std::vector<Channel*> channels;
684 friend int Listen (Address addr);
685 friend void Shutdown (int sock_des);
686 friend void AddPeer (Address address, const Sha1Hash& root);
687 friend void SetTracker(const Address& tracker);
688 friend int Open (const char*, const Sha1Hash&, Address tracker, bool force_check_diskvshash, bool check_netwvshash, uint32_t chunk_size) ; // FIXME
693 /*************** The top-level API ****************/
694 /** Start listening a port. Returns socket descriptor. */
695 int Listen (Address addr);
696 /** Stop listening to a port. */
697 void Shutdown (int sock_des=-1);
699 /** Open a file, start a transmission; fill it with content for a given
700 root hash and tracker (optional). If "force_check_diskvshash" is true, the
701 hashtree state will be (re)constructed from the file on disk (if any).
702 If not, open will try to reconstruct the hashtree state from
703 the .mhash and .mbinmap files on disk. .mhash files are created
704 automatically, .mbinmap files must be written by checkpointing the
705 transfer by calling FileTransfer::serialize(). If the reconstruction
706 fails, it will hashcheck anyway. Roothash is optional for new files or
707 files already hashchecked and checkpointed. If "check_netwvshash" is
708 false, no uncle hashes will be sent and no data will be verified against
709 then on receipt. In this mode, checking disk contents against hashes
710 no longer works on restarts, unless checkpoints are used.
712 int Open (const char* filename, const Sha1Hash& hash=Sha1Hash::ZERO,Address tracker=Address(), bool force_check_diskvshash=true, bool check_netwvshash=true, uint32_t chunk_size=SWIFT_DEFAULT_CHUNK_SIZE);
713 /** Get the root hash for the transmission. */
714 const Sha1Hash& RootMerkleHash (int file) ;
715 /** Close a file and a transmission. */
716 void Close (int fd) ;
717 /** Add a possible peer which participares in a given transmission. In the case
718 root hash is zero, the peer might be talked to regarding any transmission
719 (likely, a tracker, cache or an archive). */
720 void AddPeer (Address address, const Sha1Hash& root=Sha1Hash::ZERO);
722 void SetTracker(const Address& tracker);
723 /** Set the default tracker that is used when Open is not passed a tracker
726 /** Returns size of the file in bytes, 0 if unknown. Might be rounded up to a kilobyte
727 before the transmission is complete. */
728 uint64_t Size (int fdes);
729 /** Returns the amount of retrieved and verified data, in bytes.
730 A 100% complete transmission has Size()==Complete(). */
731 uint64_t Complete (int fdes);
732 bool IsComplete (int fdes);
733 /** Returns the number of bytes that are complete sequentially, starting from the
734 beginning, till the first not-yet-retrieved packet. */
735 uint64_t SeqComplete (int fdes);
737 int Find (Sha1Hash hash);
738 /** Returns the number of bytes in a chunk for this transmission */
739 uint32_t ChunkSize(int fdes);
741 /** Get the address bound to the socket descriptor returned by Listen() */
742 Address BoundAddress(evutil_socket_t sock);
744 void AddProgressCallback (int transfer,ProgressCallback cb,uint8_t agg);
745 void RemoveProgressCallback (int transfer,ProgressCallback cb);
746 void ExternallyRetrieved (int transfer,bin_t piece);
749 /** Must be called by any client using the library */
750 void LibraryInit(void);
752 int evbuffer_add_string(struct evbuffer *evb, std::string str);
753 int evbuffer_add_8(struct evbuffer *evb, uint8_t b);
754 int evbuffer_add_16be(struct evbuffer *evb, uint16_t w);
755 int evbuffer_add_32be(struct evbuffer *evb, uint32_t i);
756 int evbuffer_add_64be(struct evbuffer *evb, uint64_t l);
757 int evbuffer_add_hash(struct evbuffer *evb, const Sha1Hash& hash);
759 uint8_t evbuffer_remove_8(struct evbuffer *evb);
760 uint16_t evbuffer_remove_16be(struct evbuffer *evb);
761 uint32_t evbuffer_remove_32be(struct evbuffer *evb);
762 uint64_t evbuffer_remove_64be(struct evbuffer *evb);
763 Sha1Hash evbuffer_remove_hash(struct evbuffer* evb);
765 const char* tintstr(tint t=0);
766 std::string sock2str (struct sockaddr_in addr);
767 #define SWIFT_MAX_CONNECTIONS 20
769 void nat_test_update(void);
771 // Arno: Save transfer's binmap for zero-hashcheck restart
772 void Checkpoint(int fdes);
776 // #define SWIFT_MUTE
779 #define dprintf(...) do { if (Channel::debug_file) fprintf(Channel::debug_file,__VA_ARGS__); } while (0)
780 #define dflush() fflush(Channel::debug_file)
782 #define dprintf(...) do {} while(0)
783 #define dflush() do {} while(0)
785 #define eprintf(...) fprintf(stderr,__VA_ARGS__)