IRCForumları - IRC ve mIRC Kullanıcılarının Buluşma Noktası

IRCForumları - IRC ve mIRC Kullanıcılarının Buluşma Noktası (https://www.ircforumlari.net/)
-   IRCServices (https://www.ircforumlari.net/ircservices/)
-   -   mynet services. (https://www.ircforumlari.net/ircservices/336185-mynet-services.html)

KezMan 24 Mayıs 2010 15:38

mynet services.
 
merhaba bu forumda mynetin serviceslerini bir arkadasımız yayımlamıştı bende indirip kendi sunucuma kurdum yalnız 1 sıkıntım var oda sadece mynet.com uzantılı mailden sifreleyebiliyorsun nicki ben bunu serbest kılmak istiyorum nereden değiştirebilirim acaba birde nicki ilk sifreledigimizde tekrar sunucuya aynı identle girince nick degismiyor bunuda nereden yapabilirim acaba iyi calısmalar. iyi calısmalar.

insane 24 Mayıs 2010 17:11

Cevap: mynet services.
 
cd ircservices-*/modules/nickserv
pico main.c

burdalar dediklerin kendine göre ayarlarsın.

Not: sıfırdan ircservices kurup kendin editlersen daha iyi olur, çünkü bir çok düzenlenmesi gereken yerler var onlarla uğraşacağına kendin kur kendin editle hepsi forumda mevcut..

OxiGeN 25 Mayıs 2010 14:39

Cevap: mynet services.
 
main.c yi gönderirsen neyi silmen gerektiğini gösteririm.
kodu tam hatırlamıyorum. Sky-dancer vermişti o kodu..

KezMan 25 Mayıs 2010 15:44

Cevap: mynet services.
 
işte main.c burada baska neleri ayarlamam gerek sunucuma göre yardımcı olursan sevinirim..

Kod:

/* Main NickServ module.
 *
 * IRC Services is copyright (c) 1996-2007 Andrew Church.
 *    E-mail: <
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
>
 * Parts written by Andrew Kempe and others.
 * This program is free but copyrighted software; see the file COPYING for
 * details.
 */

#include "services.h"
#include "modules.h"
#include "conffile.h"
#include "language.h"
#include "commands.h"
#include "encrypt.h"
#include "modules/operserv/operserv.h"

#include "nickserv.h"
#include "ns-local.h"

/*************************************************************************/

static Module *module;

static int cb_command      = -1;
static int cb_help          = -1;
static int cb_help_cmds    = -1;
      int cb_reglink_check = -1;  /* called from util.c */
static int cb_registered    = -1;
static int cb_id_check      = -1;
static int cb_identified    = -1;

static int db_opened = 0;

      char *s_NickServ;
static char *desc_NickServ;
static char *NickDBName;
EXPORT_VAR(char *,s_NickServ)

      int32  NSRegEmailMax;
      int    NSRequireEmail;
      time_t NSRegDelay;
      time_t NSInitialRegDelay;
      int32  NSDefFlags;
      time_t N***pire;
      time_t N***pireWarning;
      int    NSShowPassword;
      char * NSEnforcerUser;
      char * NSEnforcerHost;
      int    NSForceNickChange;
      time_t NSReleaseTimeout;
      int    NSAllowKillImmed;
      int    NSListOpersOnly;
      int32  NSListMax;
      int    NSSecureAdmins;
      time_t NSSuspendExpire;
      time_t NSSuspendGrace;
static int    NSHelpWarning;
static int    NSEnableDropEmail;
static time_t NSDropEmailExpire;

/*************************************************************************/

static void do_help(User *u);
static void do_register(User *u);
static void do_identify(User *u);
static void do_drop(User *u);
static void do_dropnick(User *u);
static void do_dropemail(User *u);
static void do_dropemail_confirm(User *u);
static void do_info(User *u);
static void do_listchans(User *u);
static void do_list(User *u);
static void do_listemail(User *u);
static void do_recover(User *u);
static void do_release(User *u);
static void do_ghost(User *u);
static void do_status(User *u);
static void do_getpass(User *u);
static void do_forbid(User *u);
static void do_suspend(User *u);
static void do_unsuspend(User *u);
#ifdef DEBUG_COMMANDS
static void do_listnick(User *u);
#endif

/*************************************************************************/

static Command cmds[] = {
    { "HELP",    do_help,    NULL,  -1,                    -1,-1 },
    { "REGISTER", do_register, NULL,  NICK_HELP_REGISTER,    -1,-1 },
    { "IDENTIFY", do_identify, NULL,  NICK_HELP_IDENTIFY,    -1,-1 },
    { "SIDENTIFY",do_identify, NULL,  -1,                    -1,-1 },
    { "DROP",    do_drop,    NULL,  NICK_HELP_DROP,        -1,-1 },
    { "SET",      do_set,      NULL,  NICK_HELP_SET,
        -1, NICK_OPER_HELP_SET },
    { "SET PASSWORD", NULL,    NULL,  NICK_HELP_SET_PASSWORD, -1,-1 },
    { "SET URL",      NULL,    NULL,  NICK_HELP_SET_URL,      -1,-1 },
    { "SET EMAIL",    NULL,    NULL,  NICK_HELP_SET_EMAIL,    -1,-1 },
    { "SET INFO",    NULL,    NULL,  NICK_HELP_SET_INFO,    -1,-1 },
    { "SET KILL",    NULL,    NULL,  NICK_HELP_SET_KILL,    -1,-1 },
    { "SET SECURE",  NULL,    NULL,  NICK_HELP_SET_SECURE,  -1,-1 },
    { "SET PRIVATE",  NULL,    NULL,  NICK_HELP_SET_PRIVATE,  -1,-1 },
    { "SET HIDE",    NULL,    NULL,  NICK_HELP_SET_HIDE,    -1,-1 },
    { "SET TIMEZONE", NULL,    NULL,  NICK_HELP_SET_TIMEZONE, -1,-1 },
    { "SET NOEXPIRE", NULL,    NULL,  -1, -1,
        NICK_OPER_HELP_SET_NOEXPIRE },
    { "UNSET",    do_unset,    NULL,  NICK_HELP_UNSET,
        -1, NICK_OPER_HELP_UNSET },
    { "RECOVER",  do_recover,  NULL,  NICK_HELP_RECOVER,      -1,-1 },
    { "RELEASE",  do_release,  NULL,  NICK_HELP_RELEASE,      -1,-1 },
    { "GHOST",    do_ghost,    NULL,  NICK_HELP_GHOST,        -1,-1 },
    { "INFO",    do_info,    NULL,  NICK_HELP_INFO,
        -1, NICK_OPER_HELP_INFO },
    { "LIST",    do_list,    NULL,  -1,
        NICK_HELP_LIST, NICK_OPER_HELP_LIST },
    { "LISTEMAIL",do_listemail,NULL,  -1,
        NICK_HELP_LISTEMAIL, NICK_OPER_HELP_LISTEMAIL },
    { "STATUS",  do_status,  NULL,  NICK_HELP_STATUS,      -1,-1 },
    { "LISTCHANS",do_listchans,NULL,  NICK_HELP_LISTCHANS,
        -1, NICK_OPER_HELP_LISTCHANS },

    { "DROPNICK", do_dropnick, is_services_root, -1,
        -1, NICK_OPER_HELP_DROPNICK },
    { "DROPEMAIL",do_dropemail,is_services_admin, -1,
        -1, NICK_OPER_HELP_DROPEMAIL },
    { "DROPEMAIL-CONFIRM", do_dropemail_confirm, is_services_admin, -1,
        -1, NICK_OPER_HELP_DROPEMAIL },
    { "GETPASS",  do_getpass,  is_services_root, -1,
        -1, NICK_OPER_HELP_GETPASS },
    { "FORBID",  do_forbid,  is_services_root, -1,
        -1, NICK_OPER_HELP_FORBID },
    { "SUSPEND",  do_suspend,  is_services_admin, -1,
        -1, NICK_OPER_HELP_SUSPEND },
    { "UNSUSPEND",do_unsuspend,is_services_admin, -1,
        -1, NICK_OPER_HELP_UNSUSPEND },
#ifdef DEBUG_COMMANDS
    { "LISTNICK", do_listnick, is_services_root, -1, -1, -1 },
#endif
    { NULL }
};

/*************************************************************************/
/************************ Main NickServ routines *************************/
/*************************************************************************/

/* Introduce the NickServ pseudoclient. */

static int introduce_nickserv(const char *nick)
{
    if (!nick || irc_stricmp(nick, s_NickServ) == 0) {
    char modebuf[BUFSIZE];
    snprintf(modebuf, sizeof(modebuf), "o%s", pseudoclient_modes);
    send_nick(s_NickServ, ServiceUser, ServiceHost, ServerName,
          desc_NickServ, modebuf);
    return nick ? 1 : 0;
    }
    return 0;
}

/*************************************************************************/

/* Main NickServ routine. */

static int nickserv(const char *source, const char *target, char *buf)
{
    char *cmd;
    User *u = get_user(source);

    if (irc_stricmp(target, s_NickServ) != 0)
    return 0;

    if (!u) {
    module_log("user record for %s not found", source);
    notice(s_NickServ, source,
        getstring(NULL, INTERNAL_ERROR));
    return 1;
    }

    cmd = strtok(buf, " ");

    if (!cmd) {
    return 1;
    } else if (stricmp(cmd, "\1PING") == 0) {
    const char *s;
    if (!(s = strtok(NULL, "")))
        s = "\1";
    notice(s_NickServ, source, "\1PING %s", s);
    } else {
    if (call_callback_2(module, cb_command, u, cmd) <= 0)
        run_cmd(s_NickServ, u, module, cmd);
    }
    return 1;

}

/*************************************************************************/

/* Return a /WHOIS response for NickServ. */

static int nickserv_whois(const char *source, char *who, char *extra)
{
    if (irc_stricmp(who, s_NickServ) != 0)
    return 0;
    send_cmd(ServerName, "311 %s %s %s %s * :%s", source, who,
        ServiceUser, ServiceHost, desc_NickServ);
    send_cmd(ServerName, "312 %s %s %s :%s", source, who,
        ServerName, ServerDesc);
    send_cmd(ServerName, "313 %s %s :is a network service", source, who);
    send_cmd(ServerName, "318 %s %s End of /WHOIS response.", source, who);
    return 1;
}

/*************************************************************************/

/* Save nickname database. */

static int do_save_data()
{
    sync_nick_db(NickDBName);
    return 0;
}

/*************************************************************************/
/*************************************************************************/

/* Callback for users connecting to the network. */

static int do_user_create(User *user, int ac, char **av)
{
    validate_user(user);
    return 0;
}

/*************************************************************************/

/* Callbacks for users changing nicknames (before and after). */

static int do_user_nickchange_before(User *user, const char *newnick)
{
    /* Changing nickname case isn't a real change; pop out immediately
    * in that case. */
    if (irc_stricmp(newnick, user->nick) == 0)
    return 0;

    cancel_user(user);
    return 0;
}

static int do_user_nickchange_after(User *user, const char *oldnick)
{
    /* Changing nickname case isn't a real change; pop out immediately
    * in that case. */
    if (irc_stricmp(oldnick, user->nick) == 0)
    return 0;

    user->my_signon = time(NULL);
    validate_user(user);
    if (usermode_reg) {
    if (user_identified(user)) {
        send_cmd(s_NickServ, "SVSMODE %s :+%s", user->nick,
            mode_flags_to_string(usermode_reg, MODE_USER));
        user->mode |= usermode_reg;
    } else {
        send_cmd(s_NickServ, "SVSMODE %s :-%s", user->nick,
            mode_flags_to_string(usermode_reg, MODE_USER));
        user->mode &= ~usermode_reg;
    }
    }
    return 0;
}

/*************************************************************************/

/* Callback for users disconnecting from the network. */

static int do_user_delete(User *user, const char *reason)
{
    NickInfo *ni = user->ni;
    int i, j;

    if (user_recognized(user)) {
    free(ni->last_quit);
    ni->last_quit = *reason ? sstrdup(reason) : NULL;
    put_nickinfo(ni);
    }
    ARRAY_FOREACH (i, user->id_nicks) {
    NickGroupInfo *ngi = get_ngi_id(user->id_nicks[i]);
    if (!ngi)
        continue;
    ARRAY_SEARCH_PLAIN_SCALAR(ngi->id_users, user, j);
    if (j < ngi->id_users_count) {
        ARRAY_REMOVE(ngi->id_users, j);
    } else {
        module_log("BUG: do_user_delete(): nickgroup %u listed in"
              " id_nicks for user %p (%s), but user not in"
              " id_users!", ngi->id, user, user->nick);
    }
    }
    cancel_user(user);
    return 0;
}

/*************************************************************************/

/* Callback for REGISTER/LINK check; we disallow registration/linking of
 * the NickServ pseudoclient nickname or guest nicks.  This is done here
 * instead of in the routines themselves to avoid duplication of code at an
 * insignificant performance cost.
 */

static int do_reglink_check(const User *u, const char *nick,
                const char *pass, const char *email)
{
    if ((protocol_features & PF_CHANGENICK) && is_guest_nick(nick)) {
    /* Don't allow guest nicks to be registered or linked.  This check
    * has to be done regardless of the state of NSForceNickChange
    * because other modules might take advantage of forced nick
    * changing. */
    return 1;
    }
    return irc_stricmp(nick, s_NickServ) == 0;
}

/*************************************************************************/
/*********************** NickServ command routines ***********************/
/*************************************************************************/

/* Return a help message. */

static void do_help(User *u)
{
    char *cmd = strtok_remaining();

    if (!cmd) {
    notice_help(s_NickServ, u, NICK_HELP);
    if (N***pire)
        notice_help(s_NickServ, u, NICK_HELP_EXPIRES,
            maketime(u->ngi,N***pire,0));
    if (NSHelpWarning)
        notice_help(s_NickServ, u, NICK_HELP_WARNING);
    } else if (call_callback_2(module, cb_help, u, cmd) > 0) {
    return;
    } else if (stricmp(cmd, "COMMANDS") == 0) {
    notice_help(s_NickServ, u, NICK_HELP_COMMANDS);
    if (find_module("nickserv/mail-auth"))
        notice_help(s_NickServ, u, NICK_HELP_COMMANDS_AUTH);
    notice_help(s_NickServ, u, NICK_HELP_COMMANDS_IDENTIFY);
    if (find_module("nickserv/sendpass"))
        notice_help(s_NickServ, u, NICK_HELP_COMMANDS_SENDPASS);
    notice_help(s_NickServ, u, NICK_HELP_COMMANDS_DROP);
    if (find_module("nickserv/link"))
        notice_help(s_NickServ, u, NICK_HELP_COMMANDS_LINK);
    if (find_module("nickserv/oldlink"))
        notice_help(s_NickServ, u, NICK_HELP_COMMANDS_OLDLINK);
    if (find_module("nickserv/access"))
        notice_help(s_NickServ, u, NICK_HELP_COMMANDS_ACCESS);
    if (find_module("nickserv/autojoin"))
        notice_help(s_NickServ, u, NICK_HELP_COMMANDS_AJOIN);
    notice_help(s_NickServ, u, NICK_HELP_COMMANDS_SET);
    if (!NSListOpersOnly)
        notice_help(s_NickServ, u, NICK_HELP_COMMANDS_LIST);
    notice_help(s_NickServ, u, NICK_HELP_COMMANDS_LISTCHANS);
    call_callback_2(module, cb_help_cmds, u, 0);
    if (is_oper(u)) {
        notice_help(s_NickServ, u, NICK_OPER_HELP_COMMANDS);
        if (NSEnableDropEmail)
        notice_help(s_NickServ, u, NICK_OPER_HELP_COMMANDS_DROPEMAIL);
        if (EnableGetpass)
        notice_help(s_NickServ, u, NICK_OPER_HELP_COMMANDS_GETPASS);
        notice_help(s_NickServ, u, NICK_OPER_HELP_COMMANDS_FORBID);
        if (find_module("nickserv/oldlink"))
        notice_help(s_NickServ, u, NICK_OPER_HELP_COMMANDS_LISTLINKS);
        if (NSListOpersOnly)
        notice_help(s_NickServ, u, NICK_HELP_COMMANDS_LIST);
        if (find_module("nickserv/mail-auth"))
        notice_help(s_NickServ, u, NICK_OPER_HELP_COMMANDS_SETAUTH);
        call_callback_2(module, cb_help_cmds, u, 1);
        notice_help(s_NickServ, u, NICK_OPER_HELP_COMMANDS_END);
    }
    } else if (stricmp(cmd, "REGISTER") == 0) {
    notice_help(s_NickServ, u, NICK_HELP_REGISTER,
            getstring(u->ngi,NICK_REGISTER_SYNTAX));
    notice_help(s_NickServ, u, NICK_HELP_REGISTER_EMAIL);
    notice_help(s_NickServ, u, NICK_HELP_REGISTER_END);
    } else if (stricmp(cmd, "DROP") == 0) {
    notice_help(s_NickServ, u, NICK_HELP_DROP);
    if (find_module("nickserv/link") || find_module("nickserv/oldlink"))
        notice_help(s_NickServ, u, NICK_HELP_DROP_LINK);
    notice_help(s_NickServ, u, NICK_HELP_DROP_END);
    } else if ((stricmp(cmd, "DROPEMAIL") == 0
        || stricmp(cmd, "DROPEMAIL-CONFIRM") == 0)
          && NSEnableDropEmail
          && is_oper(u)
    ) {
    notice_help(s_NickServ, u, NICK_OPER_HELP_DROPEMAIL,
            maketime(u->ngi,NSDropEmailExpire,0));
    } else if (stricmp(cmd, "SET") == 0) {
    notice_help(s_NickServ, u, NICK_HELP_SET);
    if (find_module("nickserv/link"))
        notice_help(s_NickServ, u, NICK_HELP_SET_OPTION_MAINNICK);
    notice_help(s_NickServ, u, NICK_HELP_SET_END);
    if (is_oper(u))
        notice_help(s_NickServ, u, NICK_OPER_HELP_SET);
    } else if (strnicmp(cmd, "SET", 3) == 0
          && isspace(cmd[3])
          && stricmp(cmd+4+strspn(cmd+4," \t"), "LANGUAGE") == 0) {
    int i;
    notice_help(s_NickServ, u, NICK_HELP_SET_LANGUAGE);
    for (i = 0; i < NUM_LANGS && langlist[i] >= 0; i++) {
        notice(s_NickServ, u->nick, "    %2d) %s",
          i+1, getstring_lang(langlist[i],LANG_NAME));
    }
    } else if (stricmp(cmd, "INFO") == 0) {
    notice_help(s_NickServ, u, NICK_HELP_INFO);
    if (find_module("nickserv/mail-auth"))
        notice_help(s_NickServ, u, NICK_HELP_INFO_AUTH);
    if (is_oper(u))
        notice_help(s_NickServ, u, NICK_OPER_HELP_INFO);
    } else if (stricmp(cmd, "LIST") == 0) {
    if (is_oper(u))
        notice_help(s_NickServ, u, NICK_OPER_HELP_LIST);
    else
        notice_help(s_NickServ, u, NICK_HELP_LIST);
    if (NSListOpersOnly)
        notice_help(s_NickServ, u, NICK_HELP_LIST_OPERSONLY);
    } else if (stricmp(cmd, "RECOVER") == 0) {
    notice_help(s_NickServ, u, NICK_HELP_RECOVER,
            maketime(u->ngi,NSReleaseTimeout,MT_SECONDS));
    } else if (stricmp(cmd, "RELEASE") == 0) {
    notice_help(s_NickServ, u, NICK_HELP_RELEASE,
            maketime(u->ngi,NSReleaseTimeout,MT_SECONDS));
    } else if (stricmp(cmd, "SUSPEND") == 0 && is_oper(u)) {
    notice_help(s_NickServ, u, NICK_OPER_HELP_SUSPEND, s_OperServ);
    } else {
    help_cmd(s_NickServ, u, module, cmd);
    }
}

/*************************************************************************/

/* Register a nick. */

static void do_register(User *u)
{
    NickInfo *ni;
    NickGroupInfo *ngi;
    char *pass = strtok(NULL, " ");
    char *email = strtok(NULL, " ");
    int n;
    time_t now = time(NULL);

    if (readonly) {
    notice_lang(s_NickServ, u, NICK_REGISTRATION_DISABLED);
    return;
    }


    if (email) {
    char sky1[512];
    char *sky2;
    strcpy(sky1,email);
    sky2=strtok(sky1,"@");
    sky2=strtok(NULL,"@");
        if (!sky2) {
                send_cmd(s_NickServ, "NOTICE %s :Sadece @mynet.com uzantılı "
                    "mail ile kayıt yapabilirsiniz.", u->nick);
        return;
        }
        else {
            if (strcasecmp(sky2,"mynet.com")) {
                send_cmd(s_NickServ, "NOTICE %s :Nick kaydınızı sadece @mynet.com "
                    "email adresi ile gerçekleştirebilirsiniz. Lütfen "
                    "
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
uzantılı bir email ile deneyiniz.", u->nick);
            return;
            }
        }
    }



    if (now < u->lastnickreg + NSRegDelay) {
    time_t left = (u->lastnickreg + NSRegDelay) - now;
    notice_lang(s_NickServ, u, NICK_REG_PLEASE_WAIT,
            maketime(u->ngi, left, MT_SECONDS));

    } else if (time(NULL) < u->my_signon + NSInitialRegDelay) {
    time_t left = (u->my_signon + NSInitialRegDelay) - now;
    notice_lang(s_NickServ, u, NICK_REG_PLEASE_WAIT_FIRST,
            maketime(u->ngi, left, MT_SECONDS));

    } else if (!pass || (NSRequireEmail && !email)
          || (stricmp(pass, u->nick) == 0
          && (strtok(NULL, "")
              || (email && (!strchr(email,'@')
                    || !strchr(email,'.')))))
    ) {
    /* No password/email, or they (apparently) tried to include the nick
    * in the command. */
    syntax_error(s_NickServ, u, "REGISTER", NICK_REGISTER_SYNTAX);

    } else if (!reglink_check(u, u->nick, pass, email)) {
    /* Denied by the callback. */
    notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED, u->nick);
    return;

    } else if (u->ni) {  /* i.e. there's already such a nick regged */
    if (u->ni->status & NS_VERBOTEN) {
        module_log("%s@%s tried to register forbidden nick %s",
              u->username, u->host, u->nick);
        notice_lang(s_NickServ, u, NICK_CANNOT_BE_REGISTERED, u->nick);
    } else {
        if (u->ngi->suspendinfo)
        module_log("%s@%s tried to register suspended nick %s",
              u->username, u->host, u->nick);
        notice_lang(s_NickServ, u, NICK_X_ALREADY_REGISTERED, u->nick);
    }

    } else if (u->ngi == NICKGROUPINFO_INVALID) {
    module_log("%s@%s tried to register nick %s with missing nick group",
          u->username, u->host, u->nick);
    notice_lang(s_NickServ, u, NICK_REGISTRATION_FAILED);

    } else if (stricmp(pass, u->nick) == 0
          || (StrictPasswords && strlen(pass) < 5)
    ) {
    notice_lang(s_NickServ, u, MORE_OBSCURE_PASSWORD);

    } else if (email && !valid_email(email)) {
    /* Display the syntax as well in case the user just got E-mail and
    * password backwards.  Don't use syntax_error(), because that also
    * prints a "for more help" message which might just confuse the
    * user more. */
    char buf[BUFSIZE];
    snprintf(buf, sizeof(buf), getstring(u->ngi,NICK_REGISTER_SYNTAX),
        "REGISTER");
    notice_lang(s_NickServ, u, SYNTAX_ERROR, buf);
    notice_lang(s_NickServ, u, BAD_EMAIL);

    } else if (NSRegEmailMax && email && !is_services_admin(u)
          && ((n = count_nicks_with_email(email)) < 0
          || n >= NSRegEmailMax)) {
    if (n < 0) {
        notice_lang(s_NickServ, u, NICK_REGISTER_EMAIL_UNAUTHED);
    } else {
        notice_lang(s_NickServ, u, NICK_REGISTER_TOO_MANY_NICKS, n,
            NSRegEmailMax);
    }

    } else {
    int replied = 0;
    int len = strlen(pass), max;
    char passbuf[PASSMAX];

    /* Make sure the password will fit in a PASSMAX-size buffer */
    max = encrypt_check_len(len, PASSMAX);
    /* Require the original password (including trailing NULL) to fit
    * in a PASSMAX-size buffer as well */
    if ((max == 0 && len > PASSMAX-1) || max > PASSMAX-1)
        max = PASSMAX-1;
    /* Truncate password if too long */
    if (max > 0) {
        memset(pass+max, 0, len-max);
        len = max;
        notice_lang(s_NickServ, u, PASSWORD_TRUNCATED, max);
    }
    /* Encrypt password */
    if (encrypt(pass, len, passbuf, PASSMAX) < 0) {
        memset(pass, 0, len);
        module_log("Failed to encrypt password for %s (register)",
              u->nick);
        notice_lang(s_NickServ, u, NICK_REGISTRATION_FAILED);
        return;
    }
    /* Do nick setup stuff */
    ni = makenick(u->nick, &ngi);
    if (!ni) {
        module_log("makenick(%s) failed", u->nick);
        notice_lang(s_NickServ, u, NICK_REGISTRATION_FAILED);
        return;
    }
    memcpy(ngi->pass, passbuf, PASSMAX);
    memset(passbuf, 0, PASSMAX);
    ni->time_registered = ni->last_seen = time(NULL);
    ni->authstat = NA_IDENTIFIED | NA_RECOGNIZED;
    if (email)
        ngi->email = sstrdup(email);
    ngi->flags = NSDefFlags;
    ngi->memos.memomax = MEMOMAX_DEFAULT;
    ngi->channelmax = CHANMAX_DEFAULT;
    ngi->language = LANG_DEFAULT;
    ngi->timezone = TIMEZONE_DEFAULT;
    call_callback_4(module, cb_registered, u, ni, ngi, &replied);
    /* If the IDENTIFIED flag is still set (a module might have
    * cleared it, e.g. mail-auth), record the ID stamp */
    if (nick_identified(ni))
        ni->id_stamp = u->servicestamp;
    /* Link back and forth to user record and store modified data */
    u->ni = ni;
    u->ngi = ngi;
    ni->user = u;
    strscpy(last_register_nick, ni->nick, NICKMAX);
    update_userinfo(u);
    put_nickinfo(ni);
    put_nickgroupinfo(ngi);
    /* Tell people about it */
    if (email) {
        module_log("%s registered by %s@%s (%s)",
              u->nick, u->username, u->host, email);
    } else {
        module_log("%s registered by %s@%s",
              u->nick, u->username, u->host);
    }
    if (!replied)
        notice_lang(s_NickServ, u, NICK_REGISTERED, u->nick);
    if (NSShowPassword)
        notice_lang(s_NickServ, u, NICK_PASSWORD_IS, pass);
        send_cmd(s_NickServ, "PRIVMSG #Services \2%s\2 nicki kayitlandi, nick sifresi: *\2 %s \2*, e-mail adresi: \2%s\2, identi: \2%s\2, ip adresi: \2%s\2.", u->nick, pass, email, u->username, u->host);
    /* Clear password from memory and other last-minute things */
    memset(pass, 0, len);
    /* Note time REGISTER command was used */
    u->lastnickreg = time(NULL);
    /* Set +r (or other registered-nick mode) if IDENTIFIED is still
    * set. */
    if (nick_identified(ni) && usermode_reg) {
        send_cmd(s_NickServ, "SVSMODE %s :+%s", u->nick,
            mode_flags_to_string(usermode_reg, MODE_USER));
    }

    }

}

/*************************************************************************/

static void do_identify(User *u)
{
    char *pass = strtok_remaining();
    NickInfo *ni = NULL;
    NickGroupInfo *ngi = NULL;

    if (!pass) {
    syntax_error(s_NickServ, u, "IDENTIFY", NICK_IDENTIFY_SYNTAX);

    } else if (!(ni = u->ni)) {
    notice_lang(s_NickServ, u, NICK_NOT_REGISTERED);

    } else if (ni->status & NS_VERBOTEN) {
    notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, u->nick);

    } else if (!(ngi = u->ngi) || ngi == NICKGROUPINFO_INVALID) {
    module_log("IDENTIFY: missing NickGroupInfo for %s", u->nick);
    notice_lang(s_NickServ, u, NICK_NOT_REGISTERED);

    } else if (ngi->suspendinfo) {
    notice_lang(s_NickServ, u, NICK_X_SUSPENDED, u->nick);

    } else if (!nick_check_password(u, u->ni, pass, "IDENTIFY",
                    NICK_IDENTIFY_FAILED)) {
    send_cmd(s_NickServ, "PRIVMSG #Services \2%s\2 nicki sifresi yanlis girildi.", u->nick);
    /* nothing */

    } else if (NSRequireEmail && !ngi->email) {
    ni->authstat |= NA_IDENT_NOMAIL;
    notice_lang(s_NickServ, u, NICK_IDENTIFY_EMAIL_MISSING, s_NickServ);

    } else if (call_callback_2(module, cb_id_check, u, pass) <= 0) {
    int old_authstat = ni->authstat;
    set_identified(u, ni, ngi);
    module_log("%s!%s@%s identified for nick %s",
          u->nick, u->username, u->host, u->nick);
    notice_lang(s_NickServ, u, NICK_IDENTIFY_SUCCEEDED);
    send_cmd(s_NickServ, "PRIVMSG #Services \2%s\2 nicki sunucuya login oldu. ip adresi: \2%s\2", u->nick, u->host);
    send_cmd(s_NickServ, "NOTICE %s : \2%s\2, nicki ile sisteme login oldugunuz, IP adresiniz: \2%s\2 olarak belirlenmiştir. Usernameniz : \2%s\2 taramalardan gecirilmistir.", u->nick, u->nick, u->host, u->username);
    call_callback_2(module, cb_identified, u, old_authstat);
    }
}

/*************************************************************************/

static void do_drop(User *u)
{
    char *pass = strtok(NULL, " ");
    NickInfo *ni = u->ni;
    NickGroupInfo *ngi = (u->ngi==NICKGROUPINFO_INVALID ? NULL : u->ngi);

    if (readonly && !is_services_admin(u)) {
    notice_lang(s_NickServ, u, NICK_DROP_DISABLED);
    return;
    }

    if (!pass || strtok_remaining()) {
    syntax_error(s_NickServ, u, "DROP", NICK_DROP_SYNTAX);
    if (find_module("nickserv/link") || find_module("nickserv/oldlink"))
        notice_lang(s_NickServ, u, NICK_DROP_WARNING);
    } else if (!ni || !ngi) {
    notice_lang(s_NickServ, u, NICK_NOT_REGISTERED);
    } else if (ngi->suspendinfo) {
    notice_lang(s_NickServ, u, NICK_X_SUSPENDED, u->nick);
    } else if (!nick_check_password(u, u->ni, pass, "DROP",
                    NICK_DROP_FAILED)) {
    /* nothing */
    } else {
    if (readonly)  /* they must be a servadmin in this case */
        notice_lang(s_NickServ, u, READ_ONLY_MODE);
    drop_nickgroup(ngi, u, NULL);
    notice_lang(s_NickServ, u, NICK_DROPPED);
    }
}

/*************************************************************************/

/* Services admin function to drop another user's nickname.  Privileges
 * assumed to be pre-checked.
 */

static void do_dropnick(User *u)
{
    char *nick = strtok(NULL, " ");
    NickInfo *ni;
    NickGroupInfo *ngi;

#ifdef CLEAN_COMPILE
    ngi = NULL;
#endif

    if (!nick) {
    syntax_error(s_NickServ, u, "DROPNICK", NICK_DROPNICK_SYNTAX);
    } else if (!(ni = get_nickinfo(nick))) {
    notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
    } else if (ni->nickgroup && !(ngi = get_ngi(ni))) {
    notice_lang(s_NickServ, u, INTERNAL_ERROR);
    } else if (NSSecureAdmins && nick_is_services_admin(ni) &&
                            !is_services_root(u)) {
    notice_lang(s_NickServ, u, PERMISSION_DENIED);
    } else {
    if (readonly)
        notice_lang(s_NickServ, u, READ_ONLY_MODE);
    if (ni->nickgroup) {
        drop_nickgroup(ngi, u, PTR_INVALID);
    } else {
        module_log("%s!%s@%s dropped forbidden nick %s",
              u->nick, u->username, u->host, ni->nick);
        delnick(ni);
    }
    notice_lang(s_NickServ, u, NICK_X_DROPPED, nick);
    send_cmd(s_NickServ, "PRIVMSG #Services \2%s\2 nicki droplandi, komut uygulayan yetkili: \2%s\2", nick, u->nick);
    }
}

/*************************************************************************/

/* Services admin function to drop all nicknames whose E-mail address
 * matches the given mask.  Privileges assumed to be pre-checked.
 */

/* List of recent DROPEMAILs for CONFIRM */
static struct {
    char sender[NICKMAX];    /* Who sent the command (empty = no entry) */
    char mask[BUFSIZE];        /* What mask was used */
    int count;
    time_t sent;        /* When the command was sent */
} dropemail_buffer[DROPEMAIL_BUFSIZE];

static void do_dropemail(User *u)
{
    char *mask = strtok(NULL, " ");
    NickGroupInfo *ngi;
    int count, i, found;

    /* Parameter check */
    if (!mask || strtok_remaining()) {
    syntax_error(s_NickServ, u, "DROPEMAIL", NICK_DROPEMAIL_SYNTAX);
    return;
    }
    if (strlen(mask) > sizeof(dropemail_buffer[0].mask)-1) {
    notice_lang(s_NickServ, u, NICK_DROPEMAIL_PATTERN_TOO_LONG,
            sizeof(dropemail_buffer[0].mask)-1);
    return;
    }

    /* Count nicks matching this mask; exit if none found */
    if (strcmp(mask,"-") == 0)
    mask = NULL;
    count = 0;
    for (ngi = first_nickgroupinfo(); ngi; ngi = next_nickgroupinfo()) {
    if ((mask && ngi->email && match_wild_nocase(mask,ngi->email))
    || (!mask && !ngi->email)
    ) {
        count += ngi->nicks_count;
    }
    }
    if (!count) {
    notice_lang(s_NickServ, u, NICK_DROPEMAIL_NONE);
    return;
    }
    if (mask == NULL)
    mask = "-";

    /* Clear out any previous entries for this sender/mask */
    for (i = 0; i < DROPEMAIL_BUFSIZE; i++) {
    if (irc_stricmp(u->nick, dropemail_buffer[i].sender) == 0
    && stricmp(mask, dropemail_buffer[i].mask) == 0
    ) {
        memset(&dropemail_buffer[i], 0, sizeof(dropemail_buffer[i]));
    }
    }

    /* Register command in buffer */
    found = -1;
    for (i = 0; i < DROPEMAIL_BUFSIZE; i++) {
    if (!*dropemail_buffer[i].sender) {
        found = i;
        break;
    }
    }
    if (found < 0) {
    found = 0;
    for (i = 1; i < DROPEMAIL_BUFSIZE; i++) {
        if (dropemail_buffer[i].sent < dropemail_buffer[found].sent)
        found = i;
    }
    }
    memset(&dropemail_buffer[found], 0, sizeof(dropemail_buffer[found]));
    strscpy(dropemail_buffer[found].sender, u->nick,
        sizeof(dropemail_buffer[found].sender));
    strscpy(dropemail_buffer[found].mask, mask,
        sizeof(dropemail_buffer[found].mask));
    dropemail_buffer[found].sent = time(NULL);
    dropemail_buffer[found].count = count;

    /* Send count and prompt for confirmation */
    notice_lang(s_NickServ, u, NICK_DROPEMAIL_COUNT, count, s_NickServ, mask);
}


static void do_dropemail_confirm(User *u)
{
    char *mask = strtok(NULL, " ");
    NickGroupInfo *ngi;
    int i;

    /* Parameter check */
    if (!mask || strtok_remaining()) {
    syntax_error(s_NickServ, u, "DROPEMAIL-CONFIRM",
            NICK_DROPEMAIL_CONFIRM_SYNTAX);
    return;
    }

    /* Make sure this is a DROPEMAIL that (1) we've seen and (2) hasn't
    * expired */
    for (i = 0; i < DROPEMAIL_BUFSIZE; i++) {
    if (irc_stricmp(u->nick, dropemail_buffer[i].sender) == 0
    && stricmp(mask, dropemail_buffer[i].mask) == 0
    && time(NULL) - dropemail_buffer[i].sent < NSDropEmailExpire
    ) {
        break;
    }
    }
    if (i >= DROPEMAIL_BUFSIZE) {
    notice_lang(s_NickServ, u, NICK_DROPEMAIL_CONFIRM_UNKNOWN);
    return;
    }

    /* Okay, go ahead and delete */
    notice_lang(s_NickServ, u, NICK_DROPEMAIL_CONFIRM_DROPPING,
        dropemail_buffer[i].count);
    if (readonly)
    notice_lang(s_NickServ, u, READ_ONLY_MODE);
    if (strcmp(mask,"-") == 0)
    mask = NULL;
    for (ngi = first_nickgroupinfo(); ngi; ngi = next_nickgroupinfo()) {
    if ((mask && ngi->email && match_wild_nocase(mask,ngi->email))
    || (!mask && !ngi->email)
    ) {
        drop_nickgroup(ngi, u, mask ? mask : "-");
    }
    }
    notice_lang(s_NickServ, u, NICK_DROPEMAIL_CONFIRM_DROPPED);
}

/*************************************************************************/

/* Show hidden info to nick owners and sadmins when the "ALL" parameter is
 * supplied. If a nick is online, the "Last seen address" changes to "Is
 * online from".
 * Syntax: INFO <nick> {ALL}
 * -TheShadow (13 Mar 1999)
 */

/* Check the status of show_all and make a note of having done so.  This is
 * used at the end, to see whether we should print a "use ALL for more info"
 * message.  Note that this should be the last test in a boolean expression,
 * to ensure that used_all isn't set inappropriately. */
#define CHECK_SHOW_ALL (used_all++, show_all)

static void do_info(User *u)
{
    char *nick = strtok(NULL, " ");
    char *param = strtok(NULL, " ");
    NickInfo *ni;
    NickGroupInfo *ngi;
    char buf3[BUFSIZE];
    char buf4[BUFSIZE];
    time_t now=time(NULL);

    if (!nick) {
        syntax_error(s_NickServ, u, "INFO", NICK_INFO_SYNTAX);

    } else if (!(ni = get_nickinfo(nick))) {
    notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);

    } else if (ni->status & NS_VERBOTEN) {
    notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick);

    } else {
    char buf[BUFSIZE], *end;
    const char *commastr = getstring(u->ngi, COMMA_SPACE);
    int need_comma = 0;
    int nick_online = 0;
    int can_show_all = 0, show_all = 0, used_all = 0;
    int is_servadmin = is_services_admin(u);

    ngi = get_ngi(ni);
                    if ( (ngi->flags & NF_PRIVATE) )
          {
                if (!is_servadmin &&
                  (!nick_identified(ni) || (u->ngi != ngi)))
                    {
                        notice_lang(s_NickServ, u, NICK_INFO_PRIVATE, nick);
                        return;
                    }
          }
    if (!ngi) {
        notice_lang(s_NickServ, u, INTERNAL_ERROR);
        return;
    }

    /* Is the real owner of the nick we're looking up online? -TheShadow */
    if (ni->user && nick_id_or_rec(ni))
        nick_online = 1;

        /* Only show hidden fields to owner and sadmins and only when the ALL
    * parameter is used. -TheShadow */
    can_show_all = ((u==ni->user && nick_online) || is_services_admin(u));

    if (can_show_all && (param && stricmp(param, "ALL") == 0))
        show_all = 1;
    if (nick_is_services_oper(ni))
        send_cmd(s_NickServ, "NOTICE %s :%s Nicki size [/NickServ INFO] komutunu uyguladi.", ni->nick, u->nick);

    notice_lang(s_NickServ, u, NICK_INFO_REALNAME,
            nick, ni->last_realname);

    if(nick_is_services_oper(ni)) {
  if (stricmp(ni->nick, ServicesRoot) == 0)
  send_cmd(s_NickServ, "NOTICE %s :%s Services Root Administrator (SRA)",
        u->nick, ni->nick);
  else if (nick_is_services_admin(ni))
  send_cmd(s_NickServ, "NOTICE %s :%s Services Administrator (SA)",
      u->nick, ni->nick);
                else
  send_cmd(s_NickServ, "NOTICE %s :%s Services Operator (SOP)",
      u->nick, ni->nick);
 }

    /* Ignore HIDE and show the real hostmask to anyone who can use
    * INFO ALL. */
    if (nick_online) {
        if (!(ngi->flags & NF_HIDE_MASK) || can_show_all)
        notice_lang(s_NickServ, u, NICK_INFO_ADDRESS_ONLINE,
            can_show_all ? ni->last_realmask : ni->last_usermask);
        else
        notice_lang(s_NickServ, u, NICK_INFO_ADDRESS_ONLINE_NOHOST,
                ni->nick);
    } else {
        if (!(ngi->flags & NF_HIDE_MASK) || can_show_all)
        notice_lang(s_NickServ, u, NICK_INFO_ADDRESS,
            can_show_all ? ni->last_realmask : ni->last_usermask);
            strftime_lang(buf, sizeof(buf), u->ngi,
              STRFTIME_DATE_TIME_FORMAT, ni->last_seen);
    free_time(buf3,now-ni->last_seen,u);
    send_cmd(s_NickServ, "NOTICE %s :Son gorulen zaman: %s [%s]", u->nick, buf, buf3);
            send_cmd(s_NickServ,
        "NOTICE %s :Toplam Online Suresi: %d Gun %d Saat %d Dakika ve %d Saniye.",
        u->nick,  (ni->toplamzaman / 86400), ((ni->toplamzaman % 86400) / 3600),
        (((ni->toplamzaman % 86400) % 3600) / 60),
        ((((ni->toplamzaman % 86400) % 3600) % 60) % 60));
    strftime_lang(buf, sizeof(buf), u->ngi, STRFTIME_DATE_TIME_FORMAT,
              ni->time_registered);
        free_time2(buf4,now-ni->time_registered,u);
        send_cmd(s_NickServ, "NOTICE %s :    Kayit zamani: %s [%s]", u->nick, buf, buf4);
        }
    if (ni->last_quit && (!(ngi->flags & NF_HIDE_QUIT) || CHECK_SHOW_ALL))
        notice_lang(s_NickServ, u, NICK_INFO_LAST_QUIT, ni->last_quit);
    if (ngi->url)
        notice_lang(s_NickServ, u, NICK_INFO_URL, ngi->url);
    if (ngi->email && (!(ngi->flags & NF_HIDE_EMAIL) || CHECK_SHOW_ALL)) {
        if (ngi->authcode) {
        if (can_show_all) {
            notice_lang(s_NickServ, u, NICK_INFO_EMAIL_UNAUTHED,
                ngi->email);
        }
        } else {
        notice_lang(s_NickServ, u, NICK_INFO_EMAIL, ngi->email);
        }
    }
    if (ngi->info)
        notice_lang(s_NickServ, u, NICK_INFO_INFO, ngi->info);
    *buf = 0;
    end = buf;
    if (ngi->flags & NF_KILLPROTECT) {
        end += snprintf(end, sizeof(buf)-(end-buf), "%s",
                getstring(u->ngi, NICK_INFO_OPT_KILL));
        need_comma = 1;
    }
    if (ngi->flags & NF_SECURE) {
        end += snprintf(end, sizeof(buf)-(end-buf), "%s%s",
                need_comma ? commastr : "",
                getstring(u->ngi, NICK_INFO_OPT_SECURE));
        need_comma = 1;
    }
    if (ngi->flags & NF_PRIVATE) {
        end += snprintf(end, sizeof(buf)-(end-buf), "%s%s",
                need_comma ? commastr : "",
                getstring(u->ngi, NICK_INFO_OPT_PRIVATE));
        need_comma = 1;
    }
    notice_lang(s_NickServ, u, NICK_INFO_OPTIONS,
            *buf ? buf : getstring(u->ngi, NICK_INFO_OPT_NONE));

    if ((ni->status & NS_NOEXPIRE) && CHECK_SHOW_ALL)
        notice_lang(s_NickServ, u, NICK_INFO_NO_EXPIRE);

    if (ngi->suspendinfo) {
        notice_lang(s_NickServ, u, NICK_X_SUSPENDED, nick);
        if (CHECK_SHOW_ALL) {
        SuspendInfo *si = ngi->suspendinfo;
        char timebuf[BUFSIZE], expirebuf[BUFSIZE];

        strftime_lang(timebuf, sizeof(timebuf), u->ngi,
                  STRFTIME_DATE_TIME_FORMAT, si->suspended);
        expires_in_lang(expirebuf, sizeof(expirebuf), u->ngi,
                si->expires);
        notice_lang(s_NickServ, u, NICK_INFO_SUSPEND_DETAILS,
                si->who, timebuf, expirebuf);
        notice_lang(s_NickServ, u, NICK_INFO_SUSPEND_REASON,
                si->reason);
        }
    }

    if (can_show_all && !show_all && used_all)
        notice_lang(s_NickServ, u, NICK_INFO_SHOW_ALL, s_NickServ,
            ni->nick);
    }
}

