ircd-hybrid/contrib/m_services.c

/*
 *  ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
 *  m_services.c: SVS commands and Services support
 *
 *  Copyright (C) 2005 by the past and present ircd coders, and others.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 *  USA
 *
 *  $Id$
 */
/*
 *
 * With code from 'bane' the URL following is valid as of this date.
 * http://hybserv2.net/file/trunk/contrib/hybrid_services.c
 *
 *
 *   Copyright (C) 2002, 2003, 2004, 2005 by Dragan 'bane' Dosen and the
 *   Hybrid Development Team.
 *
 *   Based on m_services.c, originally from bahamut ircd.
 *
 *   Contact info:
 *
 *     E-mail : bane@idolnet.org
 *     IRC    : (*) bane, idolNET, irc.idolnet.org, #twilight_zone
 */

/* MODULE CONFIGURATION FOLLOWS -- please read!! */

/* Change this to the name of your services server
 * otherwise the services aliases will not work!
 */
#define SERVICES_NAME "services.yournet.net"

/* END OF MODULE CONFIGURATION */

#include "stdinc.h"
#include "handlers.h"
#include "client.h"
#include "hash.h"
#include "ircd.h"
#include "numeric.h"
#include "s_conf.h"
#include "s_user.h"
#include "whowas.h"
#include "s_serv.h"
#include "send.h"
#include "channel.h"
#include "resv.h"
#include "msg.h"
#include "parse.h"
#include "modules.h"
#include "common.h"
#include "packet.h"

/* Custom Macros */
#define services_function(a,b,c) static void a(struct Client *client_p,\
        struct Client *source_p, int parc,\
        char *parv[]) \
{ deliver_services_msg(b, c, client_p, source_p, parc, parv); }

static void mo_svsnick(struct Client *, struct Client *, int, char *[]);

static void m_botserv(struct Client *, struct Client *, int, char *[]);
static void m_chanserv(struct Client *, struct Client *, int, char *[]);
static void m_global(struct Client *, struct Client *, int, char *[]);
static void m_helpserv(struct Client *, struct Client *, int, char *[]);
static void m_hostserv(struct Client *, struct Client *, int, char *[]);
static void m_identify(struct Client *, struct Client *, int, char *[]);
static void m_memoserv(struct Client *, struct Client *, int, char *[]);
static void m_nickserv(struct Client *, struct Client *, int, char *[]);
static void m_operserv(struct Client *, struct Client *, int, char *[]);
static void m_seenserv(struct Client *, struct Client *, int, char *[]);
static void m_statserv(struct Client *, struct Client *, int, char *[]);

static void get_string(int, char *[], char *);
static int clean_nick_name(char *, int);
static void deliver_services_msg(const char *, const char *, struct Client *,
                                 struct Client *, int, char *[]);

/* SVS commands */
struct Message svsnick_msgtab = {
  "SVSNICK", 0, 0, 3, 0, MFLG_SLOW, 0,
  {m_unregistered, m_not_oper, mo_svsnick, mo_svsnick, mo_svsnick, m_ignore}
};

/* Services */
struct Message botserv_msgtab = {
  "BOTSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_botserv, m_ignore, m_ignore, m_botserv, m_ignore}
};

struct Message chanserv_msgtab = {
  "CHANSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_chanserv, m_ignore, m_ignore, m_chanserv, m_ignore}
};

struct Message global_msgtab = {
  "GLOBAL", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_global, m_ignore, m_ignore, m_global, m_ignore}
};

struct Message helpserv_msgtab = {
  "HELPSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_helpserv, m_ignore, m_ignore, m_helpserv, m_ignore}
};

struct Message hostserv_msgtab = {
  "HOSTSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_hostserv, m_ignore, m_ignore, m_hostserv, m_ignore}
};

struct Message memoserv_msgtab = {
  "MEMOSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_memoserv, m_ignore, m_ignore, m_memoserv, m_ignore}
};

struct Message nickserv_msgtab = {
  "NICKSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_nickserv, m_ignore, m_ignore, m_nickserv, m_ignore}
};

struct Message operserv_msgtab = {
  "OPERSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_operserv, m_ignore, m_ignore, m_operserv, m_ignore}
};

