[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);
    np->ipnode = refnode(iptree, &ipaddress, PATRICIA_MAXBITS);
    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;
    np->accountts=0;
    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],':'))) {
          time_t accountts_t=strtoul(accountts,&accountid,10)
          *accountts++='\0';
          if(accountid) {
            strncpy(np->authname,cargv[accountarg],ACCOUNTLEN);
            np->authname[ACCOUNTLEN]='\0';
            np->accountts=accountts_t;

            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);
            }
          }
        }        
      } 
      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);
          np->opername = NULL;
        }
      }
      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;
  time_t accountts;
  flag_t accountflags;

  if (cargc<4) {
    return CMD_OK;
  }
  
  if ((target=getnickbynumericstr(cargv[0]))==NULL) {
    return CMD_OK;
  }
  
  accountts=strtoul(cargv[2],NULL,10);
  userid=strtoul(cargv[3],NULL,10);
  if(cargv>=5)
    accountflags=strtoul(cargv[4],NULL,10);

  /* allow user flags to change if all fields match */
  if (IsAccount(target)) {
    void *arg[2];

    if (!target->auth || strcmp(target->authname,cargv[1]) || (target->auth->userid != userid) || (target->accountts != accountts)) {
      return CMD_OK;
    }

    arg[0] = (void *)target->auth;
    arg[1] = (void *)(long)target->auth->flags;
    
    if (cargc>=5)
      target->auth->flags=accountflags;

    triggerhook(HOOK_AUTH_FLAGSUPDATED, (void *)arg);

    /* TODO: trigger flag update hook */
    return CMD_OK;
  }
  
  SetAccount(target);
  strncpy(target->authname,cargv[1],ACCOUNTLEN);
  target->authname[ACCOUNTLEN]='\0';
  target->accountts=accountts;

  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=accountflags;
  }

  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
526e7c1d P	141	base64toip(cargv[cargc-3], &ipaddress);
071d403d	142	np->ipnode = refnode(iptree, &ipaddress, PATRICIA_MAXBITS);
96644df6	143	node_increment_usercount(np->ipnode);
526e7c1d	144
c86edd1d Q	145	np->shident=NULL;
c86edd1d Q	146	np->sethost=NULL;
843184e3	147	np->opername=NULL;
c86edd1d Q	148	np->umodes=0;
	149	np->marker=0;
	150	memset(np->exts, 0, MAXNICKEXTS * sizeof(void *));
	151	np->authname[0]='\0';