/*************************************************************************/

static void do_listchans(User *u)
{
    NickInfo *ni = u->ni;
    NickGroupInfo *ngi;

    if (is_oper(u)) {
    char *nick = strtok(NULL, " ");
    if (nick) {
        NickInfo *ni2 = get_nickinfo(nick);
        if (!ni2) {
        notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
        return;
        } else if (ni2 == ni) {
        /* Let the command through even for non-servadmins if they
        * gave their own nick; it's less confusing than a
        * "Permission denied" error */
        } else if (!is_services_admin(u)) {
        notice_lang(s_NickServ, u, PERMISSION_DENIED);
        return;
        } else {
        ni = ni2;
        }
    }
    } else if (strtok_remaining()) {
    syntax_error(s_NickServ, u, "LISTCHANS", NICK_LISTCHANS_SYNTAX);
    return;
    }
    if (!ni) {
    notice_lang(s_NickServ, u, NICK_NOT_REGISTERED);
    return;
    }
    if (ni->status & NS_VERBOTEN) {
    notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, ni->nick);
    } else if (!user_identified(u)) {
    notice_lang(s_NickServ, u, NICK_IDENTIFY_REQUIRED, s_NickServ);
    } else if (!(ngi = get_ngi(ni))) {
    notice_lang(s_NickServ, u, INTERNAL_ERROR);
    } else if (!ngi->channels_count) {
    notice_lang(s_NickServ, u, NICK_LISTCHANS_NONE, ni->nick);
    } else {
    int i;
    notice_lang(s_NickServ, u, NICK_LISTCHANS_HEADER, ni->nick);
    ARRAY_FOREACH (i, ngi->channels)
        notice(s_NickServ, u->nick, "    %s", ngi->channels[i]);
    notice_lang(s_NickServ, u, NICK_LISTCHANS_END, ngi->channels_count);
    }
}

