downloads.h

Go to the documentation of this file.

/*
 * $Id: downloads.h,v 1.23 2005/12/18 06:09:10 cbiere Exp $
 *
 * Copyright (c) 2001-2003, Raphael Manfredi, Richard Eckart
 *
 *----------------------------------------------------------------------
 * This file is part of gtk-gnutella.
 *
 *  gtk-gnutella is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  gtk-gnutella is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with gtk-gnutella; if not, write to the Free Software
 *  Foundation, Inc.:
 *      59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *----------------------------------------------------------------------
 */

#ifndef _if_core_downloads_h_
#define _if_core_downloads_h_

#include "lib/tm.h"             /* For tm_t */
#include "lib/event.h"          /* For frequency_t */

#include "if/core/search.h"     /* For gnet_host_vec_t */

/***
 *** Sources (traditionally called "downloads")
 ***/

typedef guint32 gnet_src_t;

typedef void (*src_listener_t) (gnet_src_t);
typedef enum {
    EV_SRC_ADDED = 0,
    EV_SRC_REMOVED,
    EV_SRC_INFO_CHANGED,
    EV_SRC_STATUS_CHANGED,
    EV_SRC_RANGES_CHANGED,

    EV_SRC_EVENTS /* Number of events in this domain */
} gnet_src_ev_t;

#define URN_INDEX   0xffffffff      
/*
 * We keep a list of all the downloads queued per GUID+IP:port (host).  Indeed
 * some broken clients (e.g. Morpheus) share the same GUID, so we cannot
 * fully discriminate on the GUID alone.  So GUID+IP:port forms the "key",
 * the `dl_key' structure.
 *
 * Inside the `dl_server', we keep track all `download' structures and
 * other server-related information, which are shared by all downloads
 * from this host..
 *
 * Within a single server, a download can be in either runnning, waiting
 * or stopped.  An array of lists is kept, and since the download can be
 * in only one of them, it also keeps track of the proper list index.
 */

enum dl_list {
    DL_LIST_INVALID = -1,
    DL_LIST_RUNNING = 0,
    DL_LIST_WAITING = 1,
    DL_LIST_STOPPED = 2,
    DL_LIST_SZ      = 3
};

struct vernum {
    guint major;
    guint minor;
};

struct dl_key {
    gchar *guid;                
    host_addr_t addr;           
    guint16 port;               
};

enum dl_server_magic { DL_SERVER_MAGIC = 0x5e45e4ffU };

struct dl_server {
    enum dl_server_magic magic; 
    gint refcnt;             
    struct dl_key *key;      
    GList *list[DL_LIST_SZ]; 
    guint count[DL_LIST_SZ]; 
    const gchar *vendor;     
    const gchar *hostname;   
    gint country;            
    time_t retry_after;      
    time_t dns_lookup;      
    struct vernum parq_version; 
    guint32 attrs;
    GSList *proxies;        
    time_t proxies_stamp;   
};

#define dl_server_valid(x)  ((x) != NULL && (x)->magic == DL_SERVER_MAGIC)

typedef enum {
    GTA_DL_QUEUED           = 1,  
    GTA_DL_CONNECTING       = 2,  
    GTA_DL_PUSH_SENT        = 3,  
    GTA_DL_FALLBACK         = 4,  
    GTA_DL_REQ_SENT         = 5,  
    GTA_DL_HEADERS          = 6,  
    GTA_DL_RECEIVING        = 7,  
    GTA_DL_COMPLETED        = 8,  
    GTA_DL_ERROR            = 9,  
    GTA_DL_ABORTED          = 10, 
    GTA_DL_TIMEOUT_WAIT     = 11, 
    GTA_DL_REMOVED          = 12, 
    GTA_DL_VERIFY_WAIT      = 13, 
    GTA_DL_VERIFYING        = 14, 
    GTA_DL_VERIFIED         = 15, 
    GTA_DL_MOVE_WAIT        = 16, 
    GTA_DL_MOVING           = 17, 
    GTA_DL_DONE             = 18, 
    GTA_DL_SINKING          = 19, 
    GTA_DL_ACTIVE_QUEUED    = 20, 
    GTA_DL_PASSIVE_QUEUED   = 21, 
    GTA_DL_REQ_SENDING      = 22  
} download_status_t;

typedef struct download download_t;

struct bio_source;
struct http_buffer;

enum dl_bufmode {
    DL_BUF_READING = 0,
    DL_BUF_WRITING,
};

struct dl_buffers {
    enum dl_bufmode mode;       
    gint count;                 
    gchar **buffers;            
    struct iovec *iov;          
    struct iovec *iov_cur;      
    gint iovcnt;                
    size_t size;                
    size_t amount;              
    size_t held;                
};

