30#include <microhttpd.h>
44#define GNUNET_ADV_TIMEOUT \
45 GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MINUTES, 5)
157 MHD_add_response_header (resp,
"Access-Control-Allow-Origin",
"*");
158 MHD_add_response_header (resp,
159 "Access-Control-Allow-Methods",
161 MHD_add_response_header (resp,
"Access-Control-Max-Age",
"86400");
165static struct MHD_Response*
176 hello_uri_j = json_object ();
177 hello_array = json_array ();
178 while (offset < bu->
size)
183 json_array_append_new (hello_array, json_string (hello_uri));
186 offset += ntohs (hello->
size);
188 json_object_set_new (hello_uri_j,
"hellos", hello_array);
189 hello_uris = json_dumps (hello_uri_j, JSON_INDENT (2));
190 json_decref (hello_uri_j);
191 return MHD_create_response_from_buffer (strlen (hello_uris),
193 MHD_RESPMEM_MUST_FREE);
208 "Creating hostlist response with %u bytes\n",
212 MHD_RESPMEM_MUST_FREE);
256 s = ntohs (hello->
size);
258 "Received %u bytes of `%s' from peer `%s' for hostlist.\n",
268 "bytes not included in hostlist (size limit)"),
274 "Adding peer `%s' to hostlist (%u bytes)\n",
295 const struct sockaddr *addr,
302 "Received request for hostlist, but I am not yet ready; rejecting!\n");
310 enum MHD_ValueKind kind,
316 if (0 != strcasecmp(
key,
"Accept"))
318 if (0 == strcasecmp (
value,
"application/json"))
360 struct MHD_Connection *connection,
364 const char *upload_data,
365 size_t *upload_data_size,
369 struct MHD_Response *selected_response;
372 if (0 == strcmp (MHD_HTTP_METHOD_OPTIONS, method))
374 struct MHD_Response *options_response;
378 MHD_create_response_from_buffer (0, NULL, MHD_RESPMEM_PERSISTENT);
380 rc = MHD_queue_response (connection,
MHD_HTTP_OK, options_response);
381 MHD_destroy_response (options_response);
384 if (0 != strcmp (method, MHD_HTTP_METHOD_GET))
387 _ (
"Refusing `%s' request to hostlist server\n"),
391 "hostlist requests refused (not HTTP GET)"),
396 if (NULL == *con_cls)
401 if (0 != *upload_data_size)
404 _ (
"Refusing `%s' request with %llu bytes of upload data\n"),
406 (
unsigned long long) *upload_data_size);
409 "hostlist requests refused (upload data)"),
416 MHD_get_connection_values (connection,
424 if (NULL == selected_response)
429 "Could not handle hostlist request since I do not have a response yet\n"));
432 "hostlist requests refused (not ready)"),
438 _ (
"Received request for our hostlist\n"));
443 return MHD_queue_response (connection,
MHD_HTTP_OK, selected_response);
459 static uint64_t hostlist_adv_count;
474 "Sent advertisement message: Copied %u bytes into buffer!\n",
475 (
unsigned int) uri_size);
476 hostlist_adv_count++;
478 " # Sent advertisement message: %llu\n",
479 (
unsigned long long) hostlist_adv_count);
520 "Asked CORE to transmit advertisement message with a size of %u bytes to peer `%s'\n",
549 "Peerstore is notifying us to rebuild our hostlist map size %u\n",
554 _ (
"Error in communication with PEERSTORE service: %s\n"),
587 "1 Peerstore is notifying us to rebuild our hostlist map size %u peer %s\n",
611 struct MHD_Daemon *daemon_handle = cls;
641 MHD_UNSIGNED_LONG_LONG
timeout;
651 GNUNET_assert (MHD_YES == MHD_get_fdset (daemon_handle, &rs, &ws, &es, &
max));
652 haveto = MHD_get_timeout (daemon_handle, &
timeout);
653 if (haveto == MHD_YES)
675 "Error in PEERSTORE monitoring\n");
683 "Done with initial PEERSTORE iteration during monitoring\n");
693 "Starting to process new hellos to add to hostlist.\n");
724 unsigned long long port;
731 struct sockaddr_in v4;
732 struct sockaddr_in6 v6;
733 const struct sockaddr *sa4;
734 const struct sockaddr *sa6;
741 "Advertising not enabled on this hostlist server\n");
746 "Advertising enabled on this hostlist server\n");
754 _ (
"Could not access PEERSTORE service. Exiting.\n"));
762 if ((0 ==
port) || (
port > UINT16_MAX))
765 _ (
"Invalid port number %llu. Exiting.\n"),
777 _ (
"Hostlist service starts on %s:%llu\n"),
780 if (NULL != hostname)
782 size = strlen (hostname);
792 (
unsigned int)
port);
794 _ (
"Address to obtain hostlist: `%s'\n"),
809 _ (
"BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV4.\n"));
823 _ (
"BINDTOIP does not a valid IPv4 address! Ignoring BINDTOIPV6.\n"));
831 if (1 == inet_pton (AF_INET,
ipv4, &i4))
833 memset (&v4, 0,
sizeof(v4));
834 v4.sin_family = AF_INET;
836 v4.sin_port = htons (
port);
837#if HAVE_SOCKADDR_IN_SIN_LEN
838 v4.sin_len =
sizeof(v4);
840 sa4 = (
const struct sockaddr *) &v4;
845 "`%s' is not a valid IPv4 address! Ignoring BINDTOIPV4.\n"),
852 if (1 == inet_pton (AF_INET6,
ipv6, &i6))
854 memset (&v6, 0,
sizeof(v6));
855 v6.sin6_family = AF_INET6;
857 v6.sin6_port = htons (
port);
858#if HAVE_SOCKADDR_IN_SIN_LEN
859 v6.sin6_len =
sizeof(v6);
861 sa6 = (
const struct sockaddr *) &v6;
866 "`%s' is not a valid IPv6 address! Ignoring BINDTOIPV6.\n"),
877 MHD_OPTION_CONNECTION_LIMIT,
879 MHD_OPTION_PER_IP_CONNECTION_LIMIT,
881 MHD_OPTION_CONNECTION_TIMEOUT,
883 MHD_OPTION_CONNECTION_MEMORY_LIMIT,
884 (
size_t) (16 * 1024),
885 MHD_OPTION_SOCK_ADDR,
894 MHD_OPTION_CONNECTION_LIMIT,
896 MHD_OPTION_PER_IP_CONNECTION_LIMIT,
898 MHD_OPTION_CONNECTION_TIMEOUT,
900 MHD_OPTION_CONNECTION_MEMORY_LIMIT,
901 (
size_t) (16 * 1024),
902 MHD_OPTION_SOCK_ADDR,
909 _ (
"Could not start hostlist HTTP server on port %u\n"),
910 (
unsigned short)
port);
struct GNUNET_MQ_Handle * mq
struct GNUNET_MQ_Envelope * env
#define gettext_noop(String)
static int ret
Final status code.
static struct GNUNET_TIME_Relative timeout
User defined timestamp for completing operations.
static uint16_t port
Port number.
static struct GNUNET_SCHEDULER_Task * st
The shutdown task.
static void record(void *cls, size_t data_size, const void *data)
Process recorded audio data.
static GNUNET_CORE_ConnectEventHandler server_ch
Handle to hostlist server's connect handler.
common internal definitions for hostlist daemon
#define MAX_URL_LEN
How long can hostlist URLs be?
#define MAX_BYTES_PER_HOSTLISTS
How many bytes do we download at most from a hostlist server?
static struct MHD_Daemon * daemon_handle_v6
Handle to the HTTP server as provided by libmicrohttpd for IPv6.
static struct MHD_Response * response
Our canonical response.
static void sync_cb(void *cls)
static struct MHD_Daemon * daemon_handle_v4
Handle to the HTTP server as provided by libmicrohttpd for IPv4.
static struct GNUNET_SCHEDULER_Task * hostlist_task_v4
Our primary task for IPv4.
static struct HostSet * builder
NULL if we are not currently iterating over peer information.
static struct GNUNET_CORE_Handle * core
Handle to the core service (NULL until we've connected to it).
static int advertising
Set if we are allowed to advertise our hostlist to others.
static void add_cors_headers(struct MHD_Response *resp)
Add headers to a request indicating that we allow Cross-Origin Resource Sharing.
static struct GNUNET_PEERSTORE_Monitor * peerstore_notify
Our peerstore notification context.
static void * connect_handler(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
static struct GNUNET_STATISTICS_Handle * stats
For keeping statistics.
struct GNUNET_CONTAINER_MultiPeerMap * hellos
Map with hellos we build the hostlist with.
static const struct GNUNET_CONFIGURATION_Handle * cfg
Our configuration.
static struct GNUNET_SCHEDULER_Task * hostlist_task_v6
Our primary task for IPv6.
static struct GNUNET_PEERSTORE_Handle * peerstore
Handle to the PEERSTORE service.
static struct MHD_Response * build_json_response(const struct HostSet *bu)
static enum GNUNET_GenericReturnValue host_processor(void *cls, const struct GNUNET_PeerIdentity *peer, void *value)
Callback that processes each of the known HELLOs for the hostlist response construction.
static struct GNUNET_SCHEDULER_Task * prepare_daemon(struct MHD_Daemon *daemon_handle)
Function that queries MHD's select sets and starts the task waiting for them.
static void start_notify(void *cls)
static struct MHD_Response * response_json
Our json response.
static void adv_transmit(struct GNUNET_MQ_Handle *mq)
Handler called by CORE when CORE is ready to transmit message.
struct GNUNET_SCHEDULER_Task * peerstore_notify_task
The task to delayed start the notification process initially.
int GNUNET_HOSTLIST_server_start(const struct GNUNET_CONFIGURATION_Handle *c, struct GNUNET_STATISTICS_Handle *st, struct GNUNET_CORE_Handle *co, GNUNET_CORE_ConnectEventHandler *server_ch, int advertise)
Start server offering our hostlist.
static void run_daemon(void *cls)
Call MHD to process pending requests and then go back and schedule the next run.
static int header_iterator(void *cls, enum MHD_ValueKind kind, const char *key, const char *value)
static void finish_response()
Function that assembles our response.
static void error_cb(void *cls)
static MHD_RESULT access_handler_callback(void *cls, struct MHD_Connection *connection, const char *url, const char *method, const char *version, const char *upload_data, size_t *upload_data_size, void **con_cls)
Main request handler.
static void process_notify(void *cls, const struct GNUNET_PEERSTORE_Record *record, const char *err_msg)
PEERSTORE calls this function to let us know about a possible peer that we might want to connect to.
void GNUNET_HOSTLIST_server_stop()
Stop server offering our hostlist.
static char * hostlist_uri
Buffer for the hostlist address.
static MHD_RESULT accept_policy_callback(void *cls, const struct sockaddr *addr, socklen_t addrlen)
Hostlist access policy (very permissive, allows everything).
struct GNUNET_HashCode key
The key used in the DHT.
static struct in_addr dummy
Target "dummy" address of the packet we pretend to respond to.
static char * value
Value of the record to add/remove.
static int ipv4
Option -4: IPv4 requested.
static int ipv6
Option -6: IPv6 requested.
static unsigned int map_size
Command-line argument specifying desired size of the hash map with all of our pending names.
commonly used definitions; globals in this file are exempt from the rule that the module name ("commo...
Helper library for handling HELLO URIs.
API to the peerstore service.
Functions related to doing DNS lookups.
#define GNUNET_MAX_MESSAGE_SIZE
Largest supported message (to be precise, one byte more than the largest possible message,...
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_number(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, unsigned long long *number)
Get a configuration value that should be a number.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_get_value_string(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option, char **value)
Get a configuration value that should be a string.
enum GNUNET_GenericReturnValue GNUNET_CONFIGURATION_have_value(const struct GNUNET_CONFIGURATION_Handle *cfg, const char *section, const char *option)
Test if we have a value for a particular option.
void *(* GNUNET_CORE_ConnectEventHandler)(void *cls, const struct GNUNET_PeerIdentity *peer, struct GNUNET_MQ_Handle *mq)
Method called whenever a given peer connects.
int GNUNET_CONTAINER_multipeermap_iterate(struct GNUNET_CONTAINER_MultiPeerMap *map, GNUNET_CONTAINER_PeerMapIterator it, void *it_cls)
Iterate over all entries in the map.
struct GNUNET_CONTAINER_MultiPeerMap * GNUNET_CONTAINER_multipeermap_create(unsigned int len, int do_not_copy_keys)
Create a multi peer map (hash map for public keys of peers).
unsigned int GNUNET_CONTAINER_multipeermap_size(const struct GNUNET_CONTAINER_MultiPeerMap *map)
Get the number of key-value pairs in the map.
int GNUNET_CONTAINER_multipeermap_put(struct GNUNET_CONTAINER_MultiPeerMap *map, const struct GNUNET_PeerIdentity *key, void *value, enum GNUNET_CONTAINER_MultiHashMapOption opt)
Store a key-value pair in the map.
@ GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE
Allow multiple values with the same key.
void GNUNET_HELLO_builder_free(struct GNUNET_HELLO_Builder *builder)
Release resources of a builder.
struct GNUNET_HELLO_Builder * GNUNET_HELLO_builder_from_msg(const struct GNUNET_MessageHeader *msg)
Parse msg into builder.
char * GNUNET_HELLO_builder_to_url(const struct GNUNET_HELLO_Builder *builder, const struct GNUNET_CRYPTO_EddsaPrivateKey *priv)
Generate GNUnet HELLO URI from a builder.
#define GNUNET_log(kind,...)
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
GNUNET_GenericReturnValue
Named constants for return values.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format.
@ GNUNET_SCHEDULER_PRIORITY_HIGH
Run with high priority (important requests).
const char * GNUNET_i2s(const struct GNUNET_PeerIdentity *pid)
Convert a peer identity to a string (for printing debug messages).
#define GNUNET_assert(cond)
Use this for fatal errors that cannot be handled.
#define GNUNET_break(cond)
Use this for internal assertion violations that are not fatal (can be handled) but should not occur.
@ GNUNET_ERROR_TYPE_WARNING
@ GNUNET_ERROR_TYPE_ERROR
@ GNUNET_ERROR_TYPE_DEBUG
int int GNUNET_asprintf(char **buf, const char *format,...) __attribute__((format(printf
Like asprintf, just portable.
#define GNUNET_MAX_MALLOC_CHECKED
Maximum allocation with GNUNET_malloc macro.
#define GNUNET_array_grow(arr, size, tsize)
Grow a well-typed (!) array.
#define GNUNET_new(type)
Allocate a struct or union of the given type.
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
void GNUNET_MQ_env_set_options(struct GNUNET_MQ_Envelope *env, enum GNUNET_MQ_PriorityPreferences pp)
Set application-specific options for this envelope.
void GNUNET_MQ_send(struct GNUNET_MQ_Handle *mq, struct GNUNET_MQ_Envelope *ev)
Send a message with the given message queue.
#define GNUNET_MQ_msg_extra(mvar, esize, type)
Allocate an envelope, with extra space allocated after the space needed by the message struct.
@ GNUNET_MQ_PREF_CORK_ALLOWED
Flag to indicate that CORKing is acceptable.
@ GNUNET_MQ_PREF_UNRELIABLE
Flag to indicate that unreliable delivery is acceptable.
void GNUNET_NETWORK_fdset_destroy(struct GNUNET_NETWORK_FDSet *fds)
Releases the associated memory of an fd set.
void GNUNET_NETWORK_fdset_copy_native(struct GNUNET_NETWORK_FDSet *to, const fd_set *from, int nfds)
Copy a native fd set into the GNUnet representation.
struct GNUNET_NETWORK_FDSet * GNUNET_NETWORK_fdset_create(void)
Creates an fd set.
void GNUNET_PEERSTORE_monitor_stop(struct GNUNET_PEERSTORE_Monitor *zm)
Stop monitoring.
void GNUNET_PEERSTORE_disconnect(struct GNUNET_PEERSTORE_Handle *h)
Disconnect from the PEERSTORE service.
struct GNUNET_PEERSTORE_Monitor * GNUNET_PEERSTORE_monitor_start(const struct GNUNET_CONFIGURATION_Handle *cfg, int iterate_first, const char *sub_system, const struct GNUNET_PeerIdentity *peer, const char *key, GNUNET_SCHEDULER_TaskCallback error_cb, void *error_cb_cls, GNUNET_SCHEDULER_TaskCallback sync_cb, void *sync_cb_cls, GNUNET_PEERSTORE_Processor callback, void *callback_cls)
Request watching a given key The monitoring can be filtered to contain only records matching peer and...
struct GNUNET_PEERSTORE_Handle * GNUNET_PEERSTORE_connect(const struct GNUNET_CONFIGURATION_Handle *cfg)
Connect to the PEERSTORE service.
void GNUNET_PEERSTORE_monitor_next(struct GNUNET_PEERSTORE_Monitor *zm, uint64_t limit)
Calls the monitor processor specified in GNUNET_PEERSTORE_monitor_start for the next record(s).
#define GNUNET_PEERSTORE_HELLO_KEY
Key used for storing HELLO in the peerstore.
#define GNUNET_MESSAGE_TYPE_HOSTLIST_ADVERTISEMENT
Hostlist advertisement message.
char * GNUNET_RESOLVER_local_fqdn_get(void)
Get local fully qualified domain name.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_select(enum GNUNET_SCHEDULER_Priority prio, struct GNUNET_TIME_Relative delay, const struct GNUNET_NETWORK_FDSet *rs, const struct GNUNET_NETWORK_FDSet *ws, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay or when any of the specified file descriptor set...
void * GNUNET_SCHEDULER_cancel(struct GNUNET_SCHEDULER_Task *task)
Cancel the task with the specified identifier.
struct GNUNET_SCHEDULER_Task * GNUNET_SCHEDULER_add_delayed(struct GNUNET_TIME_Relative delay, GNUNET_SCHEDULER_TaskCallback task, void *task_cls)
Schedule a new task to be run with a specified delay.
void GNUNET_STATISTICS_set(struct GNUNET_STATISTICS_Handle *handle, const char *name, uint64_t value, int make_persistent)
Set statistic value for the peer.
void GNUNET_STATISTICS_update(struct GNUNET_STATISTICS_Handle *handle, const char *name, int64_t delta, int make_persistent)
Set statistic value for the peer.
#define GNUNET_TIME_UNIT_FOREVER_REL
Constant used to specify "forever".
#define GNUNET_TIME_UNIT_MINUTES
One minute.
@ MHD_HTTP_OK
OK [RFC7231, Section 6.3.1].
static unsigned int size
Size of the "table".
Internal representation of the hash map.
Context for the core service connection.
Context for building (or parsing) HELLO URIs.
Handle to a message queue.
collection of IO descriptors
Handle to the PEERSTORE service.
The identity of the host (wraps the signing key of the peer).
Entry in list of pending tasks.
Time for relative time used by GNUnet, in microseconds.
uint64_t rel_value_us
The actual value.
Context for host_processor().
char * data
Place where we accumulate all of the HELLO messages.
unsigned int size
Number of bytes in data.