#include "ChanNode.h"
#include "ChanUser.h"
#include "UserNode.h"
+#include "BanNode.h"
+#include "modcmd.h"
static struct ChanNode **chanList;
static int modes_with_strarg, modes_with_intarg;
---------------------------
= 47
*/
- chanList = calloc(47, sizeof(*chanList));
+ #define CHANNEL_LIST_SIZE 47
+ chanList = calloc(CHANNEL_LIST_SIZE, sizeof(*chanList));
unsigned int *mode, flag = 1;
modes_with_strarg = 0;
modes_with_intarg = 0;
}
}
+void free_ChanNode() {
+ //kamikaze free all channels and chanusers
+ int i;
+ struct ChanNode *chan, *next;
+ struct ChanUser *chanuser, *next_chanuser;
+ for(i = 0; i < CHANNEL_LIST_SIZE; i++) {
+ for(chan = chanList[i]; chan; chan = next) {
+ next = chan->next;
+ for(chanuser = getChannelUsers(chan, NULL); chanuser; chanuser = next_chanuser) {
+ next_chanuser = getChannelUsers(chan, chanuser);
+ free(chanuser);
+ }
+ freeChanNode(chan);
+ }
+ }
+ free(chanList);
+}
+
int is_valid_chan(const char *name) {
unsigned int ii;
if (*name !='#')
}
strcpy(chan->name, name);
chan->user = NULL;
+ chan->bans = NULL;
+ chan->usercount = 0;
chan->chanbot = NULL;
chan->topic[0] = 0;
chan->flags = 0;
/* mode lists */
+ chan->modes = 0;
+ chan->trigger = NULL;
chan->mode_str_args = calloc(modes_with_strarg, sizeof(char*));
chan->mode_int_args = calloc(modes_with_intarg, sizeof(int));
return chan;
}
+int getChannelCount() {
+ int i, count = 0;
+ struct ChanNode *chan;
+ for(i = 0; i < CHANNEL_LIST_SIZE; i++) {
+ for(chan = chanList[i]; chan; chan = chan->next) {
+ count++;
+ }
+ }
+ return count;
+}
+
+int getChanUserCount() {
+ int i, count = 0;
+ struct ChanNode *chan;
+ for(i = 0; i < CHANNEL_LIST_SIZE; i++) {
+ for(chan = chanList[i]; chan; chan = chan->next) {
+ count += chan->usercount;
+ }
+ }
+ return count;
+}
+
void delChannel(struct ChanNode* chan, int freeChan) {
int chanListIndex = get_chanlist_entry(chan->name[1]);
if(chanListIndex == -1) return;
if(chan->mode_str_args[i])
free(chan->mode_str_args[i]);
}
+ if(chan->trigger) {
+ struct trigger_cache *trigger, *next_trigger;
+ for(trigger = chan->trigger; trigger; trigger = next_trigger) {
+ next_trigger = trigger;
+ free(trigger->trigger);
+ free(trigger);
+ }
+ }
free(chan->mode_str_args);
free(chan->mode_int_args);
+ if(chan->bans)
+ removeChannelBans(chan);
free(chan);
}
#undef MODE_VALUE_INDEX
}
+static void parseModesUserPriv(struct ChanNode* chan, unsigned char flag, int add, char *nick) {
+ struct UserNode *user = getUserByNick(nick);
+ if(user == NULL) return;
+ struct ChanUser *chanuser = getChanUser(user, chan);
+ if(chanuser == NULL) return;
+ if(add)
+ chanuser->flags |= flag;
+ else
+ chanuser->flags &= ~flag;
+}
+
+static void parseModesBan(struct ChanNode* chan, int add, char *mask) {
+ if(add)
+ addChannelBan(chan, mask);
+ else
+ removeChannelBanMask(chan, mask);
+}
+
void parseModes(struct ChanNode* chan, char *modeStr, char **argv, int argc) {
int i, argpos = 0, add = 1;
#define MODE_TYPE (modeOpt[2] & CHANNEL_MODE_TYPE)
modeOpt = getModeOptions(modeStr[i]);
if(!modeOpt) continue; // unknown mode?
if(MODE_TYPE == CHANNEL_MODE_TYPE_A) {
+ if(argpos == argc) continue;
//special mode ;)
+ switch(modeStr[i]) {
+ case 'o':
+ parseModesUserPriv(chan, CHANUSERFLAG_OPPED, add, argv[argpos]);
+ break;
+ case 'v':
+ parseModesUserPriv(chan, CHANUSERFLAG_VOICED, add, argv[argpos]);
+ break;
+ case 'b':
+ parseModesBan(chan, add, argv[argpos]);
+ break;
+ default:
+ //we have an unknown TYPE_A mode???
+ break;
+ }
+ argpos++;
continue;
}
if(add) {
if(MODE_VALUE == CHANNEL_MODE_VALUE_STRING) {
if(chan->mode_str_args[MODE_VALUE_INDEX])
free(chan->mode_str_args[MODE_VALUE_INDEX]);
- chan->mode_str_args[MODE_VALUE_INDEX] = strdup(argv[argc++]);
+ chan->mode_str_args[MODE_VALUE_INDEX] = strdup(argv[argpos++]);
} else if(MODE_VALUE == CHANNEL_MODE_VALUE_INTEGER)
- chan->mode_int_args[MODE_VALUE_INDEX] = atoi(argv[argc++]);
+ chan->mode_int_args[MODE_VALUE_INDEX] = atoi(argv[argpos++]);
else
- argc++; //we simply don't know what to do with the argument...
+ argpos++; //we simply don't know what to do with the argument...
}
chan->modes |= modeOpt[0];
} else {
chan->mode_str_args[MODE_VALUE_INDEX] = NULL;
} else if(MODE_VALUE == CHANNEL_MODE_VALUE_INTEGER)
chan->mode_int_args[MODE_VALUE_INDEX] = 0;
- argc++; //we don't need the argument when unsetting a mode...
+ argpos++; //we don't need the argument when unsetting a mode...
}
}
}
#undef MODE_VALUE_INDEX
}
-
+void getModeString(struct ChanNode* chan, char *modesStr) {
+ #define MODE_TYPE (mode[2] & CHANNEL_MODE_TYPE)
+ #define MODE_VALUE (mode[2] & CHANNEL_MODE_VALUE)
+ #define MODE_VALUE_INDEX (mode[2] & CHANNEL_MODE_VALUE_INDEX_MASK) >> CHANNEL_MODE_VALUE_INDEX_SHIFT
+ char paramStr[MAXLEN];
+ modesStr[0] = '+';
+ unsigned int *mode;
+ int modePos = 1;
+ int paramPos = 0;
+ for (mode = valid_modes; mode[1]; mode += 3) {
+ if(chan->modes & mode[0]) {
+ modesStr[modePos++] = (char) mode[1];
+ if(MODE_TYPE != CHANNEL_MODE_TYPE_D) {
+ if(MODE_VALUE == CHANNEL_MODE_VALUE_STRING)
+ paramPos += sprintf(paramStr + paramPos, " %s", chan->mode_str_args[MODE_VALUE_INDEX]);
+ else if(MODE_VALUE == CHANNEL_MODE_VALUE_INTEGER)
+ paramPos += sprintf(paramStr + paramPos, " %d", chan->mode_int_args[MODE_VALUE_INDEX]);
+ }
+ }
+ }
+ paramStr[paramPos] = '\0';
+ strcpy(modesStr + modePos, paramStr);
+ #undef MODE_TYPE
+ #undef MODE_VALUE
+ #undef MODE_VALUE_INDEX
+}