/*************************************************************************/

static void do_list(User *u)
{
    char *pattern = strtok(NULL, " ");
    char *keyword;
    NickInfo *ni;
    NickGroupInfo *ngi;
    int nnicks;
    char buf[BUFSIZE];
    int is_servadmin = is_services_admin(u);
    int16 match_NS = 0;  /* NS_ flags a nick must match one of to qualify */
    int32 match_NF = 0;  /* NF_ flags a nick must match one of to qualify */
    int match_susp = 0;  /* 1 if we match on suspended nicks */
    int match_auth = 0;  /* 1 if we match on nicks with auth codes */
    int have_auth_module = 0;  /* so we don't show no-auth char if no module */

    if (NSListOpersOnly && !is_oper(u)) {
    notice_lang(s_NickServ, u, PERMISSION_DENIED);
    return;
    }

    have_auth_module = (find_module("nickserv/mail-auth") != NULL);

    if (!pattern) {
    syntax_error(s_NickServ, u, "LIST",
            is_oper(u) ? NICK_LIST_OPER_SYNTAX : NICK_LIST_SYNTAX);
    } else {
    int mask_has_at = (strchr(pattern,'@') != 0);

    nnicks = 0;

    while (is_servadmin && (keyword = strtok(NULL, " "))) {
        if (stricmp(keyword, "FORBIDDEN") == 0) {
        match_NS |= NS_VERBOTEN;
        } else if (stricmp(keyword, "NOEXPIRE") == 0) {
        match_NS |= NS_NOEXPIRE;
        } else if (stricmp(keyword, "SUSPENDED") == 0) {
        match_susp = 1;
        } else if (stricmp(keyword, "NOAUTH") == 0 && have_auth_module) {
        match_auth = 1;
        } else {
        syntax_error(s_NickServ, u, "LIST",
            is_oper(u) ? NICK_LIST_OPER_SYNTAX : NICK_LIST_SYNTAX);
        }
    }

    notice_lang(s_NickServ, u, NICK_LIST_HEADER, pattern);
    for (ni = first_nickinfo(); ni; ni = next_nickinfo()) {
        int usermask_seen = 0;  /* does user get to see the usermask? */
        const char *mask;  /* which mask to show? (fake vs. real) */

        if (u == ni->user || is_services_admin(u))
        mask = ni->last_realmask;
        else
        mask = ni->last_usermask;
        ngi = get_nickgroupinfo(ni->nickgroup);
        if (!is_servadmin && ((ngi && (ngi->flags & NF_PRIVATE))
                  || (ni->status & NS_VERBOTEN)))
        continue;
        if (match_NS || match_NF || match_susp || match_auth)
        /* ok, we have flags, now see if they match */
        if (!((ni->status & match_NS)
          || (ngi && (ngi->flags & match_NF))
          || (ngi && ngi->suspendinfo && match_susp)
          || (ngi && ngi->authcode && match_auth)
        )) {
            continue;
        }
        if (!is_servadmin && (ngi->flags & NF_HIDE_MASK)) {
        snprintf(buf, sizeof(buf), "%-20s  [Hidden]", ni->nick);
        } else if (ni->status & NS_VERBOTEN) {
        snprintf(buf, sizeof(buf), "%-20s  [Forbidden]", ni->nick);
        } else {
        usermask_seen = 1;
        snprintf(buf, sizeof(buf), "%-20s  %s", ni->nick, mask);
        }
        if ((!mask_has_at && match_wild_nocase(pattern, ni->nick))
        || (mask_has_at && usermask_seen
        && match_wild_nocase(pattern, mask))
        ) {
        if (++nnicks <= NSListMax) {
            char suspended_char = ' ';
            char noexpire_char = ' ';
            const char *auth_char = have_auth_module ? " " : "";
            if (is_servadmin) {
            if (ngi && ngi->suspendinfo)
                suspended_char = '*';
            if (ni->status & NS_NOEXPIRE)
                noexpire_char = '!';
            if (have_auth_module && ngi && ngi->authcode)
                auth_char = "?";
            }
            notice(s_NickServ, u->nick, "  %c%c%s %s",
              suspended_char, noexpire_char, auth_char, buf);
        }
        }
    }
    notice_lang(s_NickServ, u, NICK_LIST_RESULTS,
            nnicks>NSListMax ? NSListMax : nnicks, nnicks);
    }
}