struct Message seenserv_msgtab = {
  "SEENSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_seenserv, m_ignore, m_ignore, m_seenserv, m_ignore}
};

struct Message statserv_msgtab = {
  "STATSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_statserv, m_ignore, m_ignore, m_statserv, m_ignore}
};

/* Short-hand aliases for NickServ, ChanServ, MemoServ and OperServ */
struct Message cs_msgtab = {
  "CS", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_chanserv, m_ignore, m_ignore, m_chanserv, m_ignore}
};

struct Message identify_msgtab = {
  "IDENTIFY", 0, 0, 0, 2, MFLG_SLOW, 0,
  {m_unregistered, m_identify, m_ignore, m_ignore, m_identify, m_ignore}
};

struct Message ms_msgtab = {
  "MS", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_memoserv, m_ignore, m_ignore, m_memoserv, m_ignore}
};

struct Message ns_msgtab = {
  "NS", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_nickserv, m_ignore, m_ignore, m_nickserv, m_ignore}
};

struct Message os_msgtab = {
  "OS", 0, 0, 1, 0, MFLG_SLOW, 0,
  {m_unregistered, m_operserv, m_ignore, m_ignore, m_operserv, m_ignore}
};

INIT_MODULE(m_services, "$Revision$")
{
  mod_add_cmd(&svsnick_msgtab);
  mod_add_cmd(&botserv_msgtab);
  mod_add_cmd(&chanserv_msgtab); 
  mod_add_cmd(&global_msgtab);
  mod_add_cmd(&helpserv_msgtab);
  mod_add_cmd(&hostserv_msgtab);
  mod_add_cmd(&identify_msgtab);
  mod_add_cmd(&memoserv_msgtab);
  mod_add_cmd(&nickserv_msgtab);
  mod_add_cmd(&operserv_msgtab);
  mod_add_cmd(&seenserv_msgtab);
  mod_add_cmd(&statserv_msgtab);
  mod_add_cmd(&ns_msgtab);
  mod_add_cmd(&cs_msgtab);
  mod_add_cmd(&ms_msgtab);
  mod_add_cmd(&os_msgtab);
}

CLEANUP_MODULE
{
  mod_del_cmd(&svsnick_msgtab);
  mod_del_cmd(&botserv_msgtab);
  mod_del_cmd(&chanserv_msgtab); 
  mod_del_cmd(&global_msgtab);
  mod_del_cmd(&helpserv_msgtab);
  mod_del_cmd(&hostserv_msgtab);
  mod_del_cmd(&identify_msgtab);
  mod_del_cmd(&memoserv_msgtab);
  mod_del_cmd(&nickserv_msgtab);
  mod_del_cmd(&operserv_msgtab);
  mod_del_cmd(&seenserv_msgtab);
  mod_del_cmd(&statserv_msgtab);
  mod_del_cmd(&ns_msgtab);
  mod_del_cmd(&cs_msgtab);
  mod_del_cmd(&ms_msgtab);
  mod_del_cmd(&os_msgtab);
}

/*
 * mo_svsnick()
 *
 * parv[0] = sender prefix
 * parv[1] = user to force
 * parv[2] = nick to force them to
 */
static void
mo_svsnick(struct Client *client_p, struct Client *source_p,
           int parc, char *parv[])
{
  char newnick[NICKLEN];
  struct Client *target_p = NULL;

  if (MyClient(source_p) && !IsOperAdmin(source_p))
  {
    sendto_one(source_p, form_str(ERR_NOPRIVS),
               me.name, parv[0], "SVSNICK");
    return;
  }

  if (parc < 3 || *parv[2] == '\0')
  {
    sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
               me.name, parv[0], "SVSNICK");
    return;
  }

  if ((target_p = find_person(client_p, parv[1])) == NULL)
  {
    sendto_one(source_p, form_str(ERR_NOSUCHNICK),
               me.name, parv[0], parv[1]);
    return;
  }

  /* terminate nick to NICKLEN */
  strlcpy(newnick, parv[2], sizeof(newnick));

  if (!clean_nick_name(newnick, 1))
  {
    if (IsClient(source_p))
      sendto_one(source_p, ":%s NOTICE %s :*** Notice -- Invalid new ",
                 "nickname: %s", me.name, parv[0], newnick);
    return;
  }

  if (find_client(newnick) != NULL)
  {
    if (IsClient(source_p))
      sendto_one(source_p, ":%s NOTICE %s :*** Notice -- Nickname %s is "
                 "already in use", me.name, parv[0], newnick);
    return;
  }

  if (MyConnect(target_p))
    change_local_nick(&me, target_p, newnick);
  else
    sendto_one(target_p, ":%s ENCAP %s SVSNICK %s %s",
               me.name, target_p->servptr->name, ID(target_p), newnick);
}

