Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members
home » brain » inspircd-cvs » inspircd » src

channels.cpp File Reference

#include "inspircd_config.h"
#include "inspircd.h"
#include "inspircd_io.h"
#include "inspircd_util.h"
#include <unistd.h>
#include <sys/errno.h>
#include <sys/ioctl.h>
#include <sys/utsname.h>
#include <time.h>
#include <string>
#include <hash_map>
#include <map>
#include <sstream>
#include <vector>
#include <deque>
#include "users.h"
#include "ctables.h"
#include "globals.h"
#include "modules.h"
#include "dynamic.h"
#include "commands.h"
#include "wildcard.h"
#include "message.h"
#include "mode.h"
#include "xline.h"
#include "inspstring.h"
#include "helperfuncs.h"
#include "typedefs.h"

Include dependency graph for channels.cpp:

Go to the source code of this file.

Namespaces

namespace  std

Defines

#define nspace   std

Functions

chanrec * ForceChan (chanrec *Ptr, ucrec &a, userrec *user, int created)
chanrec * add_channel (userrec *user, const char *cn, const char *key, bool override)
chanrec * del_channel (userrec *user, const char *cname, const char *reason, bool local)
void kick_channel (userrec *src, userrec *user, chanrec *Ptr, char *reason)

Variables

ServerConfig * Config
int MODCOUNT = -1
std::vector< Module * > modules
std::vector< ircd_module * > factory
int WHOWAS_STALE
int WHOWAS_MAX
time_t TIME
chan_hash chanlist
std::vector< ModeParameter > custom_mode_params

Define Documentation

#define nspace   std
 

Definition at line 55 of file channels.cpp.

Function Documentation

chanrec* add_channel (  userrec *  user,
const char *  cn,
const char *  key,
bool  override
) 
 

Definition at line 195 of file channels.cpp.

References chanrec::bans, chanrec::binarymodes, chanlist, userrec::chans, CM_INVITEONLY, CM_NOEXTERNAL, CM_TOPICLOCK, DEBUG, DEFAULT, connection::fd, FindChan(), ForceChan(), FOREACH_RESULT, userrec::GetFullHost(), has_channel(), userrec::IsInvited(), chanrec::key, chanrec::limit, log(), userrec::modes, chanrec::name, userrec::nick, userrec::RemoveInvite(), TIME, and WriteServ().

Referenced by Server::JoinUserToChannel().

