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));
110 Address(const char* ip, uint16_t port) {
115 Address(const char* ip_port);
116 Address(uint16_t port) {
118 set_ipv4((uint32_t)INADDR_ANY);
121 Address(uint32_t ipv4addr, uint16_t port) {
126 Address(const struct sockaddr_in& address) {
127 addr->dests[0].addr = address.sin_addr.s_addr;
128 addr->dests[0].port = address.sin_port;
133 uint32_t ipv4 () const { return ntohl(addr->dests[0].addr); }
134 uint16_t port () const { return ntohs(addr->dests[0].port); }
135 bool operator == (const Address& b) const {
136 return addr->count == b.addr->count &&
137 addr->dests[0].port==b.addr->dests[0].port &&
138 addr->dests[0].addr==b.addr->dests[0].addr;
140 const char* str () const {
141 // Arno, 2011-10-04: not thread safe, replace.
142 static char rs[4][32];
145 sprintf(rs[i],"%i.%i.%i.%i:%i",ipv4()>>24,(ipv4()>>16)&0xff,
146 (ipv4()>>8)&0xff,ipv4()&0xff,port());
149 const char* ipv4str () const {
150 // Arno, 2011-10-04: not thread safe, replace.
151 static char rs[4][32];
154 sprintf(rs[i],"%i.%i.%i.%i",ipv4()>>24,(ipv4()>>16)&0xff,
155 (ipv4()>>8)&0xff,ipv4()&0xff);
158 bool operator != (const Address& b) const { return !(*this==b); }
159 bool is_private() const {
161 uint32_t no = ipv4(); uint8_t no0 = no>>24,no1 = (no>>16)&0xff;
162 if (no0 == 10) return true;
163 else if (no0 == 172 && no1 >= 16 && no1 <= 31) return true;
164 else if (no0 == 192 && no1 == 168) return true;
169 // Arno, 2011-10-03: Use libevent callback functions, no on_error?
170 #define sockcb_t event_callback_fn
172 sckrwecb_t (evutil_socket_t s=0, sockcb_t mr=NULL, sockcb_t mw=NULL,
174 sock(s), may_read(mr), may_write(mw), on_error(oe) {}
175 evutil_socket_t sock;
185 #define NOW now_t::now
187 /** tintbin is basically a pair<tint,bin64_t> plus some nice operators.
188 Most frequently used in different queues (acknowledgements, requests,
193 tintbin(const tintbin& b) : time(b.time), bin(b.bin) {}
194 tintbin() : time(TINT_NEVER), bin(bin_t::NONE) {}
195 tintbin(tint time_, bin_t bin_) : time(time_), bin(bin_) {}
196 tintbin(bin_t bin_) : time(NOW), bin(bin_) {}
197 bool operator < (const tintbin& b) const
198 { return time > b.time; }
199 bool operator == (const tintbin& b) const
200 { return time==b.time && bin==b.bin; }
201 bool operator != (const tintbin& b) const
202 { return !(*this==b); }
205 typedef std::deque<tintbin> tbqueue;
206 typedef std::deque<bin_t> binqueue;
207 typedef Address Address;
209 /** A heap (priority queue) for timestamped bin numbers (tintbins). */
213 int size () const { return data_.size(); }
214 bool is_empty () const { return data_.empty(); }
216 tintbin ret = data_.front();
217 std::pop_heap(data_.begin(),data_.end());
221 void push(const tintbin& tb) {
223 push_heap(data_.begin(),data_.end());
225 const tintbin& peek() const {
226 return data_.front();
230 /** swift protocol message types; these are used on the wire. */
239 SWIFT_SIGNED_HASH = 7,
241 SWIFT_MSGTYPE_RCVD = 9,
242 SWIFT_RANDOMIZE = 10, //FRAGRAND
243 SWIFT_VERSION = 11, // Arno, 2011-10-19: TODO to match RFC-rev-03
244 SWIFT_MESSAGE_COUNT = 12
253 //class CongestionController; // Arno: Currently part of Channel. See ::NextSendTime
256 typedef void (*ProgressCallback) (int transfer, bin_t bin);
258 /** A class representing single file transfer. */
263 /** A constructor. Open/submit/retrieve a file.
264 * @param file_name the name of the file
265 * @param root_hash the root hash of the file; zero hash if the file
268 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);
270 /** Close everything. */
274 /** While we need to feed ACKs to every peer, we try (1) avoid
275 unnecessary duplication and (2) keep minimum state. Thus,
276 we use a rotating queue of bin completion events. */
277 //bin64_t RevealAck (uint64_t& offset);
278 /** Rotating queue read for channels of this transmission. */
280 int RevealChannel (int& i);
282 int RandomChannel (int own_id);
285 /** Find transfer by the root hash. */
286 static FileTransfer* Find (const Sha1Hash& hash);
287 /** Find transfer by the file descriptor. */
288 static FileTransfer* file (int fd) {
289 return fd<files.size() ? files[fd] : NULL;
292 /** The binmap for data already retrieved and checked. */
293 binmap_t& ack_out () { return file_.ack_out(); }
294 /** Piece picking strategy used by this transfer. */
295 PiecePicker& picker () { return *picker_; }
296 /** The number of channels working for this transfer. */
297 int channel_count () const { return hs_in_.size(); }
298 /** Hash tree checked file; all the hashes and data are kept here. */
299 HashTree& file() { return file_; }
300 /** File descriptor for the data file. */
301 int fd () const { return file_.file_descriptor(); }
302 /** Root SHA1 hash of the transfer (and the data file). */
303 const Sha1Hash& root_hash () const { return file_.root_hash(); }
304 /** Ric: the availability in the swarm */
305 Availability& availability() { return *availability_; }
308 /** Arno: Call when n bytes are received. */
309 void OnRecvData(int n);
310 /** Arno: Call when n bytes are sent. */
311 void OnSendData(int n);
312 /** Arno: Call when no bytes are sent due to rate limiting. */
314 /** Arno: Return current speed for the given direction in bytes/s */
315 double GetCurrentSpeed(data_direction_t ddir);
316 /** Arno: Return maximum speed for the given direction in bytes/s */
317 double GetMaxSpeed(data_direction_t ddir);
318 /** Arno: Set maximum speed for the given direction in bytes/s */
319 void SetMaxSpeed(data_direction_t ddir, double m);
320 /** Arno: Return the number of non-seeders current channeled with. */
321 uint32_t GetNumLeechers();
322 /** Arno: Return the number of seeders current channeled with. */
323 uint32_t GetNumSeeders();
324 /** Arno: Return the set of Channels for this transfer. MORESTATS */
325 std::set<Channel *> GetChannels() { return mychannels_; }
327 /** Arno: set the tracker for this transfer. Reseting it won't kill
328 * any existing connections.
330 void SetTracker(Address tracker) { tracker_ = tracker; }
332 /** Arno: (Re)Connect to tracker for this transfer, or global Channel::tracker if not set */
333 void ConnectToTracker();
335 /** Arno: Reconnect to the tracker if no established peers and
336 * exp backoff allows it.
338 void ReConnectToTrackerIfAllowed(bool hasestablishedpeers);
340 /** Arno: Return the Channel to peer "addr" that is not equal to "notc". */
341 Channel * FindChannel(const Address &addr, Channel *notc);
344 static void LibeventCleanCallback(int fd, short event, void *arg);
349 /** Piece picker strategy. */
350 PiecePicker* picker_;
352 /** Channels working for this transfer. */
353 binqueue hs_in_; // Arno, 2011-10-03: Should really be queue of channel ID (=uint32_t)
355 /** Messages we are accepting. */
361 /** Availability in the swarm */
362 Availability* availability_;
364 #define SWFT_MAX_TRANSFER_CB 8
365 ProgressCallback callbacks[SWFT_MAX_TRANSFER_CB];
366 uint8_t cb_agg[SWFT_MAX_TRANSFER_CB];
370 std::set<Channel *> mychannels_; // Arno, 2012-01-31: May be duplicate of hs_in_
371 MovingAverageSpeed cur_speed_[2];
372 double max_speed_[2];
376 struct event evclean_;
378 Address tracker_; // Tracker for this transfer
379 tint tracker_retry_interval_;
380 tint tracker_retry_time_;
383 void OnDataIn (bin_t pos);
384 // Gertjan fix: return bool
385 bool OnPexIn (const Address& addr);
387 static std::vector<FileTransfer*> files;
390 friend class Channel;
391 // Ric: maybe not really needed
392 friend class Availability;
393 friend uint64_t Size (int fdes);
394 friend bool IsComplete (int fdes);
395 friend uint64_t Complete (int fdes);
396 friend uint64_t SeqComplete (int fdes);
397 friend int Open (const char* filename, const Sha1Hash& hash, Address tracker, bool force_check_diskvshash, bool check_netwvshash, uint32_t chunk_size);
398 friend void Close (int fd) ;
399 friend void AddProgressCallback (int transfer,ProgressCallback cb,uint8_t agg);
400 friend void RemoveProgressCallback (int transfer,ProgressCallback cb);
401 friend void ExternallyRetrieved (int transfer,bin_t piece);
405 /** PiecePicker implements some strategy of choosing (picking) what
406 to request next, given the possible range of choices:
407 data acknowledged by the peer minus data already retrieved.
408 May pick sequentially, do rarest first or in some other way. */
411 virtual void Randomize (uint64_t twist) = 0;
412 /** The piece picking method itself.
413 * @param offered the data acknowledged by the peer
414 * @param max_width maximum number of packets to ask for
415 * @param expires (not used currently) when to consider request expired
416 * @return the bin number to request */
417 virtual bin_t Pick (binmap_t& offered, uint64_t max_width, tint expires) = 0;
418 virtual void LimitRange (bin_t range) = 0;
419 /** updates the playback position for streaming piece picking.
420 * @param amount amount to increment in bin unit size (1KB default) */
421 virtual void updatePlaybackPos (int amount=1) = 0;
422 virtual ~PiecePicker() {}
426 class PeerSelector { // Arno: partically unused
428 virtual void AddPeer (const Address& addr, const Sha1Hash& root) = 0;
429 virtual Address GetPeer (const Sha1Hash& for_root) = 0;
433 /* class DataStorer { // Arno: never implemented
435 DataStorer (const Sha1Hash& id, size_t size);
436 virtual size_t ReadData (bin_t pos,uint8_t** buf) = 0;
437 virtual size_t WriteData (bin_t pos, uint8_t* buf, size_t len) = 0;
441 /** swift channel's "control block"; channels loosely correspond to TCP
442 connections or FTP sessions; one channel is created for one file
443 being transferred between two peers. As we don't need buffers and
444 lots of other TCP stuff, sizeof(Channel+members) must be below 1K.
445 Normally, API users do not deal with this class. */
448 #define DGRAM_MAX_SOCK_OPEN 128
449 static int sock_count;
450 static sckrwecb_t sock_open[DGRAM_MAX_SOCK_OPEN];
453 Channel (FileTransfer* file, int socket=INVALID_SOCKET, Address peer=Address());
465 static Address tracker; // Global tracker for all transfers
466 struct event *evsend_ptr_; // Arno: timer per channel // SAFECLOSE
467 static struct event_base *evbase;
468 static struct event evrecv;
469 static const char* SEND_CONTROL_MODES[];
471 static tint epoch, start;
472 static uint64_t global_dgrams_up, global_dgrams_down, global_raw_bytes_up, global_raw_bytes_down, global_bytes_up, global_bytes_down;
473 static void CloseChannelByAddress(const Address &addr);
476 // Arno: channel is also a "singleton" class that manages all sockets
477 // for a swift process
478 static void LibeventSendCallback(int fd, short event, void *arg);
479 static void LibeventReceiveCallback(int fd, short event, void *arg);
480 static void RecvDatagram (evutil_socket_t socket); // Called by LibeventReceiveCallback
481 static int RecvFrom(evutil_socket_t sock, Address& addr, struct evbuffer *evb); // Called by RecvDatagram
482 static int SendTo(evutil_socket_t sock, const Address& addr, struct evbuffer *evb); // Called by Channel::Send()
483 static evutil_socket_t Bind(Address address, sckrwecb_t callbacks=sckrwecb_t());
484 static Address BoundAddress(evutil_socket_t sock);
485 static evutil_socket_t default_socket()
486 { return sock_count ? sock_open[0].sock : INVALID_SOCKET; }
488 /** close the port */
489 static void CloseSocket(evutil_socket_t sock);
490 static void Shutdown ();
491 /** the current time */
494 // Arno: Per instance methods
495 void Recv (struct evbuffer *evb);
496 void Send (); // Called by LibeventSendCallback
499 void OnAck (struct evbuffer *evb);
500 void OnHave (struct evbuffer *evb);
501 bin_t OnData (struct evbuffer *evb);
502 void OnHint (struct evbuffer *evb);
503 void OnHash (struct evbuffer *evb);
504 void OnPex (struct evbuffer *evb);
505 void OnHandshake (struct evbuffer *evb);
506 void OnRandomize (struct evbuffer *evb); //FRAGRAND
507 void AddHandshake (struct evbuffer *evb);
508 bin_t AddData (struct evbuffer *evb);
509 void AddAck (struct evbuffer *evb);
510 void AddHave (struct evbuffer *evb);
511 void AddHint (struct evbuffer *evb);
512 void AddUncleHashes (struct evbuffer *evb, bin_t pos);
513 void AddPeakHashes (struct evbuffer *evb);
514 void AddPex (struct evbuffer *evb);
516 void AddPexReq(struct evbuffer *evb);
517 void BackOffOnLosses (float ratio=0.5);
518 tint SwitchSendControl (int control_mode);
519 tint NextSendTime ();
520 tint KeepAliveNextSendTime ();
521 tint PingPongNextSendTime ();
522 tint CwndRateNextSendTime ();
523 tint SlowStartNextSendTime ();
524 tint AimdNextSendTime ();
525 tint LedbatNextSendTime ();
526 /** Arno: return true if this peer has complete file. May be fuzzy if Peak Hashes not in */
528 /** Arno: return (UDP) port for this channel */
529 uint16_t GetMyPort();
530 bool IsDiffSenderOrDuplicate(Address addr, uint32_t chid);
532 static int MAX_REORDERING;
535 static tint MAX_SEND_INTERVAL;
536 static tint LEDBAT_TARGET;
537 static float LEDBAT_GAIN;
538 static tint LEDBAT_DELAY_BIN;
539 static bool SELF_CONN_OK;
540 static tint MAX_POSSIBLE_RTT;
541 static tint MIN_PEX_REQUEST_INTERVAL;
542 static FILE* debug_file;
544 const std::string id_string () const;
545 /** A channel is "established" if had already sent and received packets. */
546 bool is_established () { return peer_channel_id_ && own_id_mentioned_; }
547 FileTransfer& transfer() { return *transfer_; }
548 HashTree& file () { return transfer_->file(); }
549 const Address& peer() const { return peer_; }
550 const Address& recv_peer() const { return recv_peer_; }
551 tint ack_timeout () {
552 tint dev = dev_avg_ < MIN_DEV ? MIN_DEV : dev_avg_;
553 tint tmo = rtt_avg_ + dev * 4;
554 return tmo < 30*TINT_SEC ? tmo : 30*TINT_SEC;
556 uint32_t id () const { return id_; }
559 uint64_t raw_bytes_up() { return raw_bytes_up_; }
560 uint64_t raw_bytes_down() { return raw_bytes_down_; }
561 uint64_t bytes_up() { return bytes_up_; }
562 uint64_t bytes_down() { return bytes_down_; }
564 static int DecodeID(int scrambled);
565 static int EncodeID(int unscrambled);
566 static Channel* channel(int i) {
567 return i<channels.size()?channels[i]:NULL;
569 static void CloseTransfer (FileTransfer* trans);
573 void Schedule4Close() { scheduled4close_ = true; }
574 bool IsScheduled4Close() { return scheduled4close_; }
578 /** Channel id: index in the channel array. */
580 /** Socket address of the peer. */
582 /** The UDP socket fd. */
583 evutil_socket_t socket_;
584 /** Descriptor of the file in question. */
585 FileTransfer* transfer_;
586 /** Peer channel id; zero if we are trying to open a channel. */
587 uint32_t peer_channel_id_;
588 bool own_id_mentioned_;
589 /** Peer's progress, based on acknowledgements. */
591 /** Last data received; needs to be acked immediately. */
594 /** The history of data sent and still unacknowledged. */
596 /** Timeouted data (potentially to be retransmitted). */
597 tbqueue data_out_tmo_;
599 /** Index in the history array. */
601 /** Transmit schedule: in most cases filled with the peer's hints */
603 /** Hints sent (to detect and reschedule ignored hints). */
605 uint64_t hint_out_size_;
606 /** Types of messages the peer accepts. */
609 //tint last_send_time, last_recv_time;
612 tint last_pex_request_time_;
613 tint next_pex_request_time_;
614 bool pex_request_outstanding_;
615 tbqueue reverse_pex_out_; // Arno, 2011-10-03: should really be a queue of (tint,channel id(= uint32_t)) pairs.
616 int useless_pex_count_;
617 /** Smoothed averages for RTT, RTT deviation and data interarrival periods. */
618 tint rtt_avg_, dev_avg_, dip_avg_;
619 tint last_send_time_;
620 tint last_recv_time_;
621 tint last_data_out_time_;
622 tint last_data_in_time_;
623 tint last_loss_time_;
624 tint next_send_time_;
625 /** Congestion window; TODO: int, bytes. */
628 /** Data sending interval. */
630 /** The congestion control strategy. */
632 /** Datagrams (not data) sent since last recv. */
633 int sent_since_recv_;
635 /** Arno: Fix for KEEP_ALIVE_CONTROL */
636 bool lastrecvwaskeepalive_;
637 bool lastsendwaskeepalive_;
639 /** Recent acknowlegements for data previously sent. */
640 int ack_rcvd_recent_;
641 /** Recent non-acknowlegements (losses) of data previously sent. */
642 int ack_not_rcvd_recent_;
643 /** LEDBAT one-way delay machinery */
644 tint owd_min_bins_[4];
646 tint owd_min_bin_start_;
647 tint owd_current_[4];
652 // Arno, 2011-11-28: for detailed, per-peer stats. MORESTATS
653 uint64_t raw_bytes_up_, raw_bytes_down_, bytes_up_, bytes_down_;
656 bool scheduled4close_;
657 /** Arno: Socket address of the peer where packets are received from,
658 * when an IANA private address, otherwise 0.
659 * May not be equal to peer_. 2PEERSBEHINDSAMENAT */
662 int PeerBPS() const {
663 return TINT_SEC / dip_avg_ * 1024;
665 /** Get a request for one packet from the queue of peer's requests. */
666 bin_t DequeueHint(bool *retransmitptr);
668 void TimeoutDataOut ();
669 void CleanStaleHintOut();
670 void CleanHintOut(bin_t pos);
672 void UpdateDIP(bin_t pos); // RETRANSMIT
675 static PeerSelector* peer_selector;
677 static tint last_tick;
678 //static tbheap send_queue;
680 static std::vector<Channel*> channels;
682 friend int Listen (Address addr);
683 friend void Shutdown (int sock_des);
684 friend void AddPeer (Address address, const Sha1Hash& root);
685 friend void SetTracker(const Address& tracker);
686 friend int Open (const char*, const Sha1Hash&, Address tracker, bool force_check_diskvshash, bool check_netwvshash, uint32_t chunk_size) ; // FIXME
691 /*************** The top-level API ****************/
692 /** Start listening a port. Returns socket descriptor. */
693 int Listen (Address addr);
694 /** Stop listening to a port. */
695 void Shutdown (int sock_des=-1);
697 /** Open a file, start a transmission; fill it with content for a given
698 root hash and tracker (optional). If "force_check_diskvshash" is true, the
699 hashtree state will be (re)constructed from the file on disk (if any).
700 If not, open will try to reconstruct the hashtree state from
701 the .mhash and .mbinmap files on disk. .mhash files are created
702 automatically, .mbinmap files must be written by checkpointing the
703 transfer by calling FileTransfer::serialize(). If the reconstruction
704 fails, it will hashcheck anyway. Roothash is optional for new files or
705 files already hashchecked and checkpointed. If "check_netwvshash" is
706 false, no uncle hashes will be sent and no data will be verified against
707 then on receipt. In this mode, checking disk contents against hashes
708 no longer works on restarts, unless checkpoints are used.
710 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);
711 /** Get the root hash for the transmission. */
712 const Sha1Hash& RootMerkleHash (int file) ;
713 /** Close a file and a transmission. */
714 void Close (int fd) ;
715 /** Add a possible peer which participares in a given transmission. In the case
716 root hash is zero, the peer might be talked to regarding any transmission
717 (likely, a tracker, cache or an archive). */
718 void AddPeer (Address address, const Sha1Hash& root=Sha1Hash::ZERO);
720 void SetTracker(const Address& tracker);
721 /** Set the default tracker that is used when Open is not passed a tracker
724 /** Returns size of the file in bytes, 0 if unknown. Might be rounded up to a kilobyte
725 before the transmission is complete. */
726 uint64_t Size (int fdes);
727 /** Returns the amount of retrieved and verified data, in bytes.
728 A 100% complete transmission has Size()==Complete(). */
729 uint64_t Complete (int fdes);
730 bool IsComplete (int fdes);
731 /** Returns the number of bytes that are complete sequentially, starting from the
732 beginning, till the first not-yet-retrieved packet. */
733 uint64_t SeqComplete (int fdes);
735 int Find (Sha1Hash hash);
736 /** Returns the number of bytes in a chunk for this transmission */
737 uint32_t ChunkSize(int fdes);
739 /** Get the address bound to the socket descriptor returned by Listen() */
740 Address BoundAddress(evutil_socket_t sock);
742 void AddProgressCallback (int transfer,ProgressCallback cb,uint8_t agg);
743 void RemoveProgressCallback (int transfer,ProgressCallback cb);
744 void ExternallyRetrieved (int transfer,bin_t piece);
747 /** Must be called by any client using the library */
748 void LibraryInit(void);
750 int evbuffer_add_string(struct evbuffer *evb, std::string str);
751 int evbuffer_add_8(struct evbuffer *evb, uint8_t b);
752 int evbuffer_add_16be(struct evbuffer *evb, uint16_t w);
753 int evbuffer_add_32be(struct evbuffer *evb, uint32_t i);
754 int evbuffer_add_64be(struct evbuffer *evb, uint64_t l);
755 int evbuffer_add_hash(struct evbuffer *evb, const Sha1Hash& hash);
757 uint8_t evbuffer_remove_8(struct evbuffer *evb);
758 uint16_t evbuffer_remove_16be(struct evbuffer *evb);
759 uint32_t evbuffer_remove_32be(struct evbuffer *evb);
760 uint64_t evbuffer_remove_64be(struct evbuffer *evb);
761 Sha1Hash evbuffer_remove_hash(struct evbuffer* evb);
763 const char* tintstr(tint t=0);
764 std::string sock2str (struct sockaddr_in addr);
765 #define SWIFT_MAX_CONNECTIONS 20
767 void nat_test_update(void);
769 // Arno: Save transfer's binmap for zero-hashcheck restart
770 void Checkpoint(int fdes);
774 // #define SWIFT_MUTE
777 #define dprintf(...) do { if (Channel::debug_file) fprintf(Channel::debug_file,__VA_ARGS__); } while (0)
778 #define dflush() fflush(Channel::debug_file)
780 #define dprintf(...) do {} while(0)
781 #define dflush() do {} while(0)
783 #define eprintf(...) fprintf(stderr,__VA_ARGS__)