47657339	152	np->auth=NULL;
c4ffdb9b	153	np->accountts=0;
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],':'))) {
94699bdc	170	time_t accountts_t=strtoul(accountts,&accountid,10)
c86edd1d	171	*accountts++='\0';
47657339	172	if(accountid) {
c4ffdb9b CP	173	strncpy(np->authname,cargv[accountarg],ACCOUNTLEN);
c4ffdb9b CP	174	np->authname[ACCOUNTLEN]='\0';
94699bdc	175	np->accountts=accountts_t;
c4ffdb9b	176
c153c0dc	177	userid=strtoul(accountid + 1,&accountflags,10);
47657339 C	178	if(!userid) {
	179	np->auth=NULL;
	180	} else {
843184e3	181	np->auth=findorcreateauthname(userid, cargv[accountarg]);
47657339 C	182	np->auth->usercount++;
	183	np->nextbyauthname=np->auth->nicks;
	184	np->auth->nicks=np;
0b0fb773 CP	185	if(accountflags)
0b0fb773 CP	186	np->auth->flags=strtoul(accountflags + 1,NULL,10);
47657339	187	}
47657339	188	}
c86edd1d	189	}
c86edd1d	190	}
843184e3	191	if (IsSetHost(np) && (fakehost=strchr(cargv[sethostarg],'@'))) {
c86edd1d Q	192	/* valid sethost */
c86edd1d Q	193	*fakehost++='\0';
843184e3	194	np->shident=getsstring(cargv[sethostarg],USERLEN);
c86edd1d Q	195	np->sethost=getsstring(fakehost,HOSTLEN);
	196	}
	197	}
	198
	199	/* Place this nick in the server nick table. Note that nh is valid from the numeric check above */
	200	if (*nh) {
	201	/* There was a nick there already -- we have a masked numeric collision
	202	* This shouldn't happen, but if it does the newer nick takes precedence
	203	* (the two nicks are from the same server, and if the server has reissued
	204	* the masked numeric it must believe the old user no longer exists).
	205	*/
	206	Error("nick",ERR_ERROR,"Masked numeric collision for %s [%s vs %s]",cargv[0],cargv[cargc-2],longtonumeric((*nh)->numeric,5));
	207	deletenick(*nh);
	208	}
	209	*nh=np;
	210
	211	/* And the nick hash table */
	212	addnicktohash(np);
	213
	214	/* Trigger the hook */
	215	triggerhook(HOOK_NICK_NEWNICK,np);
	216	} else {
	217	Error("nick",ERR_WARNING,"Nick message with weird number of parameters (%d)",cargc);
	218	}
	219
	220	return CMD_OK;
	221	}
	222
	223	int handlequitmsg(void source, int cargc, char *cargv) {
	224	nick *np;
	225	void *harg[2];
	226
85c382d3	227	if (cargc>0) {
85c382d3	228	harg[1]=(void *)cargv[0];
c86edd1d Q	229	} else {
	230	harg[1]="";
	231	}
	232
	233	np=getnickbynumericstr((char *)source);
	234	if (np) {
	235	harg[0]=(void *)np;
	236	triggerhook(HOOK_NICK_QUIT, harg);
	237	deletenick(np);
	238	} else {
	239	Error("nick",ERR_WARNING,"Quit from non-existant numeric %s",(char *)source);
	240	}
	241	return CMD_OK;
	242	}
	243
	244	int handlekillmsg(void source, int cargc, char *cargv) {
	245	nick *np;
acd438c7	246	void *harg[2];
e3073692 CP	247	#warning Fix me to use source
e3073692 CP	248
c86edd1d Q	249	if (cargc<1) {
	250	Error("nick",ERR_WARNING,"Kill message with too few parameters");
	251	return CMD_ERROR;
	252	}
acd438c7 CP	253
	254	if (cargc>1) {
	255	harg[1]=(void *)cargv[1];
	256	} else {
	257	harg[1]="";
	258	}
	259
c86edd1d Q	260	np=getnickbynumericstr(cargv[0]);
c86edd1d Q	261	if (np) {
acd438c7 CP	262	harg[0]=(void *)np;
acd438c7 CP	263	triggerhook(HOOK_NICK_KILL, harg);
c86edd1d Q	264	deletenick(np);
	265	} else {
	266	Error("nick",ERR_WARNING,"Kill for non-existant numeric %s",cargv[0]);
	267	}
	268	return CMD_OK;
	269	}
	270
	271	int handleusermodemsg(void source, int cargc, char *cargv) {
	272	nick *np;
	273	flag_t oldflags;
	274	char *fakehost;
	275
	276	if (cargc<2) {
	277	Error("nick",ERR_WARNING,"Mode message with too few parameters");
	278	return CMD_LAST; /* With <2 params the channels module won't want it either */
	279	}
	280
	281	if (cargv[0][0]=='#') {
	282	/* Channel mode change, we don't care.
	283	* We don't bother checking for other channel types here, since & channel mode
	284	* changes aren't broadcast and + channels don't have mode changes :) */
	285	return CMD_OK;
	286	}
	287
	288	np=getnickbynumericstr((char *)source);
	289	if (np!=NULL) {
	290	if (ircd_strcmp(cargv[0],np->nick)) {
	291	Error("nick",ERR_WARNING,"Attempted mode change on user %s by %s",cargv[0],np->nick);
	292	return CMD_OK;
	293	}
	294	oldflags=np->umodes;
	295	setflags(&(np->umodes),UMODE_ALL,cargv[1],umodeflags,REJECT_NONE);
843184e3 CP	296
	297	if (strchr(cargv[1],'o')) { /* o always comes on its own when being set */
	298	if(serverlist[myhub].flags & SMODE_OPERNAME) {
	299	if((np->umodes & UMODE_OPER)) {
	300	np->opername = getsstring(cargv[2], ACCOUNTLEN);
	301	} else {
	302	freesstring(np->opername);
1a0e3977	303	np->opername = NULL;
843184e3 CP	304	}
	305	}
	306	if((np->umodes ^ oldflags) & UMODE_OPER)
	307	triggerhook(HOOK_NICK_MODEOPER,np);
	308	}
c86edd1d Q	309	if (strchr(cargv[1],'h')) { /* Have to allow +h twice.. */
	310	/* +-h: just the freesstring() calls for the -h case */
	311	freesstring(np->shident); /* freesstring(NULL) is OK */
	312	freesstring(np->sethost);
	313	np->shident=NULL;
	314	np->sethost=NULL;
	315	if (IsSetHost(np) && cargc>2) { /* +h and mask received */
	316	if ((fakehost=strchr(cargv[2],'@'))) {
	317	/* user@host change */
	318	*fakehost++='\0';
	319	np->shident=getsstring(cargv[2],USERLEN);
	320	np->sethost=getsstring(fakehost,HOSTLEN);
	321	} else {
	322	np->sethost=getsstring(cargv[2],HOSTLEN);
	323	}
	324	}
	325	triggerhook(HOOK_NICK_SETHOST, (void *)np);
	326	}
	327	} else {
	328	Error("nick",ERR_WARNING,"Usermode change by unknown user %s",(char *)source);
	329	}
	330	return CMD_OK;
	331	}
	332
	333	int handlewhoismsg(void source, int cargc, char *cargv) {
	334	nick sender,target;
	335	nick *nicks[2];
	336
	337	if (cargc<2)
	338	return CMD_OK;
	339
	340	if (strncmp(cargv[0],mynumeric->content,2)) {
	341	return CMD_OK;
	342	}
	343
	344	/* Find the sender... */
	345	if ((sender=getnickbynumericstr((char *)source))==NULL) {
	346	Error("localuser",ERR_WARNING,"WHOIS message from non existent numeric %s",(char *)source);
	347	return CMD_OK;
	348	}
	349
	350	/* :hub.splidge.netsplit.net 311 moo splidge splidge ground.stbarnab.as * :splidge
	351	:hub.splidge.netsplit.net 312 moo splidge splidge.netsplit.net :splidge's netsplit leaf
	352	:hub.splidge.netsplit.net 313 moo splidge :is an IRC Operator
	353	:hub.splidge.netsplit.net 318 moo splidge :End of /WHOIS list.
	354	*/
	355
	356	/* And the target... */
	357	if ((target=getnickbynick(cargv[1]))==NULL) {
	358	irc_send(":%s 401 %s %s :No such nick",myserver->content,sender->nick,cargv[1]);
	359	} else {
	360	irc_send(":%s 311 %s %s %s %s * :%s",myserver->content,sender->nick,target->nick,target->ident,
	361	target->host->name->content, target->realname->name->content);
	362	nicks[0]=sender; nicks[1]=target;
	363	triggerhook(HOOK_NICK_WHOISCHANNELS,nicks);
	364	if (IsOper(sender) \|\| !HIS_SERVER ) {
	365	irc_send(":%s 312 %s %s %s :%s",myserver->content,sender->nick,target->nick,
	366	serverlist[homeserver(target->numeric)].name->content,
	367	serverlist[homeserver(target->numeric)].description->content);
	368	} else {
	369	irc_send(":%s 312 %s %s " HIS_SERVERNAME " :" HIS_SERVERDESC,myserver->content,sender->nick,target->nick);
	370	}
	371	if (IsOper(target)) {
	372	irc_send(":%s 313 %s %s :is an IRC Operator",myserver->content,sender->nick,target->nick);
373	}
374	if (IsAccount(target)) {
109ba422	375	irc_send(":%s 330 %s %s %s :is authed as",myserver->content,sender->nick,target->nick,target->authname);
c86edd1d	376	}
109ba422	377	if (homeserver(target->numeric)==mylongnum && !IsService(target) && !IsHideIdle(target)) {
c86edd1d	378	irc_send(":%s 317 %s %s %ld %ld :seconds idle, signon time",myserver->content,sender->nick,target->nick,
80300a20	379	(getnettime() - target->timestamp) % (((target->numeric + target->timestamp) % 983) + 7),target->timestamp);
c86edd1d Q	380	}
	381	}
	382
	383	irc_send(":%s 318 %s %s :End of /WHOIS list.",myserver->content,sender->nick,cargv[1]);
	384	return CMD_OK;
	385	}
	386
	387	int handleaccountmsg(void source, int cargc, char *cargv) {
	388	nick *target;
47657339	389	unsigned long userid;
c4ffdb9b CP	390	time_t accountts;
	391	flag_t accountflags;
	392
	393	if (cargc<4) {
c86edd1d Q	394	return CMD_OK;
	395	}
	396
	397	if ((target=getnickbynumericstr(cargv[0]))==NULL) {
	398	return CMD_OK;
	399	}
	400
c4ffdb9b CP	401	accountts=strtoul(cargv[2],NULL,10);
	402	userid=strtoul(cargv[3],NULL,10);
	403	if(cargv>=5)
	404	accountflags=strtoul(cargv[4],NULL,10);
	405
	406	/* allow user flags to change if all fields match */
c86edd1d	407	if (IsAccount(target)) {
c4ffdb9b CP	408	void *arg[2];
	409
	410	if (!target->auth \|\| strcmp(target->authname,cargv[1]) \|\| (target->auth->userid != userid) \|\| (target->accountts != accountts)) {
	411	return CMD_OK;
	412	}
	413
	414	arg[0] = (void *)target->auth;
	415	arg[1] = (void *)(long)target->auth->flags;
	416
	417	if (cargc>=5)
	418	target->auth->flags=accountflags;
	419
	420	triggerhook(HOOK_AUTH_FLAGSUPDATED, (void *)arg);
	421
	422	/* TODO: trigger flag update hook */
c86edd1d Q	423	return CMD_OK;
	424	}
	425
	426	SetAccount(target);
	427	strncpy(target->authname,cargv[1],ACCOUNTLEN);
	428	target->authname[ACCOUNTLEN]='\0';
c4ffdb9b CP	429	target->accountts=accountts;
	430
	431	if(!userid) {
47657339	432	target->auth=NULL;
c4ffdb9b CP	433	} else {
	434	target->auth=findorcreateauthname(userid, target->authname);
	435	target->auth->usercount++;
	436	target->nextbyauthname = target->auth->nicks;
	437	target->auth->nicks = target;
	438	if (cargc>=5)
	439	target->auth->flags=accountflags;
47657339	440	}
c4ffdb9b	441
c86edd1d	442	triggerhook(HOOK_NICK_ACCOUNT, (void *)target);
526e7c1d	443
c86edd1d Q	444	return CMD_OK;
	445	}
	446
	447	int handlestatsmsg(void source, int cargc, char *cargv) {
	448	int sourceserver;
	449	char sender=(char )source;
	450	char *replytarget;
	451	char *fromstring;
	452	nick *np;
	453
	454	if (cargc<2) {
	455	Error("nick",ERR_WARNING,"STATS request without enough parameters!");
	456	return CMD_OK;
	457	}
	458
	459	if (strlen(sender)==5) {
	460	/* client */
	461	np=getnickbynumericstr(sender);
	462	if (!np) {
	463	Error("nick",ERR_WARNING,"STATS request from unknown client %s",sender);
	464	return CMD_OK;
	465	}
	466	replytarget=np->nick;
	467	} else {
	468	Error("nick",ERR_WARNING,"STATS request from odd source %s",sender);
	469	return CMD_OK;
	470	}
	471
	472	/* Reply to stats for ANY server.. including any we are juping */
	473	sourceserver=numerictolong(cargv[1],2);
	474	if (serverlist[sourceserver].maxusernum==0) {
	475	Error("nick",ERR_WARNING,"Stats request for bad server %s",cargv[1]);
	476	return CMD_OK;
	477	}
	478	fromstring=serverlist[sourceserver].name->content;
	479
	480	switch(cargv[0][0]) {
	481	case 'u':
	482	irc_send(":%s 242 %s :Server Up %s",fromstring,replytarget,
	483	longtoduration(time(NULL)-starttime, 0));
	484	irc_send(":%s 250 %s :Highest connection count: 10 (9 clients)",fromstring,replytarget);
	485	break;
	486
	487	case 'P':
	488	irc_send(":%s 217 %s P none 0 :0x2000",fromstring,replytarget);
	489	break;
	490
	491	}
	492
	493	irc_send(":%s 219 %s %c :End of /STATS report",fromstring,replytarget,cargv[0][0]);
	494
	495	return CMD_OK;
	496	}
6885ae9c CP	497
	498	int handleprivmsg(void source, int cargc, char *cargv) {
	499	nick *sender;
	500	char *message;
	501	void *args[3];
	502
	503	if (cargc<2)
	504	return CMD_OK;
	505
	506	if (cargv[0][0]!='$')
	507	return CMD_OK;
	508
	509	sender=getnickbynumericstr((char *)source);
	510
	511	if (!match2strings(cargv[0] + 1,myserver->content))
	512	return CMD_OK;
	513
	514	message=cargv[0];
	515
	516	args[0]=sender;
	517	args[1]=cargv[0];
	518	args[2]=cargv[1];
	519
	520	triggerhook(HOOK_NICK_MASKPRIVMSG, (void *)args);
	521
	522	return CMD_OK;
	523	}
	524