/*
 * These generate the services functions through
 * a macro.
 */
services_function(m_botserv,  "BotServ",  "BOTSERV" )
services_function(m_chanserv, "ChanServ", "CHANSERV")
services_function(m_global,   "Global",   "GLOBAL"  )
services_function(m_helpserv, "HelpServ", "HELPSERV")
services_function(m_hostserv, "HostServ", "HOSTSERV")
services_function(m_memoserv, "MemoServ", "MEMOSERV")
services_function(m_nickserv, "NickServ", "NICKSERV")
services_function(m_operserv, "OperServ", "OPERSERV")
services_function(m_seenserv, "SeenServ", "SEENSERV")
services_function(m_statserv, "StatServ", "STATSERV")

/*
 * get_string() 
 *
 * Reverse the array parv back into a normal string assuming
 * there are "parc" indicies in the array.
 *
 * Originally GetString() written by sidewndr.
 * Modified by Michael for use with hybrid-7.
*/
static void
get_string(int parc, char *parv[], char *buf)
{
  int ii = 0;
  int bw = 0;

  for (; ii < parc; ++ii)
    bw += ircsprintf(buf+bw, "%s ", parv[ii]);
  buf[bw-1] = '\0';
}

/*
 * clean_nick_name()
 *
 * input        - nickname
 * output       - none
 * side effects - walks through the nickname, returning 0 if erroneous
 */
static int
clean_nick_name(char *nick, int local)
{
  assert(nick);

  /* nicks can't start with a digit or - or be 0 length */
  /* This closer duplicates behaviour of hybrid-6 */

  if (*nick == '-' || (IsDigit(*nick) && local) || *nick == '\0')
    return 0;

  for (; *nick; ++nick)
    if (!IsNickChar(*nick))
      return 0;

  return 1;
}

/*
 * m_identify()
 *
 * parv[0] = sender prefix
 * parv[1] = NickServ Password or Channel
 * parv[2] = ChanServ Password
 */
static void
m_identify(struct Client *client_p, struct Client *source_p,
           int parc, char *parv[])
{
  struct Client *target_p = NULL;

  switch (parc)
  {
    case 2:
      if (!(target_p = find_server(SERVICES_NAME)))
        sendto_one(source_p, form_str(ERR_SERVICESDOWN),
                   me.name, source_p->name);
      else
        sendto_one(target_p, ":%s PRIVMSG NickServ@%s :IDENTIFY %s",
                   source_p->name, SERVICES_NAME, parv[1]);
      break;

    case 3:
      if (!(target_p = find_server(SERVICES_NAME)))
        sendto_one(source_p, form_str(ERR_SERVICESDOWN),
                   me.name, source_p->name);
      else
        sendto_one(target_p, ":%s PRIVMSG ChanServ@%s :IDENTIFY %s %s",
                   source_p->name, SERVICES_NAME, parv[1], parv[2]);
      break;

    default:
      sendto_one(source_p, ":%s NOTICE %s :Syntax: IDENTIFY <password> "
                 "- for nickname", me.name, source_p->name);
      sendto_one(source_p, ":%s NOTICE %s :Syntax: IDENTIFY <channel> "
                 "<password> - for channel", me.name, source_p->name);
      break;
  }
}

/*
 * deliver_services_msg()
 *
 * parv[0] = sender prefix
 * servmsg = message for services (utilising GetString())
 *
 * Borrowed from HybServ -- knight-
 */
static void
deliver_services_msg(const char *service, const char *command,
                     struct Client *client_p,
                     struct Client *source_p, int parc, char *parv[])
{
  struct Client *target_p = NULL;
  char buf[IRCD_BUFSIZE] = { '\0' };