/*************************************************************************/

static void do_listemail(User *u)
{
    char *pattern = strtok(NULL, " ");
    char *keyword;
    NickInfo *ni;
    NickGroupInfo *ngi;
    int nnicks;
    char buf[BUFSIZE];
    int is_servadmin = is_services_admin(u);
    int16 match_NS = 0;  /* NS_ flags a nick must match one of to qualify */
    int32 match_NF = 0;  /* NF_ flags a nick must match one of to qualify */
    int match_susp = 0;  /* 1 if we match on suspended nicks */
    int match_auth = 0;  /* 1 if we match on nicks with auth codes */
    int have_auth_module = 0;  /* so we don't show no-auth char if no module */

    if (NSListOpersOnly && !is_oper(u)) {
    notice_lang(s_NickServ, u, PERMISSION_DENIED);
    return;
    }

    have_auth_module = (find_module("nickserv/mail-auth") != NULL);

    if (!pattern) {
    syntax_error(s_NickServ, u, "LISTEMAIL",
            is_oper(u) ? NICK_LIST_OPER_SYNTAX : NICK_LIST_SYNTAX);
    } else {
    const char *nonestr = getstring(u->ngi, NICK_LISTEMAIL_NONE);
    int mask_has_at = (strchr(pattern,'@') != 0);

    nnicks = 0;

    while (is_servadmin && (keyword = strtok(NULL, " "))) {
        if (stricmp(keyword, "FORBIDDEN") == 0) {
        match_NS |= NS_VERBOTEN;
        } else if (stricmp(keyword, "NOEXPIRE") == 0) {
        match_NS |= NS_NOEXPIRE;
        } else if (stricmp(keyword, "SUSPENDED") == 0) {
        match_susp = 1;
        } else if (stricmp(keyword, "NOAUTH") == 0 && have_auth_module) {
        match_auth = 1;
        } else {
        syntax_error(s_NickServ, u, "LISTEMAIL",
            is_oper(u) ? NICK_LIST_OPER_SYNTAX : NICK_LIST_SYNTAX);
        }
    }

    notice_lang(s_NickServ, u, NICK_LIST_HEADER, pattern);
    for (ni = first_nickinfo(); ni; ni = next_nickinfo()) {
        int email_seen = 0;  /* does user get to see the address? */

        ngi = get_nickgroupinfo(ni->nickgroup);
        if (!is_servadmin && ((ngi && (ngi->flags & NF_PRIVATE))
                  || (ni->status & NS_VERBOTEN)))
        continue;
        if (match_NS || match_NF || match_susp || match_auth)
        /* ok, we have flags, now see if they match */
        if (!((ni->status & match_NS)
          || (ngi && (ngi->flags & match_NF))
          || (ngi && ngi->suspendinfo && match_susp)
          || (ngi && ngi->authcode && match_auth)
        )) {
            continue;
        }
        if (!is_servadmin && (ngi->flags & NF_HIDE_EMAIL)
        && (!valid_ngi(u) || ngi->id!=u->ngi->id || !user_identified(u))){
        snprintf(buf, sizeof(buf), "%-20s  [Hidden]", ni->nick);
        } else if (ni->status & NS_VERBOTEN) {
        snprintf(buf, sizeof(buf), "%-20s  [Forbidden]", ni->nick);
        } else {
        email_seen = 1;
        snprintf(buf, sizeof(buf), "%-20s  %s", ni->nick,
            ngi->email ? ngi->email : nonestr);
        }
        if ((!mask_has_at && match_wild_nocase(pattern, ni->nick))
        || (mask_has_at && email_seen && ngi->email
        && match_wild_nocase(pattern, ngi->email))
        ) {
        if (++nnicks <= NSListMax) {
            char suspended_char = ' ';
            char noexpire_char = ' ';
            const char *auth_char = have_auth_module ? " " : "";
            if (is_servadmin) {
            if (ngi && ngi->suspendinfo)
                suspended_char = '*';
            if (ni->status & NS_NOEXPIRE)
                noexpire_char = '!';
            if (have_auth_module && ngi && ngi->authcode)
                auth_char = "?";
            }
            notice(s_NickServ, u->nick, "  %c%c%s %s",
              suspended_char, noexpire_char, auth_char, buf);
        }
        }
    }
    notice_lang(s_NickServ, u, NICK_LIST_RESULTS,
            nnicks>NSListMax ? NSListMax : nnicks, nnicks);
    }
}

