[irc/quakenet/newserv.git] / nick / nickhandlers.c

/* nickhandlers.c */

#include "nick.h"
#include "../lib/flags.h"
#include "../lib/irc_string.h"
#include "../lib/base64.h"
#include "../irc/irc.h"
#include "../irc/irc_config.h"
#include "../core/error.h"
#include "../core/hooks.h"
#include "../lib/sstring.h"
#include "../server/server.h"
#include "../parser/parser.h"
#include <stdlib.h>
#include <string.h>

/*
 * handlenickmsg:
 *  Handle new nicks being introduced to the network.
 *  Handle renames.
 */
 
int handlenickmsg(void *source, int cargc, char **cargv) {
  char *sender=(char *)source;
  time_t timestamp;
  nick *np,*np2;
  nick **nh;
  char *fakehost;
  char *accountts;
  char *accountflags;
  struct irc_in_addr ipaddress;
  char *accountid;
  unsigned long userid;
  
  if (cargc==2) { /* rename */
    /* Nyklon 1017697578 */
    timestamp=strtol(cargv[1],NULL,10);
    np=getnickbynumericstr(sender);
    if (np==NULL) {
      Error("nick",ERR_ERROR,"Rename from non-existent sender %s",sender);
      return CMD_OK;
    }
    np2=getnickbynick(cargv[0]);
    if (np==np2) {
      /* The new and old nickname have the same hash, this means a rename to the same name in 
       * different case, e.g. Flash -> flash.  In this case the timestamp for the change should
       * match the existing timestamp, and we can bypass all the collision checking and hash fettling. */
      if (np->timestamp!=timestamp) {
        Error("nick",ERR_WARNING,"Rename to same nickname with different timestamp (%s(%d) -> %s(%d))",
                            np->nick,np->timestamp,cargv[0],timestamp);
        np->timestamp=timestamp;
      }
      strncpy(np->nick,cargv[0],NICKLEN);
      np->nick[NICKLEN]='\0';
      triggerhook(HOOK_NICK_RENAME,np);        
      return CMD_OK;
    }
    if (np2!=NULL) {
      /* Nick collision */
      if (ircd_strcmp(np->ident,np2->ident) || (np->host!=np2->host)) {
        /* Different user@host */
        if (np2->timestamp < timestamp) {
          /* The nick attempting to rename got killed.  Guess we don't need to do the rename now :) */
          deletenick(np);
          return CMD_OK;
        } else {
          /* The other nick got killed */
          deletenick(np2);
        }
      } else {
        if (np2->timestamp < timestamp) {
          /* Same user@host: reverse logic.  Whose idea was all this anyway? */
          deletenick(np2);
        } else {
          deletenick(np);
          return CMD_OK;
        }
      }
    }
    /* OK, we've survived the collision hazard.  Change timestamp and rename */
    np->timestamp=timestamp;
    removenickfromhash(np);
    strncpy(np->nick,cargv[0],NICKLEN);
    np->nick[NICKLEN]='\0';
    addnicktohash(np);
    triggerhook(HOOK_NICK_RENAME,np);
  } else if (cargc>=8) { /* new nick */
    /* Jupiler 2 1016645147 ~Jupiler www.iglobal.be +ir moo [FUTURE CRAP HERE] DV74O] BNBd7 :Jupiler */
    timestamp=strtol(cargv[2],NULL,10);
    np=getnickbynick(cargv[0]);
    if (np!=NULL) {
      /* Nick collision */
      if (ircd_strcmp(np->ident,cargv[3]) || ircd_strcmp(np->host->name->content,cargv[4])) {
        /* Different user@host */
        if (timestamp>np->timestamp) {
          /* New nick is newer.  Ignore this nick message */
          return CMD_OK;
        } else {
          /* New nick is older.  Kill the imposter, and drop through */
          deletenick(np);
        }
      } else {
        if (timestamp>np->timestamp) {
          /* Same user@host, newer timestamp: we're killing off a ghost */
          deletenick(np);
        } else {
          /* This nick is the ghost, so ignore it */
          return CMD_OK;
        }
      }
    }
    
    nh=gethandlebynumeric(numerictolong(cargv[cargc-2],5));
    if (!nh) {
      /* This isn't a valid numeric */      
      Error("nick",ERR_WARNING,"Received NICK with invalid numeric %s from %s.",cargv[cargc-2],sender);
      return CMD_ERROR;
    }

    base64toip(cargv[cargc-3], &ipaddress);
    if (!irc_in_addr_valid(&ipaddress)) {
      Error("nick",ERR_ERROR,"Received NICK with invalid ipaddress for %s from %s.",cargv[0],sender);
      return CMD_ERROR;
    }

    /* At this stage the nick is cleared to proceed */
    np=newnick();
    strncpy(np->nick,cargv[0],NICKLEN);
    np->nick[NICKLEN]='\0';
    np->numeric=numerictolong(cargv[cargc-2],5);
    strncpy(np->ident,cargv[3],USERLEN);
    np->ident[USERLEN]='\0';
    np->host=findorcreatehost(cargv[4]);
    np->realname=findorcreaterealname(cargv[cargc-1]);
    np->nextbyhost=np->host->nicks;
    np->host->nicks=np;
    np->nextbyrealname=np->realname->nicks;
    np->realname->nicks=np;
    np->timestamp=timestamp;

    base64toip(cargv[cargc-3], &ipaddress);
    /* todo: use a single node for /64 prefixes */
    np->ipnode = refnode(iptree, &ipaddress, irc_in_addr_is_ipv4(&ipaddress) ? PATRICIA_MAXBITS : 64);
    node_increment_usercount(np->ipnode);

    np->shident=NULL;
    np->sethost=NULL;
    np->opername=NULL;
    np->umodes=0;
    np->marker=0;
    memset(np->exts, 0, MAXNICKEXTS * sizeof(void *));
    np->authname[0]='\0';
    np->auth=NULL;
    if(cargc>=9) {
      int sethostarg = 6, opernamearg = 6, accountarg = 6;

      setflags(&(np->umodes),UMODE_ALL,cargv[5],umodeflags,REJECT_NONE);

      if(IsOper(np) && (serverlist[myhub].flags & SMODE_OPERNAME)) {
        accountarg++;
        sethostarg++;

        np->opername=getsstring(cargv[opernamearg],ACCOUNTLEN);
      }

      if (IsAccount(np)) {
        sethostarg++;

        if ((accountts=strchr(cargv[accountarg],':'))) {
          *accountts++='\0';
          np->accountts=strtoul(accountts,&accountid,10);
          if(accountid) {
            userid=strtoul(accountid + 1,&accountflags,10);
            if(!userid) {
              np->auth=NULL;
            } else {
              np->auth=findorcreateauthname(userid, cargv[accountarg]);
              np->auth->usercount++;
              np->nextbyauthname=np->auth->nicks;
              np->auth->nicks=np;
              if(accountflags)
                np->auth->flags=strtoul(accountflags + 1,NULL,10);
            }
          } else {
            np->auth=NULL;
          }
        } else {
          np->accountts=0;
          np->auth=NULL;
        }        
        strncpy(np->authname,cargv[accountarg],ACCOUNTLEN);
        np->authname[ACCOUNTLEN]='\0';
      } 
      if (IsSetHost(np) && (fakehost=strchr(cargv[sethostarg],'@'))) {
	/* valid sethost */
	*fakehost++='\0';
	np->shident=getsstring(cargv[sethostarg],USERLEN);
	np->sethost=getsstring(fakehost,HOSTLEN);
      }
    }
    
    /* Place this nick in the server nick table.  Note that nh is valid from the numeric check above */
    if (*nh) {
      /* There was a nick there already -- we have a masked numeric collision
       * This shouldn't happen, but if it does the newer nick takes precedence
       * (the two nicks are from the same server, and if the server has reissued
       * the masked numeric it must believe the old user no longer exists).
       */
       Error("nick",ERR_ERROR,"Masked numeric collision for %s [%s vs %s]",cargv[0],cargv[cargc-2],longtonumeric((*nh)->numeric,5));
       deletenick(*nh);
    }
    *nh=np;
    
    /* And the nick hash table */
    addnicktohash(np);      
    
    /* Trigger the hook */
    triggerhook(HOOK_NICK_NEWNICK,np);
  } else {
    Error("nick",ERR_WARNING,"Nick message with weird number of parameters (%d)",cargc);
  }
  
  return CMD_OK;
}