  if (parc < 2 || *parv[1] == '\0')
  {
    sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
               me.name, source_p->name, command);
    return;
  }

  if (!(target_p = find_server(SERVICES_NAME)))
    sendto_one(source_p, form_str(ERR_SERVICESDOWN),
               me.name, source_p->name);
  else
  {
    get_string(parc - 1, parv + 1, buf);
    sendto_one(target_p, ":%s PRIVMSG %s@%s :%s",
               source_p->name, service, SERVICES_NAME, buf);
  }
}
Revision:	515
Committed:	Sun Mar 5 09:26:04 2006 UTC (20 years, 5 months ago) by michael
Content type:	text/x-csrc
File size:	12029 byte(s)
Log Message:	- Moved tstats() to m_stats.c and killed s_stats.(c\|h) - Got rid of extra ServerStats pointer - Killed ms_error which was basically a duplication of m_error
#	User	Rev	Content
1	adx	30	/*
2			* ircd-hybrid: an advanced Internet Relay Chat Daemon(ircd).
3			* m_services.c: SVS commands and Services support
4			*
5			* Copyright (C) 2005 by the past and present ircd coders, and others.
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License as published by
9			* the Free Software Foundation; either version 2 of the License, or
10			* (at your option) any later version.
11			*
12			* This program is distributed in the hope that it will be useful,
13			* but WITHOUT ANY WARRANTY; without even the implied warranty of
14			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			* GNU General Public License for more details.
16			*
17			* You should have received a copy of the GNU General Public License
18			* along with this program; if not, write to the Free Software
19			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
20			* USA
21			*
22	knight	31	* $Id$
23	adx	30	*/
24			/*
25			*
26			* With code from 'bane' the URL following is valid as of this date.
27			* http://hybserv2.net/file/trunk/contrib/hybrid_services.c
28			*
29			*
30			* Copyright (C) 2002, 2003, 2004, 2005 by Dragan 'bane' Dosen and the
31			* Hybrid Development Team.
32			*
33			* Based on m_services.c, originally from bahamut ircd.
34			*
35			* Contact info:
36			*
37			* E-mail : bane@idolnet.org
38			* IRC : (*) bane, idolNET, irc.idolnet.org, #twilight_zone
39			*/
40
41			/* MODULE CONFIGURATION FOLLOWS -- please read!! */
42
43			/* Change this to the name of your services server
44			* otherwise the services aliases will not work!
45			*/
46			#define SERVICES_NAME "services.yournet.net"
47
48			/* END OF MODULE CONFIGURATION */
49
50			#include "stdinc.h"
51			#include "handlers.h"
52			#include "client.h"
53			#include "hash.h"
54			#include "ircd.h"
55			#include "numeric.h"
56			#include "s_conf.h"
57			#include "s_user.h"
58			#include "whowas.h"
59			#include "s_serv.h"
60			#include "send.h"
61			#include "channel.h"
62			#include "resv.h"
63			#include "msg.h"
64			#include "parse.h"
65			#include "modules.h"
66			#include "common.h"
67			#include "packet.h"
68
69			/* Custom Macros */
70			#define services_function(a,b,c) static void a(struct Client *client_p,\
71			struct Client *source_p, int parc,\
72			char *parv[]) \
73			{ deliver_services_msg(b, c, client_p, source_p, parc, parv); }
74
75			static void mo_svsnick(struct Client , struct Client , int, char *[]);
76
77			static void m_botserv(struct Client , struct Client , int, char *[]);
78			static void m_chanserv(struct Client , struct Client , int, char *[]);
79			static void m_global(struct Client , struct Client , int, char *[]);
80			static void m_helpserv(struct Client , struct Client , int, char *[]);
81			static void m_hostserv(struct Client , struct Client , int, char *[]);
82			static void m_identify(struct Client , struct Client , int, char *[]);
83			static void m_memoserv(struct Client , struct Client , int, char *[]);
84			static void m_nickserv(struct Client , struct Client , int, char *[]);
85			static void m_operserv(struct Client , struct Client , int, char *[]);
86			static void m_seenserv(struct Client , struct Client , int, char *[]);
87			static void m_statserv(struct Client , struct Client , int, char *[]);
88
89			static void get_string(int, char [], char );
90			static int clean_nick_name(char *, int);
91			static void deliver_services_msg(const char , const char , struct Client *,
92			struct Client , int, char []);
93
94			/* SVS commands */
95			struct Message svsnick_msgtab = {
96			"SVSNICK", 0, 0, 3, 0, MFLG_SLOW, 0,
97			{m_unregistered, m_not_oper, mo_svsnick, mo_svsnick, mo_svsnick, m_ignore}
98			};
99
100			/* Services */
101			struct Message botserv_msgtab = {
102			"BOTSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
103			{m_unregistered, m_botserv, m_ignore, m_ignore, m_botserv, m_ignore}
104			};
105
106			struct Message chanserv_msgtab = {
107			"CHANSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
108			{m_unregistered, m_chanserv, m_ignore, m_ignore, m_chanserv, m_ignore}
109			};
110
111			struct Message global_msgtab = {
112			"GLOBAL", 0, 0, 1, 0, MFLG_SLOW, 0,
113			{m_unregistered, m_global, m_ignore, m_ignore, m_global, m_ignore}
114			};
115
116			struct Message helpserv_msgtab = {
117			"HELPSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
118			{m_unregistered, m_helpserv, m_ignore, m_ignore, m_helpserv, m_ignore}
119			};
120
121			struct Message hostserv_msgtab = {
122			"HOSTSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
123			{m_unregistered, m_hostserv, m_ignore, m_ignore, m_hostserv, m_ignore}
124			};
125
126			struct Message memoserv_msgtab = {
127			"MEMOSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
128			{m_unregistered, m_memoserv, m_ignore, m_ignore, m_memoserv, m_ignore}
129			};
130
131			struct Message nickserv_msgtab = {
132			"NICKSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
133			{m_unregistered, m_nickserv, m_ignore, m_ignore, m_nickserv, m_ignore}
134			};
135
136			struct Message operserv_msgtab = {
137			"OPERSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
138			{m_unregistered, m_operserv, m_ignore, m_ignore, m_operserv, m_ignore}
139			};
140
141			struct Message seenserv_msgtab = {
142			"SEENSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
143			{m_unregistered, m_seenserv, m_ignore, m_ignore, m_seenserv, m_ignore}
144			};
145
146			struct Message statserv_msgtab = {
147			"STATSERV", 0, 0, 1, 0, MFLG_SLOW, 0,
148			{m_unregistered, m_statserv, m_ignore, m_ignore, m_statserv, m_ignore}
149			};
150
151			/* Short-hand aliases for NickServ, ChanServ, MemoServ and OperServ */
152			struct Message cs_msgtab = {
153			"CS", 0, 0, 1, 0, MFLG_SLOW, 0,
154			{m_unregistered, m_chanserv, m_ignore, m_ignore, m_chanserv, m_ignore}
155			};
156
157			struct Message identify_msgtab = {
158			"IDENTIFY", 0, 0, 0, 2, MFLG_SLOW, 0,
159			{m_unregistered, m_identify, m_ignore, m_ignore, m_identify, m_ignore}
160			};
161
162			struct Message ms_msgtab = {
163			"MS", 0, 0, 1, 0, MFLG_SLOW, 0,
164			{m_unregistered, m_memoserv, m_ignore, m_ignore, m_memoserv, m_ignore}
165			};
166
167			struct Message ns_msgtab = {
168			"NS", 0, 0, 1, 0, MFLG_SLOW, 0,
169			{m_unregistered, m_nickserv, m_ignore, m_ignore, m_nickserv, m_ignore}
170			};
171
172			struct Message os_msgtab = {
173			"OS", 0, 0, 1, 0, MFLG_SLOW, 0,
174			{m_unregistered, m_operserv, m_ignore, m_ignore, m_operserv, m_ignore}
175			};
176
177	adx	443	INIT_MODULE(m_services, "$Revision$")
178	adx	30	{
179			mod_add_cmd(&svsnick_msgtab);
180			mod_add_cmd(&botserv_msgtab);
181			mod_add_cmd(&chanserv_msgtab);
182			mod_add_cmd(&global_msgtab);
183			mod_add_cmd(&helpserv_msgtab);
184			mod_add_cmd(&hostserv_msgtab);
185			mod_add_cmd(&identify_msgtab);
186			mod_add_cmd(&memoserv_msgtab);
187			mod_add_cmd(&nickserv_msgtab);
188			mod_add_cmd(&operserv_msgtab);
189			mod_add_cmd(&seenserv_msgtab);
190			mod_add_cmd(&statserv_msgtab);
191			mod_add_cmd(&ns_msgtab);
192			mod_add_cmd(&cs_msgtab);
193			mod_add_cmd(&ms_msgtab);
194			mod_add_cmd(&os_msgtab);
195			}
196
197	adx	443	CLEANUP_MODULE
198	adx	30	{
199			mod_del_cmd(&svsnick_msgtab);
200			mod_del_cmd(&botserv_msgtab);
201			mod_del_cmd(&chanserv_msgtab);
202			mod_del_cmd(&global_msgtab);
203			mod_del_cmd(&helpserv_msgtab);
204			mod_del_cmd(&hostserv_msgtab);
205			mod_del_cmd(&identify_msgtab);
206			mod_del_cmd(&memoserv_msgtab);
207			mod_del_cmd(&nickserv_msgtab);
208			mod_del_cmd(&operserv_msgtab);
209			mod_del_cmd(&seenserv_msgtab);
210			mod_del_cmd(&statserv_msgtab);
211			mod_del_cmd(&ns_msgtab);
212			mod_del_cmd(&cs_msgtab);
213			mod_del_cmd(&ms_msgtab);
214			mod_del_cmd(&os_msgtab);
215			}
216
217			/*
218			* mo_svsnick()
219			*
220			* parv[0] = sender prefix
221			* parv[1] = user to force
222			* parv[2] = nick to force them to
223			*/
224			static void
225			mo_svsnick(struct Client client_p, struct Client source_p,
226			int parc, char *parv[])
227			{
228			char newnick[NICKLEN];
229			struct Client *target_p = NULL;
230
231			if (MyClient(source_p) && !IsOperAdmin(source_p))
232			{
233			sendto_one(source_p, form_str(ERR_NOPRIVS),
234			me.name, parv[0], "SVSNICK");
235			return;
236			}
237
238			if (parc < 3 \|\| *parv[2] == '\0')
239			{
240			sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
241			me.name, parv[0], "SVSNICK");
242			return;
243			}
244
245			if ((target_p = find_person(client_p, parv[1])) == NULL)
246			{
247			sendto_one(source_p, form_str(ERR_NOSUCHNICK),
248			me.name, parv[0], parv[1]);
249			return;
250			}
251
252			/* terminate nick to NICKLEN */
253			strlcpy(newnick, parv[2], sizeof(newnick));
254
255			if (!clean_nick_name(newnick, 1))
256			{
257			if (IsClient(source_p))
258			sendto_one(source_p, ":%s NOTICE %s :*** Notice -- Invalid new ",
259			"nickname: %s", me.name, parv[0], newnick);
260			return;
261			}
262
263			if (find_client(newnick) != NULL)
264			{
265			if (IsClient(source_p))
266			sendto_one(source_p, ":%s NOTICE %s :*** Notice -- Nickname %s is "
267			"already in use", me.name, parv[0], newnick);
268			return;
269			}
270
271			if (MyConnect(target_p))
272			change_local_nick(&me, target_p, newnick);
273			else
274			sendto_one(target_p, ":%s ENCAP %s SVSNICK %s %s",
275			me.name, target_p->servptr->name, ID(target_p), newnick);
276			}
277
278			/*
279			* These generate the services functions through
280			* a macro.
281			*/
282			services_function(m_botserv, "BotServ", "BOTSERV" )
283			services_function(m_chanserv, "ChanServ", "CHANSERV")
284			services_function(m_global, "Global", "GLOBAL" )
285			services_function(m_helpserv, "HelpServ", "HELPSERV")
286			services_function(m_hostserv, "HostServ", "HOSTSERV")
287			services_function(m_memoserv, "MemoServ", "MEMOSERV")
288			services_function(m_nickserv, "NickServ", "NICKSERV")
289			services_function(m_operserv, "OperServ", "OPERSERV")
290			services_function(m_seenserv, "SeenServ", "SEENSERV")
291			services_function(m_statserv, "StatServ", "STATSERV")
292
293			/*
294			* get_string()
295			*
296			* Reverse the array parv back into a normal string assuming
297			* there are "parc" indicies in the array.
298			*
299			* Originally GetString() written by sidewndr.
300			* Modified by Michael for use with hybrid-7.
301			*/
302			static void
303			get_string(int parc, char parv[], char buf)
304			{
305			int ii = 0;
306			int bw = 0;
307
308			for (; ii < parc; ++ii)
309			bw += ircsprintf(buf+bw, "%s ", parv[ii]);
310			buf[bw-1] = '\0';
311			}
312
313			/*
314			* clean_nick_name()
315			*
316			* input - nickname
317			* output - none
318			* side effects - walks through the nickname, returning 0 if erroneous
319			*/
320			static int
321			clean_nick_name(char *nick, int local)
322			{
323			assert(nick);
324
325			/* nicks can't start with a digit or - or be 0 length */
326			/* This closer duplicates behaviour of hybrid-6 */
327
328			if (nick == '-' \|\| (IsDigit(nick) && local) \|\| *nick == '\0')
329			return 0;
330
331			for (; *nick; ++nick)
332			if (!IsNickChar(*nick))
333			return 0;
334
335			return 1;
336			}
337
338			/*
339			* m_identify()
340			*
341			* parv[0] = sender prefix
342			* parv[1] = NickServ Password or Channel
343			* parv[2] = ChanServ Password
344			*/
345			static void
346			m_identify(struct Client client_p, struct Client source_p,
347			int parc, char *parv[])
348			{
349			struct Client *target_p = NULL;
350
351			switch (parc)
352			{
353			case 2:
354			if (!(target_p = find_server(SERVICES_NAME)))
355			sendto_one(source_p, form_str(ERR_SERVICESDOWN),
356			me.name, source_p->name);
357			else
358			sendto_one(target_p, ":%s PRIVMSG NickServ@%s :IDENTIFY %s",
359			source_p->name, SERVICES_NAME, parv[1]);
360			break;
361
362			case 3:
363			if (!(target_p = find_server(SERVICES_NAME)))
364			sendto_one(source_p, form_str(ERR_SERVICESDOWN),
365			me.name, source_p->name);
366			else
367			sendto_one(target_p, ":%s PRIVMSG ChanServ@%s :IDENTIFY %s %s",
368			source_p->name, SERVICES_NAME, parv[1], parv[2]);
369			break;
370
371			default:
372			sendto_one(source_p, ":%s NOTICE %s :Syntax: IDENTIFY <password> "
373			"- for nickname", me.name, source_p->name);
374			sendto_one(source_p, ":%s NOTICE %s :Syntax: IDENTIFY <channel> "
375			"<password> - for channel", me.name, source_p->name);
376			break;
377			}
378			}
379
380			/*
381			* deliver_services_msg()
382			*
383			* parv[0] = sender prefix
384			* servmsg = message for services (utilising GetString())
385			*
386			* Borrowed from HybServ -- knight-
387			*/
388			static void
389			deliver_services_msg(const char service, const char command,
390			struct Client *client_p,
391			struct Client source_p, int parc, char parv[])
392			{
393			struct Client *target_p = NULL;
394			char buf[IRCD_BUFSIZE] = { '\0' };
395
396			if (parc < 2 \|\| *parv[1] == '\0')
397			{
398			sendto_one(source_p, form_str(ERR_NEEDMOREPARAMS),
399			me.name, source_p->name, command);
400			return;
401			}
402
403			if (!(target_p = find_server(SERVICES_NAME)))
404			sendto_one(source_p, form_str(ERR_SERVICESDOWN),
405			me.name, source_p->name);
406			else
407			{
408			get_string(parc - 1, parv + 1, buf);
409			sendto_one(target_p, ":%s PRIVMSG %s@%s :%s",
410			source_p->name, service, SERVICES_NAME, buf);
411			}
412			}