lws-dht.h

Go to the documentation of this file.

/*
 * Copyright (c) 2009-2011 by Juliusz Chroboczek
 * Copyright (c) 2026 Andy Green <andy@warmcat.com>
 *  Adaptation for lws, cleaning, modernization
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
 
#if !defined(__LWS_DHT_H__)
#define __LWS_DHT_H__
 
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>

 
struct lws_dht_ctx;
 
extern const struct lws_protocols lws_dht_protocol;

typedef struct lws_dht_hash {
        uint8_t                 type; /* LWS_DHT_HASH_TYPE_... */
        uint8_t                 len;
        uint8_t                 id[];
} lws_dht_hash_t;
 
enum {
        LWS_DHT_HASH_TYPE_UNKNOWN      = 0,
        LWS_DHT_HASH_TYPE_SHA1            = 0x11, /* 20 bytes */
        LWS_DHT_HASH_TYPE_SHA256        = 0x12, /* 32 bytes */
        LWS_DHT_HASH_TYPE_SHA512        = 0x13, /* 64 bytes */
        LWS_DHT_HASH_TYPE_BLAKE3        = 0x1e, /* 32 bytes */
};

LWS_VISIBLE LWS_EXTERN lws_dht_hash_t *
lws_dht_hash_create(int type, int len, const uint8_t *data);

LWS_VISIBLE LWS_EXTERN void
lws_dht_hash_destroy(lws_dht_hash_t **p);

typedef void
lws_dht_callback_t(void *closure, int event, const lws_dht_hash_t *info_hash, const void *data, size_t data_len);

typedef int
lws_dht_blacklist_cb_t(const struct sockaddr *sa, size_t salen);

typedef void
lws_dht_hash_cb_t(void *hash_return, int hash_size,
                  const void *v1, int len1,
                  const void *v2, int len2,
                  const void *v3, int len3);

typedef void
lws_dht_capture_announce_cb_t(struct lws_dht_ctx *ctx, lws_dht_hash_t *hash,
                              const struct sockaddr *fromaddr,
                              unsigned short prt);
 
/* The maximum number of peers we store for a given hash. */
#define DHT_MAX_PEERS 2048
 
/* The maximum number of hashes we're willing to track. */
#define DHT_MAX_HASHES 16384
 
/* The maximum number of searches we keep data about. */
#define DHT_MAX_SEARCHES 1024
 
/* The time after which we consider a search to be expirable. */
#define DHT_SEARCH_EXPIRE_TIME (62 * 60)

typedef enum {
        LWS_DHT_EVENT_NONE,
        LWS_DHT_EVENT_VALUES,               
        LWS_DHT_EVENT_VALUES6,             
        LWS_DHT_EVENT_SEARCH_DONE,     
        LWS_DHT_EVENT_SEARCH_DONE6,   
        LWS_DHT_EVENT_EXTERNAL_ADDR, 
        LWS_DHT_EVENT_EXTERNAL_ADDR6,       
} lws_dht_event_t;
 

typedef struct lws_dht_info {
        struct lws_vhost                *vhost;
        lws_dht_callback_t            *cb;
        void                            *closure;
        const lws_dht_hash_t              *id;
        const char                      *v;
        int                             port;
        uint8_t                         ipv6:1;
        uint8_t                         legacy:1;
        uint8_t                         aux;
        const char                      *iface;
        lws_dht_blacklist_cb_t            *blacklist_cb;
        lws_dht_hash_cb_t              *hash_cb;
        lws_dht_capture_announce_cb_t      *capture_announce_cb;
} lws_dht_info_t;

LWS_VISIBLE LWS_EXTERN struct lws_dht_ctx *
lws_dht_create(const lws_dht_info_t *info);

LWS_VISIBLE LWS_EXTERN void
lws_dht_destroy(struct lws_dht_ctx **pctx);

LWS_VISIBLE LWS_EXTERN int
lws_dht_insert_node(struct lws_dht_ctx *ctx, const lws_dht_hash_t *id,
                    struct sockaddr *sa, size_t salen);

LWS_VISIBLE LWS_EXTERN int
lws_dht_ping_node(struct lws_dht_ctx *ctx, struct sockaddr *sa, size_t salen);

LWS_VISIBLE LWS_EXTERN int
lws_dht_search(struct lws_dht_ctx *ctx, const lws_dht_hash_t *id, int port, int af,
               lws_dht_callback_t *callback, void *closure);

LWS_VISIBLE LWS_EXTERN int
lws_dht_nodes(struct lws_dht_ctx *ctx, int af, int *good_return, int *dubious_return,
              int *cached_return, int *incoming_return);

LWS_VISIBLE LWS_EXTERN void
lws_dht_dump_tables(struct lws_dht_ctx *ctx);

LWS_VISIBLE LWS_EXTERN int
lws_dht_get_nodes(struct lws_dht_ctx *ctx, struct sockaddr_in *sin, int *num,
                  struct sockaddr_in6 *sin6, int *num6);

LWS_VISIBLE LWS_EXTERN int
lws_dht_get_external_addr(struct lws_dht_ctx *ctx, struct sockaddr_storage *ss, size_t *sslen);
 
#endif /* __LWS_DHT_H__ */