Anope IRC Services  Version 1.8
ns_register.c
Go to the documentation of this file.
1 /* NickServ core functions
2  *
3  * (C) 2003-2014 Anope Team
4  * Contact us at team@anope.org
5  *
6  * Please read COPYING and README for further details.
7  *
8  * Based on the original code of Epona by Lara.
9  * Based on the original code of Services by Andy Church.
10  *
11  *
12  */
13 /*************************************************************************/
14 
15 #include "module.h"
16 #include "encrypt.h"
17 
18 static int do_confirm(User * u);
19 static int do_register(User * u);
20 static int do_resend(User * u);
21 static void myNickServHelp(User * u);
22 NickRequest *makerequest(const char *nick);
23 NickAlias *makenick(const char *nick);
24 static int do_sendregmail(User * u, NickRequest * nr);
25 int ns_do_register(User * u);
26 
33 int AnopeInit(int argc, char **argv)
34 {
35  Command *c;
36 
37  moduleAddAuthor("Anope");
38  moduleAddVersion(VERSION_STRING);
40 
41  c = createCommand("REGISTER", do_register, NULL, NICK_HELP_REGISTER,
42  -1, -1, -1, -1);
44 
45  c = createCommand("CONFIRM", do_confirm, NULL, NICK_HELP_CONFIRM, -1, -1, -1, -1);
47 
48  c = createCommand("RESEND", do_resend, NULL, NICK_HELP_RESEND, -1, -1, -1, -1);
50 
51 
53 
54  return MOD_CONT;
55 }
56 
60 void AnopeFini(void)
61 {
62 
63 }
64 
65 
66 
71 static void myNickServHelp(User * u)
72 {
73  notice_lang(s_NickServ, u, NICK_HELP_CMD_REGISTER);
74  if (NSEmailReg) {
75  notice_lang(s_NickServ, u, NICK_HELP_CMD_CONFIRM);
76  notice_lang(s_NickServ, u, NICK_HELP_CMD_RESEND);
77  }
78 }
79 
85 static int do_register(User * u)
86 {
87  NickRequest *nr = NULL, *anr = NULL;
88  NickCore *nc = NULL;
89  int prefixlen = strlen(NSGuestNickPrefix);
90  int nicklen = strlen(u->nick);
91  char *pass = strtok(NULL, " ");
92  char *email = strtok(NULL, " ");
93  char passcode[11];
94  int idx, min = 1, max = 62, i = 0;
95  int chars[] =
96  { ' ', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l',
97  'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
98  'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L',
99  'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y',
100  'Z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'
101  };
102 
103  if (readonly) {
104  notice_lang(s_NickServ, u, NICK_REGISTRATION_DISABLED);
105  return MOD_CONT;
106  }
107 
109  notice_lang(s_NickServ, u, OPER_DEFCON_DENIED);
110  return MOD_CONT;
111  }
112 
113  if (!is_oper(u) && NickRegDelay
114  && ((time(NULL) - u->my_signon) < NickRegDelay)) {
115  notice_lang(s_NickServ, u, NICK_REG_DELAY, NickRegDelay);
116  return MOD_CONT;
117  }
118 
119  if ((anr = findrequestnick(u->nick))) {
120  notice_lang(s_NickServ, u, NICK_REQUESTED);
121  return MOD_CONT;
122  }
123  /* Prevent "Guest" nicks from being registered. -TheShadow */
124 
125  /* Guest nick can now have a series of between 1 and 7 digits.
126  * --lara
127  */
128  if (nicklen <= prefixlen + 7 && nicklen >= prefixlen + 1 &&
129  stristr(u->nick, NSGuestNickPrefix) == u->nick &&
130  strspn(u->nick + prefixlen, "1234567890") == nicklen - prefixlen) {
131  notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED, u->nick);
132  return MOD_CONT;
133  }
134 
135  if (!anope_valid_nick(u->nick)) {
136  notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, u->nick);
137  return MOD_CONT;
138  }
139 
140  if (RestrictOperNicks) {
141  for (i = 0; i < RootNumber; i++) {
142  if (stristr(u->nick, ServicesRoots[i]) && !is_oper(u)) {
143  notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED,
144  u->nick);
145  return MOD_CONT;
146  }
147  }
148  for (i = 0; i < servadmins.count && (nc = servadmins.list[i]); i++) {
149  if (stristr(u->nick, nc->display) && !is_oper(u)) {
150  notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED,
151  u->nick);
152  return MOD_CONT;
153  }
154  }
155  for (i = 0; i < servopers.count && (nc = servopers.list[i]); i++) {
156  if (stristr(u->nick, nc->display) && !is_oper(u)) {
157  notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED,
158  u->nick);
159  return MOD_CONT;
160  }
161  }
162  }
163 
164  if (!pass) {
165  if (NSForceEmail) {
166  syntax_error(s_NickServ, u, "REGISTER",
167  NICK_REGISTER_SYNTAX_EMAIL);
168  } else {
169  syntax_error(s_NickServ, u, "REGISTER", NICK_REGISTER_SYNTAX);
170  }
171  } else if (NSForceEmail && !email) {
172  syntax_error(s_NickServ, u, "REGISTER",
173  NICK_REGISTER_SYNTAX_EMAIL);
174  } else if (time(NULL) < u->lastnickreg + NSRegDelay) {
175  notice_lang(s_NickServ, u, NICK_REG_PLEASE_WAIT, NSRegDelay);
176  } else if (u->na) { /* i.e. there's already such a nick regged */
177  if (u->na->status & NS_VERBOTEN) {
178  alog("%s: %s@%s tried to register FORBIDden nick %s",
179  s_NickServ, u->username, u->host, u->nick);
180  notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED, u->nick);
181  } else {
182  notice_lang(s_NickServ, u, NICK_ALREADY_REGISTERED, u->nick);
183  }
184  } else if (stricmp(u->nick, pass) == 0
185  || (StrictPasswords && strlen(pass) < 5)) {
186  notice_lang(s_NickServ, u, MORE_OBSCURE_PASSWORD);
187  } else if (enc_encrypt_check_len(strlen(pass), PASSMAX - 1)) {
188  notice_lang(s_NickServ, u, PASSWORD_TOO_LONG);
189  } else if (email && !MailValidate(email)) {
190  notice_lang(s_NickServ, u, MAIL_X_INVALID, email);
191  } else {
192  for (idx = 0; idx < 9; idx++) {
193  passcode[idx] =
194  chars[(1 +
195  (int) (((float) (max - min)) * getrandom16() /
196  (65535 + 1.0)) + min)];
197  } passcode[idx] = '\0';
198  nr = makerequest(u->nick);
199  nr->passcode = sstrdup(passcode);
200  if (enc_encrypt(pass, strlen(pass), nr->password, PASSMAX - 1) < 0) {
201  alog("Failed to encrypt password for %s", nr->nick);
202  }
203  if (email) {
204  nr->email = sstrdup(email);
205  }
206  nr->requested = time(NULL);
207  if (NSEmailReg) {
209  if (do_sendregmail(u, nr) == 0) {
210  notice_lang(s_NickServ, u, NICK_ENTER_REG_CODE, email,
211  s_NickServ);
212  alog("%s: sent registration verification code to %s",
213  s_NickServ, nr->email);
214  } else {
215  alog("%s: Unable to send registration verification mail",
216  s_NickServ);
217  notice_lang(s_NickServ, u, NICK_REG_UNABLE);
218  delnickrequest(nr); /* Delete the NickRequest if we couldnt send the mail */
219  return MOD_CONT;
220  }
221  } else {
222  do_confirm(u);
223  }
224 
225  }
226  return MOD_CONT;
227 }
228 
229 /*************************************************************************/
230 
232 {
233  return do_register(u);
234 }
235 
236 
237 static int do_confirm(User * u)
238 {
239 
240  NickRequest *nr = NULL;
241  NickAlias *na = NULL;
242  char *passcode = strtok(NULL, " ");
243  char *email = NULL;
244  int forced = 0;
245  User *utmp = NULL;
246  char modes[512];
247  int len;
248 
249  nr = findrequestnick(u->nick);
250 
251  if (NSEmailReg) {
252  if (!passcode) {
253  notice_lang(s_NickServ, u, NICK_CONFIRM_INVALID);
254  return MOD_CONT;
255  }
256 
257  if (!nr) {
258  if (is_services_admin(u)) {
259 /* If an admin, their nick is obviously already regged, so look at the passcode to get the nick
260  of the user they are trying to validate, and push that user through regardless of passcode */
261  nr = findrequestnick(passcode);
262  if (nr) {
263  utmp = finduser(passcode);
264  if (utmp) {
265  sprintf(passcode,
266  "FORCE_ACTIVATION_DUE_TO_OPER_CONFIRM %s",
267  nr->passcode);
268  passcode = strtok(passcode, " ");
269  notice_lang(s_NickServ, u, NICK_FORCE_REG,
270  nr->nick);
271  do_confirm(utmp);
272  return MOD_CONT;
273  } else {
274  passcode = sstrdup(nr->passcode);
275  forced = 1;
276  }
277  } else {
278  notice_lang(s_NickServ, u, NICK_CONFIRM_NOT_FOUND,
279  s_NickServ);
280  return MOD_CONT;
281  }
282  } else {
283  notice_lang(s_NickServ, u, NICK_CONFIRM_NOT_FOUND,
284  s_NickServ);
285  return MOD_CONT;
286  }
287  }
288 
289  if (stricmp(nr->passcode, passcode) != 0) {
290  notice_lang(s_NickServ, u, NICK_CONFIRM_INVALID);
291  return MOD_CONT;
292  }
293  }
294 
295  if (!nr) {
296  notice_lang(s_NickServ, u, NICK_REGISTRATION_FAILED);
297  return MOD_CONT;
298  }
299 
300  if (nr->email) {
301  email = sstrdup(nr->email);
302  }
303  na = makenick(nr->nick);
304 
305  if (na) {
306  int i;
307  char tsbuf[16];
308  char tmp_pass[PASSMAX];
309 
310  memcpy(na->nc->pass, nr->password, PASSMAX);
312 /* na->nc->flags |= NI_ENCRYPTEDPW; */
313 
314  na->nc->flags |= NSDefFlags;
315  for (i = 0; i < RootNumber; i++) {
316  if (!stricmp(ServicesRoots[i], nr->nick)) {
317  na->nc->flags |= NI_SERVICES_ROOT;
318  break;
319  }
320  }
321  na->nc->memos.memomax = MSMaxMemos;
322  na->nc->channelmax = CSMaxReg;
323  if (forced == 1) {
324  na->last_usermask = sstrdup("*@*");
325  na->last_realname = sstrdup("unknown");
326  } else {
327  na->last_usermask =
328  scalloc(strlen(common_get_vident(u)) +
329  strlen(common_get_vhost(u)) + 2, 1);
330  sprintf(na->last_usermask, "%s@%s", common_get_vident(u),
331  common_get_vhost(u));
332  na->last_realname = sstrdup(u->realname);
333  }
334  na->time_registered = na->last_seen = time(NULL);
335  if (NSAddAccessOnReg) {
336  na->nc->accesscount = 1;
337  na->nc->access = scalloc(sizeof(char *), 1);
338  na->nc->access[0] = create_mask(u);
339  } else {
340  na->nc->accesscount = 0;
341  na->nc->access = NULL;
342  }
343  na->nc->language = NSDefLanguage;
344  if (email)
345  na->nc->email = sstrdup(email);
346  if (forced != 1) {
347  u->na = na;
348  na->u = u;
349  alog("%s: '%s' registered by %s@%s (e-mail: %s)", s_NickServ,
350  u->nick, u->username, u->host, (email ? email : "none"));
351  if (NSAddAccessOnReg)
352  notice_lang(s_NickServ, u, NICK_REGISTERED, u->nick,
353  na->nc->access[0]);
354  else
355  notice_lang(s_NickServ, u, NICK_REGISTERED_NO_MASK,
356  u->nick);
358 
359  if(enc_decrypt(na->nc->pass, tmp_pass, PASSMAX - 1)==1)
360  notice_lang(s_NickServ, u, NICK_PASSWORD_IS, tmp_pass);
361 
362  u->lastnickreg = time(NULL);
363  if (ircd->modeonreg) {
364  len = strlen(ircd->modeonreg);
365  strncpy(modes,ircd->modeonreg,512);
366  if(ircd->rootmodeonid && is_services_root(u)) {
367  strncat(modes,ircd->rootmodeonid,512-len);
368  } else if(ircd->adminmodeonid && is_services_admin(u)) {
369  strncat(modes,ircd->adminmodeonid,512-len);
370  } else if(ircd->opermodeonid && is_services_oper(u)) {
371  strncat(modes,ircd->opermodeonid,512-len);
372  }
373 
374  if (ircd->tsonmode) {
375  snprintf(tsbuf, sizeof(tsbuf), "%lu",
376  (unsigned long int) u->timestamp);
377  common_svsmode(u, modes, tsbuf);
378  } else {
379  common_svsmode(u, modes, NULL);
380  }
381  }
382 
383  } else {
384  free(passcode);
385  notice_lang(s_NickServ, u, NICK_FORCE_REG, nr->nick);
386  }
387  delnickrequest(nr); /* remove the nick request */
388  } else {
389  alog("%s: makenick(%s) failed", s_NickServ, u->nick);
390  notice_lang(s_NickServ, u, NICK_REGISTRATION_FAILED);
391  }
392 
393  if (email)
394  free(email);
395 
396  /* Enable nick tracking if enabled */
397  if (NSNickTracking)
399 
400  return MOD_CONT;
401 }
402 
403 NickRequest *makerequest(const char *nick)
404 {
405  NickRequest *nr;
406 
407  nr = scalloc(1, sizeof(NickRequest));
408  nr->nick = sstrdup(nick);
409  insert_requestnick(nr);
410  alog("%s: Nick %s has been requested", s_NickServ, nr->nick);
411  return nr;
412 }
413 
414 /* Creates a full new nick (alias + core) in NickServ database. */
415 
416 NickAlias *makenick(const char *nick)
417 {
418  NickAlias *na;
419  NickCore *nc;
420 
421  /* First make the core */
422  nc = scalloc(1, sizeof(NickCore));
423  nc->display = sstrdup(nick);
424  slist_init(&nc->aliases);
425  insert_core(nc);
426  alog("%s: group %s has been created", s_NickServ, nc->display);
427 
428  /* Then make the alias */
429  na = scalloc(1, sizeof(NickAlias));
430  na->nick = sstrdup(nick);
431  na->nc = nc;
432  slist_add(&nc->aliases, na);
433  alpha_insert_alias(na);
434  return na;
435 }
436 
437 /* Register a nick. */
438 
439 static int do_resend(User * u)
440 {
441  NickRequest *nr = NULL;
442  if (NSEmailReg) {
443  if ((nr = findrequestnick(u->nick))) {
444  if (time(NULL) < nr->lastmail + NSResendDelay) {
445  notice_lang(s_NickServ, u, MAIL_LATER);
446  return MOD_CONT;
447  }
448  if (do_sendregmail(u, nr) == 0) {
449  nr->lastmail = time(NULL);
450  notice_lang(s_NickServ, u, NICK_REG_RESENT, nr->email);
451  alog("%s: re-sent registration verification code for %s to %s", s_NickServ, nr->nick, nr->email);
452  } else {
453  alog("%s: Unable to re-send registration verification mail for %s", s_NickServ, nr->nick);
454  return MOD_CONT;
455  }
456  }
457  }
458  return MOD_CONT;
459 }
460 
461 static int do_sendregmail(User * u, NickRequest * nr)
462 {
463  MailInfo *mail = NULL;
464  char buf[BUFSIZE];
465 
466  if (!(nr || u)) {
467  return -1;
468  }
469  snprintf(buf, sizeof(buf), getstring2(NULL, NICK_REG_MAIL_SUBJECT),
470  nr->nick);
471  mail = MailRegBegin(u, nr, buf, s_NickServ);
472  if (!mail) {
473  return -1;
474  }
475  fprintf(mail->pipe, "%s", getstring2(NULL, NICK_REG_MAIL_HEAD));
476  fprintf(mail->pipe, "\n\n");
477  fprintf(mail->pipe, getstring2(NULL, NICK_REG_MAIL_LINE_1), nr->nick);
478  fprintf(mail->pipe, "\n\n");
479  fprintf(mail->pipe, getstring2(NULL, NICK_REG_MAIL_LINE_2), s_NickServ,
480  nr->passcode);
481  fprintf(mail->pipe, "\n\n");
482  fprintf(mail->pipe, "%s", getstring2(NULL, NICK_REG_MAIL_LINE_3));
483  fprintf(mail->pipe, "\n\n");
484  fprintf(mail->pipe, "%s", getstring2(NULL, NICK_REG_MAIL_LINE_4));
485  fprintf(mail->pipe, "\n\n");
486  fprintf(mail->pipe, getstring2(NULL, NICK_REG_MAIL_LINE_5),
487  NetworkName);
488  fprintf(mail->pipe, "\n.\n");
489  MailEnd(mail);
490  return 0;
491 }
492 
E int is_oper(User *user)
Definition: users.c:937
E int CSMaxReg
Definition: extern.h:403
E size_t strspn(const char *s, const char *accept)
Definition: compat.c:106
char * email
Definition: services.h:519
#define EVENT_NICK_REGISTERED
Definition: events.h:43
#define NI_SERVICES_ROOT
Definition: services.h:1305
E int readonly
Definition: extern.h:776
char ** access
Definition: services.h:551
void AnopeFini(void)
Definition: ns_register.c:60
E void insert_core(NickCore *nc)
Definition: nickserv.c:1370
E int RestrictOperNicks
Definition: extern.h:359
char nick[NICKMAX]
Definition: services.h:875
E int snprintf(char *buf, size_t size, const char *fmt,...)
Definition: compat.c:37
char * adminmodeonid
Definition: services.h:309
E int checkDefCon(int level)
Definition: operserv.c:1608
E u_int16_t getrandom16(void)
Definition: misc.c:1061
E IRCDVar * ircd
Definition: extern.h:39
E int NSEmailReg
Definition: extern.h:396
char * passcode
Definition: services.h:517
E SList servadmins
Definition: extern.h:971
E void send_event(const char *name, int argc,...)
Definition: events.c:37
E int NSNickTracking
Definition: extern.h:399
char * opermodeonid
Definition: services.h:310
E int delnickrequest(NickRequest *nr)
Definition: nickserv.c:1554
E int stricmp(const char *s1, const char *s2)
Definition: compat.c:58
E char * stristr(char *s1, char *s2)
Definition: misc.c:113
int ns_do_register(User *u)
Definition: ns_register.c:231
#define NS_RECOGNIZED
Definition: services.h:1276
#define NS_VERBOTEN
Definition: services.h:1273
E int NSDefLanguage
Definition: extern.h:378
uint16 language
Definition: services.h:549
char password[PASSMAX]
Definition: services.h:518
char * host
Definition: services.h:878
char * modeonreg
Definition: services.h:307
#define getstring2(nc, index)
Definition: extern.h:733
E char * NetworkName
Definition: extern.h:281
uint16 accesscount
Definition: services.h:550
MemoInfo memos
Definition: services.h:552
MDE void moduleAddAuthor(const char *author)
Definition: modules.c:1772
E void syntax_error(char *service, User *u, const char *command, int msgnum)
Definition: language.c:295
E void alpha_insert_alias(NickAlias *na)
Definition: nickserv.c:1338
E void notice_lang(char *source, User *dest, int message,...)
Definition: send.c:169
MDE void moduleSetType(MODType type)
Definition: modules.c:818
E char * sstrdup(const char *s)
Definition: memory.c:105
time_t requested
Definition: services.h:520
NickCore * nc
Definition: services.h:533
E void * scalloc(long elsize, long els)
Definition: memory.c:55
char * display
Definition: services.h:542
E int is_services_root(User *u)
Definition: operserv.c:577
static int do_resend(User *u)
Definition: ns_register.c:439
struct smtp_message mail
Definition: smtp.h:125
void ** list
Definition: slist.h:21
time_t my_signon
Definition: services.h:887
E int enc_encrypt(const char *src, int len, char *dest, int size)
Definition: encrypt.c:50
int16 memomax
Definition: services.h:505
E NickRequest * findrequestnick(const char *nick)
Definition: nickserv.c:1218
FILE * pipe
Definition: services.h:1068
int16 count
Definition: slist.h:23
E int NSRegDelay
Definition: extern.h:379
E int NickRegDelay
Definition: extern.h:356
#define PASSMAX
Definition: config.h:65
E User * finduser(const char *nick)
Definition: users.c:323
static void myNickServHelp(User *u)
Definition: ns_register.c:71
uint16 status
Definition: services.h:532
MDE void moduleAddVersion(const char *version)
Definition: modules.c:1760
Command * c
Definition: ns_recover.c:17
E void alog(const char *fmt,...) FORMAT(printf
#define MOD_CONT
Definition: modules.h:54
int16_t int16
Definition: db-merger.c:120
time_t time_registered
Definition: services.h:530
static int do_register(User *u)
Definition: ns_register.c:85
E int NSAddAccessOnReg
Definition: extern.h:400
E int is_services_admin(User *u)
Definition: operserv.c:591
E void MailEnd(MailInfo *mail)
Definition: mail.c:206
E int NSDefFlags
Definition: extern.h:377
E int enc_encrypt_check_len(int passlen, int bufsize)
Definition: encrypt.c:66
char * nick
Definition: services.h:526
char * username
Definition: services.h:877
uint16 channelmax
Definition: services.h:554
char * last_realname
Definition: services.h:528
E char * create_mask(User *u)
Definition: users.c:1122
E char * NSGuestNickPrefix
Definition: extern.h:393
MDE void moduleSetNickHelp(void(*func)(User *u))
Definition: modules.c:2078
Definition: modules.h:99
int AnopeInit(int argc, char **argv)
Definition: ns_register.c:33
MDE Command * createCommand(const char *name, int(*func)(User *u), int(*has_priv)(User *u), int help_all, int help_reg, int help_oper, int help_admin, int help_root)
Definition: modules.c:987
int tsonmode
Definition: services.h:339
E char ** ServicesRoots
Definition: extern.h:434
char pass[PASSMAX]
Definition: services.h:543
time_t lastmail
Definition: services.h:521
#define NS_IDENTIFIED
Definition: services.h:1275
time_t lastnickreg
Definition: services.h:913
E int StrictPasswords
Definition: extern.h:341
SList aliases
Definition: services.h:559
static int do_confirm(User *u)
Definition: ns_register.c:237
#define EVENT_NICK_REQUESTED
Definition: events.h:44
E int is_services_oper(User *u)
Definition: operserv.c:606
NickRequest * makerequest(const char *nick)
Definition: ns_register.c:403
E void insert_requestnick(NickRequest *nr)
Definition: nickserv.c:1391
E void slist_init(SList *slist)
Definition: slist.c:302
E int NSResendDelay
Definition: extern.h:380
uint32 flags
Definition: services.h:548
E void common_svsmode(User *u, char *modes, char *arg)
Definition: actions.c:228
E int enc_decrypt(const char *src, char *dest, int size)
Definition: encrypt.c:80
time_t last_seen
Definition: services.h:531
E int slist_add(SList *slist, void *item)
Definition: slist.c:29
#define DEFCON_NO_NEW_NICKS
Definition: services.h:1255
User * u
Definition: services.h:536
char * nick
Definition: services.h:516
E char * s_NickServ
Definition: extern.h:284
static int do_sendregmail(User *u, NickRequest *nr)
Definition: ns_register.c:461
E int MSMaxMemos
Definition: extern.h:415
MDE int moduleAddCommand(CommandHash *cmdTable[], Command *c, int pos)
Definition: modules.c:1082
E SList servopers
Definition: extern.h:972
char * last_usermask
Definition: services.h:529
time_t timestamp
Definition: services.h:886
E int NSForceEmail
Definition: extern.h:383
char * rootmodeonid
Definition: services.h:308
E char * common_get_vhost(User *u)
Definition: actions.c:251
E int MailValidate(const char *email)
Definition: mail.c:296
E int anope_valid_nick(char *nick)
Definition: ircd.c:661
#define BUFSIZE
Definition: config.h:47
E int RootNumber
Definition: extern.h:435
#define NICKSERV
Definition: modules.h:59
char * realname
Definition: services.h:883
E char * common_get_vident(User *u)
Definition: actions.c:272
NickAlias * na
Definition: services.h:892
#define MOD_UNIQUE
Definition: module.h:11
NickAlias * makenick(const char *nick)
Definition: ns_register.c:416
char * email
Definition: services.h:544
E MailInfo * MailRegBegin(User *u, NickRequest *nr, char *subject, char *service)
Definition: mail.c:29
E void nsStartNickTracking(User *u)
Definition: nickserv.c:1962