ChanNode.c

   1 #include "ChanNode.h"
   2 #include "ChanUser.h"
   3 #include "UserNode.h"
   4
   5 static struct ChanNode **chanList;
   6 static int modes_with_strarg, modes_with_intarg;
   7
   8 //Types: http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt
   9 #define CHANNEL_MODE_TYPE_A        0x01 /* ... special (addresses or users) ... */
  10 #define CHANNEL_MODE_TYPE_B        0x02 /* These modes always take a parameter. */
  11 #define CHANNEL_MODE_TYPE_C        0x03 /* These modes take a parameter only when set. */
  12 #define CHANNEL_MODE_TYPE_D        0x04 /* These modes never take a parameter. */
  13 #define CHANNEL_MODE_TYPE          0x07 /* bit mask to get the type */
  14
  15 #define CHANNEL_MODE_VALUE_STRING  0x10
  16 #define CHANNEL_MODE_VALUE_INTEGER 0x20
  17 #define CHANNEL_MODE_VALUE         0x30 /* bit mask to get the value */
  18
  19 #define CHANNEL_MODE_VALUE_INDEX_SHIFT 8
  20 #define CHANNEL_MODE_VALUE_INDEX_MASK  (0xff << CHANNEL_MODE_VALUE_INDEX_SHIFT) /* this "bitrange" is reserved for storing the array indexes of the mode values */
  21
  22 static unsigned char valid_modes[] = { /* Thats our mode list :P */
  23     1,  'b', CHANNEL_MODE_TYPE_A,
  24     2,  'o', CHANNEL_MODE_TYPE_A,
  25     3,  'v', CHANNEL_MODE_TYPE_A,
  26     4,  'k', CHANNEL_MODE_TYPE_B | CHANNEL_MODE_VALUE_STRING,
  27     5,  'a', CHANNEL_MODE_TYPE_C | CHANNEL_MODE_VALUE_INTEGER,
  28     6,  'l', CHANNEL_MODE_TYPE_C | CHANNEL_MODE_VALUE_INTEGER,
  29     7,  'f', CHANNEL_MODE_TYPE_C | CHANNEL_MODE_VALUE_STRING,
  30     8,  'F', CHANNEL_MODE_TYPE_C | CHANNEL_MODE_VALUE_STRING,
  31     9,  'c', CHANNEL_MODE_TYPE_D,
  32     10, 'C', CHANNEL_MODE_TYPE_D,
  33     11, 'i', CHANNEL_MODE_TYPE_D,
  34     12, 'm', CHANNEL_MODE_TYPE_D,
  35     13, 'M', CHANNEL_MODE_TYPE_D,
  36     14, 'n', CHANNEL_MODE_TYPE_D,
  37     15, 'N', CHANNEL_MODE_TYPE_D,
  38     16, 'p', CHANNEL_MODE_TYPE_D,
  39     17, 'r', CHANNEL_MODE_TYPE_D,
  40     18, 's', CHANNEL_MODE_TYPE_D,
  41     19, 't', CHANNEL_MODE_TYPE_D,
  42     20, 'u', CHANNEL_MODE_TYPE_D,
  43     21, 'D', CHANNEL_MODE_TYPE_D,
  44     22, 'd', CHANNEL_MODE_TYPE_D,
  45     23, 'R', CHANNEL_MODE_TYPE_D,
  46     24, 'z', CHANNEL_MODE_TYPE_D,
  47 //  ^ maximum is 32!!!
  48     0x00, 0x00, 0x00
  49 };
  50
  51 void init_ChanNode() {
  52     /*
  53      len pos chars
  54      26  0   a-z
  55      10  26  0-9
  56      10  36  {|}~[\]^_`
  57      1   46  *everything else*
  58      ---------------------------
  59      = 47
  60     */
  61     chanList = calloc(47, sizeof(*chanList));
  62     unsigned int *mode, flag = 1;
  63     modes_with_strarg = 0;
  64     modes_with_intarg = 0;
  65     for (mode = valid_modes; mode[1]; mode += 3) {
  66         if((mode[2] & CHANNEL_MODE_VALUE) == CHANNEL_MODE_VALUE_STRING) {
  67             mode[2] |= modes_with_strarg << CHANNEL_MODE_VALUE_INDEX_SHIFT;
  68             modes_with_strarg++;
  69         }
  70         if((mode[2] & CHANNEL_MODE_VALUE) == CHANNEL_MODE_VALUE_INTEGER) {
  71             mode[2] |= modes_with_intarg << CHANNEL_MODE_VALUE_INDEX_SHIFT;
  72             modes_with_intarg++;
  73         }
  74         mode[0] = flag;
  75         flag = flag << 1;
  76     }
  77 }
  78
  79 int is_valid_chan(const char *name) {
  80     unsigned int ii;
  81     if (*name !='#')
  82         return 0;
  83     for (ii=1; name[ii]; ++ii) {
  84         if ((name[ii] > 0) && (name[ii] <= 32))
  85             return 0;
  86         if (name[ii] == ',')
  87             return 0;
  88         if (name[ii] == '\xa0')
  89             return 0;
  90     }
  91     return 1;
  92 }
  93
  94 static int get_chanlist_entry(int name) {
  95     if((name > 0 && name <= 32) || name == ',' || name == '\xa0') return -1; //invalid name
  96     if(tolower(name) >= 97 && tolower(name) <= 122) {
  97         return (tolower(name) - 97);
  98     }
  99     if(tolower(name) >= 48 && tolower(name) <= 57) {
 100         return (tolower(name) - 48 + 26);
 101     }
 102     /* {|}~[\]^_` */
 103     if(name == '{') return 36;
 104     if(name == '|') return 37;
 105     if(name == '}') return 38;
 106     if(name == '~') return 39;
 107     if(name == '[') return 40;
 108     if(name == '\\') return 41;
 109     if(name == ']') return 42;
 110     if(name == '^') return 43;
 111     if(name == '_') return 44;
 112     if(name == '`') return 45;
 113     return 46;
 114 }
 115
 116 struct ChanNode* getChanByName(const char *name) { //case insensitive
 117     int chanListIndex = get_chanlist_entry(name[1]);
 118     if(chanListIndex == -1 || chanList[chanListIndex] == NULL)
 119         return NULL;
 120     struct ChanNode *chan;
 121     for(chan = chanList[chanListIndex]; chan; chan = chan->next) {
 122         if(!stricmp(name, chan->name))
 123             return chan;
 124     }
 125     return NULL;
 126 }
 127
 128 struct ChanNode* addChannel(const char *name) {
 129     int chanListIndex = get_chanlist_entry(name[1]);
 130     if(chanListIndex == -1 || !is_valid_chan(name))
 131         return NULL;
 132     struct ChanNode *chan = malloc(sizeof(*chan));
 133     if (!chan)
 134     {
 135         perror("malloc() failed");
 136         return NULL;
 137     }
 138     strcpy(chan->name, name);
 139     chan->user = NULL;
 140     chan->chanbot = NULL;
 141     chan->topic[0] = 0;
 142     chan->flags = 0;
 143     /* mode lists */
 144     chan->mode_str_args = calloc(modes_with_strarg, sizeof(char*));
 145     chan->mode_int_args = calloc(modes_with_intarg, sizeof(int));
 146
 147     chan->next = chanList[chanListIndex];
 148     chanList[chanListIndex] = chan;
 149     return chan;
 150 }
 151
 152 void delChannel(struct ChanNode* chan, int freeChan) {
 153     int chanListIndex = get_chanlist_entry(chan->name[1]);
 154     if(chanListIndex == -1) return;
 155     struct ChanNode *cchan, *last_chan = NULL;
 156     for(cchan = chanList[chanListIndex]; cchan; cchan = cchan->next) {
 157         if(cchan == chan) {
 158             if(last_chan)
 159                 last_chan->next = chan->next;
 160             else
 161                 chanList[chanListIndex] = chan->next;
 162             break;
 163         } else
 164             last_chan = cchan;
 165     }
 166     if(chan->user) {
 167         //free all chanusers
 168         struct ChanUser *chanuser, *next;
 169         for(chanuser = getChannelUsers(chan, NULL); chanuser; chanuser = next) {
 170             next = getChannelUsers(chan, chanuser);
 171             removeChanUserFromLists(chanuser, 0, 1, 1);
 172         }
 173     }
 174     if(freeChan)
 175         freeChanNode(chan);
 176     else
 177         chan->next = NULL;
 178 }
 179
 180 void freeChanNode(struct ChanNode* chan) {
 181     int i;
 182     for(i = 0; i < modes_with_strarg; i++) {
 183         if(chan->mode_str_args[i])
 184             free(chan->mode_str_args[i]);
 185     }
 186     free(chan->mode_str_args);
 187     free(chan->mode_int_args);
 188     free(chan);
 189 }
 190
 191 void checkChannelVisibility(struct ChanNode* chan) {
 192     struct ChanUser *chanuser, *next;
 193     for(chanuser = getChannelUsers(chan, NULL); chanuser; chanuser = getChannelUsers(chan, chanuser)) {
 194         if(chanuser->user->flags & USERFLAG_ISBOT) {
 195             chan->chanbot = chanuser->user;
 196             return;
 197         }
 198     }
 199     //free the channel...
 200     for(chanuser = getChannelUsers(chan, NULL); chanuser; chanuser = next) {
 201         next = getChannelUsers(chan, chanuser);
 202         //remove the channel from the user's channel-list
 203         removeChanUserFromLists(chanuser, 0, 1, 0);
 204         if(!chanuser->user->channel) {
 205             //free the user (no more channels)
 206             delUser(chanuser->user, 1);
 207         }
 208         free(chanuser);
 209     }
 210     chan->user = NULL;
 211     delChannel(chan, 1);
 212 }
 213
 214 static int* getModeOptions(char mode) {
 215     unsigned int *cmode;
 216     for (cmode = valid_modes; cmode[1]; cmode += 3) {
 217         if(cmode[1] == mode)
 218             return cmode;
 219     }
 220     return NULL;
 221 }
 222
 223 int isModeSet(struct ChanNode* chan, char modeChar) {
 224     int *modeOpt = getModeOptions(modeChar);
 225     return (chan->modes & modeOpt[0])
 226 }
 227
 228 void* getModeValue(struct ChanNode* chan, char modeChar) {
 229     int *modeOpt = getModeOptions(modeChar);
 230     int index = (modeOpt[2] & CHANNEL_MODE_VALUE_INDEX_MASK) >> CHANNEL_MODE_VALUE_INDEX_SHIFT;
 231     if((mode[2] & CHANNEL_MODE_VALUE) == CHANNEL_MODE_VALUE_STRING)
 232         return chan->mode_str_args[index];
 233     if((mode[2] & CHANNEL_MODE_VALUE) == CHANNEL_MODE_VALUE_INTEGER)
 234         return chan->mode_int_args[index];
 235     return NULL;
 236 }
 237
 238 void parseModes(struct ChanNode* chan, char *modeStr, char **argv, int argc) {
 239     int i, argpos = 0, add = 1;
 240     #define MODE_TYPE modeOpt[2] & CHANNEL_MODE_TYPE
 241     #define MODE_VALUE modeOpt[2] & CHANNEL_MODE_VALUE
 242     #define MODE_VALUE_INDEX (modeOpt[2] & CHANNEL_MODE_VALUE_INDEX_MASK) >> CHANNEL_MODE_VALUE_INDEX_SHIFT
 243     int *modeOpt;
 244     for(i = 0; i < strlen(modeStr); i++) {
 245         if(modeStr[i] == '+') {
 246             add = 1;
 247             continue;
 248         }
 249         if(modeStr[i] == '-') {
 250             add = 0;
 251             continue;
 252         }
 253         modeOpt = getModeOptions(modeStr[i]);
 254         if(!modeOpt) continue; // unknown mode?
 255         if(MODE_TYPE == CHANNEL_MODE_TYPE_A) {
 256             //special mode ;)
 257             continue;
 258         }
 259         if(add) {
 260             if(MODE_TYPE != CHANNEL_MODE_TYPE_D) { //all other types take parameters when set
 261                 if(argpos == argc) continue;
 262                 if(MODE_VALUE == CHANNEL_MODE_VALUE_STRING) {
 263                     if(chan->mode_str_args[MODE_VALUE_INDEX])
 264                         free(chan->mode_str_args[MODE_VALUE_INDEX]);
 265                     chan->mode_str_args[MODE_VALUE_INDEX] = strdup(argv[argc++]);
 266                 } else if(MODE_VALUE == CHANNEL_MODE_VALUE_INTEGER)
 267                     chan->mode_int_args[MODE_VALUE_INDEX] = atoi(argv[argc++]);
 268                 else
 269                     argc++; //we simply don't know what to do with the argument...
 270             }
 271             chan->modes |= modeOpt[0];
 272         } else {
 273             chan->modes &= ~modeOpt[0];
 274             if(MODE_TYPE == CHANNEL_MODE_TYPE_B) {
 275                 if(argpos == argc) continue;
 276                 if(MODE_VALUE == CHANNEL_MODE_VALUE_STRING) {
 277                     free(chan->mode_str_args[MODE_VALUE_INDEX]);
 278                     chan->mode_str_args[MODE_VALUE_INDEX] = NULL;
 279                 } else if(MODE_VALUE == CHANNEL_MODE_VALUE_INTEGER)
 280                     chan->mode_int_args[MODE_VALUE_INDEX] = 0;
 281                 argc++; //we don't need the argument when unsetting a mode...
 282             }
 283         }
 284     }
 285     #undef MODE_TYPE
 286     #undef MODE_VALUE
 287     #undef MODE_VALUE_INDEX
 288 }
 289
 290