00196 {
00197         if ((!user) || (!cn))
00198         {
00199                 log(DEFAULT,"*** BUG *** add_channel was given an invalid parameter");
00200                 return 0;
00201         }
00202 
00203         int created = 0;
00204         char cname[MAXBUF];
00205         int MOD_RESULT = 0;
00206         strncpy(cname,cn,CHANMAX);
00207 
00208         log(DEBUG,"add_channel: %s %s",user->nick,cname);
00209 
00210         chanrec* Ptr = FindChan(cname);
00211 
00212         if (!Ptr)
00213         {
00214                 if (user->fd > -1)
00215                 {
00216                         MOD_RESULT = 0;
00217                         FOREACH_RESULT(OnUserPreJoin(user,NULL,cname));
00218                         if (MOD_RESULT == 1)
00219                                 return NULL;
00220                 }
00221                 /* create a new one */
00222                 chanlist[cname] = new chanrec();
00223                 strlcpy(chanlist[cname]->name, cname,CHANMAX);
00224                 chanlist[cname]->binarymodes = CM_TOPICLOCK | CM_NOEXTERNAL;
00225                 chanlist[cname]->created = TIME;
00226                 strcpy(chanlist[cname]->topic, "");
00227                 strncpy(chanlist[cname]->setby, user->nick,NICKMAX);
00228                 chanlist[cname]->topicset = 0;
00229                 Ptr = chanlist[cname];
00230                 log(DEBUG,"add_channel: created: %s",cname);
00231                 /* set created to 2 to indicate user
00232                  * is the first in the channel
00233                  * and should be given ops */
00234                 created = 2;
00235         }
00236         else
00237         {
00238                 /* Already on the channel */
00239                 if (has_channel(user,Ptr))
00240                         return NULL;
00241 
00242                 // remote users are allowed us to bypass channel modes
00243                 // and bans (used by servers)
00244                 if (user->fd > -1)
00245                 {
00246                         MOD_RESULT = 0;
00247                         FOREACH_RESULT(OnUserPreJoin(user,Ptr,cname));
00248                         if (MOD_RESULT == 1)
00249                         {
00250                                 return NULL;
00251                         }
00252                         else
00253                         {
00254                                 if (*Ptr->key)
00255                                 {
00256                                         MOD_RESULT = 0;
00257                                         FOREACH_RESULT(OnCheckKey(user, Ptr, key ? key : ""));
00258                                         if (!MOD_RESULT)
00259                                         {
00260                                                 if (!key)
00261                                                 {
00262                                                         log(DEBUG,"add_channel: no key given in JOIN");
00263                                                         WriteServ(user->fd,"475 %s %s :Cannot join channel (Requires key)",user->nick, Ptr->name);
00264                                                         return NULL;
00265                                                 }
00266                                                 else
00267                                                 {
00268                                                         if (strcasecmp(key,Ptr->key))
00269                                                         {
00270                                                                 log(DEBUG,"add_channel: bad key given in JOIN");
00271                                                                 WriteServ(user->fd,"475 %s %s :Cannot join channel (Incorrect key)",user->nick, Ptr->name);
00272                                                                 return NULL;
00273                                                         }
00274                                                 }
00275                                         }
00276                                 }
00277                                 if (Ptr->binarymodes & CM_INVITEONLY)
00278                                 {
00279                                         MOD_RESULT = 0;
00280                                         FOREACH_RESULT(OnCheckInvite(user, Ptr));
00281                                         if (!MOD_RESULT)
00282                                         {
00283                                                 log(DEBUG,"add_channel: channel is +i");
00284                                                 if (user->IsInvited(Ptr->name))
00285                                                 {
00286                                                         /* user was invited to channel */
00287                                                         /* there may be an optional channel NOTICE here */
00288                                                 }
00289                                                 else
00290                                                 {
00291                                                         WriteServ(user->fd,"473 %s %s :Cannot join channel (Invite only)",user->nick, Ptr->name);
00292                                                         return NULL;
00293                                                 }
00294                                         }
00295                                         user->RemoveInvite(Ptr->name);
00296                                 }
00297                                 if (Ptr->limit)
00298                                 {
00299                                         MOD_RESULT = 0;
00300                                         FOREACH_RESULT(OnCheckLimit(user, Ptr));
00301                                         if (!MOD_RESULT)
00302                                         {
00303                                                 if (usercount(Ptr) >= Ptr->limit)
00304                                                 {
00305                                                         WriteServ(user->fd,"471 %s %s :Cannot join channel (Channel is full)",user->nick, Ptr->name);
00306                                                         return NULL;
00307                                                 }
00308                                         }
00309                                 }
00310                                 if (Ptr->bans.size())
00311                                 {
00312                                         log(DEBUG,"add_channel: about to walk banlist");
00313                                         MOD_RESULT = 0;
00314                                         FOREACH_RESULT(OnCheckBan(user, Ptr));
00315                                         if (!MOD_RESULT)
00316                                         {
00317                                                 for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
00318                                                 {
00319                                                         if (match(user->GetFullHost(),i->data))
00320                                                         {
00321                                                                 WriteServ(user->fd,"474 %s %s :Cannot join channel (You're banned)",user->nick, Ptr->name);
00322                                                                 return NULL;
00323                                                         }
00324                                                 }
00325                                         }
00326                                 }
00327                         }
00328                 }
00329                 else
00330                 {
00331                         log(DEBUG,"Overridden checks");
00332                 }
00333                 created = 1;
00334         }
00335 
00336         log(DEBUG,"Passed channel checks");
00337 
00338         for (unsigned int index =0; index < user->chans.size(); index++)
00339         {
00340                 if (user->chans[index].channel == NULL)
00341                 {
00342                         return ForceChan(Ptr,user->chans[index],user,created);
00343                 }
00344         }
00345         /* XXX: If the user is an oper here, we can just extend their user->chans vector by one
00346          * and put the channel in here. Same for remote users which are not bound by
00347          * the channel limits. Otherwise, nope, youre boned.
00348          */
00349         if (user->fd < 0)
00350         {
00351                 ucrec a;
00352                 chanrec* c = ForceChan(Ptr,a,user,created);
00353                 user->chans.push_back(a);
00354                 return c;
00355         }
00356         else if (strchr(user->modes,'o'))
00357         {
00358                 /* Oper allows extension up to the OPERMAXCHANS value */
00359                 if (user->chans.size() < OPERMAXCHANS)
00360                 {
00361                         ucrec a;
00362                         chanrec* c = ForceChan(Ptr,a,user,created);
00363                         user->chans.push_back(a);
00364                         return c;
00365                 }
00366         }
00367         log(DEBUG,"add_channel: user channel max exceeded: %s %s",user->nick,cname);
00368         WriteServ(user->fd,"405 %s %s :You are on too many channels",user->nick, cname);
00369         return NULL;
00370 }

