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 Address &b) {
113 addr->dests[0].addr = b.addr->dests[0].addr;
114 addr->dests[0].port = b.addr->dests[0].port;
116 Address(const char* ip, uint16_t port) {
121 Address(const char* ip_port);
122 Address(uint16_t port) {
124 set_ipv4((uint32_t)INADDR_ANY);
127 Address(uint32_t ipv4addr, uint16_t port) {
132 Address(const struct sockaddr_in& address) {
134 addr->dests[0].addr = address.sin_addr.s_addr;
135 addr->dests[0].port = address.sin_port;
140 uint32_t ipv4 () const { return ntohl(addr->dests[0].addr); }
141 uint16_t port () const { return ntohs(addr->dests[0].port); }
142 Address& operator = (const Address& b) {
146 addr->dests[0].addr = b.addr->dests[0].addr;
147 addr->dests[0].port = b.addr->dests[0].port;
151 bool operator == (const Address& b) const {
152 return addr->count == b.addr->count &&
153 addr->dests[0].port==b.addr->dests[0].port &&
154 addr->dests[0].addr==b.addr->dests[0].addr;
156 const char* str () const {
157 // Arno, 2011-10-04: not thread safe, replace.
158 static char rs[4][32];
161 sprintf(rs[i],"%i.%i.%i.%i:%i",ipv4()>>24,(ipv4()>>16)&0xff,
162 (ipv4()>>8)&0xff,ipv4()&0xff,port());
165 const char* ipv4str () const {
166 // Arno, 2011-10-04: not thread safe, replace.
167 static char rs[4][32];
170 sprintf(rs[i],"%i.%i.%i.%i",ipv4()>>24,(ipv4()>>16)&0xff,
171 (ipv4()>>8)&0xff,ipv4()&0xff);
174 bool operator != (const Address& b) const { return !(*this==b); }
175 bool is_private() const {
177 uint32_t no = ipv4(); uint8_t no0 = no>>24,no1 = (no>>16)&0xff;
178 if (no0 == 10) return true;
179 else if (no0 == 172 && no1 >= 16 && no1 <= 31) return true;
180 else if (no0 == 192 && no1 == 168) return true;
185 // Arno, 2011-10-03: Use libevent callback functions, no on_error?
186 #define sockcb_t event_callback_fn
188 sckrwecb_t (evutil_socket_t s=0, sockcb_t mr=NULL, sockcb_t mw=NULL,
190 sock(s), may_read(mr), may_write(mw), on_error(oe) {}
191 evutil_socket_t sock;
201 #define NOW now_t::now
203 /** tintbin is basically a pair<tint,bin64_t> plus some nice operators.
204 Most frequently used in different queues (acknowledgements, requests,
209 tintbin(const tintbin& b) : time(b.time), bin(b.bin) {}
210 tintbin() : time(TINT_NEVER), bin(bin_t::NONE) {}
211 tintbin(tint time_, bin_t bin_) : time(time_), bin(bin_) {}
212 tintbin(bin_t bin_) : time(NOW), bin(bin_) {}
213 bool operator < (const tintbin& b) const
214 { return time > b.time; }
215 bool operator == (const tintbin& b) const
216 { return time==b.time && bin==b.bin; }
217 bool operator != (const tintbin& b) const
218 { return !(*this==b); }
221 typedef std::deque<tintbin> tbqueue;
222 typedef std::deque<bin_t> binqueue;
223 typedef Address Address;
225 /** A heap (priority queue) for timestamped bin numbers (tintbins). */
229 int size () const { return data_.size(); }
230 bool is_empty () const { return data_.empty(); }
232 tintbin ret = data_.front();
233 std::pop_heap(data_.begin(),data_.end());
237 void push(const tintbin& tb) {
239 push_heap(data_.begin(),data_.end());
241 const tintbin& peek() const {
242 return data_.front();
246 /** swift protocol message types; these are used on the wire. */
255 SWIFT_SIGNED_HASH = 7,
257 SWIFT_MSGTYPE_RCVD = 9,
258 SWIFT_RANDOMIZE = 10, //FRAGRAND
259 SWIFT_VERSION = 11, // Arno, 2011-10-19: TODO to match RFC-rev-03
260 SWIFT_MESSAGE_COUNT = 12
269 //class CongestionController; // Arno: Currently part of Channel. See ::NextSendTime
272 typedef void (*ProgressCallback) (int transfer, bin_t bin);
274 /** A class representing single file transfer. */
279 /** A constructor. Open/submit/retrieve a file.
280 * @param file_name the name of the file
281 * @param root_hash the root hash of the file; zero hash if the file
284 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);
286 /** Close everything. */
290 /** While we need to feed ACKs to every peer, we try (1) avoid
291 unnecessary duplication and (2) keep minimum state. Thus,
292 we use a rotating queue of bin completion events. */
293 //bin64_t RevealAck (uint64_t& offset);
294 /** Rotating queue read for channels of this transmission. */
296 int RevealChannel (int& i);
298 int RandomChannel (int own_id);
301 /** Find transfer by the root hash. */
302 static FileTransfer* Find (const Sha1Hash& hash);
303 /** Find transfer by the file descriptor. */
304 static FileTransfer* file (int fd) {
305 return fd<files.size() ? files[fd] : NULL;
308 /** The binmap for data already retrieved and checked. */
309 binmap_t& ack_out () { return file_.ack_out(); }
310 /** Piece picking strategy used by this transfer. */
311 PiecePicker& picker () { return *picker_; }
312 /** The number of channels working for this transfer. */
313 int channel_count () const { return hs_in_.size(); }
314 /** Hash tree checked file; all the hashes and data are kept here. */
315 HashTree& file() { return file_; }
316 /** File descriptor for the data file. */
317 int fd () const { return file_.file_descriptor(); }
318 /** Root SHA1 hash of the transfer (and the data file). */
319 const Sha1Hash& root_hash () const { return file_.root_hash(); }
320 /** Ric: the availability in the swarm */
321 Availability& availability() { return *availability_; }
324 /** Arno: Call when n bytes are received. */
325 void OnRecvData(int n);
326 /** Arno: Call when n bytes are sent. */
327 void OnSendData(int n);
328 /** Arno: Call when no bytes are sent due to rate limiting. */
330 /** Arno: Return current speed for the given direction in bytes/s */
331 double GetCurrentSpeed(data_direction_t ddir);
332 /** Arno: Return maximum speed for the given direction in bytes/s */
333 double GetMaxSpeed(data_direction_t ddir);
334 /** Arno: Set maximum speed for the given direction in bytes/s */
335 void SetMaxSpeed(data_direction_t ddir, double m);
336 /** Arno: Return the number of non-seeders current channeled with. */
337 uint32_t GetNumLeechers();
338 /** Arno: Return the number of seeders current channeled with. */
339 uint32_t GetNumSeeders();
340 /** Arno: Return the set of Channels for this transfer. MORESTATS */
341 std::set<Channel *> GetChannels() { return mychannels_; }
343 /** Arno: set the tracker for this transfer. Reseting it won't kill
344 * any existing connections.
346 void SetTracker(Address tracker) { tracker_ = tracker; }
348 /** Arno: (Re)Connect to tracker for this transfer, or global Channel::tracker if not set */
349 void ConnectToTracker();
351 /** Arno: Reconnect to the tracker if no established peers and
352 * exp backoff allows it.
354 void ReConnectToTrackerIfAllowed(bool hasestablishedpeers);
356 /** Arno: Return the Channel to peer "addr" that is not equal to "notc". */
357 Channel * FindChannel(const Address &addr, Channel *notc);
360 static void LibeventCleanCallback(int fd, short event, void *arg);
365 /** Piece picker strategy. */
366 PiecePicker* picker_;
368 /** Channels working for this transfer. */
369 binqueue hs_in_; // Arno, 2011-10-03: Should really be queue of channel ID (=uint32_t)
371 /** Messages we are accepting. */
377 /** Availability in the swarm */
378 Availability* availability_;
380 #define SWFT_MAX_TRANSFER_CB 8
381 ProgressCallback callbacks[SWFT_MAX_TRANSFER_CB];
382 uint8_t cb_agg[SWFT_MAX_TRANSFER_CB];
386 std::set<Channel *> mychannels_; // Arno, 2012-01-31: May be duplicate of hs_in_
387 MovingAverageSpeed cur_speed_[2];
388 double max_speed_[2];
392 struct event evclean_;
394 Address tracker_; // Tracker for this transfer
395 tint tracker_retry_interval_;
396 tint tracker_retry_time_;
399 void OnDataIn (bin_t pos);
400 // Gertjan fix: return bool
401 bool OnPexIn (const Address& addr);
403 static std::vector<FileTransfer*> files;
406 friend class Channel;
407 // Ric: maybe not really needed
408 friend class Availability;
409 friend uint64_t Size (int fdes);
410 friend bool IsComplete (int fdes);
411 friend uint64_t Complete (int fdes);
412 friend uint64_t SeqComplete (int fdes);
413 friend int Open (const char* filename, const Sha1Hash& hash, Address tracker, bool force_check_diskvshash, bool check_netwvshash, uint32_t chunk_size);
414 friend void Close (int fd) ;
415 friend void AddProgressCallback (int transfer,ProgressCallback cb,uint8_t agg);
416 friend void RemoveProgressCallback (int transfer,ProgressCallback cb);
417 friend void ExternallyRetrieved (int transfer,bin_t piece);
421 /** PiecePicker implements some strategy of choosing (picking) what
422 to request next, given the possible range of choices:
423 data acknowledged by the peer minus data already retrieved.
424 May pick sequentially, do rarest first or in some other way. */
427 virtual void Randomize (uint64_t twist) = 0;
428 /** The piece picking method itself.
429 * @param offered the data acknowledged by the peer
430 * @param max_width maximum number of packets to ask for
431 * @param expires (not used currently) when to consider request expired
432 * @return the bin number to request */
433 virtual bin_t Pick (binmap_t& offered, uint64_t max_width, tint expires) = 0;
434 virtual void LimitRange (bin_t range) = 0;
435 /** updates the playback position for streaming piece picking.
436 * @param amount amount to increment in bin unit size (1KB default) */
437 virtual void updatePlaybackPos (int amount=1) = 0;
438 virtual ~PiecePicker() {}
442 class PeerSelector { // Arno: partically unused
444 virtual void AddPeer (const Address& addr, const Sha1Hash& root) = 0;
445 virtual Address GetPeer (const Sha1Hash& for_root) = 0;
449 /* class DataStorer { // Arno: never implemented
451 DataStorer (const Sha1Hash& id, size_t size);
452 virtual size_t ReadData (bin_t pos,uint8_t** buf) = 0;
453 virtual size_t WriteData (bin_t pos, uint8_t* buf, size_t len) = 0;
457 /** swift channel's "control block"; channels loosely correspond to TCP
458 connections or FTP sessions; one channel is created for one file
459 being transferred between two peers. As we don't need buffers and
460 lots of other TCP stuff, sizeof(Channel+members) must be below 1K.
461 Normally, API users do not deal with this class. */
464 #define DGRAM_MAX_SOCK_OPEN 128
465 static int sock_count;
466 static sckrwecb_t sock_open[DGRAM_MAX_SOCK_OPEN];
469 Channel (FileTransfer* file, int socket=INVALID_SOCKET, Address peer=Address());
481 static Address tracker; // Global tracker for all transfers
482 struct event *evsend_ptr_; // Arno: timer per channel // SAFECLOSE
483 static struct event_base *evbase;
484 static struct event evrecv;
485 static const char* SEND_CONTROL_MODES[];
487 static tint epoch, start;
488 static uint64_t global_dgrams_up, global_dgrams_down, global_raw_bytes_up, global_raw_bytes_down, global_bytes_up, global_bytes_down;
489 static void CloseChannelByAddress(const Address &addr);
492 // Arno: channel is also a "singleton" class that manages all sockets
493 // for a swift process
494 static void LibeventSendCallback(int fd, short event, void *arg);
495 static void LibeventReceiveCallback(int fd, short event, void *arg);
496 static void RecvDatagram (evutil_socket_t socket); // Called by LibeventReceiveCallback
497 static int RecvFrom(evutil_socket_t sock, Address& addr, struct evbuffer **evb); // Called by RecvDatagram
498 static int SendTo(evutil_socket_t sock, const Address& addr, struct evbuffer *evb); // Called by Channel::Send()
499 static evutil_socket_t Bind(Address address, sckrwecb_t callbacks=sckrwecb_t());
500 static Address BoundAddress(evutil_socket_t sock);
501 static evutil_socket_t default_socket()
502 { return sock_count ? sock_open[0].sock : INVALID_SOCKET; }
504 /** close the port */
505 static void CloseSocket(evutil_socket_t sock);
506 static void Shutdown ();
507 /** the current time */
510 // Arno: Per instance methods
511 void Recv (struct evbuffer *evb);
512 void Send (); // Called by LibeventSendCallback
515 void OnAck (struct evbuffer *evb);
516 void OnHave (struct evbuffer *evb);
517 bin_t OnData (struct evbuffer *evb);
518 void OnHint (struct evbuffer *evb);
519 void OnHash (struct evbuffer *evb);
520 void OnPex (struct evbuffer *evb);
521 void OnHandshake (struct evbuffer *evb);
522 void OnRandomize (struct evbuffer *evb); //FRAGRAND
523 void AddHandshake (struct evbuffer *evb);
524 bin_t AddData (struct evbuffer *evb);
525 void AddAck (struct evbuffer *evb);
526 void AddHave (struct evbuffer *evb);
527 void AddHint (struct evbuffer *evb);
528 void AddUncleHashes (struct evbuffer *evb, bin_t pos);
529 void AddPeakHashes (struct evbuffer *evb);
530 void AddPex (struct evbuffer *evb);
532 void AddPexReq(struct evbuffer *evb);
533 void BackOffOnLosses (float ratio=0.5);
534 tint SwitchSendControl (int control_mode);
535 tint NextSendTime ();
536 tint KeepAliveNextSendTime ();
537 tint PingPongNextSendTime ();
538 tint CwndRateNextSendTime ();
539 tint SlowStartNextSendTime ();
540 tint AimdNextSendTime ();
541 tint LedbatNextSendTime ();
542 /** Arno: return true if this peer has complete file. May be fuzzy if Peak Hashes not in */
544 /** Arno: return (UDP) port for this channel */
545 uint16_t GetMyPort();
546 bool IsDiffSenderOrDuplicate(Address addr, uint32_t chid);
548 static int MAX_REORDERING;
551 static tint MAX_SEND_INTERVAL;
552 static tint LEDBAT_TARGET;
553 static float LEDBAT_GAIN;
554 static tint LEDBAT_DELAY_BIN;
555 static bool SELF_CONN_OK;
556 static tint MAX_POSSIBLE_RTT;
557 static tint MIN_PEX_REQUEST_INTERVAL;
558 static FILE* debug_file;
560 const std::string id_string () const;
561 /** A channel is "established" if had already sent and received packets. */
562 bool is_established () { return peer_channel_id_ && own_id_mentioned_; }
563 FileTransfer& transfer() { return *transfer_; }
564 HashTree& file () { return transfer_->file(); }
565 const Address& peer() const { return peer_; }
566 const Address& recv_peer() const { return recv_peer_; }
567 tint ack_timeout () {
568 tint dev = dev_avg_ < MIN_DEV ? MIN_DEV : dev_avg_;
569 tint tmo = rtt_avg_ + dev * 4;
570 return tmo < 30*TINT_SEC ? tmo : 30*TINT_SEC;
572 uint32_t id () const { return id_; }
575 uint64_t raw_bytes_up() { return raw_bytes_up_; }
576 uint64_t raw_bytes_down() { return raw_bytes_down_; }
577 uint64_t bytes_up() { return bytes_up_; }
578 uint64_t bytes_down() { return bytes_down_; }
580 static int DecodeID(int scrambled);
581 static int EncodeID(int unscrambled);
582 static Channel* channel(int i) {
583 return i<channels.size()?channels[i]:NULL;
585 static void CloseTransfer (FileTransfer* trans);
589 void Schedule4Close() { scheduled4close_ = true; }
590 bool IsScheduled4Close() { return scheduled4close_; }
594 /** Channel id: index in the channel array. */
596 /** Socket address of the peer. */
598 /** The UDP socket fd. */
599 evutil_socket_t socket_;
600 /** Descriptor of the file in question. */
601 FileTransfer* transfer_;
602 /** Peer channel id; zero if we are trying to open a channel. */
603 uint32_t peer_channel_id_;
604 bool own_id_mentioned_;
605 /** Peer's progress, based on acknowledgements. */
607 /** Last data received; needs to be acked immediately. */
610 /** The history of data sent and still unacknowledged. */
612 /** Timeouted data (potentially to be retransmitted). */
613 tbqueue data_out_tmo_;
615 /** Index in the history array. */
617 /** Transmit schedule: in most cases filled with the peer's hints */
619 /** Hints sent (to detect and reschedule ignored hints). */
621 uint64_t hint_out_size_;
622 /** Types of messages the peer accepts. */
625 //tint last_send_time, last_recv_time;
628 tint last_pex_request_time_;
629 tint next_pex_request_time_;
630 bool pex_request_outstanding_;
631 tbqueue reverse_pex_out_; // Arno, 2011-10-03: should really be a queue of (tint,channel id(= uint32_t)) pairs.
632 int useless_pex_count_;
633 /** Smoothed averages for RTT, RTT deviation and data interarrival periods. */
634 tint rtt_avg_, dev_avg_, dip_avg_;
635 tint last_send_time_;
636 tint last_recv_time_;
637 tint last_data_out_time_;
638 tint last_data_in_time_;
639 tint last_loss_time_;
640 tint next_send_time_;
641 /** Congestion window; TODO: int, bytes. */
644 /** Data sending interval. */
646 /** The congestion control strategy. */
648 /** Datagrams (not data) sent since last recv. */
649 int sent_since_recv_;
651 /** Arno: Fix for KEEP_ALIVE_CONTROL */
652 bool lastrecvwaskeepalive_;
653 bool lastsendwaskeepalive_;
655 /** Recent acknowlegements for data previously sent. */
656 int ack_rcvd_recent_;
657 /** Recent non-acknowlegements (losses) of data previously sent. */
658 int ack_not_rcvd_recent_;
659 /** LEDBAT one-way delay machinery */
660 tint owd_min_bins_[4];
662 tint owd_min_bin_start_;
663 tint owd_current_[4];
668 // Arno, 2011-11-28: for detailed, per-peer stats. MORESTATS
669 uint64_t raw_bytes_up_, raw_bytes_down_, bytes_up_, bytes_down_;
672 bool scheduled4close_;
673 /** Arno: Socket address of the peer where packets are received from,
674 * when an IANA private address, otherwise 0.
675 * May not be equal to peer_. 2PEERSBEHINDSAMENAT */
678 int PeerBPS() const {
679 return TINT_SEC / dip_avg_ * 1024;
681 /** Get a request for one packet from the queue of peer's requests. */
682 bin_t DequeueHint(bool *retransmitptr);
684 void TimeoutDataOut ();
685 void CleanStaleHintOut();
686 void CleanHintOut(bin_t pos);
688 void UpdateDIP(bin_t pos); // RETRANSMIT
691 static PeerSelector* peer_selector;
693 static tint last_tick;
694 //static tbheap send_queue;
696 static std::vector<Channel*> channels;
698 friend int Listen (Address addr);
699 friend void Shutdown (int sock_des);
700 friend void AddPeer (Address address, const Sha1Hash& root);
701 friend void SetTracker(const Address& tracker);
702 friend int Open (const char*, const Sha1Hash&, Address tracker, bool force_check_diskvshash, bool check_netwvshash, uint32_t chunk_size) ; // FIXME
707 /*************** The top-level API ****************/
708 /** Start listening a port. Returns socket descriptor. */
709 int Listen (Address addr);
710 /** Stop listening to a port. */
711 void Shutdown (int sock_des=-1);
713 /** Open a file, start a transmission; fill it with content for a given
714 root hash and tracker (optional). If "force_check_diskvshash" is true, the
715 hashtree state will be (re)constructed from the file on disk (if any).
716 If not, open will try to reconstruct the hashtree state from
717 the .mhash and .mbinmap files on disk. .mhash files are created
718 automatically, .mbinmap files must be written by checkpointing the
719 transfer by calling FileTransfer::serialize(). If the reconstruction
720 fails, it will hashcheck anyway. Roothash is optional for new files or
721 files already hashchecked and checkpointed. If "check_netwvshash" is
722 false, no uncle hashes will be sent and no data will be verified against
723 then on receipt. In this mode, checking disk contents against hashes
724 no longer works on restarts, unless checkpoints are used.
726 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);
727 /** Get the root hash for the transmission. */
728 const Sha1Hash& RootMerkleHash (int file) ;
729 /** Close a file and a transmission. */
730 void Close (int fd) ;
731 /** Add a possible peer which participares in a given transmission. In the case
732 root hash is zero, the peer might be talked to regarding any transmission
733 (likely, a tracker, cache or an archive). */
734 void AddPeer (Address address, const Sha1Hash& root=Sha1Hash::ZERO);
736 void SetTracker(const Address& tracker);
737 /** Set the default tracker that is used when Open is not passed a tracker
740 /** Returns size of the file in bytes, 0 if unknown. Might be rounded up to a kilobyte
741 before the transmission is complete. */
742 uint64_t Size (int fdes);
743 /** Returns the amount of retrieved and verified data, in bytes.
744 A 100% complete transmission has Size()==Complete(). */
745 uint64_t Complete (int fdes);
746 bool IsComplete (int fdes);
747 /** Returns the number of bytes that are complete sequentially, starting from the
748 beginning, till the first not-yet-retrieved packet. */
749 uint64_t SeqComplete (int fdes);
751 int Find (Sha1Hash hash);
752 /** Returns the number of bytes in a chunk for this transmission */
753 uint32_t ChunkSize(int fdes);
755 /** Get the address bound to the socket descriptor returned by Listen() */
756 Address BoundAddress(evutil_socket_t sock);
758 void AddProgressCallback (int transfer,ProgressCallback cb,uint8_t agg);
759 void RemoveProgressCallback (int transfer,ProgressCallback cb);
760 void ExternallyRetrieved (int transfer,bin_t piece);
763 /** Must be called by any client using the library */
764 void LibraryInit(void);
766 int evbuffer_add_string(struct evbuffer *evb, std::string str);
767 int evbuffer_add_8(struct evbuffer *evb, uint8_t b);
768 int evbuffer_add_16be(struct evbuffer *evb, uint16_t w);
769 int evbuffer_add_32be(struct evbuffer *evb, uint32_t i);
770 int evbuffer_add_64be(struct evbuffer *evb, uint64_t l);
771 int evbuffer_add_hash(struct evbuffer *evb, const Sha1Hash& hash);
773 uint8_t evbuffer_remove_8(struct evbuffer *evb);
774 uint16_t evbuffer_remove_16be(struct evbuffer *evb);
775 uint32_t evbuffer_remove_32be(struct evbuffer *evb);
776 uint64_t evbuffer_remove_64be(struct evbuffer *evb);
777 Sha1Hash evbuffer_remove_hash(struct evbuffer* evb);
779 const char* tintstr(tint t=0);
780 std::string sock2str (struct sockaddr_in addr);
781 #define SWIFT_MAX_CONNECTIONS 20
783 void nat_test_update(void);
785 // Arno: Save transfer's binmap for zero-hashcheck restart
786 void Checkpoint(int fdes);
790 // #define SWIFT_MUTE
793 #define dprintf(...) do { if (Channel::debug_file) fprintf(Channel::debug_file,__VA_ARGS__); } while (0)
794 #define dflush() fflush(Channel::debug_file)
796 #define dprintf(...) do {} while(0)
797 #define dflush() do {} while(0)
799 #define eprintf(...) fprintf(stderr,__VA_ARGS__)