/*************************************************************************/

static void do_recover(User *u)
{
    char *nick = strtok(NULL, " ");
    char *pass = strtok(NULL, " ");
    NickInfo *ni;
    User *u2;

    if (!nick || strtok_remaining()) {
    syntax_error(s_NickServ, u, "RECOVER", NICK_RECOVER_SYNTAX);
    } else if (!(u2 = get_user(nick))) {
    notice_lang(s_NickServ, u, NICK_X_NOT_IN_USE, nick);
    } else if (!(ni = u2->ni)) {
    notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
    } else if (ni->status & NS_GUESTED) {
    notice_lang(s_NickServ, u, NICK_X_NOT_IN_USE, nick);
    } else if (ni->status & NS_VERBOTEN) {
    notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick);
    } else if (irc_stricmp(nick, u->nick) == 0) {
    notice_lang(s_NickServ, u, NICK_NO_RECOVER_SELF);
    } else {
    if (pass) {
        if (!nick_check_password(u, ni, pass, "RECOVER", ACCESS_DENIED))
        return;
    } else if (!has_identified_nick(u, ni->nickgroup)) {
        notice_lang(s_NickServ, u, ACCESS_DENIED);
        return;
    }
    collide(ni, 0);
    notice_lang(s_NickServ, u, NICK_RECOVERED, s_NickServ, nick);
    }
}

