src/datacache/plugin_datacache_template.c

   1 /*
   2      This file is part of GNUnet
   3      Copyright (C) 2006, 2009, 2015 GNUnet e.V.
   4
   5      GNUnet is free software: you can redistribute it and/or modify it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  19  */
  20
  21 /**
  22  * @file datacache/plugin_datacache_template.c
  23  * @brief template for an implementation of a database backend for the datacache
  24  * @author Christian Grothoff
  25  */
  26 #include "platform.h"
  27 #include "gnunet_util_lib.h"
  28 #include "gnunet_datacache_plugin.h"
  29
  30
  31 /**
  32  * Context for all functions in this plugin.
  33  */
  34 struct Plugin {
  35   /**
  36    * Our execution environment.
  37    */
  38   struct GNUNET_DATACACHE_PluginEnvironment *env;
  39 };
  40
  41
  42 /**
  43  * Store an item in the datastore.
  44  *
  45  * @param cls closure (our `struct Plugin`)
  46  * @param key key to store @a data under
  47  * @param xor_distance distance of @a key to our PID
  48  * @param size number of bytes in @a data
  49  * @param data data to store
  50  * @param type type of the value
  51  * @param discard_time when to discard the value in any case
  52  * @param path_info_len number of entries in @a path_info
  53  * @param path_info a path through the network
  54  * @return 0 if duplicate, -1 on error, number of bytes used otherwise
  55  */
  56 static ssize_t
  57 template_plugin_put(void *cls,
  58                     const struct GNUNET_HashCode *key,
  59                     uint32_t xor_distance,
  60                     size_t size,
  61                     const char *data,
  62                     enum GNUNET_BLOCK_Type type,
  63                     struct GNUNET_TIME_Absolute discard_time,
  64                     unsigned int path_info_len,
  65                     const struct GNUNET_PeerIdentity *path_info)
  66 {
  67   GNUNET_break(0);
  68   return -1;
  69 }
  70
  71
  72 /**
  73  * Iterate over the results for a particular key
  74  * in the datastore.
  75  *
  76  * @param cls closure (our `struct Plugin`)
  77  * @param key
  78  * @param type entries of which type are relevant?
  79  * @param iter maybe NULL (to just count)
  80  * @param iter_cls closure for @a iter
  81  * @return the number of results found
  82  */
  83 static unsigned int
  84 template_plugin_get(void *cls,
  85                     const struct GNUNET_HashCode *key,
  86                     enum GNUNET_BLOCK_Type type,
  87                     GNUNET_DATACACHE_Iterator iter,
  88                     void *iter_cls)
  89 {
  90   GNUNET_break(0);
  91   return 0;
  92 }
  93
  94
  95 /**
  96  * Delete the entry with the lowest expiration value
  97  * from the datacache right now.
  98  *
  99  * @param cls closure (our `struct Plugin`)
 100  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
 101  */
 102 static int
 103 template_plugin_del(void *cls)
 104 {
 105   GNUNET_break(0);
 106   return GNUNET_SYSERR;
 107 }
 108
 109
 110 /**
 111  * Return a random value from the datastore.
 112  *
 113  * @param cls closure (internal context for the plugin)
 114  * @param iter maybe NULL (to just count)
 115  * @param iter_cls closure for @a iter
 116  * @return the number of results found (zero or one)
 117  */
 118 static unsigned int
 119 template_plugin_get_random(void *cls,
 120                            GNUNET_DATACACHE_Iterator iter,
 121                            void *iter_cls)
 122 {
 123   GNUNET_break(0);
 124   return 0;
 125 }
 126
 127
 128
 129 /**
 130  * Iterate over the results that are "close" to a particular key in
 131  * the datacache.  "close" is defined as numerically larger than @a
 132  * key (when interpreted as a circular address space), with small
 133  * distance.
 134  *
 135  * @param cls closure (internal context for the plugin)
 136  * @param key area of the keyspace to look into
 137  * @param num_results number of results that should be returned to @a iter
 138  * @param iter maybe NULL (to just count)
 139  * @param iter_cls closure for @a iter
 140  * @return the number of results found
 141  */
 142 static unsigned int
 143 template_plugin_get_closest(void *cls,
 144                             const struct GNUNET_HashCode *key,
 145                             unsigned int num_results,
 146                             GNUNET_DATACACHE_Iterator iter,
 147                             void *iter_cls)
 148 {
 149   GNUNET_break(0);
 150   return 0;
 151 }
 152
 153
 154 /**
 155  * Entry point for the plugin.
 156  *
 157  * @param cls closure (the `struct GNUNET_DATACACHE_PluginEnvironmnet`)
 158  * @return the plugin's closure (our `struct Plugin`)
 159  */
 160 void *
 161 libgnunet_plugin_datacache_template_init(void *cls)
 162 {
 163   struct GNUNET_DATACACHE_PluginEnvironment *env = cls;
 164   struct GNUNET_DATACACHE_PluginFunctions *api;
 165   struct Plugin *plugin;
 166
 167   plugin = GNUNET_new(struct Plugin);
 168   plugin->env = env;
 169   api = GNUNET_new(struct GNUNET_DATACACHE_PluginFunctions);
 170   api->cls = plugin;
 171   api->get = &template_plugin_get;
 172   api->put = &template_plugin_put;
 173   api->del = &template_plugin_del;
 174   api->get_random = &template_plugin_get_random;
 175   api->get_closest = &template_plugin_get_closest;
 176   GNUNET_log_from(GNUNET_ERROR_TYPE_INFO,
 177                   "template",
 178                   "Template datacache running\n");
 179   return api;
 180 }
 181
 182
 183 /**
 184  * Exit point from the plugin.
 185  *
 186  * @param cls closure (our `struct Plugin`)
 187  * @return NULL
 188  */
 189 void *
 190 libgnunet_plugin_datacache_template_done(void *cls)
 191 {
 192   struct GNUNET_DATACACHE_PluginFunctions *api = cls;
 193   struct Plugin *plugin = api->cls;
 194
 195   GNUNET_free(plugin);
 196   GNUNET_free(api);
 197   return NULL;
 198 }
 199
 200
 201 /* end of plugin_datacache_template.c */