int handlequitmsg(void *source, int cargc, char **cargv) {
  nick *np;
  void *harg[2];
  
  if (cargc>0) {
    harg[1]=(void *)cargv[0];
  } else {
    harg[1]="";
  } 
  
  np=getnickbynumericstr((char *)source);
  if (np) {
    harg[0]=(void *)np;
    triggerhook(HOOK_NICK_QUIT, harg);
    deletenick(np);
  } else {
    Error("nick",ERR_WARNING,"Quit from non-existant numeric %s",(char *)source);
  }
  return CMD_OK; 
}

int handlekillmsg(void *source, int cargc, char **cargv) {
  nick *np;
  void *harg[2];
#warning Fix me to use source

  if (cargc<1) {
    Error("nick",ERR_WARNING,"Kill message with too few parameters");
    return CMD_ERROR;  
  }

  if (cargc>1) {
    harg[1]=(void *)cargv[1];
  } else {
    harg[1]="";
  } 
  
  np=getnickbynumericstr(cargv[0]);
  if (np) {
    harg[0]=(void *)np;
    triggerhook(HOOK_NICK_KILL, harg);
    deletenick(np);
  } else {
    Error("nick",ERR_WARNING,"Kill for non-existant numeric %s",cargv[0]);
  }
  return CMD_OK; 
}