struct download {
    gnet_src_t src_handle;      
    gchar error_str[256];       
    download_status_t status;   
    gpointer io_opaque;         
    struct bio_source *bio;     
    struct dl_server *server;   
    enum dl_list list_idx;      
    struct dl_file_info *file_info;
    guint32 record_index;       
    gchar *file_name;           
    gchar *escaped_name;        
    filesize_t file_size;       
    filesize_t size;            
    filesize_t skip;            
    filesize_t pos;             
    filesize_t range_end;       
    struct gnutella_socket *socket;
    gint file_desc;             
    guint32 overlap_size;       
    struct http_buffer *req;    
    struct dl_buffers *buffers; 
    time_t start_date;          
    time_t last_update;         
    time_t last_gui_update;     
    time_t record_stamp;        
    time_t retry_after;         
    tm_t header_sent;           
    guint32 retries;
    guint32 timeout_delay;
    guint32 served_reqs;        
    const gchar *remove_msg;

    gchar *sha1;                
    gchar *uri;                 
    guint32 last_dmesh;         
    GSList *ranges;             
    filesize_t ranges_size;     
    filesize_t sinkleft;        
    guint32 flags;
    guint32 cflags;

    gboolean keep_alive;        
    gboolean visible;           
    gboolean push;              
    gboolean always_push;       
    gboolean got_giv;           
    gboolean unavailable;       
    struct cproxy *cproxy;      
    gpointer queue_status;      
    struct browse_ctx *browse;  
};

/*
 * Download flags.
 */

#define DL_F_URIRES         0x00000001  
#define DL_F_PUSH_IGN       0x00000002  
#define DL_F_OVERLAPPED     0x00000004  
#define DL_F_REPLIED        0x00000008  
#define DL_F_CHUNK_CHOSEN   0x00000010  
#define DL_F_SHRUNK_REPLY   0x00000020  
#define DL_F_SUNK_DATA      0x00000040  
#define DL_F_ACTIVE_QUEUED  0x00000080  
#define DL_F_PASSIVE_QUEUED 0x00000100  
#define DL_F_DNS_LOOKUP     0x00000200  
#define DL_F_BROWSE         0x00000400  
#define DL_F_TRANSIENT      0x20000000  
#define DL_F_SUSPENDED      0x40000000  
#define DL_F_MARK           0x80000000  
/*
 * Server attributes.
 */

#define DLS_A_UNUSED_1      0x00000001  
#define DLS_A_PUSH_IGN      0x00000002  
#define DLS_A_UNUSED_2      0x00000004  
#define DLS_A_NO_HTTP_1_1   0x00000008  
#define DLS_A_MINIMAL_HTTP  0x00000010  
#define DLS_A_BANNING       0x00000020  
#define DLS_A_FAKE_G2       0x00000040  
#define DLS_A_DNS_LOOKUP    0x00000080  
#define DLS_A_REMOVED       0x80000000  
/*
 * Access macros.
 */

#define download_guid(d)        ((d)->server->key->guid)
#define download_addr(d)        ((d)->server->key->addr)
#define download_port(d)        ((d)->server->key->port)
#define download_vendor(d)      ((d)->server->vendor)
#define download_country(d)     ((d)->server->country)
#define download_hostname(d)    ((d)->server->hostname)

#define download_vendor_str(d) \
    ((d)->server->vendor ? (d)->server->vendor : "")

#define download_path(d)        ((d)->file_info->path)
#define download_outname(d)     ((d)->file_info->file_name)
#define download_filesize(d)    ((d)->file_info->size)
#define download_filedone(d)    ((d)->file_info->done)

/*
 * State inspection macros.
 */

#define DOWNLOAD_IS_QUEUED(d)  ((d)->status == GTA_DL_QUEUED)

#define DOWNLOAD_IS_VERIFYING(d)         \
    (  (d)->status == GTA_DL_VERIFY_WAIT \
    || (d)->status == GTA_DL_VERIFYING   \
    || (d)->status == GTA_DL_VERIFIED    )

#define DOWNLOAD_IS_MOVING(d)           \
    (  (d)->status == GTA_DL_MOVE_WAIT  \
    || (d)->status == GTA_DL_MOVING     )

#define DOWNLOAD_IS_STOPPED(d)          \
    (  (d)->status == GTA_DL_ABORTED    \
    || (d)->status == GTA_DL_ERROR      \
    || (d)->status == GTA_DL_COMPLETED  \
    || DOWNLOAD_IS_VERIFYING(d)         \
    || DOWNLOAD_IS_MOVING(d)            \
    || (d)->status == GTA_DL_DONE       )

