package/libnl-tiny/src/cache_mngt.c

   1 /*
   2  * lib/cache_mngt.c     Cache Management
   3  *
   4  *      This library is free software; you can redistribute it and/or
   5  *      modify it under the terms of the GNU Lesser General Public
   6  *      License as published by the Free Software Foundation version 2.1
   7  *      of the License.
   8  *
   9  * Copyright (c) 2003-2008 Thomas Graf <tgraf@suug.ch>
  10  */
  11
  12 /**
  13  * @ingroup core
  14  * @defgroup cache_mngt Caching
  15  * @{
  16  */
  17
  18 #include <netlink-local.h>
  19 #include <netlink/netlink.h>
  20 #include <netlink/cache.h>
  21 #include <netlink/utils.h>
  22
  23 static struct nl_cache_ops *cache_ops;
  24
  25 /**
  26  * @name Cache Operations Sets
  27  * @{
  28  */
  29
  30 /**
  31  * Lookup the set cache operations of a certain cache type
  32  * @arg name            name of the cache type
  33  *
  34  * @return The cache operations or NULL if no operations
  35  *         have been registered under the specified name.
  36  */
  37 struct nl_cache_ops *nl_cache_ops_lookup(const char *name)
  38 {
  39         struct nl_cache_ops *ops;
  40
  41         for (ops = cache_ops; ops; ops = ops->co_next)
  42                 if (!strcmp(ops->co_name, name))
  43                         return ops;
  44
  45         return NULL;
  46 }
  47
  48 /**
  49  * Associate a message type to a set of cache operations
  50  * @arg protocol                netlink protocol
  51  * @arg msgtype                 netlink message type
  52  *
  53  * Associates the specified netlink message type with
  54  * a registered set of cache operations.
  55  *
  56  * @return The cache operations or NULL if no association
  57  *         could be made.
  58  */
  59 struct nl_cache_ops *nl_cache_ops_associate(int protocol, int msgtype)
  60 {
  61         int i;
  62         struct nl_cache_ops *ops;
  63
  64         for (ops = cache_ops; ops; ops = ops->co_next) {
  65                 if (ops->co_protocol != protocol)
  66                         continue;
  67
  68                 for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++)
  69                         if (ops->co_msgtypes[i].mt_id == msgtype)
  70                                 return ops;
  71         }
  72
  73         return NULL;
  74 }
  75
  76 #ifdef disabled
  77
  78 /**
  79  * Lookup message type cache association
  80  * @arg ops                     cache operations
  81  * @arg msgtype                 netlink message type
  82  *
  83  * Searches for a matching message type association ing the specified
  84  * cache operations.
  85  *
  86  * @return A message type association or NULL.
  87  */
  88 struct nl_msgtype *nl_msgtype_lookup(struct nl_cache_ops *ops, int msgtype)
  89 {
  90         int i;
  91
  92         for (i = 0; ops->co_msgtypes[i].mt_id >= 0; i++)
  93                 if (ops->co_msgtypes[i].mt_id == msgtype)
  94                         return &ops->co_msgtypes[i];
  95
  96         return NULL;
  97 }
  98
  99 static struct nl_cache_ops *cache_ops_lookup_for_obj(struct nl_object_ops *obj_ops)
 100 {
 101         struct nl_cache_ops *ops;
 102
 103         for (ops = cache_ops; ops; ops = ops->co_next)
 104                 if (ops->co_obj_ops == obj_ops)
 105                         return ops;
 106
 107         return NULL;
 108
 109 }
 110
 111 /**
 112  * Call a function for each registered cache operation
 113  * @arg cb              Callback function to be called
 114  * @arg arg             User specific argument.
 115  */
 116 void nl_cache_ops_foreach(void (*cb)(struct nl_cache_ops *, void *), void *arg)
 117 {
 118         struct nl_cache_ops *ops;
 119
 120         for (ops = cache_ops; ops; ops = ops->co_next)
 121                 cb(ops, arg);
 122 }
 123 #endif
 124
 125 /**
 126  * Register a set of cache operations
 127  * @arg ops             cache operations
 128  *
 129  * Called by users of caches to announce the avaibility of
 130  * a certain cache type.
 131  *
 132  * @return 0 on success or a negative error code.
 133  */
 134 int nl_cache_mngt_register(struct nl_cache_ops *ops)
 135 {
 136         if (!ops->co_name || !ops->co_obj_ops)
 137                 return -NLE_INVAL;
 138
 139         if (nl_cache_ops_lookup(ops->co_name))
 140                 return -NLE_EXIST;
 141
 142         ops->co_next = cache_ops;
 143         cache_ops = ops;
 144
 145         NL_DBG(1, "Registered cache operations %s\n", ops->co_name);
 146
 147         return 0;
 148 }
 149
 150 /**
 151  * Unregister a set of cache operations
 152  * @arg ops             cache operations
 153  *
 154  * Called by users of caches to announce a set of
 155  * cache operations is no longer available. The
 156  * specified cache operations must have been registered
 157  * previously using nl_cache_mngt_register()
 158  *
 159  * @return 0 on success or a negative error code
 160  */
 161 int nl_cache_mngt_unregister(struct nl_cache_ops *ops)
 162 {
 163         struct nl_cache_ops *t, **tp;
 164
 165         for (tp = &cache_ops; (t=*tp) != NULL; tp = &t->co_next)
 166                 if (t == ops)
 167                         break;
 168
 169         if (!t)
 170                 return -NLE_NOCACHE;
 171
 172         NL_DBG(1, "Unregistered cache operations %s\n", ops->co_name);
 173
 174         *tp = t->co_next;
 175         return 0;
 176 }
 177
 178 /** @} */
 179
 180 /**
 181  * @name Global Cache Provisioning/Requiring
 182  * @{
 183  */
 184 #ifdef disabled
 185 /**
 186  * Provide a cache for global use
 187  * @arg cache           cache to provide
 188  *
 189  * Offers the specified cache to be used by other modules.
 190  * Only one cache per type may be shared at a time,
 191  * a previsouly provided caches will be overwritten.
 192  */
 193 void nl_cache_mngt_provide(struct nl_cache *cache)
 194 {
 195         struct nl_cache_ops *ops;
 196
 197         ops = cache_ops_lookup_for_obj(cache->c_ops->co_obj_ops);
 198         if (!ops)
 199                 BUG();
 200         else
 201                 ops->co_major_cache = cache;
 202 }
 203
 204 /**
 205  * Unprovide a cache for global use
 206  * @arg cache           cache to unprovide
 207  *
 208  * Cancels the offer to use a cache globally. The
 209  * cache will no longer be returned via lookups but
 210  * may still be in use.
 211  */
 212 void nl_cache_mngt_unprovide(struct nl_cache *cache)
 213 {
 214         struct nl_cache_ops *ops;
 215
 216         ops = cache_ops_lookup_for_obj(cache->c_ops->co_obj_ops);
 217         if (!ops)
 218                 BUG();
 219         else if (ops->co_major_cache == cache)
 220                 ops->co_major_cache = NULL;
 221 }
 222
 223 /**
 224  * Demand the use of a global cache
 225  * @arg name            name of the required object type
 226  *
 227  * Trys to find a cache of the specified type for global
 228  * use.
 229  *
 230  * @return A cache provided by another subsystem of the
 231  *         specified type marked to be available.
 232  */
 233 struct nl_cache *nl_cache_mngt_require(const char *name)
 234 {
 235         struct nl_cache_ops *ops;
 236
 237         ops = nl_cache_ops_lookup(name);
 238         if (!ops || !ops->co_major_cache) {
 239                 fprintf(stderr, "Application BUG: Your application must "
 240                         "call nl_cache_mngt_provide() and\nprovide a valid "
 241                         "%s cache to be used for internal lookups.\nSee the "
 242                         " API documentation for more details.\n", name);
 243
 244                 return NULL;
 245         }
 246
 247         return ops->co_major_cache;
 248 }
 249
 250 #endif
 251 /** @} */
 252
 253 /** @} */