int handleusermodemsg(void *source, int cargc, char **cargv) {
  nick *np;
  flag_t oldflags;
  char *fakehost;
  
  if (cargc<2) {
    Error("nick",ERR_WARNING,"Mode message with too few parameters");
    return CMD_LAST; /* With <2 params the channels module won't want it either */
  }
  
  if (cargv[0][0]=='#') {
    /* Channel mode change, we don't care.
     * We don't bother checking for other channel types here, since & channel mode 
     * changes aren't broadcast and + channels don't have mode changes :) */
    return CMD_OK;
  }
  
  np=getnickbynumericstr((char *)source);
  if (np!=NULL) {
    if (ircd_strcmp(cargv[0],np->nick)) {
      Error("nick",ERR_WARNING,"Attempted mode change on user %s by %s",cargv[0],np->nick);
      return CMD_OK;
    }
    oldflags=np->umodes;
    setflags(&(np->umodes),UMODE_ALL,cargv[1],umodeflags,REJECT_NONE);

    if (strchr(cargv[1],'o')) { /* o always comes on its own when being set */
      if(serverlist[myhub].flags & SMODE_OPERNAME) {
        if((np->umodes & UMODE_OPER)) {
          np->opername = getsstring(cargv[2], ACCOUNTLEN);
        } else {
          freesstring(np->opername);
        }
      }
      if((np->umodes ^ oldflags) & UMODE_OPER)
        triggerhook(HOOK_NICK_MODEOPER,np);
    }
    if (strchr(cargv[1],'h')) { /* Have to allow +h twice.. */
      /* +-h: just the freesstring() calls for the -h case */
      freesstring(np->shident); /* freesstring(NULL) is OK */
      freesstring(np->sethost);
      np->shident=NULL;
      np->sethost=NULL;
      if (IsSetHost(np) && cargc>2) { /* +h and mask received */
	if ((fakehost=strchr(cargv[2],'@'))) {
	  /* user@host change */
	  *fakehost++='\0';
	  np->shident=getsstring(cargv[2],USERLEN);
	  np->sethost=getsstring(fakehost,HOSTLEN);
	} else {
	  np->sethost=getsstring(cargv[2],HOSTLEN);
	}
      }
      triggerhook(HOOK_NICK_SETHOST, (void *)np);
    }  
  } else {
    Error("nick",ERR_WARNING,"Usermode change by unknown user %s",(char *)source);
  }
  return CMD_OK;
}

int handlewhoismsg(void *source, int cargc, char **cargv) {
  nick *sender,*target;
  nick *nicks[2];
  
  if (cargc<2)
    return CMD_OK;
  
  if (strncmp(cargv[0],mynumeric->content,2)) {
    return CMD_OK;
  }
  
  /* Find the sender... */  
  if ((sender=getnickbynumericstr((char *)source))==NULL) {
    Error("localuser",ERR_WARNING,"WHOIS message from non existent numeric %s",(char *)source);
    return CMD_OK;
  }
  
  /* :hub.splidge.netsplit.net 311 moo splidge splidge ground.stbarnab.as * :splidge
     :hub.splidge.netsplit.net 312 moo splidge splidge.netsplit.net :splidge's netsplit leaf
     :hub.splidge.netsplit.net 313 moo splidge :is an IRC Operator
     :hub.splidge.netsplit.net 318 moo splidge :End of /WHOIS list.
  */
  
  /* And the target... */
  if ((target=getnickbynick(cargv[1]))==NULL) {
    irc_send(":%s 401 %s %s :No such nick",myserver->content,sender->nick,cargv[1]);
  } else {
    irc_send(":%s 311 %s %s %s %s * :%s",myserver->content,sender->nick,target->nick,target->ident,
        target->host->name->content, target->realname->name->content);
    nicks[0]=sender; nicks[1]=target;
    triggerhook(HOOK_NICK_WHOISCHANNELS,nicks);
    if (IsOper(sender) || !HIS_SERVER ) {
      irc_send(":%s 312 %s %s %s :%s",myserver->content,sender->nick,target->nick,
          serverlist[homeserver(target->numeric)].name->content,
          serverlist[homeserver(target->numeric)].description->content);
    } else {
      irc_send(":%s 312 %s %s " HIS_SERVERNAME " :" HIS_SERVERDESC,myserver->content,sender->nick,target->nick);
    }
    if (IsOper(target)) {
      irc_send(":%s 313 %s %s :is an IRC Operator",myserver->content,sender->nick,target->nick);
    }
    if (IsAccount(target)) {
      irc_send(":%s 330 %s %s %s :is authed as",myserver->content,sender->nick,target->nick,target->authname);
    }
    if (homeserver(target->numeric)==mylongnum && !IsService(target) && !IsHideIdle(target)) {
      irc_send(":%s 317 %s %s %ld %ld :seconds idle, signon time",myserver->content,sender->nick,target->nick,
         (getnettime() - target->timestamp) % (((target->numeric + target->timestamp) % 983) + 7),target->timestamp);
    }
  }
  
  irc_send(":%s 318 %s %s :End of /WHOIS list.",myserver->content,sender->nick,cargv[1]);
  return CMD_OK;
}  