chanrec* del_channel (  userrec *  user,
const char *  cname,
const char *  reason,
bool  local
) 
 

Definition at line 401 of file channels.cpp.

References chanlist, userrec::chans, DEBUG, DEFAULT, chanrec::DelUser(), FindChan(), FOREACH_MOD, log(), chanrec::name, userrec::nick, and WriteChannel().

Referenced by Server::PartUserFromChannel().

00402 {
00403         if ((!user) || (!cname))
00404         {
00405                 log(DEFAULT,"*** BUG *** del_channel was given an invalid parameter");
00406                 return NULL;
00407         }
00408 
00409         chanrec* Ptr = FindChan(cname);
00410 
00411         if (!Ptr)
00412                 return NULL;
00413 
00414         FOREACH_MOD OnUserPart(user,Ptr);
00415         log(DEBUG,"del_channel: removing: %s %s",user->nick,Ptr->name);
00416 
00417         for (unsigned int i =0; i < user->chans.size(); i++)
00418         {
00419                 /* zap it from the channel list of the user */
00420                 if (user->chans[i].channel == Ptr)
00421                 {
00422                         if (reason)
00423                         {
00424                                 WriteChannel(Ptr,user,"PART %s :%s",Ptr->name, reason);
00425                         }
00426                         else
00427                         {
00428                                 WriteChannel(Ptr,user,"PART :%s",Ptr->name);
00429                         }
00430                         user->chans[i].uc_modes = 0;
00431                         user->chans[i].channel = NULL;
00432                         log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name);
00433                         break;
00434                 }
00435         }
00436 
00437         Ptr->DelUser((char*)user);
00438 
00439         /* if there are no users left on the channel */
00440         if (!usercount(Ptr))
00441         {
00442                 chan_hash::iterator iter = chanlist.find(Ptr->name);
00443 
00444                 log(DEBUG,"del_channel: destroying channel: %s",Ptr->name);
00445 
00446                 /* kill the record */
00447                 if (iter != chanlist.end())
00448                 {
00449                         log(DEBUG,"del_channel: destroyed: %s",Ptr->name);
00450                         delete Ptr;
00451                         chanlist.erase(iter);
00452                 }
00453         }
00454 
00455         return NULL;
00456 }

chanrec * ForceChan (  chanrec *  Ptr,
ucrec &  a,
userrec *  user,
int  created
) 
 

Definition at line 372 of file channels.cpp.

References chanrec::AddUser(), ucrec::channel, DEBUG, FOREACH_MOD, log(), chanrec::name, chanrec::setby, chanrec::topic, chanrec::topicset, ucrec::uc_modes, UCMODE_OP, WriteChannel(), and WriteServ().

Referenced by add_channel().

00373 {
00374         if (created == 2)
00375         {
00376                 /* first user in is given ops */
00377                 a.uc_modes = UCMODE_OP;
00378         }
00379         else
00380         {
00381                 a.uc_modes = 0;
00382         }
00383         a.channel = Ptr;
00384         Ptr->AddUser((char*)user);
00385         WriteChannel(Ptr,user,"JOIN :%s",Ptr->name);
00386         log(DEBUG,"Sent JOIN to client");
00387         if (Ptr->topicset)
00388         {
00389                 WriteServ(user->fd,"332 %s %s :%s", user->nick, Ptr->name, Ptr->topic);
00390                 WriteServ(user->fd,"333 %s %s %s %lu", user->nick, Ptr->name, Ptr->setby, (unsigned long)Ptr->topicset);
00391         }
00392         userlist(user,Ptr);
00393         WriteServ(user->fd,"366 %s %s :End of /NAMES list.", user->nick, Ptr->name);
00394         FOREACH_MOD OnUserJoin(user,Ptr);
00395         return Ptr;
00396 }

void kick_channel (  userrec *  src,
userrec *  user,
chanrec *  Ptr,
char *  reason
) 
 

Definition at line 459 of file channels.cpp.