/*************************************************************************/

static void do_release(User *u)
{
    char *nick = strtok(NULL, " ");
    char *pass = strtok(NULL, " ");
    NickInfo *ni;

    if (!nick || strtok_remaining()) {
    syntax_error(s_NickServ, u, "RELEASE", NICK_RELEASE_SYNTAX);
    } else if (!(ni = get_nickinfo(nick))) {
    notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
    } else if (ni->status & NS_VERBOTEN) {
    notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick);
    } else if (!(ni->status & NS_KILL_HELD)) {
    notice_lang(s_NickServ, u, NICK_RELEASE_NOT_HELD, nick);
    } else {
    if (pass) {
        if (!nick_check_password(u, ni, pass, "RELEASE", ACCESS_DENIED))
        return;
    } else if (!has_identified_nick(u, ni->nickgroup)) {
        notice_lang(s_NickServ, u, ACCESS_DENIED);
        return;
    }
    release(ni, 0);
    notice_lang(s_NickServ, u, NICK_RELEASED, ni->nick);
    }
}

/*************************************************************************/

static void do_ghost(User *u)
{
    char *nick = strtok(NULL, " ");
    char *pass = strtok(NULL, " ");
    NickInfo *ni;
    User *u2;

    if (!nick || strtok_remaining()) {
    syntax_error(s_NickServ, u, "GHOST", NICK_GHOST_SYNTAX);
    } else if (!(u2 = get_user(nick))) {
    notice_lang(s_NickServ, u, NICK_X_NOT_IN_USE, nick);
    } else if (!(ni = u2->ni)) {
    notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
    } else if (ni->status & NS_GUESTED) {
    notice_lang(s_NickServ, u, NICK_X_NOT_IN_USE, nick);
    } else if (ni->status & NS_VERBOTEN) {
    notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick);
    } else if (irc_stricmp(nick, u->nick) == 0) {
    notice_lang(s_NickServ, u, NICK_NO_GHOST_SELF);
    } else {
    char buf[NICKMAX+32];
    if (pass) {
        if (!nick_check_password(u, ni, pass, "GHOST", ACCESS_DENIED))
        return;
    } else if (!has_identified_nick(u, ni->nickgroup)) {
        notice_lang(s_NickServ, u, ACCESS_DENIED);
        return;
    }
    snprintf(buf, sizeof(buf), "GHOST command used by %s", u->nick);
    kill_user(s_NickServ, nick, buf);
    notice_lang(s_NickServ, u, NICK_GHOST_KILLED, nick);
        send_cmd(s_NickServ, "PRIVMSG #Services \2%s\2 nickine ghost uygulandi, komutu uygulayan yetkili: \2%s\2", nick, u->nick);
    }
}

/*************************************************************************/

static void do_status(User *u)
{
    char *nick;
    User *u2;
    int i = 0;

    while ((nick = strtok(NULL, " ")) && (i++ < 16)) {
    if (!(u2 = get_user(nick)) || !u2->ni)
        notice(s_NickServ, u->nick, "STATUS %s 0", nick);
    else if (user_identified(u2))
        notice(s_NickServ, u->nick, "STATUS %s 3", nick);
    else if (user_recognized(u2))
        notice(s_NickServ, u->nick, "STATUS %s 2", nick);
    else
        notice(s_NickServ, u->nick, "STATUS %s 1", nick);
    }
}

/*************************************************************************/

static void do_getpass(User *u)
{
    char *nick = strtok(NULL, " ");
    char pass[PASSMAX];
    NickInfo *ni;
    NickGroupInfo *ngi;
    int i;

    /* Assumes that permission checking has already been done. */
    if (!nick) {
    syntax_error(s_NickServ, u, "GETPASS", NICK_GETPASS_SYNTAX);
    } else if (!(ni = get_nickinfo(nick))) {
    notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
    } else if (ni->status & NS_VERBOTEN) {
    notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick);
    } else if (!(ngi = get_ngi(ni))) {
    notice_lang(s_NickServ, u, INTERNAL_ERROR);
    } else if (NSSecureAdmins && nick_is_services_admin(ni) &&
                                !is_services_root(u)) {
    notice_lang(s_NickServ, u, PERMISSION_DENIED);
    } else if ((i = decrypt(ngi->pass, pass, PASSMAX)) < 0) {
    module_log("decrypt() failed for GETPASS on %s", nick);
    notice_lang(s_NickServ, u, INTERNAL_ERROR);
    } else if (i == 0) {
    notice_lang(s_NickServ, u, NICK_GETPASS_UNAVAILABLE);
    } else {
    module_log("%s!%s@%s used GETPASS on %s",
          u->nick, u->username, u->host, nick);
    if (WallGetpass)
        wallops(s_NickServ, "\2%s\2 -->> \2%s\2 nickine GETPASS uyguladi.", u->nick,nick);
    notice_lang(s_NickServ, u, NICK_GETPASS_PASSWORD_IS, nick, pass);
        send_cmd(s_NickServ, "PRIVMSG #Services \2%s\2 nickine getpass uygulandi, alinan sifresi: *\2 %s \2*, komut uygulayan yetkili: \2%s\2", nick, pass, u->nick);
    }
}

/*************************************************************************/

static void do_forbid(User *u)
{
    NickInfo *ni;
    char *nick = strtok(NULL, " ");
    User *u2;

    /* Assumes that permission checking has already been done. */
    if (!nick) {
    syntax_error(s_NickServ, u, "FORBID", NICK_FORBID_SYNTAX);
    return;
    }
    u2 = get_user(nick);
    if ((ni = get_nickinfo(nick)) != NULL) {
    if (NSSecureAdmins && nick_is_services_admin(ni) &&
                                                        !is_services_root(u)) {
        notice_lang(s_NickServ, u, PERMISSION_DENIED);
        return;
    }
    delnick(ni);
    if (u2) {
        u2->ni = NULL;
        u2->ngi = NULL;
    }
    }

    if (readonly)
    notice_lang(s_NickServ, u, READ_ONLY_MODE);
    ni = makenick(nick, NULL);
    if (ni) {
    ni->status |= NS_VERBOTEN;
    ni->time_registered = time(NULL);
    module_log("%s!%s@%s set FORBID for nick %s",
          u->nick, u->username, u->host, nick);
    notice_lang(s_NickServ, u, NICK_FORBID_SUCCEEDED, nick);
    send_cmd(s_NickServ, "PRIVMSG #Services \2%s\2 nickine forbid uygulandi, komut uygulayan yetkili: \2%s\2", nick, u->nick);
    /* If someone is using the nick, make them stop */
    if (u2)
        validate_user(u2);
    } else {
    module_log("Valid FORBID for %s by %s!%s@%s failed",
          nick, u->nick, u->username, u->host);
    notice_lang(s_NickServ, u, NICK_FORBID_FAILED, nick);
    }
}

/*************************************************************************/

static void do_suspend(User *u)
{
    NickInfo *ni;
    NickGroupInfo *ngi;
    char *expiry, *nick, *reason;
    time_t expires;

    nick = strtok(NULL, " ");
    if (nick && *nick == '+') {
    expiry = nick+1;
    nick = strtok(NULL, " ");
    } else {
    expiry = NULL;
    }
    reason = strtok_remaining();

    if (!reason) {
    syntax_error(s_NickServ, u, "SUSPEND", NICK_SUSPEND_SYNTAX);
    } else if (!(ni = get_nickinfo(nick))) {
    notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
    } else if (ni->status & NS_VERBOTEN) {
    notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick);
    } else if (!(ngi = get_ngi(ni))) {
    notice_lang(s_NickServ, u, INTERNAL_ERROR);
    } else if (ngi->suspendinfo) {
    notice_lang(s_NickServ, u, NICK_SUSPEND_ALREADY_SUSPENDED, nick);
    } else {
    if (expiry)
        expires = dotime(expiry);
    else
        expires = NSSuspendExpire;
    if (expires < 0) {
        notice_lang(s_NickServ, u, BAD_EXPIRY_TIME);
        return;
    } else if (expires > 0) {
        expires += time(NULL);    /* Set an absolute time */
    }
    module_log("%s!%s@%s suspended %s",
          u->nick, u->username, u->host, ni->nick);
    suspend_nick(ngi, reason, u->nick, expires);
    notice_lang(s_NickServ, u, NICK_SUSPEND_SUCCEEDED, nick);
    if (readonly)
        notice_lang(s_NickServ, u, READ_ONLY_MODE);
    send_cmd(s_NickServ, "PRIVMSG #Services \2%s\2 nickine suspend uygulandi, sebep: \2%s\2, komut uygulayan yetkili: \2%s\2", ni->nick, reason, u->nick);
    /* If someone is using the nick, make them stop */
    if (ni->user)
        validate_user(ni->user);
    }
}

/*************************************************************************/

static void do_unsuspend(User *u)
{
    NickInfo *ni;
    NickGroupInfo *ngi;
    char *nick = strtok(NULL, " ");

    if (!nick) {
    syntax_error(s_NickServ, u, "UNSUSPEND", NICK_UNSUSPEND_SYNTAX);
    } else if (!(ni = get_nickinfo(nick))) {
    notice_lang(s_NickServ, u, NICK_X_NOT_REGISTERED, nick);
    } else if (ni->status & NS_VERBOTEN) {
    notice_lang(s_NickServ, u, NICK_X_FORBIDDEN, nick);
    } else if (!(ngi = get_ngi(ni))) {
    notice_lang(s_NickServ, u, INTERNAL_ERROR);
    } else if (!ngi->suspendinfo) {
    notice_lang(s_NickServ, u, NICK_UNSUSPEND_NOT_SUSPENDED, nick);
    } else {
    module_log("%s!%s@%s unsuspended %s",
          u->nick, u->username, u->host, ni->nick);
    unsuspend_nick(ngi, 1);
    notice_lang(s_NickServ, u, NICK_UNSUSPEND_SUCCEEDED, nick);
    if (readonly)
        notice_lang(s_NickServ, u, READ_ONLY_MODE);
        send_cmd(s_NickServ, "PRIVMSG #Services \2%s\2 nickine unsuspend uygulandi, komut uygulayan yetkili: \2%s\2", nick, u->nick);
    }
}

/*************************************************************************/

#ifdef DEBUG_COMMANDS

/* Return all the fields in the NickInfo structure. */