int handleaccountmsg(void *source, int cargc, char **cargv) {
  nick *target;
  unsigned long userid;
  
  if (cargc<2) {
    return CMD_OK;
  }
  
  if ((target=getnickbynumericstr(cargv[0]))==NULL) {
    return CMD_OK;
  }
  
  if (IsAccount(target)) {
    return CMD_OK;
  }
  
  SetAccount(target);
  strncpy(target->authname,cargv[1],ACCOUNTLEN);
  target->authname[ACCOUNTLEN]='\0';
  
  if (cargc>=3) {
    target->accountts=strtoul(cargv[2],NULL,10);
    if (cargc>=4) {
      userid=strtoul(cargv[3],NULL,10);
      if(!userid) {
        target->auth=NULL;
      } else {
        target->auth=findorcreateauthname(userid, target->authname);
        target->auth->usercount++;
        target->nextbyauthname = target->auth->nicks;
        target->auth->nicks = target;
        if (cargc>=5)
          target->auth->flags=strtoul(cargv[4],NULL,10);
      }
    } else {
      target->auth=NULL;
    }
  } else {
    target->accountts=0;
    target->auth=NULL;
  }
  
  triggerhook(HOOK_NICK_ACCOUNT, (void *)target);

  return CMD_OK;
}

int handlestatsmsg(void *source, int cargc, char **cargv) {
  int sourceserver;
  char *sender=(char *)source;
  char *replytarget;
  char *fromstring;
  nick *np;
  
  if (cargc<2) {
    Error("nick",ERR_WARNING,"STATS request without enough parameters!");
    return CMD_OK;
  }
  
  if (strlen(sender)==5) {
    /* client */
    np=getnickbynumericstr(sender);
    if (!np) {
      Error("nick",ERR_WARNING,"STATS request from unknown client %s",sender);
      return CMD_OK;
    }
    replytarget=np->nick;
  } else {
    Error("nick",ERR_WARNING,"STATS request from odd source %s",sender);
    return CMD_OK;
  }

  /* Reply to stats for ANY server.. including any we are juping */
  sourceserver=numerictolong(cargv[1],2);
  if (serverlist[sourceserver].maxusernum==0) {
    Error("nick",ERR_WARNING,"Stats request for bad server %s",cargv[1]);
    return CMD_OK;
  }
  fromstring=serverlist[sourceserver].name->content;

  switch(cargv[0][0]) {
  case 'u':
    irc_send(":%s 242 %s :Server Up %s",fromstring,replytarget,
	     longtoduration(time(NULL)-starttime, 0));
    irc_send(":%s 250 %s :Highest connection count: 10 (9 clients)",fromstring,replytarget);
    break;

  case 'P':
    irc_send(":%s 217 %s P none 0 :0x2000",fromstring,replytarget);
    break;
    
  }

  irc_send(":%s 219 %s %c :End of /STATS report",fromstring,replytarget,cargv[0][0]);

  return CMD_OK;
}

