ircd/capability.c

   1 /*
   2  * Copyright (c) 2012 William Pitcock <nenolod@dereferenced.org>.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice is present in all copies.
   7  *
   8  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   9  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  10  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  11  * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  12  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  13  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  14  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  15  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  16  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  17  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  18  * POSSIBILITY OF SUCH DAMAGE.
  19  */
  20
  21 #include "stdinc.h"
  22 #include "capability.h"
  23 #include "rb_dictionary.h"
  24 #include "s_assert.h"
  25
  26 static rb_dlink_list capability_indexes = { NULL, NULL, 0 };
  27
  28 struct CapabilityEntry *
  29 capability_find(struct CapabilityIndex *idx, const char *cap)
  30 {
  31         s_assert(idx != NULL);
  32         if (cap == NULL)
  33                 return NULL;
  34
  35         return rb_dictionary_retrieve(idx->cap_dict, cap);
  36 }
  37
  38 unsigned int
  39 capability_get(struct CapabilityIndex *idx, const char *cap, void **ownerdata)
  40 {
  41         struct CapabilityEntry *entry;
  42
  43         s_assert(idx != NULL);
  44         if (cap == NULL)
  45                 return 0;
  46
  47         entry = rb_dictionary_retrieve(idx->cap_dict, cap);
  48         if (entry != NULL && !(entry->flags & CAP_ORPHANED))
  49         {
  50                 if (ownerdata != NULL)
  51                         *ownerdata = entry->ownerdata;
  52                 return (1 << entry->value);
  53         }
  54
  55         return 0;
  56 }
  57
  58 unsigned int
  59 capability_put(struct CapabilityIndex *idx, const char *cap, void *ownerdata)
  60 {
  61         struct CapabilityEntry *entry;
  62
  63         s_assert(idx != NULL);
  64         if (!idx->highest_bit)
  65                 return 0xFFFFFFFF;
  66
  67         if ((entry = rb_dictionary_retrieve(idx->cap_dict, cap)) != NULL)
  68         {
  69                 entry->flags &= ~CAP_ORPHANED;
  70                 return (1 << entry->value);
  71         }
  72
  73         entry = rb_malloc(sizeof(struct CapabilityEntry));
  74         entry->cap = rb_strdup(cap);
  75         entry->flags = 0;
  76         entry->value = idx->highest_bit;
  77         entry->ownerdata = ownerdata;
  78
  79         rb_dictionary_add(idx->cap_dict, entry->cap, entry);
  80
  81         idx->highest_bit++;
  82         if (idx->highest_bit % (sizeof(unsigned int) * 8) == 0)
  83                 idx->highest_bit = 0;
  84
  85         return (1 << entry->value);
  86 }
  87
  88 unsigned int
  89 capability_put_anonymous(struct CapabilityIndex *idx)
  90 {
  91         unsigned int value;
  92
  93         s_assert(idx != NULL);
  94         if (!idx->highest_bit)
  95                 return 0xFFFFFFFF;
  96         value = 1 << idx->highest_bit;
  97         idx->highest_bit++;
  98         if (idx->highest_bit % (sizeof(unsigned int) * 8) == 0)
  99                 idx->highest_bit = 0;
 100         return value;
 101 }
 102
 103 void
 104 capability_orphan(struct CapabilityIndex *idx, const char *cap)
 105 {
 106         struct CapabilityEntry *entry;
 107
 108         s_assert(idx != NULL);
 109
 110         entry = rb_dictionary_retrieve(idx->cap_dict, cap);
 111         if (entry != NULL)
 112         {
 113                 entry->flags &= ~CAP_REQUIRED;
 114                 entry->flags |= CAP_ORPHANED;
 115                 entry->ownerdata = NULL;
 116         }
 117 }
 118
 119 void
 120 capability_require(struct CapabilityIndex *idx, const char *cap)
 121 {
 122         struct CapabilityEntry *entry;
 123
 124         s_assert(idx != NULL);
 125
 126         entry = rb_dictionary_retrieve(idx->cap_dict, cap);
 127         if (entry != NULL)
 128                 entry->flags |= CAP_REQUIRED;
 129 }
 130
 131 static void
 132 capability_destroy(rb_dictionary_element *delem, void *privdata)
 133 {
 134         s_assert(delem != NULL);
 135
 136         struct CapabilityEntry *entry = delem->data;
 137         rb_free((char *)entry->cap);
 138         rb_free(entry);
 139 }
 140
 141 struct CapabilityIndex *
 142 capability_index_create(const char *name)
 143 {
 144         struct CapabilityIndex *idx;
 145
 146         idx = rb_malloc(sizeof(struct CapabilityIndex));
 147         idx->name = name;
 148         idx->cap_dict = rb_dictionary_create(name, rb_strcasecmp);
 149         idx->highest_bit = 1;
 150
 151         rb_dlinkAdd(idx, &idx->node, &capability_indexes);
 152
 153         return idx;
 154 }
 155
 156 void
 157 capability_index_destroy(struct CapabilityIndex *idx)
 158 {
 159         s_assert(idx != NULL);
 160
 161         rb_dlinkDelete(&idx->node, &capability_indexes);
 162
 163         rb_dictionary_destroy(idx->cap_dict, capability_destroy, NULL);
 164         rb_free(idx);
 165 }
 166
 167 const char *
 168 capability_index_list(struct CapabilityIndex *idx, unsigned int cap_mask)
 169 {
 170         rb_dictionary_iter iter;
 171         struct CapabilityEntry *entry;
 172         static char buf[BUFSIZE];
 173         char *t = buf;
 174         int tl;
 175
 176         s_assert(idx != NULL);
 177
 178         *t = '\0';
 179
 180         RB_DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 181         {
 182                 if ((1 << entry->value) & cap_mask)
 183                 {
 184                         tl = sprintf(t, "%s ", entry->cap);
 185                         t += tl;
 186                 }
 187         }
 188
 189         t--;
 190         *t = '\0';
 191
 192         return buf;
 193 }
 194
 195 unsigned int
 196 capability_index_mask(struct CapabilityIndex *idx)
 197 {
 198         rb_dictionary_iter iter;
 199         struct CapabilityEntry *entry;
 200         unsigned int mask = 0;
 201
 202         s_assert(idx != NULL);
 203
 204         RB_DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 205         {
 206                 if (!(entry->flags & CAP_ORPHANED))
 207                         mask |= (1 << entry->value);
 208         }
 209
 210         return mask;
 211 }
 212
 213 unsigned int
 214 capability_index_get_required(struct CapabilityIndex *idx)
 215 {
 216         rb_dictionary_iter iter;
 217         struct CapabilityEntry *entry;
 218         unsigned int mask = 0;
 219
 220         s_assert(idx != NULL);
 221
 222         RB_DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 223         {
 224                 if (!(entry->flags & CAP_ORPHANED) && (entry->flags & CAP_REQUIRED))
 225                         mask |= (1 << entry->value);
 226         }
 227
 228         return mask;
 229 }
 230
 231 void
 232 capability_index_stats(void (*cb)(const char *line, void *privdata), void *privdata)
 233 {
 234         rb_dlink_node *node;
 235         char buf[BUFSIZE];
 236
 237         RB_DLINK_FOREACH(node, capability_indexes.head)
 238         {
 239                 struct CapabilityIndex *idx = node->data;
 240                 rb_dictionary_iter iter;
 241                 struct CapabilityEntry *entry;
 242
 243                 snprintf(buf, sizeof buf, "'%s': allocated bits - %d", idx->name, (idx->highest_bit - 1));
 244                 cb(buf, privdata);
 245
 246                 RB_DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 247                 {
 248                         snprintf(buf, sizeof buf, "bit %d: '%s'", entry->value, entry->cap);
 249                         cb(buf, privdata);
 250                 }
 251
 252                 snprintf(buf, sizeof buf, "'%s': remaining bits - %u", idx->name,
 253                             (unsigned int)((sizeof(unsigned int) * 8) - (idx->highest_bit - 1)));
 254                 cb(buf, privdata);
 255         }
 256
 257         snprintf(buf, sizeof buf, "%ld capability indexes", rb_dlink_list_length(&capability_indexes));
 258         cb(buf, privdata);
 259 }