src/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 "irc_dictionary.h"
  24
  25 static rb_dlink_list capability_indexes = { NULL, NULL, 0 };
  26
  27 struct CapabilityIndex {
  28         char *name;
  29         struct Dictionary *cap_dict;
  30         unsigned int highest_bit;
  31         rb_dlink_node node;
  32 };
  33
  34 #define CAP_ORPHANED    0x1
  35 #define CAP_REQUIRED    0x2
  36
  37 struct CapabilityEntry {
  38         char *cap;
  39         unsigned int value;
  40         unsigned int flags;
  41 };
  42
  43 unsigned int
  44 capability_get(struct CapabilityIndex *idx, const char *cap)
  45 {
  46         struct CapabilityEntry *entry;
  47
  48         s_assert(idx != NULL);
  49         if (cap == NULL)
  50                 return 0;
  51
  52         entry = irc_dictionary_retrieve(idx->cap_dict, cap);
  53         if (entry != NULL && !(entry->flags & CAP_ORPHANED))
  54                 return (1 << entry->value);
  55
  56         return 0;
  57 }
  58
  59 unsigned int
  60 capability_put(struct CapabilityIndex *idx, const char *cap)
  61 {
  62         struct CapabilityEntry *entry;
  63
  64         s_assert(idx != NULL);
  65         if (!idx->highest_bit)
  66                 return 0xFFFFFFFF;
  67
  68         if ((entry = irc_dictionary_retrieve(idx->cap_dict, cap)) != NULL)
  69         {
  70                 entry->flags &= ~CAP_ORPHANED;
  71                 return (1 << entry->value);
  72         }
  73
  74         entry = rb_malloc(sizeof(struct CapabilityEntry));
  75         entry->cap = rb_strdup(cap);
  76         entry->flags = 0;
  77         entry->value = idx->highest_bit;
  78
  79         irc_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 = irc_dictionary_retrieve(idx->cap_dict, cap);
 111         if (entry != NULL)
 112         {
 113                 entry->flags &= ~CAP_REQUIRED;
 114                 entry->flags |= CAP_ORPHANED;
 115         }
 116 }
 117
 118 void
 119 capability_require(struct CapabilityIndex *idx, const char *cap)
 120 {
 121         struct CapabilityEntry *entry;
 122
 123         s_assert(idx != NULL);
 124
 125         entry = irc_dictionary_retrieve(idx->cap_dict, cap);
 126         if (entry != NULL)
 127                 entry->flags |= CAP_REQUIRED;
 128 }
 129
 130 static void
 131 capability_destroy(struct DictionaryElement *delem, void *privdata)
 132 {
 133         s_assert(delem != NULL);
 134
 135         rb_free(delem->data);
 136 }
 137
 138 struct CapabilityIndex *
 139 capability_index_create(const char *name)
 140 {
 141         struct CapabilityIndex *idx;
 142
 143         idx = rb_malloc(sizeof(struct CapabilityIndex));
 144         idx->name = rb_strdup(name);
 145         idx->cap_dict = irc_dictionary_create(strcasecmp);
 146         idx->highest_bit = 1;
 147
 148         rb_dlinkAdd(idx, &idx->node, &capability_indexes);
 149
 150         return idx;
 151 }
 152
 153 void
 154 capability_index_destroy(struct CapabilityIndex *idx)
 155 {
 156         s_assert(idx != NULL);
 157
 158         rb_dlinkDelete(&idx->node, &capability_indexes);
 159
 160         irc_dictionary_destroy(idx->cap_dict, capability_destroy, NULL);
 161         rb_free(idx);
 162 }
 163
 164 const char *
 165 capability_index_list(struct CapabilityIndex *idx, unsigned int cap_mask)
 166 {
 167         struct DictionaryIter iter;
 168         struct CapabilityEntry *entry;
 169         static char buf[BUFSIZE];
 170         char *t = buf;
 171         int tl;
 172
 173         s_assert(idx != NULL);
 174
 175         *t = '\0';
 176
 177         DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 178         {
 179                 if ((1 << entry->value) & cap_mask)
 180                 {
 181                         tl = rb_sprintf(t, "%s ", entry->cap);
 182                         t += tl;
 183                 }
 184         }
 185
 186         t--;
 187         *t = '\0';
 188
 189         return buf;
 190 }
 191
 192 unsigned int
 193 capability_index_mask(struct CapabilityIndex *idx)
 194 {
 195         struct DictionaryIter iter;
 196         struct CapabilityEntry *entry;
 197         unsigned int mask = 0;
 198
 199         s_assert(idx != NULL);
 200
 201         DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 202         {
 203                 if (!(entry->flags & CAP_ORPHANED))
 204                         mask |= (1 << entry->value);
 205         }
 206
 207         return mask;
 208 }
 209
 210 unsigned int
 211 capability_index_get_required(struct CapabilityIndex *idx)
 212 {
 213         struct DictionaryIter iter;
 214         struct CapabilityEntry *entry;
 215         unsigned int mask = 0;
 216
 217         s_assert(idx != NULL);
 218
 219         DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 220         {
 221                 if (!(entry->flags & CAP_ORPHANED) && (entry->flags & CAP_REQUIRED))
 222                         mask |= (1 << entry->value);
 223         }
 224
 225         return mask;
 226 }
 227
 228 void
 229 capability_index_stats(void (*cb)(const char *line, void *privdata), void *privdata)
 230 {
 231         rb_dlink_node *node;
 232         char buf[BUFSIZE];
 233
 234         RB_DLINK_FOREACH(node, capability_indexes.head)
 235         {
 236                 struct CapabilityIndex *idx = node->data;
 237                 struct DictionaryIter iter;
 238                 struct CapabilityEntry *entry;
 239
 240                 rb_snprintf(buf, sizeof buf, "'%s': allocated bits - %d", idx->name, (idx->highest_bit - 1));
 241                 cb(buf, privdata);
 242
 243                 DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 244                 {
 245                         rb_snprintf(buf, sizeof buf, "bit %d: '%s'", entry->value, entry->cap);
 246                         cb(buf, privdata);
 247                 }
 248
 249                 rb_snprintf(buf, sizeof buf, "'%s': remaining bits - %ld", idx->name,
 250                             (sizeof(unsigned int) * 8) - (idx->highest_bit - 1));
 251                 cb(buf, privdata);
 252         }
 253
 254         rb_snprintf(buf, sizeof buf, "%ld capability indexes", rb_dlink_list_length(&capability_indexes));
 255         cb(buf, privdata);
 256 }