if/core/search.h

Go to the documentation of this file.

/*
 * $Id: search.h 13870 2007-06-18 03:27:25Z cbiere $
 *
 * 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_search_h_
#define _if_core_search_h_

#include "common.h"

#include "lib/misc.h"
#include "lib/vendors.h"
#include "if/core/nodes.h"

/***
 *** Searches
 ***/
typedef guint32 gnet_search_t;

/*
 * Flags for search_new()
 */
enum {
    SEARCH_F_PASSIVE    = 1 << 0,   
    SEARCH_F_ENABLED    = 1 << 1,   
    SEARCH_F_BROWSE     = 1 << 2,   
    SEARCH_F_LITERAL    = 1 << 3,   
    SEARCH_F_LOCAL      = 1 << 4    
};

typedef struct {
    guint8 data[4 + 2];     /* IPv4 address (BE) + Port (LE) */
} gnet_ipv4_host_t;

typedef struct {
    guint8 data[16 + 2];    /* IPv6 address + Port (LE) */
} gnet_ipv6_host_t;

/*
 * Host vectors held in query hits.
 */
typedef struct gnet_host_vec {
    gnet_ipv4_host_t *hvec_v4;  
    gnet_ipv6_host_t *hvec_v6;  
    guint8 n_ipv4;              
    guint8 n_ipv6;              
} gnet_host_vec_t;

static inline gint
gnet_host_vec_count(const gnet_host_vec_t *hvec)
{
    return (gint) hvec->n_ipv4 + hvec->n_ipv6; 
}

static inline gnet_host_t
gnet_host_vec_get(const gnet_host_vec_t *hvec, guint i)
{
    gnet_host_t host;
    host_addr_t addr;
    guint16 port;

    g_assert(i < (guint) gnet_host_vec_count(hvec));

    if (i < hvec->n_ipv4) {
        addr = host_addr_peek_ipv4(hvec->hvec_v4[i].data);
        port = peek_le16(&hvec->hvec_v4[i].data[4]);
    } else {
        i -= hvec->n_ipv4;
        addr = host_addr_peek_ipv6(hvec->hvec_v6[i].data);
        port = peek_le16(&hvec->hvec_v6[i].data[16]);
    }

    gnet_host_set(&host, addr, port);
    return host;
}

gnet_host_vec_t *gnet_host_vec_alloc(void);
void gnet_host_vec_free(gnet_host_vec_t **vec_ptr);
gnet_host_vec_t *gnet_host_vec_copy(const gnet_host_vec_t *vec);
void gnet_host_vec_add(gnet_host_vec_t *vec, host_addr_t addr, guint16 port);
gnet_host_vec_t *gnet_host_vec_create(gnet_host_t *hvec, gint hcnt);

/*
 * Result sets `status' flags.
 */
enum {
     ST_GOOD_TOKEN          = (1 << 22), 
     ST_BROWSE              = (1 << 21), 
     ST_LOCAL               = (1 << 20), 
     ST_FW2FW               = (1 << 19), 
     ST_HOSTILE             = (1 << 18), 
     ST_UNREQUESTED         = (1 << 17), 
     ST_EVIL                = (1 << 16), 
     ST_ALT_SPAM            = (1 << 15), 
     ST_DUP_SPAM            = (1 << 14), 
     ST_NAME_SPAM           = (1 << 13), 
     ST_URL_SPAM            = (1 << 12), 
     ST_URN_SPAM            = (1 << 11), 
     ST_TLS                 = (1 << 10), 
     ST_BH                  = (1 << 9),  
     ST_KNOWN_VENDOR        = (1 << 8),  
     ST_PARSED_TRAILER      = (1 << 7),  
     ST_UDP                 = (1 << 6),  
     ST_BOGUS               = (1 << 5),  
     ST_PUSH_PROXY          = (1 << 4),  
     ST_GGEP                = (1 << 3),  
     ST_UPLOADED            = (1 << 2),  
     ST_BUSY                = (1 << 1),  
     ST_FIREWALL            = (1 << 0),  
     ST_SPAM    = (ST_ALT_SPAM|ST_DUP_SPAM|ST_NAME_SPAM|ST_URL_SPAM|ST_URN_SPAM)
};

/*
 * Processing of ignored files.
 */
enum {
    SEARCH_IGN_DISPLAY_AS_IS,   
    SEARCH_IGN_DISPLAY_MARKED,  
    SEARCH_IGN_NO_DISPLAY,      
};

typedef struct gnet_results_set {
    host_addr_t addr;
    host_addr_t last_hop;       
    const gchar *guid;          
    const gchar *hostname;      
    const gchar *version;       
    const gchar *query;         
    gnet_host_vec_t *proxies;   
    GSList *records;

    time_t  stamp;              
    vendor_code_t vcode;        
    guint32 speed;
    guint32 num_recs;
    guint32 status;             
    flag_t  flags;
    guint16 port;
    guint16 country;            
    guint8 hops;
    guint8 ttl;
} gnet_results_set_t;

/*
 * Result record flags
 */
enum {
    SR_DOWNLOADED   = (1 << 0),
    SR_IGNORED      = (1 << 1),
    SR_DONT_SHOW    = (1 << 2),
    SR_SPAM         = (1 << 3),
    SR_SHARED       = (1 << 4),
    SR_OWNED        = (1 << 5),
    SR_PARTIAL      = (1 << 6)
};

typedef struct gnet_record {
    const gchar  *name;         
    const struct sha1 *sha1;    
    const gchar  *tag;          
    const gchar  *xml;          
    const gchar  *path;         
    gnet_host_vec_t *alt_locs;  
    filesize_t size;            
    time_t  create_time;        
    guint32 file_index;         
    flag_t  flags;
} gnet_record_t;


typedef void (*search_got_results_listener_t)
    (GSList *, const gnet_results_set_t *);

/*
 * Search public interface, visible only from the bridge.
 */

#ifdef CORE_SOURCES

gnet_search_t search_new(const gchar *, time_t create_time, guint lifetime,
        guint32 timeout, flag_t flags);
void search_close(gnet_search_t sh);

void search_start(gnet_search_t sh);
void search_stop(gnet_search_t sh);

/*  search_is_stopped doesn't exist yet!
gboolean search_is_stopped(gnet_search_t sh);
*/

void search_reissue(gnet_search_t sh);
void search_add_kept(gnet_search_t sh, guint32 kept);

const gchar *search_query(gnet_search_t sh);

gboolean search_is_active(gnet_search_t sh);
gboolean search_is_browse(gnet_search_t sh);
gboolean search_is_expired(gnet_search_t sh);
gboolean search_is_frozen(gnet_search_t sh);
gboolean search_is_local(gnet_search_t sh);
gboolean search_is_passive(gnet_search_t sh);

void search_set_reissue_timeout(gnet_search_t sh, guint32 timeout);
guint32 search_get_reissue_timeout(gnet_search_t sh);
guint search_get_lifetime(gnet_search_t sh);
time_t search_get_create_time(gnet_search_t sh);
void search_set_create_time(gnet_search_t sh, time_t t);

void search_free_alt_locs(gnet_record_t *rc);

void search_update_items(gnet_search_t sh, guint32 items);

gboolean search_browse(gnet_search_t sh,
    const gchar *hostname, host_addr_t addr, guint16 port,
    const gchar *guid, const gnet_host_vec_t *proxies, guint32 flags);
gboolean search_locally(gnet_search_t sh, const gchar *query);
guint search_handle_magnet(const gchar *url);

#endif /* CORE_SOURCES */
#endif /* _if_core_search_h_ */

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

---