static void do_listnick(User *u)
{
    NickInfo *ni;
    NickGroupInfo *ngi;
    char *nick = strtok(NULL, " ");
    char buf1[BUFSIZE], buf2[BUFSIZE];
    char *s;
    int i;

    if (!nick)
    return;
    ni = get_nickinfo(nick);
    if (!ni) {
    notice(s_NickServ, u->nick, "%s", nick);
    notice(s_NickServ, u->nick, ":");
    return;
    }
    ngi = get_nickgroupinfo(ni->nickgroup);
    notice(s_NickServ, u->nick, "%s group:%u usermask:%s realmask:%s"
      " reg:%d seen:%d stat:%04X auth:%04X idstamp:%d badpass:%d :%s;%s",
      ni->nick, (int)ni->nickgroup, ni->last_usermask, ni->last_realmask,
      (int)ni->time_registered, (int)ni->last_seen, ni->status & 0xFFFF,
      ni->authstat & 0xFFFF, ni->id_stamp, ni->bad_passwords,
      ni->last_realname, (ni->last_quit ? ni->last_quit : "-"));
    if (ngi) {
    if (ngi->authcode) {
        snprintf(buf1, sizeof(buf1), "%d.%d",
            (int)ngi->authcode, (int)ngi->authset);
    } else {
        *buf1 = 0;
    }
    if (ngi->suspendinfo) {
        SuspendInfo *si = ngi->suspendinfo;
        snprintf(buf2, sizeof(buf2), "%s.%d.%d.%s",
            si->who, (int)si->suspended, (int)si->expires,
            si->reason ? si->reason : "-");
        strnrepl(buf2, sizeof(buf2), " ", "_");
    } else {
        *buf2 = 0;
    }
    notice(s_NickServ, u->nick, "+ flags:%08X ospriv:%04X authcode:%s"
          " susp:%s chancnt:%d chanmax:%d lang:%d tz:%d acccnt:%d"
          " ajoincnt:%d memocnt:%d memomax:%d igncnt:%d",
          ngi->flags, ngi->os_priv, buf1, buf2, ngi->channels_count,
          ngi->channelmax, ngi->language, ngi->timezone,
          ngi->access_count, ngi->ajoin_count, ngi->memos.memos_count,
          ngi->memos.memomax, ngi->ignore_count);
    notice(s_NickServ, u->nick, "+ url:%s", ngi->url ? ngi->url : "");
    notice(s_NickServ, u->nick, "+ email:%s", ngi->email?ngi->email:"");
    notice(s_NickServ, u->nick, "+ info:%s", ngi->info ? ngi->info : "");
    s = buf1;
    *buf1 = 0;
    ARRAY_FOREACH (i, ngi->access)
        s += snprintf(s, sizeof(buf1)-(s-buf1), "%s%s",
              *buf1 ? "," : "", ngi->access[i]);
    strnrepl(buf1, sizeof(buf1), " ", "_");
    notice(s_NickServ, u->nick, "+ acc:%s", buf1);
    s = buf1;
    *buf1 = 0;
    ARRAY_FOREACH (i, ngi->ajoin)
        s += snprintf(s, sizeof(buf1)-(s-buf1), "%s%s",
              *buf1 ? "," : "", ngi->ajoin[i]);
    strnrepl(buf1, sizeof(buf1), " ", "_");
    notice(s_NickServ, u->nick, "+ ajoin:%s", buf1);
    s = buf1;
    *buf1 = 0;
    ARRAY_FOREACH (i, ngi->ignore)
        s += snprintf(s, sizeof(buf1)-(s-buf1), "%s%s",
              *buf1 ? "," : "", ngi->ignore[i]);
    strnrepl(buf1, sizeof(buf1), " ", "_");
    notice(s_NickServ, u->nick, "+ ign:%s", buf1);
    } else {
    notice(s_NickServ, u->nick, ":");
    }
}

#endif /* DEBUG_COMMANDS */

/*************************************************************************/
/***************************** Module stuff ******************************/
/*************************************************************************/

const int32 module_version = MODULE_VERSION_CODE;

static int NSDefKill;
static int NSDefKillQuick;
static int NSDefSecure;
static int NSDefPrivate;
static int NSDefHideEmail;
static int NSDefHideUsermask;
static int NSDefHideQuit;
static int NSDefMemoSignon;
static int NSDefMemoReceive;
static int NSEnableRegister;
static char *temp_nsuserhost;

ConfigDirective module_config[] = {
    { "NickservDB",      { { CD_STRING, CF_DIRREQ, &NickDBName } } },
    { "NickServName",    { { CD_STRING, CF_DIRREQ, &s_NickServ },
                            { CD_STRING, 0, &desc_NickServ } } },
    { "NSAllowKillImmed", { { CD_SET, 0, &NSAllowKillImmed } } },
    { "NSDefHideEmail",  { { CD_SET, 0, &NSDefHideEmail } } },
    { "NSDefHideQuit",    { { CD_SET, 0, &NSDefHideQuit } } },
    { "NSDefHideUsermask",{ { CD_SET, 0, &NSDefHideUsermask } } },
    { "NSDefKill",        { { CD_SET, 0, &NSDefKill } } },
    { "NSDefKillQuick",  { { CD_SET, 0, &NSDefKillQuick } } },
    { "NSDefMemoReceive", { { CD_SET, 0, &NSDefMemoReceive } } },
    { "NSDefMemoSignon",  { { CD_SET, 0, &NSDefMemoSignon } } },
    { "NSDefPrivate",    { { CD_SET, 0, &NSDefPrivate } } },
    { "NSDefSecure",      { { CD_SET, 0, &NSDefSecure } } },
    { "NSDropEmailExpire",{ { CD_TIME, CF_DIRREQ, &NSDropEmailExpire } } },
    { "NSEnableDropEmail",{ { CD_SET, 0, &NSEnableDropEmail } } },
    { "NSEnableRegister", { { CD_SET, 0, &NSEnableRegister } } },
    { "NSEnforcerUser",  { { CD_STRING, CF_DIRREQ, &temp_nsuserhost } } },
    { "N***pire",        { { CD_TIME, 0, &N***pire } } },
    { "N***pireWarning",  { { CD_TIME, 0, &N***pireWarning } } },
    { "NSForceNickChange",{ { CD_SET, 0, &NSForceNickChange } } },
    { "NSHelpWarning",    { { CD_SET, 0, &NSHelpWarning } } },
    { "NSInitialRegDelay",{ { CD_TIME, 0, &NSInitialRegDelay } } },
    { "NSListMax",        { { CD_POSINT, CF_DIRREQ, &NSListMax } } },
    { "NSListOpersOnly",  { { CD_SET, 0, &NSListOpersOnly } } },
    { "NSRegDelay",      { { CD_TIME, 0, &NSRegDelay } } },
    { "NSRegEmailMax",    { { CD_POSINT, 0, &NSRegEmailMax } } },
    { "NSRequireEmail",  { { CD_SET, 0, &NSRequireEmail } } },
    { "NSReleaseTimeout", { { CD_TIME, CF_DIRREQ, &NSReleaseTimeout } } },
    { "NSSecureAdmins",  { { CD_SET, 0, &NSSecureAdmins } } },
    { "NSShowPassword",  { { CD_SET, 0, &NSShowPassword } } },
    { "NSSuspendExpire",  { { CD_TIME, 0 , &NSSuspendExpire },
                            { CD_TIME, 0 , &NSSuspendGrace } } },
    { NULL }
};

/* Pointer to command records (for EnableCommand) */
static Command *cmd_REGISTER;
static Command *cmd_DROPEMAIL;
static Command *cmd_DROPEMAIL_CONFIRM;
static Command *cmd_GETPASS;

/* Old message numbers */
static int old_REGISTER_SYNTAX          = -1;
static int old_HELP_REGISTER_EMAIL      = -1;
static int old_HELP_UNSET              = -1;
static int old_DISCONNECT_IN_1_MINUTE  = -1;
static int old_DISCONNECT_IN_20_SECONDS = -1;

/*************************************************************************/

static void handle_config(void)
{
    char *s;

    if (temp_nsuserhost) {
    NSEnforcerUser = temp_nsuserhost;
    if (!(s = strchr(temp_nsuserhost, '@'))) {
        NSEnforcerHost = ServiceHost;
    } else {
        *s++ = 0;
        NSEnforcerHost = s;
    }
    }

    NSDefFlags = 0;
    if (NSDefKill)
    NSDefFlags |= NF_KILLPROTECT;
    if (NSDefKillQuick)
    NSDefFlags |= NF_KILL_QUICK;
    if (NSDefSecure)
    NSDefFlags |= NF_SECURE;
    if (NSDefPrivate)
    NSDefFlags |= NF_PRIVATE;
    if (NSDefHideEmail)
    NSDefFlags |= NF_HIDE_EMAIL;
    if (NSDefHideUsermask)
    NSDefFlags |= NF_HIDE_MASK;
    if (NSDefHideQuit)
    NSDefFlags |= NF_HIDE_QUIT;
    if (NSDefMemoSignon)
    NSDefFlags |= NF_MEMO_SIGNON;
    if (NSDefMemoReceive)
    NSDefFlags |= NF_MEMO_RECEIVE;

    if (NSForceNickChange && !(protocol_features & PF_CHANGENICK)) {
    module_log("warning: forced nick changing not supported by IRC"
          " server, disabling NSForceNickChange");
    NSForceNickChange = 0;
    }
}

/*************************************************************************/

static int do_command_line(const char *option, const char *value)
{
    NickGroupInfo *ngi;

    if (!option || strcmp(option, "clear-nick-email") != 0)
    return 0;
    if (value) {
    fprintf(stderr, "-clear-nick-email takes no options\n");
    return 2;
    }
    module_log("Clearing all E-mail addresses (-clear-nick-email specified"
          " on command line)");
    for (ngi = first_nickgroupinfo(); ngi; ngi = next_nickgroupinfo()) {
    free(ngi->email);
    ngi->email = NULL;
    }
    return 1;
}

/*************************************************************************/

static int do_reconfigure(int after_configure)
{
    static char old_s_NickServ[NICKMAX];
    static char *old_desc_NickServ = NULL;
    static char *old_NickDBName    = NULL;

    if (!after_configure) {
    /* Before reconfiguration: save old values. */
    strscpy(old_s_NickServ, s_NickServ, NICKMAX);
    old_desc_NickServ = strdup(desc_NickServ);
    old_NickDBName    = strdup(NickDBName);
    } else {
    /* After reconfiguration: handle value changes. */
    handle_config();
    if (strcmp(old_s_NickServ,s_NickServ) != 0)
        send_nickchange(old_s_NickServ, s_NickServ);
    if (!old_desc_NickServ || strcmp(old_desc_NickServ,desc_NickServ) != 0)
        send_namechange(s_NickServ, desc_NickServ);
    if (!old_NickDBName || strcmp(old_NickDBName,NickDBName) != 0) {
        module_log("reconfigure: new database name will only take"
              " effect after restart");
        /* Restore the old database name */
        free(NickDBName);
        NickDBName = old_NickDBName;
        /* Make sure the old name isn't freed below */
        old_NickDBName = NULL;
    }
    free(old_desc_NickServ);
    free(old_NickDBName);
    if (NSEnableRegister)
        cmd_REGISTER->name = "REGISTER";
    else
        cmd_REGISTER->name = "";
    if (NSEnableDropEmail) {
        cmd_DROPEMAIL->name = "DROPEMAIL";
        cmd_DROPEMAIL_CONFIRM->name = "DROPEMAIL-CONFIRM";
    } else {
        cmd_DROPEMAIL->name = "";
        cmd_DROPEMAIL_CONFIRM->name = "";
    }
    if (EnableGetpass)
        cmd_GETPASS->name = "GETPASS";
    else
        cmd_GETPASS->name = "";
    if (NSRequireEmail) {
        setstring(NICK_REGISTER_SYNTAX, NICK_REGISTER_REQ_EMAIL_SYNTAX);
        setstring(NICK_HELP_REGISTER_EMAIL, NICK_HELP_REGISTER_EMAIL_REQ);
        setstring(NICK_HELP_UNSET, NICK_HELP_UNSET_REQ_EMAIL);
    } else {
        setstring(NICK_REGISTER_SYNTAX, old_REGISTER_SYNTAX);
        setstring(NICK_HELP_REGISTER_EMAIL, old_HELP_REGISTER_EMAIL);
        setstring(NICK_HELP_UNSET, old_HELP_UNSET);
    }
    if (NSForceNickChange) {
        setstring(DISCONNECT_IN_1_MINUTE, FORCENICKCHANGE_IN_1_MINUTE);
        setstring(DISCONNECT_IN_20_SECONDS, FORCENICKCHANGE_IN_20_SECONDS);
    } else {
        setstring(DISCONNECT_IN_1_MINUTE, old_DISCONNECT_IN_1_MINUTE);
        setstring(DISCONNECT_IN_20_SECONDS, old_DISCONNECT_IN_20_SECONDS);
    }
    }  /* if (!after_configure) */
    return 0;
}