int handleprivmsg(void *source, int cargc, char **cargv) {
  nick *sender;
  char *message;
  void *args[3];

  if (cargc<2)
    return CMD_OK;

  if (cargv[0][0]!='$')
    return CMD_OK;

  sender=getnickbynumericstr((char *)source);

  if (!match2strings(cargv[0] + 1,myserver->content))
    return CMD_OK;

  message=cargv[0];

  args[0]=sender;
  args[1]=cargv[0];
  args[2]=cargv[1];

  triggerhook(HOOK_NICK_MASKPRIVMSG, (void *)args);

  return CMD_OK;
}
Commit	Line	Data
c86edd1d Q	1	/* nickhandlers.c */
	2
	3	#include "nick.h"
	4	#include "../lib/flags.h"
	5	#include "../lib/irc_string.h"
	6	#include "../lib/base64.h"
	7	#include "../irc/irc.h"
	8	#include "../irc/irc_config.h"
	9	#include "../core/error.h"
	10	#include "../core/hooks.h"
	11	#include "../lib/sstring.h"
	12	#include "../server/server.h"
	13	#include "../parser/parser.h"
	14	#include <stdlib.h>
	15	#include <string.h>
	16
	17	/*
	18	* handlenickmsg:
	19	* Handle new nicks being introduced to the network.
	20	* Handle renames.
	21	*/
	22
	23	int handlenickmsg(void source, int cargc, char *cargv) {
	24	char sender=(char )source;
	25	time_t timestamp;
	26	nick np,np2;
	27	nick **nh;
	28	char *fakehost;
	29	char *accountts;
c153c0dc	30	char *accountflags;
526e7c1d	31	struct irc_in_addr ipaddress;
47657339 C	32	char *accountid;
47657339 C	33	unsigned long userid;
c86edd1d Q	34
	35	if (cargc==2) { /* rename */
	36	/* Nyklon 1017697578 */
	37	timestamp=strtol(cargv[1],NULL,10);
	38	np=getnickbynumericstr(sender);
	39	if (np==NULL) {
	40	Error("nick",ERR_ERROR,"Rename from non-existent sender %s",sender);
	41	return CMD_OK;
	42	}
	43	np2=getnickbynick(cargv[0]);
	44	if (np==np2) {
	45	/* The new and old nickname have the same hash, this means a rename to the same name in
	46	* different case, e.g. Flash -> flash. In this case the timestamp for the change should
	47	* match the existing timestamp, and we can bypass all the collision checking and hash fettling. */
	48	if (np->timestamp!=timestamp) {
	49	Error("nick",ERR_WARNING,"Rename to same nickname with different timestamp (%s(%d) -> %s(%d))",
	50	np->nick,np->timestamp,cargv[0],timestamp);
	51	np->timestamp=timestamp;
	52	}
	53	strncpy(np->nick,cargv[0],NICKLEN);
	54	np->nick[NICKLEN]='\0';
	55	triggerhook(HOOK_NICK_RENAME,np);
	56	return CMD_OK;
	57	}
	58	if (np2!=NULL) {
	59	/* Nick collision */
	60	if (ircd_strcmp(np->ident,np2->ident) \|\| (np->host!=np2->host)) {
	61	/* Different user@host */
	62	if (np2->timestamp < timestamp) {
	63	/* The nick attempting to rename got killed. Guess we don't need to do the rename now :) */
	64	deletenick(np);
	65	return CMD_OK;
	66	} else {
	67	/* The other nick got killed */
	68	deletenick(np2);
	69	}
	70	} else {
	71	if (np2->timestamp < timestamp) {
	72	/* Same user@host: reverse logic. Whose idea was all this anyway? */
	73	deletenick(np2);
	74	} else {
	75	deletenick(np);
	76	return CMD_OK;
	77	}
	78	}
	79	}
	80	/* OK, we've survived the collision hazard. Change timestamp and rename */
	81	np->timestamp=timestamp;
	82	removenickfromhash(np);
	83	strncpy(np->nick,cargv[0],NICKLEN);
	84	np->nick[NICKLEN]='\0';
	85	addnicktohash(np);
	86	triggerhook(HOOK_NICK_RENAME,np);
	87	} else if (cargc>=8) { /* new nick */
	88	/* Jupiler 2 1016645147 ~Jupiler www.iglobal.be +ir moo [FUTURE CRAP HERE] DV74O] BNBd7 :Jupiler */
	89	timestamp=strtol(cargv[2],NULL,10);
	90	np=getnickbynick(cargv[0]);
	91	if (np!=NULL) {
	92	/* Nick collision */
	93	if (ircd_strcmp(np->ident,cargv[3]) \|\| ircd_strcmp(np->host->name->content,cargv[4])) {
	94	/* Different user@host */
	95	if (timestamp>np->timestamp) {
	96	/* New nick is newer. Ignore this nick message */
	97	return CMD_OK;
98	} else {
99	/* New nick is older. Kill the imposter, and drop through */
100	deletenick(np);
101	}
102	} else {
103	if (timestamp>np->timestamp) {
104	/* Same user@host, newer timestamp: we're killing off a ghost */
105	deletenick(np);
106	} else {
107	/* This nick is the ghost, so ignore it */
108	return CMD_OK;
109	}
110	}
111	}
112
113	nh=gethandlebynumeric(numerictolong(cargv[cargc-2],5));
114	if (!nh) {
115	/* This isn't a valid numeric */
116	Error("nick",ERR_WARNING,"Received NICK with invalid numeric %s from %s.",cargv[cargc-2],sender);
117	return CMD_ERROR;
118	}
1a38afd3 P	119
	120	base64toip(cargv[cargc-3], &ipaddress);
	121	if (!irc_in_addr_valid(&ipaddress)) {
	122	Error("nick",ERR_ERROR,"Received NICK with invalid ipaddress for %s from %s.",cargv[0],sender);
	123	return CMD_ERROR;
	124	}
	125
c86edd1d Q	126	/* At this stage the nick is cleared to proceed */
	127	np=newnick();
	128	strncpy(np->nick,cargv[0],NICKLEN);
	129	np->nick[NICKLEN]='\0';
	130	np->numeric=numerictolong(cargv[cargc-2],5);
	131	strncpy(np->ident,cargv[3],USERLEN);
	132	np->ident[USERLEN]='\0';
	133	np->host=findorcreatehost(cargv[4]);
	134	np->realname=findorcreaterealname(cargv[cargc-1]);
	135	np->nextbyhost=np->host->nicks;
	136	np->host->nicks=np;
	137	np->nextbyrealname=np->realname->nicks;
	138	np->realname->nicks=np;
	139	np->timestamp=timestamp;
526e7c1d P	140
	141	base64toip(cargv[cargc-3], &ipaddress);
	142	/* todo: use a single node for /64 prefixes */
	143	np->ipnode = refnode(iptree, &ipaddress, irc_in_addr_is_ipv4(&ipaddress) ? PATRICIA_MAXBITS : 64);
96644df6	144	node_increment_usercount(np->ipnode);
526e7c1d	145
c86edd1d Q	146	np->shident=NULL;
c86edd1d Q	147	np->sethost=NULL;
843184e3	148	np->opername=NULL;
c86edd1d Q	149	np->umodes=0;
	150	np->marker=0;
	151	memset(np->exts, 0, MAXNICKEXTS * sizeof(void *));
	152	np->authname[0]='\0';
47657339	153	np->auth=NULL;
c86edd1d	154	if(cargc>=9) {
843184e3 CP	155	int sethostarg = 6, opernamearg = 6, accountarg = 6;
843184e3 CP	156
c86edd1d	157	setflags(&(np->umodes),UMODE_ALL,cargv[5],umodeflags,REJECT_NONE);
843184e3 CP	158
	159	if(IsOper(np) && (serverlist[myhub].flags & SMODE_OPERNAME)) {
	160	accountarg++;
	161	sethostarg++;
	162
	163	np->opername=getsstring(cargv[opernamearg],ACCOUNTLEN);
	164	}
	165
c86edd1d	166	if (IsAccount(np)) {
843184e3 CP	167	sethostarg++;
	168
	169	if ((accountts=strchr(cargv[accountarg],':'))) {
c86edd1d	170	*accountts++='\0';
47657339 C	171	np->accountts=strtoul(accountts,&accountid,10);
47657339 C	172	if(accountid) {
c153c0dc	173	userid=strtoul(accountid + 1,&accountflags,10);
47657339 C	174	if(!userid) {
	175	np->auth=NULL;
	176	} else {
843184e3	177	np->auth=findorcreateauthname(userid, cargv[accountarg]);
47657339 C	178	np->auth->usercount++;
	179	np->nextbyauthname=np->auth->nicks;
	180	np->auth->nicks=np;
0b0fb773 CP	181	if(accountflags)
0b0fb773 CP	182	np->auth->flags=strtoul(accountflags + 1,NULL,10);
47657339 C	183	}
	184	} else {
	185	np->auth=NULL;
	186	}
c86edd1d Q	187	} else {
c86edd1d Q	188	np->accountts=0;
47657339	189	np->auth=NULL;
c86edd1d	190	}
843184e3	191	strncpy(np->authname,cargv[accountarg],ACCOUNTLEN);
c86edd1d Q	192	np->authname[ACCOUNTLEN]='\0';
c86edd1d Q	193	}
843184e3	194	if (IsSetHost(np) && (fakehost=strchr(cargv[sethostarg],'@'))) {
c86edd1d Q	195	/* valid sethost */
c86edd1d Q	196	*fakehost++='\0';
843184e3	197	np->shident=getsstring(cargv[sethostarg],USERLEN);
c86edd1d Q	198	np->sethost=getsstring(fakehost,HOSTLEN);
	199	}
	200	}
	201
	202	/* Place this nick in the server nick table. Note that nh is valid from the numeric check above */
	203	if (*nh) {
	204	/* There was a nick there already -- we have a masked numeric collision
	205	* This shouldn't happen, but if it does the newer nick takes precedence
	206	* (the two nicks are from the same server, and if the server has reissued
	207	* the masked numeric it must believe the old user no longer exists).
	208	*/
	209	Error("nick",ERR_ERROR,"Masked numeric collision for %s [%s vs %s]",cargv[0],cargv[cargc-2],longtonumeric((*nh)->numeric,5));
	210	deletenick(*nh);
	211	}
	212	*nh=np;
	213
	214	/* And the nick hash table */
	215	addnicktohash(np);
	216
	217	/* Trigger the hook */
	218	triggerhook(HOOK_NICK_NEWNICK,np);
	219	} else {
	220	Error("nick",ERR_WARNING,"Nick message with weird number of parameters (%d)",cargc);
	221	}
	222
	223	return CMD_OK;
	224	}
	225
	226	int handlequitmsg(void source, int cargc, char *cargv) {
	227	nick *np;
	228	void *harg[2];
	229
85c382d3	230	if (cargc>0) {
85c382d3	231	harg[1]=(void *)cargv[0];
c86edd1d Q	232	} else {
	233	harg[1]="";
	234	}
	235
	236	np=getnickbynumericstr((char *)source);
	237	if (np) {
	238	harg[0]=(void *)np;
	239	triggerhook(HOOK_NICK_QUIT, harg);
	240	deletenick(np);
	241	} else {
	242	Error("nick",ERR_WARNING,"Quit from non-existant numeric %s",(char *)source);
	243	}
	244	return CMD_OK;
	245	}
	246
	247	int handlekillmsg(void source, int cargc, char *cargv) {
	248	nick *np;
acd438c7	249	void *harg[2];
e3073692 CP	250	#warning Fix me to use source
e3073692 CP	251
c86edd1d Q	252	if (cargc<1) {
	253	Error("nick",ERR_WARNING,"Kill message with too few parameters");
	254	return CMD_ERROR;
	255	}
acd438c7 CP	256
	257	if (cargc>1) {
	258	harg[1]=(void *)cargv[1];
	259	} else {
	260	harg[1]="";
	261	}
	262
c86edd1d Q	263	np=getnickbynumericstr(cargv[0]);
c86edd1d Q	264	if (np) {
acd438c7 CP	265	harg[0]=(void *)np;
acd438c7 CP	266	triggerhook(HOOK_NICK_KILL, harg);
c86edd1d Q	267	deletenick(np);
	268	} else {
	269	Error("nick",ERR_WARNING,"Kill for non-existant numeric %s",cargv[0]);
	270	}
	271	return CMD_OK;
	272	}
	273
	274	int handleusermodemsg(void source, int cargc, char *cargv) {
	275	nick *np;
	276	flag_t oldflags;
	277	char *fakehost;
	278
	279	if (cargc<2) {
	280	Error("nick",ERR_WARNING,"Mode message with too few parameters");
	281	return CMD_LAST; /* With <2 params the channels module won't want it either */
	282	}
	283
	284	if (cargv[0][0]=='#') {
	285	/* Channel mode change, we don't care.
	286	* We don't bother checking for other channel types here, since & channel mode
	287	* changes aren't broadcast and + channels don't have mode changes :) */
	288	return CMD_OK;
	289	}
	290
	291	np=getnickbynumericstr((char *)source);
	292	if (np!=NULL) {
	293	if (ircd_strcmp(cargv[0],np->nick)) {
	294	Error("nick",ERR_WARNING,"Attempted mode change on user %s by %s",cargv[0],np->nick);
	295	return CMD_OK;
	296	}
	297	oldflags=np->umodes;
	298	setflags(&(np->umodes),UMODE_ALL,cargv[1],umodeflags,REJECT_NONE);
843184e3 CP	299
	300	if (strchr(cargv[1],'o')) { /* o always comes on its own when being set */
	301	if(serverlist[myhub].flags & SMODE_OPERNAME) {
	302	if((np->umodes & UMODE_OPER)) {
	303	np->opername = getsstring(cargv[2], ACCOUNTLEN);
	304	} else {
	305	freesstring(np->opername);
	306	}
	307	}
	308	if((np->umodes ^ oldflags) & UMODE_OPER)
	309	triggerhook(HOOK_NICK_MODEOPER,np);
	310	}
c86edd1d Q	311	if (strchr(cargv[1],'h')) { /* Have to allow +h twice.. */
	312	/* +-h: just the freesstring() calls for the -h case */
	313	freesstring(np->shident); /* freesstring(NULL) is OK */
	314	freesstring(np->sethost);
	315	np->shident=NULL;
	316	np->sethost=NULL;
	317	if (IsSetHost(np) && cargc>2) { /* +h and mask received */
	318	if ((fakehost=strchr(cargv[2],'@'))) {
	319	/* user@host change */
	320	*fakehost++='\0';
	321	np->shident=getsstring(cargv[2],USERLEN);
	322	np->sethost=getsstring(fakehost,HOSTLEN);
	323	} else {
	324	np->sethost=getsstring(cargv[2],HOSTLEN);
	325	}
	326	}
	327	triggerhook(HOOK_NICK_SETHOST, (void *)np);
	328	}
	329	} else {
	330	Error("nick",ERR_WARNING,"Usermode change by unknown user %s",(char *)source);
	331	}
	332	return CMD_OK;
	333	}
	334
	335	int handlewhoismsg(void source, int cargc, char *cargv) {
	336	nick sender,target;
	337	nick *nicks[2];
	338
	339	if (cargc<2)
	340	return CMD_OK;
	341
	342	if (strncmp(cargv[0],mynumeric->content,2)) {
	343	return CMD_OK;
	344	}
	345
	346	/* Find the sender... */
	347	if ((sender=getnickbynumericstr((char *)source))==NULL) {
	348	Error("localuser",ERR_WARNING,"WHOIS message from non existent numeric %s",(char *)source);
	349	return CMD_OK;
	350	}
	351
	352	/* :hub.splidge.netsplit.net 311 moo splidge splidge ground.stbarnab.as * :splidge
	353	:hub.splidge.netsplit.net 312 moo splidge splidge.netsplit.net :splidge's netsplit leaf
	354	:hub.splidge.netsplit.net 313 moo splidge :is an IRC Operator
	355	:hub.splidge.netsplit.net 318 moo splidge :End of /WHOIS list.
	356	*/
	357
	358	/* And the target... */
	359	if ((target=getnickbynick(cargv[1]))==NULL) {
	360	irc_send(":%s 401 %s %s :No such nick",myserver->content,sender->nick,cargv[1]);
	361	} else {
	362	irc_send(":%s 311 %s %s %s %s * :%s",myserver->content,sender->nick,target->nick,target->ident,
	363	target->host->name->content, target->realname->name->content);
	364	nicks[0]=sender; nicks[1]=target;
	365	triggerhook(HOOK_NICK_WHOISCHANNELS,nicks);
	366	if (IsOper(sender) \|\| !HIS_SERVER ) {
	367	irc_send(":%s 312 %s %s %s :%s",myserver->content,sender->nick,target->nick,
	368	serverlist[homeserver(target->numeric)].name->content,
	369	serverlist[homeserver(target->numeric)].description->content);
	370	} else {
	371	irc_send(":%s 312 %s %s " HIS_SERVERNAME " :" HIS_SERVERDESC,myserver->content,sender->nick,target->nick);
	372	}
	373	if (IsOper(target)) {
	374	irc_send(":%s 313 %s %s :is an IRC Operator",myserver->content,sender->nick,target->nick);
375	}
376	if (IsAccount(target)) {
109ba422	377	irc_send(":%s 330 %s %s %s :is authed as",myserver->content,sender->nick,target->nick,target->authname);
c86edd1d	378	}
109ba422	379	if (homeserver(target->numeric)==mylongnum && !IsService(target) && !IsHideIdle(target)) {
c86edd1d	380	irc_send(":%s 317 %s %s %ld %ld :seconds idle, signon time",myserver->content,sender->nick,target->nick,
80300a20	381	(getnettime() - target->timestamp) % (((target->numeric + target->timestamp) % 983) + 7),target->timestamp);
c86edd1d Q	382	}
	383	}
	384
	385	irc_send(":%s 318 %s %s :End of /WHOIS list.",myserver->content,sender->nick,cargv[1]);
	386	return CMD_OK;
	387	}
	388
	389	int handleaccountmsg(void source, int cargc, char *cargv) {
	390	nick *target;
47657339	391	unsigned long userid;
c86edd1d Q	392
	393	if (cargc<2) {
	394	return CMD_OK;
	395	}
	396
	397	if ((target=getnickbynumericstr(cargv[0]))==NULL) {
	398	return CMD_OK;
	399	}
	400
	401	if (IsAccount(target)) {
	402	return CMD_OK;
	403	}
	404
	405	SetAccount(target);
	406	strncpy(target->authname,cargv[1],ACCOUNTLEN);
	407	target->authname[ACCOUNTLEN]='\0';
47657339 C	408
	409	if (cargc>=3) {
	410	target->accountts=strtoul(cargv[2],NULL,10);
	411	if (cargc>=4) {
	412	userid=strtoul(cargv[3],NULL,10);
	413	if(!userid) {
	414	target->auth=NULL;
	415	} else {
5a335041	416	target->auth=findorcreateauthname(userid, target->authname);
47657339 C	417	target->auth->usercount++;
	418	target->nextbyauthname = target->auth->nicks;
	419	target->auth->nicks = target;
0b0fb773 CP	420	if (cargc>=5)
0b0fb773 CP	421	target->auth->flags=strtoul(cargv[4],NULL,10);
47657339 C	422	}
	423	} else {
	424	target->auth=NULL;
	425	}
	426	} else {
	427	target->accountts=0;
	428	target->auth=NULL;
	429	}
	430
c86edd1d	431	triggerhook(HOOK_NICK_ACCOUNT, (void *)target);
526e7c1d	432
c86edd1d Q	433	return CMD_OK;
	434	}
	435
	436	int handlestatsmsg(void source, int cargc, char *cargv) {
	437	int sourceserver;
	438	char sender=(char )source;
	439	char *replytarget;
	440	char *fromstring;
	441	nick *np;
	442
	443	if (cargc<2) {
	444	Error("nick",ERR_WARNING,"STATS request without enough parameters!");
	445	return CMD_OK;
	446	}
	447
	448	if (strlen(sender)==5) {
	449	/* client */
	450	np=getnickbynumericstr(sender);
	451	if (!np) {
	452	Error("nick",ERR_WARNING,"STATS request from unknown client %s",sender);
	453	return CMD_OK;
	454	}
	455	replytarget=np->nick;
	456	} else {
	457	Error("nick",ERR_WARNING,"STATS request from odd source %s",sender);
	458	return CMD_OK;
	459	}
	460
	461	/* Reply to stats for ANY server.. including any we are juping */
	462	sourceserver=numerictolong(cargv[1],2);
	463	if (serverlist[sourceserver].maxusernum==0) {
	464	Error("nick",ERR_WARNING,"Stats request for bad server %s",cargv[1]);
	465	return CMD_OK;
	466	}
	467	fromstring=serverlist[sourceserver].name->content;
	468
	469	switch(cargv[0][0]) {
	470	case 'u':
	471	irc_send(":%s 242 %s :Server Up %s",fromstring,replytarget,
	472	longtoduration(time(NULL)-starttime, 0));
	473	irc_send(":%s 250 %s :Highest connection count: 10 (9 clients)",fromstring,replytarget);
	474	break;
	475
	476	case 'P':
	477	irc_send(":%s 217 %s P none 0 :0x2000",fromstring,replytarget);
	478	break;
	479
	480	}
	481
	482	irc_send(":%s 219 %s %c :End of /STATS report",fromstring,replytarget,cargv[0][0]);
	483
	484	return CMD_OK;
	485	}
6885ae9c CP	486
	487	int handleprivmsg(void source, int cargc, char *cargv) {
	488	nick *sender;
	489	char *message;
	490	void *args[3];
	491
	492	if (cargc<2)
	493	return CMD_OK;
	494
	495	if (cargv[0][0]!='$')
	496	return CMD_OK;
	497
	498	sender=getnickbynumericstr((char *)source);
	499
	500	if (!match2strings(cargv[0] + 1,myserver->content))
	501	return CMD_OK;
	502
	503	message=cargv[0];
	504
	505	args[0]=sender;
	506	args[1]=cargv[0];
	507	args[2]=cargv[1];
	508
	509	triggerhook(HOOK_NICK_MASKPRIVMSG, (void *)args);
	510
	511	return CMD_OK;
	512	}
	513