X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Finclude%2Fgnunet_gns_service.h;h=73f5db5ac0a81d3252968a478affbbd2e0d1bbb0;hb=211fd52268a5ae7856273dd8d8b3b3ed427beadb;hp=405fcd2fce749605baca57f878673810a89eff72;hpb=7f572300440a8d059a6a35a54a8d5fd6c049c4c3;p=oweals%2Fgnunet.git diff --git a/src/include/gnunet_gns_service.h b/src/include/gnunet_gns_service.h index 405fcd2fc..73f5db5ac 100644 --- a/src/include/gnunet_gns_service.h +++ b/src/include/gnunet_gns_service.h @@ -1,6 +1,6 @@ /* This file is part of GNUnet - (C) 2004, 2005, 2006, 2008, 2009, 2011 Christian Grothoff (and other contributing authors) + (C) 2012 Christian Grothoff (and other contributing authors) GNUnet is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published @@ -23,11 +23,12 @@ * @brief API to the GNS service * @author Martin Schanzenbach */ - #ifndef GNUNET_GNS_SERVICE_H #define GNUNET_GNS_SERVICE_H #include "gnunet_util_lib.h" +#include "gnunet_dnsparser_lib.h" +#include "gnunet_namestore_service.h" #ifdef __cplusplus extern "C" @@ -44,15 +45,79 @@ extern "C" struct GNUNET_GNS_Handle; /** - * Handle to control a get operation. + * Handle to control a lookup operation. + */ +struct GNUNET_GNS_LookupRequest; + +/** + * Handle to control a shorten operation. + */ +struct GNUNET_GNS_ShortenRequest; + +/** + * Handle to control a get authority operation + */ +struct GNUNET_GNS_GetAuthRequest; + +/** + * Record types + * Based on GNUNET_DNSPARSER_TYPEs (standard DNS) */ -struct GNUNET_GNS_LookupHandle; +enum GNUNET_GNS_RecordType +{ + /* Standard DNS */ + /* struct in_addr */ + GNUNET_GNS_RECORD_A = GNUNET_DNSPARSER_TYPE_A, + + /* char */ + GNUNET_GNS_RECORD_NS = GNUNET_DNSPARSER_TYPE_NS, + + /* char */ + GNUNET_GNS_RECORD_CNAME = GNUNET_DNSPARSER_TYPE_CNAME, + + /* struct soa_data */ + GNUNET_GNS_RECORD_SOA = GNUNET_DNSPARSER_TYPE_SOA, + + /* struct srv_data */ + GNUNET_GNS_RECORD_SRV = GNUNET_DNSPARSER_TYPE_SRV, + + /* char */ + GNUNET_GNS_RECORD_PTR = GNUNET_DNSPARSER_TYPE_PTR, + + /* uint16_t, char */ + GNUNET_GNS_RECORD_MX = GNUNET_DNSPARSER_TYPE_MX, + + /* char */ + GNUNET_GNS_RECORD_TXT = GNUNET_DNSPARSER_TYPE_TXT, + + /* struct in6_addr */ + GNUNET_GNS_RECORD_AAAA = GNUNET_DNSPARSER_TYPE_AAAA, + + /* GNS specific */ + /* struct GNUNET_CRYPTO_ShortHashCode */ + GNUNET_GNS_RECORD_PKEY = GNUNET_NAMESTORE_TYPE_PKEY, + + /* char */ + GNUNET_GNS_RECORD_PSEU = GNUNET_NAMESTORE_TYPE_PSEU, + GNUNET_GNS_RECORD_ANY = GNUNET_NAMESTORE_TYPE_ANY, + + /* char */ + GNUNET_GNS_RECORD_LEHO = GNUNET_NAMESTORE_TYPE_LEHO, + + /* struct vpn_data */ + GNUNET_GNS_RECORD_VPN = GNUNET_NAMESTORE_TYPE_VPN, + + /* revocation */ + GNUNET_GNS_RECORD_REV = GNUNET_NAMESTORE_TYPE_REV +}; + /** * Initialize the connection with the GNS service. * * @param cfg configuration to use - * @return NULL on error + * + * @return handle to the GNS service, or NULL on error */ struct GNUNET_GNS_Handle * GNUNET_GNS_connect (const struct GNUNET_CONFIGURATION_Handle *cfg); @@ -67,99 +132,182 @@ void GNUNET_GNS_disconnect (struct GNUNET_GNS_Handle *handle); -/* *************** Standard API: add and lookup ******************* */ +/* *************** Standard API: lookup ******************* */ + +/** + * Iterator called on obtained result for a GNS + * lookup + * + * @param cls closure + * @param rd_count number of records + * @param rd the records in reply + */ +typedef void (*GNUNET_GNS_LookupResultProcessor) (void *cls, + uint32_t rd_count, + const struct GNUNET_NAMESTORE_RecordData *rd); + + + +/** + * Perform an asynchronous lookup operation on the GNS + * in the default zone. + * + * @param handle handle to the GNS service + * @param name the name to look up + * @param type the GNUNET_GNS_RecordType to look for + * @param only_cached GNUNET_NO to only check locally not DHT for performance + * @param shorten_key the private key of the shorten zone (can be NULL) + * @param proc function to call on result + * @param proc_cls closure for processor + * + * @return handle to the queued request + */ +struct GNUNET_GNS_LookupRequest* +GNUNET_GNS_lookup (struct GNUNET_GNS_Handle *handle, + const char * name, + enum GNUNET_GNS_RecordType type, + int only_cached, + struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key, + GNUNET_GNS_LookupResultProcessor proc, + void *proc_cls); + + +/** + * Perform an asynchronous lookup operation on the GNS + * in the zone specified by 'zone'. + * + * @param handle handle to the GNS service + * @param name the name to look up + * @param zone the zone to start the resolution in + * @param type the GNUNET_GNS_RecordType to look for + * @param only_cached GNUNET_YES to only check locally not DHT for performance + * @param shorten_key the private key of the shorten zone (can be NULL) + * @param proc function to call on result + * @param proc_cls closure for processor + * + * @return handle to the queued request + */ +struct GNUNET_GNS_LookupRequest* +GNUNET_GNS_lookup_zone (struct GNUNET_GNS_Handle *handle, + const char * name, + struct GNUNET_CRYPTO_ShortHashCode *zone, + enum GNUNET_GNS_RecordType type, + int only_cached, + struct GNUNET_CRYPTO_RsaPrivateKey *shorten_key, + GNUNET_GNS_LookupResultProcessor proc, + void *proc_cls); + /** - * Perform an add operation storing records in the GNS. + * Cancel pending lookup request * - * @param handle handle to GNS service - * @param key the key to store under - * @param desired_replication_level estimate of how many - * nearest peers this request should reach - * @param options routing options for this message - * @param type type of the value - * @param size number of bytes in data; must be less than 64k - * @param data the data to store - * @param exp desired expiration time for the value - * @param timeout how long to wait for transmission of this request - * @param cont continuation to call when done (transmitting request to service) - * @param cont_cls closure for cont + * @param lr the lookup request to cancel */ void -GNUNET_GNS_add (struct GNUNET_GNS_Handle *handle, const GNUNET_HashCode * key, - uint32_t desired_replication_level, - enum GNUNET_DHT_RouteOption options, - enum GNUNET_BLOCK_Type type, size_t size, const char *data, - struct GNUNET_TIME_Absolute exp, - struct GNUNET_TIME_Relative timeout, GNUNET_SCHEDULER_Task cont, - void *cont_cls); +GNUNET_GNS_cancel_lookup_request (struct GNUNET_GNS_LookupRequest *lr); + +/* *************** Standard API: shorten ******************* */ /** - * Iterator called on each result obtained for a GNS - * operation that expects a reply TODO: eh? + * Processor called on for a name shortening result + * called only once * * @param cls closure - * @param exp when will this value expire - * @param key key of the result - * @param get_path peers on reply path (or NULL if not recorded) - * @param get_path_length number of entries in get_path - * @param put_path peers on the PUT path (or NULL if not recorded) - * @param put_path_length number of entries in get_path - * @param type type of the result - * @param size number of bytes in data - * @param data pointer to the result data + * @param short_name the shortened name or NULL if no result / error */ -typedef void (*GNUNET_GNS_LookupIterator) (void *cls, - struct GNUNET_TIME_Absolute exp, - const GNUNET_HashCode * key, - const struct GNUNET_PeerIdentity * - get_path, unsigned int get_path_length, - const struct GNUNET_PeerIdentity * - put_path, unsigned int put_path_length, - enum GNUNET_BLOCK_Type type, - size_t size, const void *data); +typedef void (*GNUNET_GNS_ShortenResultProcessor) (void *cls, + const char* short_name); +/** + * Perform a name shortening operation on the GNS. + * + * @param handle handle to the GNS service + * @param name the name to look up + * @param private_zone the public zone of the private zone + * @param shorten_zone the public zone of the shorten zone + * @param proc function to call on result + * @param proc_cls closure for processor + * @return handle to the operation + */ +struct GNUNET_GNS_ShortenRequest* +GNUNET_GNS_shorten (struct GNUNET_GNS_Handle *handle, + const char * name, + struct GNUNET_CRYPTO_ShortHashCode *private_zone, + struct GNUNET_CRYPTO_ShortHashCode *shorten_zone, + GNUNET_GNS_ShortenResultProcessor proc, + void *proc_cls); + /** - * Perform an asynchronous lookup operation on the GNS. + * Perform a name shortening operation on the GNS. * * @param handle handle to the GNS service - * @param timeout how long to wait for transmission of this request to the service - * @param type expected type of the response object - * @param key the key to look up - * @param desired_replication_level estimate of how many - nearest peers this request should reach - * @param options routing options for this message - * @param xquery extended query data (can be NULL, depending on type) - * @param xquery_size number of bytes in xquery - * @param iter function to call on each result - * @param iter_cls closure for iter + * @param name the name to look up + * @param private_zone the public zone of the private zone + * @param shorten_zone the public zone of the shorten zone + * @param zone the zone to start the resolution in + * @param proc function to call on result + * @param proc_cls closure for processor + * @return handle to the operation + */ +struct GNUNET_GNS_ShortenRequest* +GNUNET_GNS_shorten_zone (struct GNUNET_GNS_Handle *handle, + const char * name, + struct GNUNET_CRYPTO_ShortHashCode *private_zone, + struct GNUNET_CRYPTO_ShortHashCode *shorten_zone, + struct GNUNET_CRYPTO_ShortHashCode *zone, + GNUNET_GNS_ShortenResultProcessor proc, + void *proc_cls); + + +/** + * Cancel pending shorten request + * + * @param sr the lookup request to cancel + */ +void +GNUNET_GNS_cancel_shorten_request (struct GNUNET_GNS_ShortenRequest *sr); + + +/* *************** Standard API: get authority ******************* */ + + +/** + * Processor called on for a name shortening result + * called only once * - * @return handle to stop the async get + * @param cls closure + * @param auth_name the name of the auhtority or NULL */ -struct GNUNET_GNS_LookupHandle * -GNUNET_GNS_lookup_start (struct GNUNET_GNS_Handle *handle, - struct GNUNET_TIME_Relative timeout, - enum GNUNET_BLOCK_Type type, const GNUNET_HashCode * key, - uint32_t desired_replication_level, - enum GNUNET_DHT_RouteOption options, const void *xquery, - size_t xquery_size, GNUNET_GNS_LookupIterator iter, - void *iter_cls); +typedef void (*GNUNET_GNS_GetAuthResultProcessor) (void *cls, + const char* short_name); /** - * Stop async GNS lookup. Frees associated resources. + * Perform an authority lookup for a given name. * - * @param lookup_handle lookup operation to stop. + * @param handle handle to the GNS service + * @param name the name to look up authority for + * @param proc function to call on result + * @param proc_cls closure for processor + * @return handle to the operation + */ +struct GNUNET_GNS_GetAuthRequest* +GNUNET_GNS_get_authority (struct GNUNET_GNS_Handle *handle, + const char * name, + GNUNET_GNS_GetAuthResultProcessor proc, + void *proc_cls); + + +/** + * Cancel pending get auth request * - * On return lookup_handle will no longer be valid, caller - * must not use again!!! + * @param gar the lookup request to cancel */ void -GNUNET_GNS_lookup_stop (struct GNUNET_GNS_LookupHandle *lookup_handle); - +GNUNET_GNS_cancel_get_auth_request (struct GNUNET_GNS_GetAuthRequest *gar); #if 0 /* keep Emacsens' auto-indent happy */ {