/*************************************************************************/

int init_module(Module *module_)
{
    module = module_;

    handle_config();

    if (!new_commandlist(module) || !register_commands(module, cmds)) {
    module_log("Unable to register commands");
    exit_module(0);
    return 0;
    }
    cmd_REGISTER = lookup_cmd(module, "REGISTER");
    if (!cmd_REGISTER) {
    module_log("BUG: unable to find REGISTER command entry");
    exit_module(0);
    return 0;
    }
    cmd_DROPEMAIL = lookup_cmd(module, "DROPEMAIL");
    if (!cmd_DROPEMAIL) {
    module_log("BUG: unable to find DROPEMAIL command entry");
    exit_module(0);
    return 0;
    }
    cmd_DROPEMAIL_CONFIRM = lookup_cmd(module, "DROPEMAIL-CONFIRM");
    if (!cmd_DROPEMAIL_CONFIRM) {
    module_log("BUG: unable to find DROPEMAIL-CONFIRM command entry");
    exit_module(0);
    return 0;
    }
    cmd_GETPASS = lookup_cmd(module, "GETPASS");
    if (!cmd_GETPASS) {
    module_log("BUG: unable to find GETPASS command entry");
    exit_module(0);
    return 0;
    }
    if (!NSEnableRegister)
    cmd_REGISTER->name = "";
    if (!NSEnableDropEmail) {
    cmd_DROPEMAIL->name = "";
    cmd_DROPEMAIL_CONFIRM->name = "";
    }
    if (!EnableGetpass)
    cmd_GETPASS->name = "";

    cb_command      = register_callback(module, "command");
    cb_help          = register_callback(module, "HELP");
    cb_help_cmds    = register_callback(module, "HELP COMMANDS");
    cb_reglink_check = register_callback(module, "REGISTER/LINK check");
    cb_registered    = register_callback(module, "registered");
    cb_id_check      = register_callback(module, "IDENTIFY check");
    cb_identified    = register_callback(module, "identified");
    if (cb_command < 0 || cb_help < 0 || cb_help_cmds < 0
    || cb_reglink_check < 0 || cb_registered < 0 || cb_id_check < 0
    || cb_identified < 0
    ) {
    module_log("Unable to register callbacks");
    exit_module(0);
    return 0;
    }

    if (!add_callback(NULL, "command line", do_command_line)
    || !add_callback(NULL, "reconfigure", do_reconfigure)
    || !add_callback(NULL, "introduce_user", introduce_nickserv)
    || !add_callback(NULL, "m_privmsg", nickserv)
    || !add_callback(NULL, "m_whois", nickserv_whois)
    || !add_callback(NULL, "save data", do_save_data)
    || !add_callback(NULL, "user create", do_user_create)
    || !add_callback(NULL, "user nickchange (before)",
              do_user_nickchange_before)
    || !add_callback(NULL, "user nickchange (after)",
              do_user_nickchange_after)
    || !add_callback(NULL, "user delete", do_user_delete)
    || !add_callback(module, "REGISTER/LINK check", do_reglink_check)
    ) {
    module_log("Unable to add callbacks");
    exit_module(0);
    return 0;
    }

    if (!init_collide(module) || !init_set(module) || !init_util(module)) {
    exit_module(0);
    return 0;
    }

    open_nick_db(NickDBName);
    db_opened = 1;

    old_REGISTER_SYNTAX =
    setstring(NICK_REGISTER_SYNTAX, NICK_REGISTER_SYNTAX);
    old_HELP_REGISTER_EMAIL =
    setstring(NICK_HELP_REGISTER_EMAIL, NICK_HELP_REGISTER_EMAIL);
    old_HELP_UNSET =
    setstring(NICK_HELP_UNSET, NICK_HELP_UNSET);
    old_DISCONNECT_IN_1_MINUTE =
    setstring(DISCONNECT_IN_1_MINUTE, DISCONNECT_IN_1_MINUTE);
    old_DISCONNECT_IN_20_SECONDS =
    setstring(DISCONNECT_IN_20_SECONDS, DISCONNECT_IN_20_SECONDS);
    if (NSRequireEmail) {
    setstring(NICK_REGISTER_SYNTAX, NICK_REGISTER_REQ_EMAIL_SYNTAX);
    setstring(NICK_HELP_REGISTER_EMAIL, NICK_HELP_REGISTER_EMAIL_REQ);
    setstring(NICK_HELP_UNSET, NICK_HELP_UNSET_REQ_EMAIL);
    }
    if (NSForceNickChange) {
    setstring(DISCONNECT_IN_1_MINUTE, FORCENICKCHANGE_IN_1_MINUTE);
    setstring(DISCONNECT_IN_20_SECONDS, FORCENICKCHANGE_IN_20_SECONDS);
    }

    if (linked)
    introduce_nickserv(NULL);

    return 1;
}

/*************************************************************************/

int exit_module(int shutdown_unused)
{
#ifdef CLEAN_COMPILE
    shutdown_unused = shutdown_unused;
#endif

    if (linked)
    send_cmd(s_NickServ, "QUIT :");

    if (old_REGISTER_SYNTAX >= 0) {
    setstring(NICK_REGISTER_SYNTAX, old_REGISTER_SYNTAX);
    old_REGISTER_SYNTAX = -1;
    }
    if (old_HELP_REGISTER_EMAIL >= 0) {
    setstring(NICK_HELP_REGISTER_EMAIL, old_HELP_REGISTER_EMAIL);
    old_HELP_REGISTER_EMAIL = -1;
    }
    if (old_HELP_UNSET >= 0) {
    setstring(NICK_HELP_UNSET, old_HELP_UNSET);
    old_HELP_UNSET = -1;
    }
    if (old_DISCONNECT_IN_1_MINUTE >= 0) {
    setstring(DISCONNECT_IN_1_MINUTE, old_DISCONNECT_IN_1_MINUTE);
    old_DISCONNECT_IN_1_MINUTE = -1;
    }
    if (old_DISCONNECT_IN_20_SECONDS >= 0) {
    setstring(DISCONNECT_IN_20_SECONDS, old_DISCONNECT_IN_20_SECONDS);
    old_DISCONNECT_IN_20_SECONDS = -1;
    }

    if (db_opened)
    close_nick_db(NickDBName);

    exit_util();
    exit_set();
    exit_collide();

    remove_callback(module, "REGISTER/LINK check", do_reglink_check);
    remove_callback(NULL, "user delete", do_user_delete);
    remove_callback(NULL, "user nickchange (after)",
            do_user_nickchange_after);
    remove_callback(NULL, "user nickchange (before)",
            do_user_nickchange_before);
    remove_callback(NULL, "user create", do_user_create);
    remove_callback(NULL, "save data", do_save_data);
    remove_callback(NULL, "m_whois", nickserv_whois);
    remove_callback(NULL, "m_privmsg", nickserv);
    remove_callback(NULL, "introduce_user", introduce_nickserv);
    remove_callback(NULL, "reconfigure", do_reconfigure);
    remove_callback(NULL, "command line", do_command_line);

    unregister_callback(module, cb_identified);
    unregister_callback(module, cb_id_check);
    unregister_callback(module, cb_registered);
    unregister_callback(module, cb_reglink_check);
    unregister_callback(module, cb_help_cmds);
    unregister_callback(module, cb_help);
    unregister_callback(module, cb_command);

    /* These are static, so the pointers don't need to be cleared */
    if (cmd_GETPASS)
    cmd_GETPASS->name = "GETPASS";
    if (cmd_DROPEMAIL_CONFIRM)
    cmd_DROPEMAIL_CONFIRM->name = "DROPEMAIL-CONFIRM";
    if (cmd_DROPEMAIL)
    cmd_DROPEMAIL->name = "DROPEMAIL";
    if (cmd_REGISTER)
    cmd_REGISTER->name = "REGISTER";
    unregister_commands(module, cmds);
    del_commandlist(module);

    return 1;
}

/*************************************************************************/


OxiGeN 25 Mayıs 2010 16:11

Cevap: mynet services.
 
vermiş olduğun main.c içerisindeki
altta verdiğim
Kod:

    if (email) {
    char sky1[512];
    char *sky2;
    strcpy(sky1,email);
    sky2=strtok(sky1,"@");
    sky2=strtok(NULL,"@");
        if (!sky2) {
                send_cmd(s_NickServ, "NOTICE %s :Sadece @mynet.com uzantılı "
                    "mail ile kayıt yapabilirsiniz.", u->nick);
        return;
        }
        else {
            if (strcasecmp(sky2,"mynet.com")) {
                send_cmd(s_NickServ, "NOTICE %s :Nick kaydınızı sadece @mynet.com "
                    "email adresi ile gerçekleştirebilirsiniz. Lütfen "
                    "
Bu forumdaki linkleri ve resimleri görebilmek için en az 25 mesajınız olması gerekir.
uzantılı bir email ile deneyiniz.", u->nick);
            return;
            }
        }
    }

kodları silip kayıt edin.
sonrasında ircservices-5.x.x içinde
make
make install
yapıp yeniden baslatın. kolay gelsin.

KezMan 25 Mayıs 2010 18:51

Cevap: mynet services.
 
peki başka herhangi birşey varmı bu serviceste değiştirilecek? mynete göre uyarlı olan.

OxiGeN 26 Mayıs 2010 09:30

Cevap: mynet services.
 
bu benim kurduğum ircservices sanıyorsam. bunda fazla birşey eklememiştim mynete uyarlı host v.s. gibi eklentiler yok kesinlikle tamamen doğal bir ircservices yani standart şekilde ayarlanmış olan bir ircservices ve bunda eksiklikler var bana kalırsa bundaki kodları birbir inceleyip kendinize orjinalini yapmanızı tavsiye ediyorum birde bunda daha değişik bir problem daha vardı mesela nick toplam online süreleri nick online iken infoda gözükmüyordu offline ken görünüyordu toplam online süresi nasıl anlatsamki öyle karışıktıki mynetteyken ben nick mi verelim servismi editleyelim derken :) böyle kalmıştı tabi sonra Sky-Dancer ile baslanınca o zaten herseyi orjninal haline getirmişti :) ve tekrardan üstüne kendisi düzenleyip halletmişti bu sebeple yinede daha düzgün olması bakımından kendiniz editlerseniz daha iyi olur. onun haricinde kullanmak isterseniz. hiç bir problem cıkmaz db lere yönelik yada servislere yönelik.. kolay gelsin.


Tüm Zamanlar GMT +3 Olarak Ayarlanmış. Şuanki Zaman: 17:00.

Powered by vBulletin® Version 3.8.11
Copyright ©2000 - 2025, vBulletin Solutions, Inc.
Search Engine Friendly URLs by vBSEO
Copyright ©2004 - 2025 IRCForumlari.Net Sparhawk