References AC_KICK, ACR_DEFAULT, ACR_DENY, chanlist, userrec::chans, cstatus(), DEBUG, DEFAULT, chanrec::DelUser(), connection::fd, FOREACH_MOD, FOREACH_RESULT, has_channel(), is_uline(), log(), chanrec::name, userrec::nick, userrec::server, STATUS_HOP, WriteChannel(), and WriteServ().

00460 {
00461         if ((!src) || (!user) || (!Ptr) || (!reason))
00462         {
00463                 log(DEFAULT,"*** BUG *** kick_channel was given an invalid parameter");
00464                 return;
00465         }
00466 
00467         if ((!Ptr) || (!user) || (!src))
00468         {
00469                 return;
00470         }
00471 
00472         log(DEBUG,"kick_channel: removing: %s %s %s",user->nick,Ptr->name,src->nick);
00473 
00474         if (!has_channel(user,Ptr))
00475         {
00476                 WriteServ(src->fd,"441 %s %s %s :They are not on that channel",src->nick, user->nick, Ptr->name);
00477                 return;
00478         }
00479 
00480         int MOD_RESULT = 0;
00481         FOREACH_RESULT(OnAccessCheck(src,user,Ptr,AC_KICK));
00482         if ((MOD_RESULT == ACR_DENY) && (!is_uline(src->server)))
00483                 return;
00484 
00485         if ((MOD_RESULT == ACR_DEFAULT) || (!is_uline(src->server)))
00486         {
00487                 if ((cstatus(src,Ptr) < STATUS_HOP) || (cstatus(src,Ptr) < cstatus(user,Ptr)))
00488                 {
00489                         if (cstatus(src,Ptr) == STATUS_HOP)
00490                         {
00491                                 WriteServ(src->fd,"482 %s %s :You must be a channel operator",src->nick, Ptr->name);
00492                         }
00493                         else
00494                         {
00495                                 WriteServ(src->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel",src->nick, Ptr->name);
00496                         }
00497 
00498                         return;
00499                 }
00500         }
00501 
00502         if (!is_uline(src->server))
00503         {
00504                 MOD_RESULT = 0;
00505                 FOREACH_RESULT(OnUserPreKick(src,user,Ptr,reason));
00506                 if (MOD_RESULT)
00507                         return;
00508         }
00509 
00510         FOREACH_MOD OnUserKick(src,user,Ptr,reason);
00511 
00512         for (unsigned int i =0; i < user->chans.size(); i++)
00513         {
00514                 /* zap it from the channel list of the user */
00515                 if (user->chans[i].channel)
00516                 if (!strcasecmp(user->chans[i].channel->name,Ptr->name))
00517                 {
00518                         WriteChannel(Ptr,src,"KICK %s %s :%s",Ptr->name, user->nick, reason);
00519                         user->chans[i].uc_modes = 0;
00520                         user->chans[i].channel = NULL;
00521                         log(DEBUG,"del_channel: unlinked: %s %s",user->nick,Ptr->name);
00522                         break;
00523                 }
00524         }
00525 
00526         Ptr->DelUser((char*)user);
00527 
00528         /* if there are no users left on the channel */
00529         if (!usercount(Ptr))
00530         {
00531                 chan_hash::iterator iter = chanlist.find(Ptr->name);
00532 
00533                 log(DEBUG,"del_channel: destroying channel: %s",Ptr->name);
00534 
00535                 /* kill the record */
00536                 if (iter != chanlist.end())
00537                 {
00538                         log(DEBUG,"del_channel: destroyed: %s",Ptr->name);
00539                         delete Ptr;
00540                         chanlist.erase(iter);
00541                 }
00542         }
00543 }

Variable Documentation

chan_hash chanlist
 

Referenced by add_channel(), del_channel(), and kick_channel().

ServerConfig* Config
 

std::vector<ModeParameter> custom_mode_params
 

Definition at line 70 of file channels.cpp.

Referenced by chanrec::GetModeParameter(), and chanrec::SetCustomModeParam().

std::vector<ircd_module*> factory
 

int MODCOUNT = -1
 

Definition at line 935 of file modules.cpp.

Referenced by Server::FindModule().

std::vector<Module*> modules
 

Referenced by Server::FindModule().

time_t TIME
 

Referenced by add_channel(), and userrec::userrec().

int WHOWAS_MAX
 

int WHOWAS_STALE
 

Generated on Thu Dec 15 11:14:15 2005 for InspIRCd by  doxygen 1.4.4-20050815