ChanNode.c

   1 #include "ChanNode.h"
   2 #include "ChanUser.h"
   3 #include "UserNode.h"
   4 #include "BanNode.h"
   5 #include "modcmd.h"
   6
   7 static struct ChanNode **chanList;
   8 static int modes_with_strarg, modes_with_intarg;
   9
  10 //Types: http://www.irc.org/tech_docs/draft-brocklesby-irc-isupport-03.txt
  11 #define CHANNEL_MODE_TYPE_A        0x01 /* ... special (addresses or users) ... */
  12 #define CHANNEL_MODE_TYPE_B        0x02 /* These modes always take a parameter. */
  13 #define CHANNEL_MODE_TYPE_C        0x03 /* These modes take a parameter only when set. */
  14 #define CHANNEL_MODE_TYPE_D        0x04 /* These modes never take a parameter. */
  15 #define CHANNEL_MODE_TYPE          0x07 /* bit mask to get the type */
  16
  17 #define CHANNEL_MODE_VALUE_STRING  0x10
  18 #define CHANNEL_MODE_VALUE_INTEGER 0x20
  19 #define CHANNEL_MODE_VALUE         0x30 /* bit mask to get the value */
  20
  21 #define CHANNEL_MODE_VALUE_INDEX_SHIFT 8
  22 #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 */
  23
  24 static unsigned int valid_modes[] = { /* Thats our mode list :P */
  25     1,  'b', CHANNEL_MODE_TYPE_A,
  26     2,  'o', CHANNEL_MODE_TYPE_A,
  27     3,  'v', CHANNEL_MODE_TYPE_A,
  28     4,  'k', CHANNEL_MODE_TYPE_B | CHANNEL_MODE_VALUE_STRING,
  29     5,  'a', CHANNEL_MODE_TYPE_C | CHANNEL_MODE_VALUE_INTEGER,
  30     6,  'l', CHANNEL_MODE_TYPE_C | CHANNEL_MODE_VALUE_INTEGER,
  31     7,  'f', CHANNEL_MODE_TYPE_C | CHANNEL_MODE_VALUE_STRING,
  32     8,  'F', CHANNEL_MODE_TYPE_C | CHANNEL_MODE_VALUE_STRING,
  33     9,  'c', CHANNEL_MODE_TYPE_D,
  34     10, 'C', CHANNEL_MODE_TYPE_D,
  35     11, 'i', CHANNEL_MODE_TYPE_D,
  36     12, 'm', CHANNEL_MODE_TYPE_D,
  37     13, 'M', CHANNEL_MODE_TYPE_D,
  38     14, 'n', CHANNEL_MODE_TYPE_D,
  39     15, 'N', CHANNEL_MODE_TYPE_D,
  40     16, 'p', CHANNEL_MODE_TYPE_D,
  41     17, 'r', CHANNEL_MODE_TYPE_D,
  42     18, 's', CHANNEL_MODE_TYPE_D,
  43     19, 't', CHANNEL_MODE_TYPE_D,
  44     20, 'u', CHANNEL_MODE_TYPE_D,
  45     21, 'D', CHANNEL_MODE_TYPE_D,
  46     22, 'd', CHANNEL_MODE_TYPE_D,
  47     23, 'R', CHANNEL_MODE_TYPE_D,
  48     24, 'z', CHANNEL_MODE_TYPE_D,
  49 //  ^ maximum is 32!!!
  50     0x00, 0x00, 0x00
  51 };
  52
  53 void init_ChanNode() {
  54     /*
  55      len pos chars
  56      26  0   a-z
  57      10  26  0-9
  58      10  36  {|}~[\]^_`
  59      1   46  *everything else*
  60      ---------------------------
  61      = 47
  62     */
  63     #define CHANNEL_LIST_SIZE 47
  64     chanList = calloc(CHANNEL_LIST_SIZE, sizeof(*chanList));
  65     unsigned int *mode, flag = 1;
  66     modes_with_strarg = 0;
  67     modes_with_intarg = 0;
  68     for (mode = valid_modes; mode[1]; mode += 3) {
  69         if((mode[2] & CHANNEL_MODE_VALUE) == CHANNEL_MODE_VALUE_STRING) {
  70             mode[2] |= modes_with_strarg << CHANNEL_MODE_VALUE_INDEX_SHIFT;
  71             modes_with_strarg++;
  72         }
  73         if((mode[2] & CHANNEL_MODE_VALUE) == CHANNEL_MODE_VALUE_INTEGER) {
  74             mode[2] |= modes_with_intarg << CHANNEL_MODE_VALUE_INDEX_SHIFT;
  75             modes_with_intarg++;
  76         }
  77         mode[0] = flag;
  78         flag = flag << 1;
  79     }
  80 }
  81
  82 void free_ChanNode() {
  83     //kamikaze free all channels and chanusers
  84     int i;
  85     struct ChanNode *chan, *next;
  86     struct ChanUser *chanuser, *next_chanuser;
  87     for(i = 0; i < CHANNEL_LIST_SIZE; i++) {
  88         for(chan = chanList[i]; chan; chan = next) {
  89             next = chan->next;
  90             for(chanuser = getChannelUsers(chan, NULL); chanuser; chanuser = next_chanuser) {
  91                 next_chanuser = getChannelUsers(chan, chanuser);
  92                 free(chanuser);
  93             }
  94             freeChanNode(chan);
  95         }
  96     }
  97     free(chanList);
  98 }
  99
 100 int is_valid_chan(const char *name) {
 101     unsigned int ii;
 102     if (*name !='#')
 103         return 0;
 104     for (ii=1; name[ii]; ++ii) {
 105         if ((name[ii] > 0) && (name[ii] <= 32))
 106             return 0;
 107         if (name[ii] == ',')
 108             return 0;
 109         if (name[ii] == '\xa0')
 110             return 0;
 111     }
 112     return 1;
 113 }
 114
 115 static int get_chanlist_entry(int name) {
 116     if((name > 0 && name <= 32) || name == ',' || name == '\xa0') return -1; //invalid name
 117     if(tolower(name) >= 97 && tolower(name) <= 122) {
 118         return (tolower(name) - 97);
 119     }
 120     if(tolower(name) >= 48 && tolower(name) <= 57) {
 121         return (tolower(name) - 48 + 26);
 122     }
 123     /* {|}~[\]^_` */
 124     if(name == '{') return 36;
 125     if(name == '|') return 37;
 126     if(name == '}') return 38;
 127     if(name == '~') return 39;
 128     if(name == '[') return 40;
 129     if(name == '\\') return 41;
 130     if(name == ']') return 42;
 131     if(name == '^') return 43;
 132     if(name == '_') return 44;
 133     if(name == '`') return 45;
 134     return 46;
 135 }
 136
 137 struct ChanNode* getChanByName(const char *name) { //case insensitive
 138     int chanListIndex = get_chanlist_entry(name[1]);
 139     if(chanListIndex == -1 || chanList[chanListIndex] == NULL)
 140         return NULL;
 141     struct ChanNode *chan;
 142     for(chan = chanList[chanListIndex]; chan; chan = chan->next) {
 143         if(!stricmp(name, chan->name))
 144             return chan;
 145     }
 146     return NULL;
 147 }
 148
 149 struct ChanNode* addChannel(const char *name) {
 150     int chanListIndex = get_chanlist_entry(name[1]);
 151     if(chanListIndex == -1 || !is_valid_chan(name))
 152         return NULL;
 153     struct ChanNode *chan = malloc(sizeof(*chan));
 154     if (!chan)
 155     {
 156         perror("malloc() failed");
 157         return NULL;
 158     }
 159     strcpy(chan->name, name);
 160     chan->user = NULL;
 161     chan->bans = NULL;
 162     chan->usercount = 0;
 163     chan->chanbot = NULL;
 164     chan->topic[0] = 0;
 165     chan->flags = 0;
 166     /* mode lists */
 167     chan->modes = 0;
 168     chan->trigger = NULL;
 169     chan->mode_str_args = calloc(modes_with_strarg, sizeof(char*));
 170     chan->mode_int_args = calloc(modes_with_intarg, sizeof(int));
 171
 172     chan->next = chanList[chanListIndex];
 173     chanList[chanListIndex] = chan;
 174     return chan;
 175 }
 176
 177 int getChannelCount() {
 178     int i, count = 0;
 179     struct ChanNode *chan;
 180     for(i = 0; i < CHANNEL_LIST_SIZE; i++) {
 181         for(chan = chanList[i]; chan; chan = chan->next) {
 182             count++;
 183         }
 184     }
 185     return count;
 186 }
 187
 188 int getChanUserCount() {
 189     int i, count = 0;
 190     struct ChanNode *chan;
 191     for(i = 0; i < CHANNEL_LIST_SIZE; i++) {
 192         for(chan = chanList[i]; chan; chan = chan->next) {
 193             count += chan->usercount;
 194         }
 195     }
 196     return count;
 197 }
 198
 199 void delChannel(struct ChanNode* chan, int freeChan) {
 200     int chanListIndex = get_chanlist_entry(chan->name[1]);
 201     if(chanListIndex == -1) return;
 202     struct ChanNode *cchan, *last_chan = NULL;
 203     for(cchan = chanList[chanListIndex]; cchan; cchan = cchan->next) {
 204         if(cchan == chan) {
 205             if(last_chan)
 206                 last_chan->next = chan->next;
 207             else
 208                 chanList[chanListIndex] = chan->next;
 209             break;
 210         } else
 211             last_chan = cchan;
 212     }
 213     if(chan->user) {
 214         //free all chanusers
 215         struct ChanUser *chanuser, *next;
 216         for(chanuser = getChannelUsers(chan, NULL); chanuser; chanuser = next) {
 217             next = getChannelUsers(chan, chanuser);
 218             removeChanUserFromLists(chanuser, 0, 1, 1);
 219         }
 220     }
 221     if(freeChan)
 222         freeChanNode(chan);
 223     else
 224         chan->next = NULL;
 225 }
 226
 227 void freeChanNode(struct ChanNode* chan) {
 228     int i;
 229     for(i = 0; i < modes_with_strarg; i++) {
 230         if(chan->mode_str_args[i])
 231             free(chan->mode_str_args[i]);
 232     }
 233     if(chan->trigger) {
 234         struct trigger_cache *trigger, *next_trigger;
 235         for(trigger = chan->trigger; trigger; trigger = next_trigger) {
 236             next_trigger = trigger;
 237             free(trigger->trigger);
 238             free(trigger);
 239         }
 240     }
 241     free(chan->mode_str_args);
 242     free(chan->mode_int_args);
 243     if(chan->bans)
 244         removeChannelBans(chan);
 245     free(chan);
 246 }
 247
 248 void checkChannelVisibility(struct ChanNode* chan) {
 249     struct ChanUser *chanuser, *next;
 250     for(chanuser = getChannelUsers(chan, NULL); chanuser; chanuser = getChannelUsers(chan, chanuser)) {
 251         if(chanuser->user->flags & USERFLAG_ISBOT) {
 252             chan->chanbot = chanuser->user;
 253             return;
 254         }
 255     }
 256     //free the channel...
 257     for(chanuser = getChannelUsers(chan, NULL); chanuser; chanuser = next) {
 258         next = getChannelUsers(chan, chanuser);
 259         //remove the channel from the user's channel-list
 260         removeChanUserFromLists(chanuser, 0, 1, 0);
 261         if(!chanuser->user->channel) {
 262             //free the user (no more channels)
 263             delUser(chanuser->user, 1);
 264         }
 265         free(chanuser);
 266     }
 267     chan->user = NULL;
 268     delChannel(chan, 1);
 269 }
 270
 271 static unsigned int* getModeOptions(char mode) {
 272     unsigned int *cmode;
 273     for (cmode = valid_modes; cmode[1]; cmode += 3) {
 274         if(cmode[1] == mode)
 275             return cmode;
 276     }
 277     return NULL;
 278 }
 279
 280 int isModeSet(struct ChanNode* chan, char modeChar) {
 281     unsigned int *modeOpt = getModeOptions(modeChar);
 282     return (chan->modes & modeOpt[0]);
 283 }
 284
 285 void* getModeValue(struct ChanNode* chan, char modeChar) {
 286     #define MODE_VALUE_INDEX (modeOpt[2] & CHANNEL_MODE_VALUE_INDEX_MASK) >> CHANNEL_MODE_VALUE_INDEX_SHIFT
 287     unsigned int *modeOpt = getModeOptions(modeChar);
 288     if((modeOpt[2] & CHANNEL_MODE_VALUE) == CHANNEL_MODE_VALUE_STRING)
 289         return chan->mode_str_args[MODE_VALUE_INDEX];
 290     if((modeOpt[2] & CHANNEL_MODE_VALUE) == CHANNEL_MODE_VALUE_INTEGER)
 291         return &chan->mode_int_args[MODE_VALUE_INDEX];
 292     return NULL;
 293     #undef MODE_VALUE_INDEX
 294 }
 295
 296 static void parseModesUserPriv(struct ChanNode* chan, unsigned char flag, int add, char *nick) {
 297     struct UserNode *user = getUserByNick(nick);
 298     if(user == NULL) return;
 299     struct ChanUser *chanuser = getChanUser(user, chan);
 300     if(chanuser == NULL) return;
 301     if(add)
 302         chanuser->flags |= flag;
 303     else
 304         chanuser->flags &= ~flag;
 305 }
 306
 307 static void parseModesBan(struct ChanNode* chan, int add, char *mask) {
 308     if(add)
 309         addChannelBan(chan, mask);
 310     else
 311         removeChannelBanMask(chan, mask);
 312 }
 313
 314 void parseModes(struct ChanNode* chan, char *modeStr, char **argv, int argc) {
 315     int i, argpos = 0, add = 1;
 316     #define MODE_TYPE (modeOpt[2] & CHANNEL_MODE_TYPE)
 317     #define MODE_VALUE (modeOpt[2] & CHANNEL_MODE_VALUE)
 318     #define MODE_VALUE_INDEX (modeOpt[2] & CHANNEL_MODE_VALUE_INDEX_MASK) >> CHANNEL_MODE_VALUE_INDEX_SHIFT
 319     unsigned int *modeOpt;
 320     for(i = 0; i < strlen(modeStr); i++) {
 321         if(modeStr[i] == '+') {
 322             add = 1;
 323             continue;
 324         }
 325         if(modeStr[i] == '-') {
 326             add = 0;
 327             continue;
 328         }
 329         modeOpt = getModeOptions(modeStr[i]);
 330         if(!modeOpt) continue; // unknown mode?
 331         if(MODE_TYPE == CHANNEL_MODE_TYPE_A) {
 332             if(argpos == argc) continue;
 333             //special mode ;)
 334             switch(modeStr[i]) {
 335                 case 'o':
 336                     parseModesUserPriv(chan, CHANUSERFLAG_OPPED, add, argv[argpos]);
 337                     break;
 338                 case 'v':
 339                     parseModesUserPriv(chan, CHANUSERFLAG_VOICED, add, argv[argpos]);
 340                     break;
 341                 case 'b':
 342                     parseModesBan(chan, add, argv[argpos]);
 343                     break;
 344                 default:
 345                     //we have an unknown TYPE_A mode???
 346                     break;
 347             }
 348             argpos++;
 349             continue;
 350         }
 351         if(add) {
 352             if(MODE_TYPE != CHANNEL_MODE_TYPE_D) { //all other types take parameters when set
 353                 if(argpos == argc) continue;
 354                 if(MODE_VALUE == CHANNEL_MODE_VALUE_STRING) {
 355                     if(chan->mode_str_args[MODE_VALUE_INDEX])
 356                         free(chan->mode_str_args[MODE_VALUE_INDEX]);
 357                     chan->mode_str_args[MODE_VALUE_INDEX] = strdup(argv[argpos++]);
 358                 } else if(MODE_VALUE == CHANNEL_MODE_VALUE_INTEGER)
 359                     chan->mode_int_args[MODE_VALUE_INDEX] = atoi(argv[argpos++]);
 360                 else
 361                     argpos++; //we simply don't know what to do with the argument...
 362             }
 363             chan->modes |= modeOpt[0];
 364         } else {
 365             chan->modes &= ~modeOpt[0];
 366             if(MODE_TYPE == CHANNEL_MODE_TYPE_B) {
 367                 if(argpos == argc) continue;
 368                 if(MODE_VALUE == CHANNEL_MODE_VALUE_STRING) {
 369                     free(chan->mode_str_args[MODE_VALUE_INDEX]);
 370                     chan->mode_str_args[MODE_VALUE_INDEX] = NULL;
 371                 } else if(MODE_VALUE == CHANNEL_MODE_VALUE_INTEGER)
 372                     chan->mode_int_args[MODE_VALUE_INDEX] = 0;
 373                 argpos++; //we don't need the argument when unsetting a mode...
 374             }
 375         }
 376     }
 377     #undef MODE_TYPE
 378     #undef MODE_VALUE
 379     #undef MODE_VALUE_INDEX
 380 }
 381
 382 void getModeString(struct ChanNode* chan, char *modesStr) {
 383     #define MODE_TYPE (mode[2] & CHANNEL_MODE_TYPE)
 384     #define MODE_VALUE (mode[2] & CHANNEL_MODE_VALUE)
 385     #define MODE_VALUE_INDEX (mode[2] & CHANNEL_MODE_VALUE_INDEX_MASK) >> CHANNEL_MODE_VALUE_INDEX_SHIFT
 386     char paramStr[MAXLEN];
 387     modesStr[0] = '+';
 388     unsigned int *mode;
 389     int modePos = 1;
 390     int paramPos = 0;
 391     for (mode = valid_modes; mode[1]; mode += 3) {
 392         if(chan->modes & mode[0]) {
 393             modesStr[modePos++] = (char) mode[1];
 394             if(MODE_TYPE != CHANNEL_MODE_TYPE_D) {
 395                 if(MODE_VALUE == CHANNEL_MODE_VALUE_STRING)
 396                     paramPos += sprintf(paramStr + paramPos, " %s", chan->mode_str_args[MODE_VALUE_INDEX]);
 397                 else if(MODE_VALUE == CHANNEL_MODE_VALUE_INTEGER)
 398                     paramPos += sprintf(paramStr + paramPos, " %d", chan->mode_int_args[MODE_VALUE_INDEX]);
 399             }
 400         }
 401     }
 402     paramStr[paramPos] = '\0';
 403     strcpy(modesStr + modePos, paramStr);
 404     #undef MODE_TYPE
 405     #undef MODE_VALUE
 406     #undef MODE_VALUE_INDEX
 407 }