node.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 naturalpolice
 * SPDX-License-Identifier: MIT
 *
 * Licensed under the MIT License (see LICENSE).
 */

#ifndef DHT_NODE_H_
#define DHT_NODE_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdint.h>
#ifdef _WIN32
typedef int socklen_t;
#include <winsock2.h>
#include <ws2ipdef.h>
#else
#include <sys/socket.h>
#endif

#include "bencode.h"

enum dht_search_type {
    FIND_NODE,
    GET_PEERS,
    GET,
};

struct search_node {
    unsigned char id[20];           
    struct sockaddr_storage addr;   
    socklen_t addrlen;              
    struct timeval reply_time;      
    struct timeval next_query;      
    int queried;                    
    unsigned char *token;           
    size_t token_len;               
    struct search_node *next;       
    struct sockaddr_storage *peers; 
    struct bvalue *v;               
    int seq;                        
    size_t peer_count;              
    int error;                      
    unsigned char k[32];            
    unsigned char sig[64];          
};

struct dht_node;

typedef void (*search_complete_t)(struct dht_node *n,
                                  const struct search_node *nodes,
                                  void *opaque);

typedef void (*node_output_t)(const unsigned char *data, size_t len,
                              const struct sockaddr *dest, socklen_t addrlen,
                              void *opaque);

typedef void (*bootstrap_status_t)(int ready, void *opaque);

struct ip_counter_entry {
    unsigned char ip[18];           
    size_t len;                     
    unsigned int count;             
    struct ip_counter_entry *next;  
};

struct ip_counter {
    unsigned int total;                 
    struct timeval heat_start;          
    struct ip_counter_entry *entries;   
};

struct bucket;
struct search;
struct peer_list;
struct put_item;

struct dht_node {
    unsigned char id[20];                   
    node_output_t output;                   
    void *opaque;                           
    struct bucket *buckets;                 
    struct {
        struct search *first;
        struct search **tail;
    } searches;                             
    uint16_t tid;                           
    struct ip_counter ip_counter;           
    unsigned char secret[16];               
    struct peer_list *peer_storage;         
    struct put_item *put_storage;           
    struct search *bootstrap;               
    bootstrap_status_t bootstrap_cb;        
    void *bootstrap_priv;                   
};

typedef struct search *dht_search_t;

int dht_node_init(struct dht_node *n, const unsigned char *id,
                  node_output_t output, void *opaque);

int dht_node_start(struct dht_node *n);

void dht_node_input(struct dht_node *n, const unsigned char *data, size_t len,
                    const struct sockaddr *src, socklen_t addrlen);

void dht_node_ping(struct dht_node *n, struct sockaddr *dest,
                   socklen_t addrlen);

void dht_node_timeout(struct dht_node *n, struct timeval *tv);

void dht_node_work(struct dht_node *n);

void dht_node_cleanup(struct dht_node *n);

int dht_node_search(struct dht_node *n, const unsigned char id[20],
                    int search_type,
                    search_complete_t callback, void *opaque,
                    dht_search_t *handle);

void dht_node_cancel(struct dht_node *n, dht_search_t handle);

void dht_node_dump_buckets(struct dht_node *n);

void dht_node_announce(struct dht_node *n, const unsigned char *info_hash,
                       const struct search_node *nodes,
                       int implied_port, int port);

void dht_node_put_immutable(struct dht_node *n,
                            const struct search_node *nodes,
                            const struct bvalue *val);

void dht_node_put_mutable(struct dht_node *n,
                          const struct search_node *nodes,
                          const unsigned char k[32],
                          const unsigned char signature[64],
                          const unsigned char *salt, size_t salt_len,
                          int seq, const struct bvalue *val);

struct bvalue *dht_node_save(const struct dht_node *n);

int dht_node_restore(const struct bvalue *dict, struct dht_node *n);

void dht_node_set_bootstrap_callback(struct dht_node *n,
                                     bootstrap_status_t callback,
                                     void *opaque);

#ifdef __cplusplus
}
#endif

#endif /* DHT_NODE_H_ */