#define DOWNLOAD_IS_ACTIVE(d)           \
    (  (d)->status == GTA_DL_RECEIVING  )

#define DOWNLOAD_IS_WAITING(d)          \
    (  (d)->status == GTA_DL_TIMEOUT_WAIT)

#define DOWNLOAD_IS_ESTABLISHING(d)     \
    (  (d)->status == GTA_DL_CONNECTING \
    || (d)->status == GTA_DL_PUSH_SENT  \
    || (d)->status == GTA_DL_FALLBACK   \
    || (d)->status == GTA_DL_REQ_SENT   \
    || (d)->status == GTA_DL_REQ_SENDING    \
    || (d)->status == GTA_DL_ACTIVE_QUEUED  \
    || (d)->status == GTA_DL_SINKING    \
    || (d)->status == GTA_DL_HEADERS    )

#define DOWNLOAD_IS_EXPECTING_GIV(d)    \
    (  (d)->status == GTA_DL_PUSH_SENT  \
    || (d)->status == GTA_DL_FALLBACK   )

#define DOWNLOAD_IS_RUNNING(d)          \
    (   DOWNLOAD_IS_ACTIVE(d)           \
    ||  DOWNLOAD_IS_ESTABLISHING(d)     )

#define DOWNLOAD_IS_IN_PUSH_MODE(d) (d->push)
#define DOWNLOAD_IS_VISIBLE(d)      (d->visible)

/*
 * Public interface, visible only from the bridge.
 */

#ifdef CORE_SOURCES

/* FIXME: download_index_changed
 *        actually needs to be in downloads.h and should be called from
 *        search.h and not from search_gui.h.
 */
void download_index_changed(const host_addr_t, guint16, gchar *,
        guint32, guint32);

gboolean download_new(gchar *,
    filesize_t, guint32, const host_addr_t addr, guint16,
    const gchar *, gchar *, gchar *, time_t,
    gboolean, struct dl_file_info *, gnet_host_vec_t *, guint32 flags);
gboolean download_new_uri(gchar *file, const gchar *uri, filesize_t size,
      const host_addr_t addr, guint16 port, const gchar *guid, gchar *hostname,
      gchar *sha1, time_t stamp, gboolean push,
      struct dl_file_info *fi, gnet_host_vec_t *proxies, guint32 flags);
void download_auto_new(gchar *,
    filesize_t, guint32, const host_addr_t, guint16, const gchar *,
    gchar *, gchar *, time_t,
    gboolean, gboolean, struct dl_file_info *, gnet_host_vec_t *,
    guint32 flags);

void src_add_listener(src_listener_t, gnet_src_ev_t, frequency_t, guint32);
void src_remove_listener(src_listener_t, gnet_src_ev_t);
struct download *src_get_download(gnet_src_t src_handle);

const gchar *build_url_from_download(const struct download *d);
gint download_get_http_req_percent(const struct download *d);
void download_fallback_to_push(struct download *, gboolean, gboolean);
gint download_remove_all_from_peer(gchar *guid, host_addr_t addr, guint16 port,
    gboolean unavailable);
gint download_remove_all_named(const gchar *name);
gint download_remove_all_with_sha1(const gchar *sha1);
void download_remove_file(struct download *d, gboolean reset);
gboolean download_file_exists(const struct download *d);
void download_requeue(struct download *);
void download_start(struct download *, gboolean);
gboolean download_remove(struct download *);
void download_abort(struct download *);
void download_resume(struct download *);
void download_freeze_queue(void);
void download_thaw_queue(void);
gint download_queue_is_frozen(void);
void download_clear_stopped(gboolean, gboolean, gboolean, gboolean);
gboolean download_new_unknown_size(gchar *file, guint32 record_index,
     const host_addr_t addr, guint16 port, const gchar *guid, gchar *hostname,
    gchar *sha1, time_t stamp, gboolean push,
    struct dl_file_info *fi, gnet_host_vec_t *proxies, guint32 flags);
const gchar *download_get_hostname(const struct download *d);
gdouble download_source_progress(const struct download *);
gdouble download_total_progress(const struct download *);
gboolean download_something_to_clear(void);
struct download *src_get_download(gnet_src_t src_handle);
void src_add_listener(src_listener_t cb, gnet_src_ev_t ev,
    frequency_t t, guint32 interval);
void src_remove_listener(src_listener_t cb, gnet_src_ev_t ev);

#endif /* CORE_SOURCES */
#endif /* _if_core_downloads_h_ */

/* vi: set ts=4 sw=4 cindent: */

---