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
  50         entry = irc_dictionary_retrieve(idx->cap_dict, cap);
  51         if (entry != NULL && !(entry->flags & CAP_ORPHANED))
  52                 return (1 << entry->value);
  53
  54         return 0;
  55 }
  56
  57 unsigned int
  58 capability_put(struct CapabilityIndex *idx, const char *cap)
  59 {
  60         struct CapabilityEntry *entry;
  61
  62         s_assert(idx != NULL);
  63         if (!idx->highest_bit)
  64                 return 0xFFFFFFFF;
  65
  66         if ((entry = irc_dictionary_retrieve(idx->cap_dict, cap)) != NULL)
  67         {
  68                 entry->flags &= ~CAP_ORPHANED;
  69                 return (1 << entry->value);
  70         }
  71
  72         entry = rb_malloc(sizeof(struct CapabilityEntry));
  73         entry->cap = rb_strdup(cap);
  74         entry->flags = 0;
  75         entry->value = idx->highest_bit;
  76
  77         irc_dictionary_add(idx->cap_dict, entry->cap, entry);
  78
  79         idx->highest_bit++;
  80         if (idx->highest_bit % (sizeof(unsigned int) * 8) == 0)
  81                 idx->highest_bit = 0;
  82
  83         return (1 << entry->value);
  84 }
  85
  86 void
  87 capability_orphan(struct CapabilityIndex *idx, const char *cap)
  88 {
  89         struct CapabilityEntry *entry;
  90
  91         s_assert(idx != NULL);
  92
  93         entry = irc_dictionary_retrieve(idx->cap_dict, cap);
  94         if (entry != NULL)
  95         {
  96                 entry->flags &= ~CAP_REQUIRED;
  97                 entry->flags |= CAP_ORPHANED;
  98         }
  99 }
 100
 101 void
 102 capability_require(struct CapabilityIndex *idx, const char *cap)
 103 {
 104         struct CapabilityEntry *entry;
 105
 106         s_assert(idx != NULL);
 107
 108         entry = irc_dictionary_retrieve(idx->cap_dict, cap);
 109         if (entry != NULL)
 110                 entry->flags |= CAP_REQUIRED;
 111 }
 112
 113 static void
 114 capability_destroy(struct DictionaryElement *delem, void *privdata)
 115 {
 116         s_assert(delem != NULL);
 117
 118         rb_free(delem->data);
 119 }
 120
 121 struct CapabilityIndex *
 122 capability_index_create(const char *name)
 123 {
 124         struct CapabilityIndex *idx;
 125
 126         idx = rb_malloc(sizeof(struct CapabilityIndex));
 127         idx->name = rb_strdup(name);
 128         idx->cap_dict = irc_dictionary_create(strcasecmp);
 129         idx->highest_bit = 1;
 130
 131         rb_dlinkAdd(idx, &idx->node, &capability_indexes);
 132
 133         return idx;
 134 }
 135
 136 void
 137 capability_index_destroy(struct CapabilityIndex *idx)
 138 {
 139         s_assert(idx != NULL);
 140
 141         rb_dlinkDelete(&idx->node, &capability_indexes);
 142
 143         irc_dictionary_destroy(idx->cap_dict, capability_destroy, NULL);
 144         rb_free(idx);
 145 }
 146
 147 const char *
 148 capability_index_list(struct CapabilityIndex *idx, unsigned int cap_mask)
 149 {
 150         struct DictionaryIter iter;
 151         struct CapabilityEntry *entry;
 152         static char buf[BUFSIZE];
 153         char *t = buf;
 154         int tl;
 155
 156         s_assert(idx != NULL);
 157
 158         *t = '\0';
 159
 160         DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 161         {
 162                 if ((1 << entry->value) & cap_mask)
 163                 {
 164                         tl = rb_sprintf(t, "%s ", entry->cap);
 165                         t += tl;
 166                 }
 167         }
 168
 169         t--;
 170         *t = '\0';
 171
 172         return buf;
 173 }
 174
 175 unsigned int
 176 capability_index_mask(struct CapabilityIndex *idx)
 177 {
 178         struct DictionaryIter iter;
 179         struct CapabilityEntry *entry;
 180         unsigned int mask = 0;
 181
 182         s_assert(idx != NULL);
 183
 184         DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 185         {
 186                 if (!(entry->flags & CAP_ORPHANED))
 187                         mask |= (1 << entry->value);
 188         }
 189
 190         return mask;
 191 }
 192
 193 unsigned int
 194 capability_index_get_required(struct CapabilityIndex *idx)
 195 {
 196         struct DictionaryIter iter;
 197         struct CapabilityEntry *entry;
 198         unsigned int mask = 0;
 199
 200         s_assert(idx != NULL);
 201
 202         DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 203         {
 204                 if (!(entry->flags & CAP_ORPHANED) && (entry->flags & CAP_REQUIRED))
 205                         mask |= (1 << entry->value);
 206         }
 207
 208         return mask;
 209 }
 210
 211 void
 212 capability_index_stats(void (*cb)(const char *line, void *privdata), void *privdata)
 213 {
 214         rb_dlink_node *node;
 215         char buf[BUFSIZE];
 216
 217         RB_DLINK_FOREACH(node, capability_indexes.head)
 218         {
 219                 struct CapabilityIndex *idx = node->data;
 220                 struct DictionaryIter iter;
 221                 struct CapabilityEntry *entry;
 222
 223                 rb_snprintf(buf, sizeof buf, "'%s': allocated bits - %d", idx->name, (idx->highest_bit - 1));
 224                 cb(buf, privdata);
 225
 226                 DICTIONARY_FOREACH(entry, &iter, idx->cap_dict)
 227                 {
 228                         rb_snprintf(buf, sizeof buf, "bit %d: '%s'", entry->value, entry->cap);
 229                         cb(buf, privdata);
 230                 }
 231
 232                 rb_snprintf(buf, sizeof buf, "'%s': remaining bits - %ld", idx->name,
 233                             (sizeof(unsigned int) * 8) - (idx->highest_bit - 1));
 234                 cb(buf, privdata);
 235         }
 236
 237         rb_snprintf(buf, sizeof buf, "%ld capability indexes", rb_dlink_list_length(&capability_indexes));
 238         cb(buf, privdata);
 239 }