}
sub agent_connect($$$$$) {
- print "agent_connect\n";
my ($nick, $ident, $host, $modes, $gecos) = @_;
my $time = time();
my ($agent, $chan) = split(/ /, $j);
if($agents{lc $agent}) {
$agents{lc $agent}{CHANS}{lc $chan} = 1;
- ircd::agent_join($agents{lc $agent}, $chan);
+ agent_join($agents{lc $agent}, $chan);
} else {
if($ircd_ready) {
print "Tried to make nonexistent agent ($agent) join channel ($chan)" if DEBUG;
$sync = 0;
$wf = $_[3];
}
-
$message = {
CLASS => 'IRCD',
TYPE => $_[0],
our $initial_synced;
sub synced {
- return 1;
- #return $synced;
+ return $synced;
}
sub initial_synced {
- return 1;
- #return $initial_synced;
+ return $initial_synced;
}
sub calc_synced {
SYNCED: {
foreach my $s (keys(%servers)) {
my $state = get_server_state($s);
-
- print "Server: $s State: $state\n" if DEBUG();
-
+ print "Server:d $s State: $state\n" if DEBUG();
if(!$state) {
$synced = 0;
last SYNCED;
# Unreal uses its own modified base64 for everything except NICKIP
use SrSv::Unreal::Base64 qw(b64toi itob64);
-
+use SrSv::User '/./';
# Unreal uses unmodified base64 for NICKIP.
# Consider private implementation,
# tho MIME's is probably faster
use MIME::Base64;
-
+use Data::Dumper;
# FIXME
use constant {
# Wait For
}
#parse_fjoin($server, $channel, $ts, $modes, @nicks, @status)
sub parse_fjoin ($$$$$$) {
- my ($server, $channel, $ts, $modes, $nicksref, $statusref) = @_;
+ my ($server, $channel, $ts, $modes, $idsr, $statusref) = @_;
my @status = @$statusref;
- my @nicks = @$nicksref;
+ my @ids = @$idsr;
my $i = 0;
my @users;
- foreach my $nick (@nicks) {
+ foreach my $id (@ids) {
my $op = 0;
my @ops = split ("",$status[$i]);
foreach my $prefix (@ops) {
$op |= $opmodes{$prefix};
}
- push @users, { NICK => ircd::getRevUuid($nick), __OP => $op};
+ my $user = {ID => $id, __OP=>$op};
+ get_user_nick ($user);
+ push @users, $user;
$i++;
}
- return ($server, $channel, $ts, $modes, undef, \@users, undef, undef, undef); #those are got from FMODE...
+ return ($server, $channel, $ts, $modes, undef, \@users, undef, undef, undef); #bans etc are got from FMODE..
}
sub parse_sjoin($$$$) {
my ($server, $ts, $cn, $parms) = @_;
sub UID ($) {
#:583 UID 583AAAAAJ 1307703236 erry__ localhost localhost errietta 127.0.0.1 1307703241 + :errietta
$_[0] =~ /^(:\S+) UID (\S+) (\d+) (\S+) (\S+) (\S+) (\S+) (\S+) (\d+) (\S+) :(.*)$/;
- my ($server, $uid, $ts, $nick, $host, $vhost, $ident, $IP, $stamp, $modes, $gecos) = ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);
+ my ($server, $uid, $stamp, $nick, $host, $vhost, $ident, $IP, $ts, $modes, $gecos) = ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);
ircd::setRevUuid ($uid, $nick);
ircd::setUuid ($nick, $uid);
- return ('NICKCONN', undef, undef, WF_NICK, $nick, 0, $ts, $ident, $host, $server, $stamp, $modes, $vhost, $gecos,
+ my $user = { NICK => $nick, ID => $uid };
+ return ('NICKCONN', undef, undef, WF_NICK, $user, 0, $ts, $ident, $host, $server, $stamp, $modes, $vhost, $gecos,
join('.', unpack('C4', MIME::Base64::decode($IP))));
}
sub EOS($) {
else {
$server = $2;
}
+ print "SERVER $server\n";
set_server_state($server, 1);
return undef() unless get_server_state($remoteserv);
if($server eq $remoteserv) { $event = 'SEOS' } else { $event = 'EOS' }
return ($event, undef, undef, WF_ALL, $server);
}
else {
+ print "wot\n";
+ $_[0] =~ /^:(\S+) ENDBURST/;
+ my $server = $1;
+ set_server_state($server, 1);
+ print "server $server remote $remoteserv\n";
+ return undef() unless get_server_state($remoteserv);
print "This be it! Got endbrust!\n";
return ("ENDBURST", undef, undef, WF_ALL, $1);
}
sub SERVER($) {
#ircd::debug($_[0]) if $debug;
+
if($_[0] =~ /^(?:SERVER|\') (\S+) (\S+) :(U[0-9]+)-([A-Za-z0-9]+)-([0-9]+) (.*)$/) {
# SERVER test-tab.surrealchat.net 1 :U2307-FhinXeOoZEmM-200 SurrealChat
# cmd, servername, hopCount, U<protocol>-<buildflags>-<numeric> infoLine
return ('SERVER', undef, undef, WF_ALL, $1, $2, $3, $4);
# src, serverName, numHops, infoLine
}
+ elsif ($_[0] =~ /SERVER (\S+) (\S+) (\d+) (\S+) :(.*)$/) {
+ #SERVER inspircd.erry.omg mypass 0 583 :erry World
+ #SERVER servername password hopcount SID :Server Desc
+ $remoteserv = $4;
+ create_server ($4);
+ #since from now on we'll be getting commands as sent from the SID it's much wiser to keep that than the name.
+ return ("SERVER", undef, undef, WF_ALL, undef, $1, $3, $5, $4);
+ }
}
sub SQUIT($) {
sub JOIN($) {
$_[0] =~ /^:(\S+) (?:C|JOIN) (\S+)$/;
- return ('JOIN', undef, 1, WF_CHAN, $1, $2);
+ my $user = { ID => $1 };
+ get_user_nick ($user);
+ return ('JOIN', undef, 1, WF_CHAN, $user, $2);
}
-#>> 13 :97K FJOIN #erry 1307879417 +nt :o,97KAAAAAA ,97KAAAAAB
+
sub FJOIN ($) {
+ #>> 13 :97K FJOIN #erry 1307879417 +nt :o,97KAAAAAA ,97KAAAAAB
$_[0] =~ m"^(:\S+) FJOIN (\S+) (\d+) (\S+) (.*)$";
my ($server, $channel, $ts, $modes, $userstring) = ($1, $2, $3, $4, $5);
my @users = split (" ", $userstring);
- my (@nicks, @status);
+ my (@ids, @status);
foreach my $user (@users) {
my @params = split (",",$user);
push (@status, $params[0]);
- push (@nicks, $params[1]);
+ push (@ids, $params[1]);
}
- return ('SJOIN', undef, undef, WF_CHAN, parse_fjoin($server, $channel, $ts, $modes, \@nicks, \@status));
+ return ('SJOIN', undef, undef, WF_CHAN, parse_fjoin($server, $channel, $ts, $modes, \@ids, \@status));
}
sub SJOIN($) {
if ($_[0] =~ /^(?:\~|SJOIN) (\S+) (\S+) (.*)$/) {
}
sub PART($) {
+ my $user;
+
if($_[0] =~ /^:(\S+) (?:D|PART) (\S+) :(.*)$/) {
- return ('PART', undef, 0, WF_CHAN, $1, $2, $3);
+ $user = {ID => $1};
+ get_user_nick ($user);
+ return ('PART', undef, 0, WF_CHAN, $user, $2, $3);
}
elsif($_[0] =~ /^:(\S+) (?:D|PART) (\S+)$/) {
- return ('PART', undef, 0, WF_CHAN, $1, $2, undef);
+ $user = {ID => $1};
+ return ('PART', undef, 0, WF_CHAN, $user, $2, undef);
+ }
+}
+sub FMODE($) {
+ #:583AAAAAR FMODE #erry 1308214721 +ib test!*@* When any mode in the channel is set.
+ #:583 FMODE #erry 1308214721 +b test1!*@* At server connect. Note that the rest of the channel modes are not there but rather at FJOIN. So this will only have bans and the like.
+ if($_[0] =~ /^:(\S+) FMODE (#\S+) (\d+) (\S+) ?(.*)$/) {
+ my $id = $1;
+ my $user = {ID => $id};
+ get_user_nick ($user);
+ return ('MODE', undef, 1, WF_ALL, $user, $2, $4, $5);
}
}
-
sub MODE($) {
+ my $user;
+
if($_[0] =~ /^(@|:)(\S+) (?:G|MODE) (#\S+) (\S+) (.*)(?: \d+)?$/) {
my $name;
if ($1 eq '@') {
$name = $servernum[b64toi($2)];
+ $user = {NICK => $name};
}
else {
$name = $2;
+ $user = { ID=>$name};
+ get_user_nick ($user);
}
- my $properName = getRevUuid ($name);
- if ($properName) { $name = $properName; }
- return ('MODE', undef, 1, WF_ALL, $name, $3, $4, $5);
+ return ('MODE', undef, 1, WF_ALL, $user, $3, $4, $5);
}
elsif($_[0] =~ /^:(\S+) (?:G|MODE) (\S+) :(\S+)$/) {
# We shouldn't ever get this, as UMODE2 is preferred
- return ('UMODE', 0, 0, WF_ALL, $1, $3);
+ $user = { ID => $1 };
+ get_user_nick ($user);
+ return ('UMODE', 0, 0, WF_ALL, $user, $3);
}
}
sub MESSAGE($) {
my ($event, @args);
if($_[0] =~ /^(@|:)(\S+) (?:\!|PRIVMSG) (\S+) :(.*)$/) {
- my $name;
+
+ my ($name, $srcUser, $dstUser) ;
if ($1 eq '@') {
$name = $servernum[b64toi($2)];
+ $srcUser = {NICK=>$name};
}
else {
$name = $2;
+ $srcUser = {ID=>$name};
+ unless (get_user_nick ($srcUser)) {
+ $srcUser = {NICK=>$name};
+ get_user_id ($name);
+ }
}
my $dest = $3;
- my $reverse_uuid = ircd::getRevUuid($dest);
- my $user_revuuid = ircd::getRevUuid($name);
- unless ($reverse_uuid eq "") {
- $dest = $reverse_uuid;
- }
- unless ($user_revuuid eq "") {
- $name = $user_revuuid;
+ $dstUser = {ID=>$dest};
+ unless (get_user_nick ($dstUser)) {
+ $dstUser = {NICK=>$dest};
}
- $event = 'PRIVMSG'; @args = ($name, $dest, $4);
+ print Dumper ($srcUser);
+ print Dumper ($dstUser);
+ $event = 'PRIVMSG'; @args = ($srcUser, $dstUser, $4);
}
elsif($_[0] =~ /^(@|:)(\S+) (?:B|NOTICE) (\S+) :(.*)$/) {
my $name;
sub AWAY($) {
if($_[0] =~ /^:(\S+) (?:6|AWAY) :(.*)$/) {
- return ('AWAY', undef, undef, WF_ALL, $1, $2);
+ my $user = {ID=>$1};
+ get_user_nick($user);
+ return ('AWAY', undef, undef, WF_ALL, $user, $2);
}
- elsif($_[0] =~ /^:(\S+) (?:6|AWAY) $/) {
- return ('BACK', undef, undef, WF_ALL, $1);
+ elsif($_[0] =~ /^:(\S+) (?:6|AWAY)$/) {
+ my $user = {ID => $1};
+ get_user_nick ($user);
+ return ('BACK', undef, undef, WF_ALL, $user);
}
}
my ($event, @args);
#:97KAAAAAA NICK erry_ 1307878528
if($_[0] =~ /^:(\S+) (?:NICK|\&) (\S+) :?(\S+)$/) {
- my $oldnick = ircd::getRevUuid ($1);
+ my $user = {ID => $1};
+ get_user_nick ($user);
ircd::setRevUuid ($1, $2);
ircd::setUuid ($2, $1);
- return ('NICKCHANGE', undef, undef, WF_NICK, $oldnick, $2, $3);
- }
- elsif(CLK && NICKIP && $_[0] =~ /^(?:NICK|\&) (\S+) (\d+) (\S+) (\S+) (\S+) (\S+) (\d+) (\S+) (\S+) (\S+) (\S+) :(.*)$/) {
-#NICK Guest57385 1 !14b7t0 northman tabriel.tabris.net 38 0 +iowghaAxNWzt netadmin.SCnet.ops SCnet-3B0714C4.tabris.net CgECgw== :Sponsored By Skuld
- my ($nick, $hops, $ts, $ident, $host, $server, $stamp, $modes, $vhost, $cloakhost, $IP, $gecos) =
- ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);
- if ($ts =~ s/^!//) {
- $ts = b64toi($ts);
- }
- if (SJB64 and length($server) <= 2 and $server !~ /\./) {
- $server = $servernum[b64toi($server)];
-
- }
- return ('NICKCONN', undef, undef, WF_NICK, $nick, $hops, $ts, $ident, $host, $server, $stamp, $modes, $vhost, $gecos,
- join('.', unpack('C4', MIME::Base64::decode($IP))), $cloakhost
- );
- }
- elsif(!CLK && NICKIP && $_[0] =~ /^(?:NICK|\&) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) :(.*)$/) {
-#NICK tab 1 1116196525 northman tabriel.tabris.net test-tab.surrealchat.net 0 +iowghaAxNWzt netadmin.SCnet.ops CgECgw== :Sponsored by Skuld
- my ($nick, $hops, $ts, $ident, $host, $server, $stamp, $modes, $vhost, $IP, $gecos) =
- ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11);
- if ($ts =~ s/^!//) {
- $ts = b64toi($ts);
- }
- if (SJB64 and length($server) <= 2 and $server !~ /\./) {
- $server = $servernum[b64toi($server)];
-
- }
- return ('NICKCONN', undef, undef, WF_NICK, $nick, $hops, $ts, $ident, $host, $server, $stamp, $modes, $vhost, $gecos,
- join('.', unpack('C4', MIME::Base64::decode($IP)))
- );
- }
- elsif(!CLK && !NICKIP && $_[0] =~ /^(?:NICK|\&) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) (\S+) :(.*)$/) {
-#NICK tab 1 1116196525 northman tabriel.tabris.net test-tab.surrealchat.net 0 +iowghaAxNWzt netadmin.SCnet.ops :Sponsored by Skuld
- my ($nick, $hops, $ts, $ident, $host, $server, $stamp, $modes, $vhost, $gecos) =
- ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10);
- if ($ts =~ s/^!//) {
- $ts = b64toi($ts);
- }
- if (SJB64 and length($server) <= 2 and $server !~ /\./) {
- $server = $servernum[b64toi($server)];
-
- }
- return ('NICKCONN', undef, undef, WF_NICK, $nick, $hops, $ts, $ident, $host, $server, $stamp, $modes, $vhost, $gecos);
+ return ('NICKCHANGE', undef, undef, WF_NICK, $user, $2, $3);
}
}
sub QUIT($) {
$_[0] =~ /^:(\S+) (?:QUIT|\,) :(.*)$/;
- my $id = $1;
- my $nick = ircd::getRevUuid($id);
- if (!$nick) { $nick = $id; }
- return ('QUIT', 0, undef, WF_NICK, $nick, $2);
+ my $user = {ID=>$1};
+ get_user_nick ($1);
+ return ('QUIT', 0, undef, WF_NICK, $user, $2);
}
sub KILL($) {
else {
$name = $2;
}
- return ('KILL', 0, 1, WF_NICK, $name, $3, $4, $5);
+ my $user = {ID => $name};
+ unless (get_user_nick ($user)) {
+ $user = {NICK => $name};
+ get_user_id ($user);
+ }
+ return ('KILL', 0, 1, WF_NICK, $user, $3, $4, $5);
}
sub KICK($) {
else {
$name = $2;
}
- return ('KICK', 0, undef, WF_CHAN, $name, $3, $4, $5);
+ my $user = {ID => $name};
+ unless (get_user_nick ($user)) {
+ $user = {NICK => $name};
+ get_user_id ($user);
+ }
+ return ('KICK', 0, undef, WF_CHAN, $user, $3, $4, $5);
}
sub HOST($) {
sub TOPIC($) {
- if($_[0] =~ /^(@|:)(\S+) (?:TOPIC|\)) (\S+) (\S+) (\S+) :(.*)$/) {
- #:tabris TOPIC #the_lounge tabris 1089336598 :Small Channel in search of Strong Founder for long term relationship, growth, and great conversation.
- my $name;
- if ($1 eq '@') {
- $name = $servernum[b64toi($2)];
- }
- else {
- $name = $2;
- }
- return ('TOPIC', 0, 1, WF_ALL, $name, $3, $4, $5, $6);
- }
- elsif($_[0] =~ /^(?:TOPIC|\)) (\S+) (\S+) (\S+) :(.*)$/) {
- # src, channel, setter, timestamp, topic
- return ('TOPIC', 0, 1, WF_ALL, undef, $1, $2, $3, $4);
+ if ($_[0] =~ /^:(\S+) TOPIC (\S+) :(.*)$/) {
+ #:583AAAAAF TOPIC #erry :Welcome to erry(world|net). Have a cookie.
+ my $setter = { ID => $1 };
+ get_user_nick ($setter);
+ return ('TOPIC', 0, 1, WF_ALL, $setter, $2, $setter, 0, $3);
}
}
# on IRCds with only MODE.
return ('UMODE', 0, 0, WF_ALL, $1, $2);
}
-
+sub OPERTYPE ($) {
+ #:583AAAAAB OPERTYPE SuperNetAdmin
+ #Every OPERTYPE will get +o, so it's safe to assume they're opers,
+ #even if we don't give them privs (either in inspircd or srsv)
+ $_[0] =~ /^:(\S+) OPERTYPE (\S+)$/;
+ my $user = { ID => $1 };
+ print Dumper ($user);
+ get_user_nick ($user);
+ return ("OPERUP", 0, 0, WF_ALL, $user);
+}
sub SVSMODE($) {
#:tabris | +oghaANWt
$_[0] =~ /^:(\S+) (?:SVS2?MODE|n|v) (\S+) (\S+)$/;
SJOIN => \&SJOIN,
'~' => \&SJOIN,
FJOIN => \&FJOIN,
+ FMODE => \&FMODE,
MODE => \&MODE,
G => \&MODE,
STATS => \&STATS,
'2' => \&STATS,
UID => \&UID,
+ OPERTYPE => \&OPERTYPE,
);
}
use Event;
use Carp;
use MIME::Base64;
-
+use Data::Dumper;
use SrSv::Conf 'main';
-
+use SrSv::Insp::UUID;
use SrSv::Debug;
use SrSv::Log;
use Exporter 'import';
}
sub getUuid($) {
my $nick = lc $_[0];
- print "Get uuid $nick " . $uuids{$nick} . "\n";
- return $uuids{$nick};
+ my $id = $uuids{$nick};
+ print "getUuid $nick $id\n";
+ return $id;
}
sub setRevUuid ($$) {
my ($id, $nick) = @_;
sub setUuid ($$) {
my ($nick, $id) = @_;
$uuids{lc $nick} = $id;
- print "Set uuid $nick $id\n";
}
sub serv_connect() {
my $remote = $main_conf{remote};
my $port = $main_conf{port};
-
ircd_connect($remote, $port);
-
#ircsendimm('PROTOCTL '.($tkn ? 'TOKEN ' : '').'NICKv2 UMODE2 TKLEXT'.
#(CLK ? ' CLK' : ' VHP'). # CLK obsoletes VHP. Plus if you leave VHP on, CLK doesn't work.
# (NOQUIT ? ' NOQUIT' : '').(SJ3 ? ' SJOIN SJOIN2 SJ3' : '').
# Handler functions
sub pong($$$) {
- my ($src, $cookie, $dst) = @_;
+ my ($src, $cookie, $dst) = @_;
# This will only make sense if you remember that
# $src is where it came from, $dst is where it went (us)
# we're basically bouncing it back, but changing from PING to PONG.
sub kick($$$$) {
my ($src, $chan, $target, $reason) = @_;
$src = $main_conf{local} unless initial_synced();
- my $propersrc = getUuid ($src);
- if ($propersrc) { $src = $propersrc; }
- ircsend(":$src $tkn{KICK}[$tkn] $chan $target :$reason");
-# thread::ircrecv(":$src $tkn{KICK}[$tkn] $chan $target :$reason");
- callfuncs('KICK', 0, 2, [$src, $chan, $target, $reason]);
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ ircsend(":$srcId $tkn{KICK}[$tkn] $chan $targetId :$reason");
+ callfuncs('KICK', 0, 2, [$srcId, $chan, $targetId, $reason]);
}
sub invite($$$) {
my ($src, $chan, $target) = @_;
- my $propersrc = getUuid ($src);
- if ($propersrc) { $src = $propersrc; }
- my $properdest = getUuid ($target);
- if ($properdest) { $target = $properdest; }
- ircsend(":$src $tkn{INVITE}[$tkn] $target $chan 0");
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ ircsend(":$srcId $tkn{INVITE}[$tkn] $targetId $chan 0");
}
sub ping {
sub privmsg($$@) {
my ($src, $dst, @msgs) = @_;
-
my @bufs;
foreach my $buf (@msgs) {
# 3 spaces, two colons, PRIVMSG=7
my $buflen = length($src) + length($dst) + 12 + (MASKLEN - (NICKLEN + 1));
push @bufs, wordwrap($buf, (MAXBUFLEN - $buflen));
}
- my $properSrc = getUuid($src);
- if ($properSrc) { $src = $properSrc; }
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+
# submit a list of messages as a single packet to the server
- ircsend(":$src $tkn{PRIVMSG}[$tkn] $dst :".join("\r\n".":$src $tkn{PRIVMSG}[$tkn] $dst :", @bufs));
+ ircsend(":$srcId $tkn{PRIVMSG}[$tkn] $dst :".join("\r\n".":$src $tkn{PRIVMSG}[$tkn] $dst :", @bufs));
callfuncs('LOOP_PRIVMSG', 0, 1, [$src, $dst, \@bufs]);
}
debug_privmsg($main_conf{local}, $main_conf{diag}, @msgs);
write_log('diag', '<'.$main_conf{local}.'>', @msgs);
}
-
+sub write_log () { }
sub debug_nolog(@) {
my (@msgs) = @_;
debug_privmsg($main_conf{local}, $main_conf{diag}, @msgs);
sub notice($$@) {
my ($src, $dst, @msgs) = @_;
-
+ my $target = $dst; #lazy erry
my @bufs;
foreach my $buf (@msgs) {
# 3 spaces, two colons, NOTICE=6
my $buflen = length($src) + length($dst) + 12 + (MASKLEN - (NICKLEN + 1));
push @bufs, wordwrap($buf, (MAXBUFLEN - $buflen));
}
- my $propersrc = getUuid($src);
- if ($propersrc) { $src = $propersrc; }
- my $properdest = getUuid($dst);
- if ($properdest) { $dst = $properdest; }
- # submit a list of notices as a single packet to the server
- ircsend(":$src $tkn{NOTICE}[$tkn] $dst :".join("\r\n".":$src $tkn{NOTICE}[$tkn] $dst :", @bufs));
- callfuncs('LOOP_NOTICE', 0, 1, [$src, $dst, \@bufs]);
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId;
+ if (ref ($dst) eq "HASH") { #User Object
+ $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ }
+ else { # /notice #channel This probably sucks. Blame erry :(
+ $targetId = $dst;
+ }
+ print "targid $targetId\n";
+ ircsend(":$srcId $tkn{NOTICE}[$tkn] $targetId :".join("\r\n".":$srcId $tkn{NOTICE}[$tkn] $targetId :", @bufs));
+ callfuncs('LOOP_NOTICE', 0, 1, [$srcId, $targetId, \@bufs]);
}
sub ctcp($$@) {
my ($src, $dst, $cmd, @toks) = @_;
-
- privmsg($src, $dst, "\x01".join(' ', ($cmd, @toks))."\x01");
+ my $target = $dst; #lazy erry
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ privmsg($srcId, $targetId, "\x01".join(' ', ($cmd, @toks))."\x01");
}
sub ctcp_reply($$@) {
my ($src, $dst, $cmd, @toks) = @_;
-
- notice($src, $dst, "\x01".join(' ', ($cmd, @toks))."\x01");
+ my $target = $dst; #lazy erry
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ notice($srcId, $targetId, "\x01".join(' ', ($cmd, @toks))."\x01");
}
sub setumode($$$) {
my ($src, $dst, $modes) = @_;
-
- ircsend(":$src $tkn{SVS2MODE}[$tkn] $dst $modes");
+ my $target = $dst; #lazy erry
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ ircsend(":$srcId $tkn{SVSMODE}[$tkn] $targetId $modes");
callfuncs('UMODE', 0, undef, [$dst, $modes]);
}
sub setsvsstamp($$$) {
my ($src, $dst, $stamp) = @_;
-
+
ircsend(":$src $tkn{SVS2MODE}[$tkn] $dst +d $stamp");
# This function basically set the svsstamp to
# be the same as the userid. Not all ircd will
sub setagent_umode($$) {
my ($src, $modes) = @_;
-
ircsend(":$src $tkn{UMODE2}[$tkn] $modes");
}
my ($src, $dst, @modelist) = @_;
#debug(" --", "-- ircd::setmode2: ".$_[0], split(/\n/, Carp::longmess($@)), " --");
foreach my $modetuple (@modelist) {
+ my $target = $modetuple->[1];
setmode($src, $dst, $modetuple->[0], $modetuple->[1]);
}
}
sub ban_list($$$$@) {
# Convenience function for lots of bans or excepts.
my ($src, $cn, $sign, $mode, @parms) = @_;
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
my @masklist;
foreach my $mask (@parms) {
push @masklist, [( ($sign >= 1) ? '+' : '-').$mode, $mask];
}
- ircd::setmode2($src, $cn, @masklist);
+ ircd::setmode2($srcId, $cn, @masklist);
}
sub setmode($$$;$) {
- my ($src, $dst, $modes, $parms) = @_;
- $src = $main_conf{local} unless initial_synced();
- my $properSrc = getUuid ($src);
- if ($properSrc) { $src = $properSrc; }
- callfuncs('MODE', undef, 1, [$src, $dst, $modes, $parms]);
-
- print "$ircline -- setmode($src, $dst, $modes, $parms)\n" if DEBUG;
- my $prev = $defer_mode{"$src $dst"}[-1];
-
- if(defined($prev)) {
- my ($oldmodes, $oldparms) = split(/ /, $prev, 2);
-
- # 12 modes per line
- if((length($oldmodes.$modes) - @{[($oldmodes.$modes) =~ /[+-]/g]}) <= 12 and length($src.$dst.$parms.$oldparms) < 400) {
- $defer_mode{"$src $dst"}[-1] = modes::merge(
- $prev, "$modes $parms", ($dst =~ /^#/ ? 1 : 0));
- print $defer_mode{"$src $dst"}[-1], " *** \n" if DEBUG;
-
- return;
- }
+ my ($src, $dst, $modes, $target) = @_;
+ my $srcId;
+ if (initial_synced()) {
+ $srcId = ($src->{ID}?$src->{ID}:($src->{UUID}?$src->{UUID}:$src->{NICK}));
}
-
- push @{$defer_mode{"$src $dst"}}, "$modes $parms";
+ else {
+ $src = $main_conf{numeric};
+ $srcId = $src;
+ }
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ callfuncs('MODE', undef, 1, [$srcId, $dst, $modes, $targetId]);
+ #print "$ircline -- setmode($srcId, $dst, $modes, $targetId)\n" ;
+ ircsend(":$srcId MODE $dst $modes $targetId");
}
+sub setmode_many($$$;@) {
+ my ($src, $dst, $modes, @targets) = @_;
+ my $srcId;
+ if (initial_synced()) {
+ $srcId = ($src->{ID}?$src->{ID}:($src->{UUID}?$src->{UUID}:$src->{NICK}));
+ }
+ else {
+ $src = $main_conf{local};
+ $srcId = $src;
+ }
+ my $parms = "";
+ foreach my $target (@targets) {
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ $parms .= ($parms == ""?"":" ") . $targetId;
+ }
+ callfuncs('MODE', undef, 1, [$srcId, $dst, $modes, $parms]);
+ print "$ircline -- setmode($srcId, $dst, $modes, $parms)\n" ;
+ ircsend(":$srcId MODE $dst $modes $parms");
+}
+
+
sub flushmodes(;$) {
my $dm = (shift or \%defer_mode);
my @k = keys(%$dm); my @v = values(%$dm);
-
for(my $i; $i<@k; $i++) {
my ($src, $dst) = split(/ /, $k[$i]);
my @m = @{$v[$i]};
foreach my $m (@m) {
my ($modes, $parms) = split(/ /, $m, 2);
-
setmode_real($src, $dst, $modes, $parms);
}
}
-
%$dm = ();
}
sub setmode_real($$$;$) {
my ($src, $dst, $modes, $parms) = @_;
-
- print "$ircline -- setmode_real($src, $dst, $modes, $parms)\n" if DEBUG;
+ print "$ircline -- setmode_real($src, $dst, $modes, $parms)\n";
# for server sources, there must be a timestamp. but you can put 0 for unspecified.
$parms =~ s/\s+$//; #trim any trailing whitespace, as it might break the simple parser in the ircd.
+
ircsend(":$src ".$tkn{MODE}[$tkn]." $dst $modes".($parms?" $parms":'').($src =~ /\./ ? ' 0' : ''));
}
sub settopic($$$$$) {
my ($src, $chan, $setter, $time, $topic) = @_;
- $src = $main_conf{local} unless initial_synced();
-
- ircsend(":$src ".$tkn{TOPIC}[$tkn]." $chan $setter $time :$topic");
- callfuncs('TOPIC', undef, undef, [$src, $chan, $setter, $time, $topic]);
+ $src = $main_conf{numeric} unless initial_synced();
+ #>> 38 :583AAAAAF TOPIC #erry :Welcome to erry(world|net). Have a cookie.
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ ircsend(":$srcId ".$tkn{TOPIC}[$tkn]." $chan :$topic");
+ callfuncs('TOPIC', undef, undef, [$srcId, $chan, $setter, $time, $topic]);
}
sub wallops ($$) {
sub globops ($$) {
my ($src, $message) = @_;
- ircsend(":$src $tkn{GLOBOPS}[$tkn] :$message");
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ ircsend(":$srcId $tkn{GLOBOPS}[$tkn] :$message");
}
sub kline ($$$$$) {
# you need to use ADDLINE for this. GLINE is a user command
# format is
#>> 47 :583AAAAAA ADDLINE G test@testie inspircd.erry.omg 1308118489 0 :hi
+ #NOTE FOR ALL ADDLINES:
+ #note that you need to provide expiry alone, not expiry +time
+ #otherwise you will end up with insanely long bans
my $setId = getUuid($setter);
if ($setId) { $setter = $setId; }
- my $line = ":$setter ADDLINE G $ident\@$host " . $main_conf{local} . " ". time() . " " . ($expiry + time())." :$reason";
+ my $line = ":$setter ADDLINE G $ident\@$host " . $main_conf{local} . " ". time() . " " . ($expiry)." :$reason";
ircsend($line);
#return ($type, +1, $ident, $host, $setter, $expire, $time, $reason);
callfuncs('TKL', undef, undef, [parse_addline($line)]);
sub unkline ($$$) {
my ($setter, $ident, $host) = @_;
- # TKL - G ident host setter
-# TKL - G ident *.test.dom tabris!northman@netadmin.SCnet.ops
my $line = "TKL - G $ident $host $setter";
+ my $setId = getUuid($setter);
+ if ($setId) { $setter = $setId; }
+ #:583AAAAAE DELLINE G test@test.com
+ my $line = ":$setter DELLINE G $ident\@$host";
ircsend($line);
- callfuncs('TKL', undef, undef, [parse_tkl($line)]);
+ callfuncs('TKL', undef, undef, [parse_delline($line)]);
}
sub zline ($$$$) {
- my ($setter, $host, $expiry, $reason) = @_;
+ my ($setter, $host, $expiry, $reason) = @_;
$setter=$main_conf{local} unless defined($setter);
-
- #foreach my $ex (@except) { return 1 if $mask =~ /\Q$ex\E/i; }
-
- # format is
- # TKL +/- type ident host setter expiretime settime :reason
- my $line = "TKL + Z * $host $setter ".($expiry + time).' '.time." :$reason";
+ my $setId = getUuid($setter);
+ if ($setId) { $setter = $setId; }
+ #:583AAAAAE ADDLINE Z test.com inspircd.erry.omg 1308216407 0 :go away
+ my $line = ":$setter ADDLINE Z $host " . $main_conf{local} . " ". time() . " " . ($expiry)." :$reason";
ircsend($line);
- callfuncs('TKL', undef, undef, [parse_tkl($line)]);
+ callfuncs('TKL', undef, undef, [parse_addline($line)]);
}
sub unzline ($$) {
my ($setter, $host) = @_;
- # TKL - G ident host setter
-# TKL - G ident *.test.dom tabris!northman@netadmin.SCnet.ops
- my $line = "TKL - Z * $host $setter";
+ my $setId = getUuid($setter);
+ if ($setId) { $setter = $setId; }
+ my $line = ":$setter DELLINE Z $host";
ircsend($line);
- callfuncs('TKL', undef, undef, [parse_tkl($line)]);
+ callfuncs('TKL', undef, undef, [parse_delline($line)]);
}
sub spamfilter($$$$$$$) {
}
sub irckill($$$) {
- my ($src, $targetlist, $reason) = @_;
+ my ($src, $target, $reason) = @_;
$src = $main_conf{local} unless initial_synced();
-
- foreach my $target (split(',', $targetlist)) {
- next unless update_userkill($target);
-
- ircsendimm(":$src ".$tkn{KILL}[$tkn]." $target :$src ($reason)");
-
- callfuncs('KILL', 0, 1, [$src, $target, $src, $reason]);
- }
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $srcNick = $target->{NICK};
+ return 0 unless update_userkill($targetId);
+ ircsendimm(":$srcId ".$tkn{KILL}[$tkn]." $targetId :$srcNick ($reason)");
+ callfuncs('KILL', 0, 1, [$srcId, $targetId, $srcNick, $reason]);
}
sub svssno($$$) {
}
sub svsnick($$$) {
- my ($src, $oldnick, $newnick) = @_;
+ my ($src, $target, $newnick) = @_;
$src=$main_conf{local} unless defined($src);
# note: we will get a NICK cmd back after a
# successful nick change.
# warning, if misused, this can KILL the user
# with a collision
- my $properSrc = getUuid ($src);
- if ($properSrc) {
- $src = $properSrc;
- }
- my $uid = getUuid ($oldnick);
- if ($uid) {
- $oldnick = $uid;
- }
- ircsend(":$src ".$tkn{SVSNICK}[$tkn]." $oldnick $newnick ".time);
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ ircsend(":$srcId ".$tkn{SVSNICK}[$tkn]." $targetId $newnick ".time);
}
sub svsnoop($$$) {
ircsend(":$main_conf{local} $tkn{SVSNOOP}[$tkn] $targetserver $bool");
}
-sub svswatch ($$@) {
+#START TODO - erry
+
+sub svswatch ($$@) {
# Changes the WATCH list of a user.
# Syntax: SVSWATCH <nick> :<watch parameters>
# Example: SVSWATCH Blah :+Blih!*@* -Bluh!*@* +Bleh!*@*.com
$src = $main_conf{local} unless defined($src);
ircsend(":$src $tkn{SWHOIS}[$tkn] $target :$swhois");
}
+#END TODO - erry
sub svsjoin($$@) {
my ($src, $target, @chans) = @_;
# a note. a JOIN is returned back to us on success
# so no need to process this command.
# similar for svspart.
- ircsend(($src?":$src":'')." $tkn{SVSJOIN}[$tkn] $target ".join(',', @chans));
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ ircsend(($srcId?":$srcId":'')." $tkn{SVSJOIN}[$tkn] $targetId ".join(',', @chans));
}
sub svspart($$$@) {
my ($src, $target, $reason, @chans) = @_;
- ircsend(($src ? ":$src" : '')." $tkn{SVSPART}[$tkn] $target ".join(',', @chans).
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ ircsend(($srcId ? ":$srcId" : '')." $tkn{SVSPART}[$tkn] $targetId ".join(',', @chans).
($reason ? " :$reason" : ''));
}
sub svshold($$$) {
my ($nickmask, $expiry, $reason) = @_;
- #>> 32 :583AAAAAA ADDLINE Q errietta3 inspircd.erry.omg 1308120417 0 :bai
- my $line = ':' . $main_conf{numeric} . ' ADDLINE Q '.$nickmask.' '.$main_conf{local}.' '.($expiry ? $expiry+time() : 0).' '.time().' :'.$reason;
+ #:583AAAAAA ADDLINE Q hell3o inspircd.erry.omg 1308295479 600 :Bye Bye
+ my $line = ':' . $main_conf{numeric} . ' ADDLINE Q '.$nickmask.' '.$main_conf{local}.' '. time() . ' ' . ($expiry ? $expiry : 0 ) . ' :'.$reason;
ircsend($line);
callfuncs('TKL', undef, undef, [parse_addline($line)]);
}
sub qline($$$) {
my ($nickmask, $expiry, $reason) = @_;
- #<< :123 ADDLINE Q NickServ <Whatever> 1308120026 0 1308120026 :Reserved for Services
- my $line = ':' . $main_conf{numeric} . ' ADDLINE Q '.$nickmask . ' ' . $main_conf{local} . ' '. time() . ' ' . ($expiry ? $expiry+time() : 0).' '.time().' :'.$reason;
+ #:583AAAAAA ADDLINE Q hell3o inspircd.erry.omg 1308295479 600 :Bye Bye
+
+ my $line = ':' . $main_conf{numeric} . ' ADDLINE Q '.$nickmask . ' ' . $main_conf{local} . ' '. time() . ' ' . ($expiry ? $expiry : 0).' :'.$reason;
ircsend($line);
# at startup we send these too early,
sub chghost($$$) {
my ($src, $target, $vhost) = @_;
- ircsend(($src?":$src ":'').$tkn{CHGHOST}[$tkn]." $target $vhost");
- callfuncs('CHGHOST', 0, 1, [$src, $target, $vhost]);
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ ircsend(($srcId?":$srcId ":'').$tkn{CHGHOST}[$tkn]." $targetId $vhost");
+ callfuncs('CHGHOST', 0, 1, [$srcId, $targetId, $vhost]);
}
sub chgident($$$) {
my ($src, $target, $ident) = @_;
- ircsend(($src?":$src ":'').$tkn{CHGIDENT}[$tkn]." $target $ident");
- callfuncs('CHGIDENT', 0, 1, [$src, $target, $ident]);
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ ircsend(($src?":$srcId ":'').$tkn{CHGIDENT}[$tkn]." $targetId $ident");
+ callfuncs('CHGIDENT', 0, 1, [$srcId, $targetId, $ident]);
}
sub jupe_server($$) {
}
sub agent_dojoin($$) {
my ($agent, $chan) = @_;
- my $uuid = getUuid($agent);
- if ($uuid) { $agent = $uuid; }
- ircsend(":" . $agent . " JOIN " . $chan);
+ print "DOJOIN " . Dumper ($agent);
+ my $srcId;
+ if (ref($agent) ne "HASH") {
+ $srcId = getUuid($agent);
+ if (!$srcId) {
+ $srcId = $agent;
+ }
+ print "SRCID " . Dumper($srcId);
+ }
+ else {
+ my $src = $agent;
+ $srcId = ($src->{ID}?$src->{ID}:($src->{UUID}?$src->{UUID}:$src->{NICK}));
+ }
+ ircsend(":" . $srcId . " JOIN " . $chan);
}
sub agent_dopart ($$$) {
my ($agent, $chan, $reason) = @_;
- my $uuid = getUuid($agent);
- if ($uuid) { $agent = $uuid; }
- ircsend(":$agent $tkn{PART}[$tkn] $chan :$reason");
+ my $srcId;
+ if (ref($agent) ne "HASH") {
+ $srcId = getUuid($agent);
+ if (!$srcId) {
+ $srcId = $agent;
+ }
+ }
+ else {
+ my $src = $agent;
+ $srcId = ($src->{ID}?$src->{ID}:($src->{UUID}?$src->{UUID}:$src->{NICK}));
+ }
+ ircsend(":$srcId $tkn{PART}[$tkn] $chan :$reason");
}
sub rehash_all_servers(;$) {
my ($type) = @_;
# It is not expected to be portable to other ircds.
# Similar concepts may exist in other ircd implementations
my ($src, $cn, @nicks) = @_;
-
+ my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
my $i = 0; my @nicklist = ();
while(my $nick = shift @nicks) {
push @nicklist, $nick;
}
}
- ircsend(($src ? ":$src " : '' ).$tkn{SVSMODE}[$tkn]." $cn -".'b'x($i).' '.join(' ', @nicklist));
+ ircsend(($srcId ? ":$srcId " : '' ).$tkn{SVSMODE}[$tkn]." $cn -".'b'x($i).' '.join(' ', @nicklist));
# We don't loopback this, as we'll receive back the list
# of removed bans.
}
int2chars($SID_int, \@SID);
my @UID = (0,0,0,0,0,0);
int2chars($UID_int, \@UID);
- print join('', @SID,@UID),"\n";
+ return join('', @SID,@UID);
}
1;
-#=cut
-#my $int = decodeUUID('751AAAAAA');
+##=cut
+#my $int = decodeUUID('583AAAAAE');
#print "$int\n";
#print log($int)/log(2), "\n";
-#encodeUUID($int);
-print decodeUUID('583AAAAAK');
+print encodeUUID(142036011587731460);
+#print decodeUUID('583AAAAAK');
#print encodeUUID (1);
#=cut
use SrSv::Text::Codes qw( strip_codes );
use SrSv::Conf2Consts qw(main);
-
+use SrSv::IRCd::Send;
use Exporter 'import';
BEGIN {
my %constants = (
sub wlog($$$) {
my ($service, $level, $text) = @_;
-
my $prefix;
$prefix = "\002\00304" if($level > LOG_INFO);
$prefix .= $levels[$level];
- ircd::privmsg($main::rsnick, main_conf_diag, "$prefix\: ($service) $text");
+ my $rsuser = { NICK => $main::rsnick, ID => ircd::getUuid($main::rsnick) };
+ ircd::privmsg($rsuser, main_conf_diag, "$prefix\: ($service) $text");
write_log('diag', '<'.$main::rsnick.'>', "$prefix\: ($service) $text");
}
=cut
use strict;
-use SrSv::IRCd::UUID;
+use SrSv::Insp::UUID;
+use SrSv::Conf qw(main services sql);
+use SrSv::Conf2Consts qw(main services sql);
use Exporter 'import';
BEGIN {
my %constants = (
__flood_inc => ['NULL', "UPDATE user SET flood = flood + ? WHERE id=?"],
__flood_expire => ['NULL', "UPDATE user SET flood = flood >> 1"], # shift is faster than mul
};
+sub kill_user($$) {
+ my ($user, $reason) = @_;
+ ircd::irckill(get_user_agent($user) || main_conf_local, $user, $reason);
+}
sub get_flood_level($) {
my ($user) = @_;
sub get_user_id($) {
my ($user) = @_;
my ($id, $n);
- return undef if(is_agent($user->{NICK}) and not $enforcers{lc $user->{NICK}});
unless(ref($user) eq 'HASH') {
die("invalid get_user_nick call");
die("get_user_id called on empty string");
}
my $properId = ircd::getUuid ($user->{NICK});
+ print "!!!!!!!!!" . ($nick . " " . $properId) . "\n";
if ($properId != "") {
- print "Decoding $properId\n";
$properId = decodeUUID($properId);
return $user->{ID} = $properId;
}
- else { print "Null properId. User->id" . $user->{ID} . "\n"; }
- if(exists($user->{ID})) { print "Returning user_>id " . $user->{ID} . "\n"; return $user->{ID}; }
-
-
-
+ return undef if(is_agent($user->{NICK}) and not $enforcers{lc $user->{NICK}});
+ if(exists($user->{ID})) { return $user->{ID}; }
# a cheat for isServer()
if($user->{NICK} =~ /\./) {
return $user->{ID} = undef;
}
-
my $nick2;
while($n < 10 and !defined($id)) {
$n++;
$get_user_id->execute($nick);
($id) = $get_user_id->fetchrow_array;
- print "Finally got id from query: $id\n";
unless($id) {
$get_nickchg->execute($nick);
($id, $nick2) = $get_nickchg->fetchrow_array;
$user->{OLDNICK} = $user->{NICK};
$user->{NICK} = $nick2;
}
-
return $user->{ID} = $id;
}
unless(ref($user) eq 'HASH') {
die("invalid get_user_nick call");
}
+ if (exists($user->{ID})) {
+ if (my $nick = ircd::getRevUuid ($user->{ID})) {
+ return $user->{NICK} = $nick;
+ }
+ }
if(exists($user->{NICK}) and is_online($user->{NICK})) {
my $realnick = ircd::getRevUuid($user->{NICK});
if ($realnick) {
BEGIN { our @EXPORT = qw(notice user_die) }
use SrSv::User qw(get_user_nick);
-
+use SrSv::IRCd::Send qw (getRevUuid getUuid setRevUuid setUuid);
+use Data::Dumper;
sub notice($@) {
+ print "FFFFFFFFFFFF\n";
my $user = shift;
-
# FIXME: ref to 'NickServ' should call for the agent-nick in nickserv.pm,
# but that's not available at this layer, so we'd be making
# a blind reference to something that _might_ be undef
- ircd::notice($user->{AGENT} || 'NickServ', get_user_nick($user), @_);
+ my $nsuser = { NICK => 'NickServ', ID => ircd::getUuid('NickServ') };
+ ircd::notice($user->{AGENT} || $nsuser, $user, @_);
}
sub user_die($@) {
-Syntax: %BREAD {%Bnum%B|%BLAST%B}%B
+Syntax: %BREAD {%Bnum%B|%BLAST%B|%BUNREAD%B}%B
-Sends you the text of memo number %Bnum%B, or of the last
+Sends you the text of memo number %Bnum%B, of the last
(i.e. most recently received) memo if LAST is given
-instead of a number.
+instead of a number, or of the first unread memo if UNREAD is given.
use SrSv::Agent;
my $csnick = 'ConnectServ';
-
agent_connect($csnick, 'services', undef, '+pqzBHS', 'Connection Monitor');
+my $csUser = { NICK => $csnick, ID => ircd::getUuid($csnick); }
agent_join($csnick, main_conf_diag);
-ircd::setmode($csnick, main_conf_diag, '+o', $csnick);
+ircd::setmode($csUser, main_conf_diag, '+o', $csUser);
addhandler('NICKCONN', undef, undef, 'connectserv::ev_nickconn', 1);
sub ev_nickconn {
};
our $rsnick = 'ServServ';
-
+our $rsUser = { NICK => $rsnick, ID => ircd::getUuid($rsnick) };
addhandler('STATS', undef, undef, 'core::stats');
sub stats($$) {
my ($src, $token) = @_;
agent_connect($rsnick, 'service', undef, '+ABHSNaopqz', 'Services Control Agent');
agent_join($rsnick, main_conf_diag);
-ircd::setmode($rsnick, main_conf_diag, '+o', $rsnick);
+ircd::setmode($rsUser, main_conf_diag, '+o', $rsUser );
addhandler('SEOS', undef, undef, 'core::ev_connect', 1);
addhandler('ENDBURST', undef, undef, 'core::ev_connect', 1);
sub dispatch {
print "DISPATCH CALLED\n";
my ($src, $dst, $msg) = @_;
- my $user = { NICK => $src, AGENT => $rsnick };
+ my $user = { NICK => $src, AGENT => $rsnick, ID => getUuid($src) };
if(!adminserv::is_ircop($user)) {
notice($user, 'Access Denied');
ircd::globops($rsnick, "\002$src\002 failed access to $rsnick $msg");
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
package services;
use strict;
-
+use Data::Dumper;
use SrSv::Conf::Parameters services => [
[noexpire => undef],
[nickexpire => 21],
our $qlreason = 'Reserved for Services';
foreach my $a (@agents) {
+ print "AGENT " . Dumper($a);
agent_connect($a->[0], 'services', undef, $a->[1], $a->[2]);
ircd::sqline($a->[0], $qlreason);
agent_join($a->[0], main_conf_diag);
- ircd::setmode($main::rsnick, main_conf_diag, '+o', $a->[0]);
+ my $rsUser = { NICK => $main::rsnick, ID => ircd::getUuid($main::rsnick) };
+ my $agent = { NICK => $a->[0], ID => ircd::getUuid ($a->[0]) };
+ ircd::setmode($agent, main_conf_diag, '+o', $agent);
}
addhandler('ENDBURST', undef, undef, 'services::ev_connect');
addhandler('CHGIDENT', undef, undef, 'nickserv::chgident');
addhandler('USERIP', undef, undef, 'nickserv::userip');
addhandler('SQUIT', undef, undef, 'nickserv::squit') if ircd::NOQUIT();
-
-addhandler('PRIVMSG', undef, 'nickserv', 'nickserv::dispatch');
+addhandler("OPERUP", undef, undef, 'nickserv::handle_oper');
+addhandler('PRIVMSG', undef, undef, 'nickserv::dispatch');
addhandler('PRIVMSG', undef, lc services_conf_nickserv, 'nickserv::dispatch') if services_conf_nickserv;
addhandler('BACK', undef, undef, 'nickserv::notify_auths');
addhandler('MODE', undef, qr/^#/, 'chanserv::chan_mode');
addhandler('TOPIC', undef, undef, 'chanserv::chan_topic');
-addhandler('PRIVMSG', undef, 'chanserv', 'chanserv::dispatch');
+addhandler('PRIVMSG', undef, undef, 'chanserv::dispatch');
addhandler('PRIVMSG', undef, lc services_conf_chanserv, 'chanserv::dispatch') if services_conf_chanserv;
# OperServ
-addhandler('PRIVMSG', undef, 'operserv', 'operserv::dispatch');
+addhandler('PRIVMSG', undef, undef, 'operserv::dispatch');
addhandler('PRIVMSG', undef, lc services_conf_operserv, 'operserv::dispatch') if services_conf_operserv;
add_timer('flood_expire', 10, __PACKAGE__, 'services::flood_expire');
}
# MemoServ
-addhandler('PRIVMSG', undef, 'memoserv', 'memoserv::dispatch');
+addhandler('PRIVMSG', undef, undef, 'memoserv::dispatch');
addhandler('PRIVMSG', undef, lc services_conf_memoserv, 'memoserv::dispatch') if services_conf_memoserv;
addhandler('BACK', undef, undef, 'memoserv::notify');
addhandler('NOTICE', undef, qr/^#/, 'botserv::chan_msg');
# AdminServ
-addhandler('PRIVMSG', undef, 'adminserv', 'adminserv::dispatch');
+addhandler('PRIVMSG', undef, undef, 'adminserv::dispatch');
addhandler('PRIVMSG', undef, lc services_conf_adminserv, 'adminserv::dispatch') if services_conf_adminserv;
add_timer('', 30, __PACKAGE__, 'services::maint');
add_timer('', 60, __PACKAGE__, 'nickserv::expire_silence_timed');
# HostServ
-addhandler('PRIVMSG', undef, 'hostserv', 'hostserv::dispatch');
+addhandler('PRIVMSG', undef, undef, 'hostserv::dispatch');
addhandler('PRIVMSG', undef, lc services_conf_hostserv, 'hostserv::dispatch') if services_conf_hostserv;
# $nick should be a registered root nick, if applicable
our $asnick_default = 'AdminServ';
our $asnick = $asnick_default;
-
+our $asuser = { NICK => $asnick, ID => "123AAAAAG" };
our @levels = ('Normal User', 'HelpOp', 'Operator', 'Administrator', 'Root');
my @defflags = (
0, # Unused
### ADMINSERV COMMANDS ###
sub dispatch($$$) {
- my ($src, $dst, $msg) = @_;
+ my ($user, $dstUser, $msg) = @_;
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
-
- my $user = { NICK => $src, AGENT => $dst };
-
- services::ulog($asnick, LOG_INFO(), "cmd: [$msg]", $user);
+ $user -> {AGENT} = $dstUser;
+ my $src = $user->{NICK};
+ return unless (lc $dstUser->{NICK} eq lc $asnick);
+ services::ulog($asuser, LOG_INFO(), "cmd: [$msg]", $user);
unless(is_svsop($user) or is_ircop($user)) {
notice($user, $err_deny);
- ircd::globops($asnick, "\002$src\002 failed access to $asnick $msg");
+ ircd::globops($asuser, "\002$src\002 failed access to $asnick $msg");
return;
}
$set_svs_level->execute($level, $oper, $root);
notice($user, "\002$nick\002 is now a \002Services $levels[$level]\002.");
- wlog($asnick, LOG_INFO(), "$src added $root as a Services $levels[$level].");
+ wlog($asuser, LOG_INFO(), "$src added $root as a Services $levels[$level].");
}
sub as_svs_del($$) {
$delete_svsop->execute($root);
notice($user, "\002$nick\002 has been stripped of services rank.");
- wlog($asnick, LOG_INFO(), "$src stripped $root of services rank.")
+ wlog($asuser, LOG_INFO(), "$src stripped $root of services rank.")
}
sub as_svs_list($$) {
my $nflag = $flags{$flag};
my ($level, $nick) = get_best_svs_level($user);
-
+ print ("LEVELS $defflags[$level] $nflag" . "\n");
if($defflags[$level] & $nflag) {
- return $nick if (($nflag == $flags{'HELP'}) or is_ircop($user));
+ return $nick if (($nflag == $flags{'HELP'}) or is_ircop($user));
}
return undef;
return $nick if(defined($level) and !defined($rlev));
if($level >= $rlev) {
- return $nick if (($rlev == S_HELP) or is_ircop($user));
+ return $nick ; #if (($rlev == S_HELP) or is_ircop($user)) FIXME - erry
+ #Problem is inspircd has a gay way of identifying opers, instead of umode +o it sends OPERTYPE crap.
}
return undef;
$user->{SVSOP_LEVEL} = $level; $user->{SVSOP_NICK} = $nick;
if(wantarray) {
+ print "LEVEL $level\n";
return ($level, $nick);
} else {
return $level;
use SrSv::Agent;
use SrSv::Process::Worker 'ima_worker'; #FIXME
-
+use SrSv::Insp::UUID;
use SrSv::Text::Format qw(columnar);
use SrSv::Errors;
+use Data::Dumper;
use SrSv::Conf2Consts qw( main services );
our $bsnick_default = 'BotServ';
our $bsnick = $bsnick_default;
our $botchmode;
+our $bsuser = { NICK => $bsnick, ID => "123AAAAAF" };
if(!ircd::PREFIXAQ_DISABLE()) {
$botchmode = '+q';
} else {
};
sub dispatch($$$) {
- my ($src, $dst, $msg) = @_;
-
- if(lc $dst eq lc $bsnick or lc $dst eq lc $bsnick_default ) {
- bs_dispatch($src, $dst, $msg);
+ my ($user, $dstUser, $msg) = @_;
+ $user -> {AGENT} = $dstUser;
+ my $src = $user->{NICK};
+ my $dst = $dstUser->{NICK};
+ if(lc $dstUser->{NICK} eq lc $bsnick or lc $dstUser->{NICK} eq lc $bsnick_default ) {
+ bs_dispatch($user, $dstUser, $msg);
}
elsif($dst =~ /^#/) {
if($msg =~ /^\!/) {
### BOTSERV COMMANDS ###
sub bs_dispatch($$$) {
- my ($src, $dst, $msg) = @_;
+ my ($user, $dst, $msg) = @_;
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
-
- my $user = { NICK => $src, AGENT => $bsnick };
-
+ $user -> {AGENT} = $dst;
+ my $src = $user->{NICK};
return if flood_check($user);
if($cmd =~ /^assign$/i) {
agent_part($oldbot, $cn, "Unassigned by \002$src\002.");
}
-
-
if($bot) {
$assign_bot->execute($bot, $cn);
- bot_join($chan, $bot);
+ my $botUser = { NICK=>$bot, ID=>ircd::getUuid($bot) };
+ bot_join($chan, $botUser);
notice($user, "\002$bot\002 now assigned to \002$cn\002.");
} else {
$unassign_bot->execute($cn);
ircd::sqline($botnick, $services::qlreason);
agent_connect($botnick, $botident, $bothost, '+pqBSrz', $botgecos);
agent_join($botnick, main_conf_diag);
- ircd::setmode($main::rsnick, main_conf_diag, '+h', $botnick);
-
+ my $bot = { NICK => $botnick};
+ get_user_id ($bot);
+ my $rsuser = { NICK => $main::rsnick };
+ get_user_id ($rsuser);
+ $rsuser->{ID} = encodeUUID($rsuser->{ID});
+ ircd::setmode($rsuser, main_conf_diag, '+h', $bot);
notice($user, "Bot $botnick connected.");
}
ircd::sqline($botnick, $services::qlreason);
agent_connect($botnick, $botident, $bothost, '+pqBSrz', $botgecos);
agent_join($botnick, main_conf_diag);
- ircd::setmode($main::rsnick, main_conf_diag, '+h', $botnick);
+ my $rsnick = $main::rsnick;
+ my $rsuser = { NICK => $main::rsnick };
+ get_user_id ($rsuser);
+ $rsuser->{ID} = encodeUUID($rsuser->{ID});
+ my $bot = { NICK => $botnick };
+ get_user_id ($bot);
+ ircd::setmode($rsuser, main_conf_diag, '+h', $bot);
notice($user, "Bot $botnick connected.");
$get_bots_chans->execute($oldnick);
while(my ($cn) = $get_bots_chans->fetchrow_array()) {
my $chan = { CHAN => $cn };
- bot_join($chan, $botnick)
+ my $botUser = { NICK=>$botnick, ID=>ircd::getUuid($botnick) };
+ bot_join($chan, $botUser)
if chanserv::get_user_count($chan) or cr_chk_flag($chan, CRF_BOTSTAY(), 1);
}
$get_bots_chans->finish();
### CHANNEL COMMANDS ###
sub chan_dispatch($$$) {
- my ($src, $cn, $msg) = @_;
-
+ my ($user, $cn, $msg) = @_;
+ my $src = $user->{NICK};
my @args = split(/\s+/, $msg);
my $cmd = lc(shift @args);
$cmd =~ s/^\!//;
my $chan = { CHAN => $cn };
- my $user = { NICK => $src, AGENT => agent($chan) };
my %cmdhash = (
'voice' => \&give_ops,
sub give_ops {
my ($user, $cmd, $chan, @args) = @_;
+
chanserv::cs_setmodes($user, $cmd, $chan, @args);
}
sub up {
### BOT COMMANDS ###
sub bot_dispatch($$$) {
- my ($src, $bot, $msg) = @_;
-
+ my ($user, $bot, $msg) = @_;
my ($cmd, $cn, $botmsg) = split(/ /, $msg, 3);
-
- my $user = { NICK => $src, AGENT => $bot };
+ my $src = $user->{NICK};
my $chan = { CHAN => $cn };
-
return if flood_check($user);
-
if ($cmd =~ /^join$/i) {
- if (adminserv::can_do($user, 'BOT')) {
- agent_join($bot, $cn);
- } else {
- notice($user, $err_deny);
- }
+ if (adminserv::can_do($user, 'BOT')) {
+ agent_join($bot, $cn);
+ } else {
+ notice($user, $err_deny);
+ }
}
elsif ($cmd =~ /^part$/i) {
- if (adminserv::can_do($user, 'BOT')) {
- agent_part($bot, $cn, "$src requested part");
- } else {
- notice($user, $err_deny);
- }
+ if (adminserv::can_do($user, 'BOT')) {
+ agent_part($bot, $cn, "$src requested part");
+ } else {
+ notice($user, $err_deny);
+ }
}
elsif ($cmd =~ /^say$/i) {
bot_say($user, $chan, $botmsg);
while(my ($nick, $ident, $vhost, $gecos, $flags) = $get_all_bots->fetchrow_array) {
agent_connect($nick, $ident, $vhost, '+pqBSrz'.(($flags & F_DEAF())?'d':''), $gecos);
ircd::sqline($nick, $services::qlreason);
+ my $bot = { NICK => $nick };
+ get_user_id ($bot);
agent_join($nick, main_conf_diag);
- ircd::setmode($main::rsnick, main_conf_diag, '+h', $nick);
+ my $rsuser = { NICK => $main::rsnick };
+ get_user_id ($rsuser);
+ $rsuser->{ID} = encodeUUID($rsuser->{ID});
+ ircd::setmode($rsuser, main_conf_diag, '+h', $bot);
}
}
sub eos() {
$get_botchans->execute();
- print "BS EOS???\n";
while(my ($cn, $nick) = $get_botchans->fetchrow_array) {
my $chan = { CHAN => $cn };
- print "BS BOT $nick $cn\n";
if(chanserv::get_user_count($chan)) {
- bot_join($chan, $nick);
+ my $botUser = { NICK=>$nick, ID=>ircd::getUuid($nick) };
+ bot_join($chan, $botUser);
}
elsif(cr_chk_flag($chan, CRF_BOTSTAY(), 1)) {
+ my $botUser = { NICK=>$nick, ID=>ircd::getUuid($nick) };
bot_join($chan, $nick);
my $modelock = chanserv::get_modelock($chan);
ircd::setmode(main_conf_local, $cn, $modelock) if $modelock;
}
sub bot_join($;$) {
- my ($chan, $nick) = @_;
-
+ my ($chan, $bot) = @_;
my $cn = $chan->{CHAN};
-
- $nick = agent($chan) unless $nick;
- print "Huuuuuuuuuuuuuuuh\n";
+ $bot = agent($chan) unless $bot;
+ my $nick = $bot->{NICK};
unless(is_agent_in_chan($nick, $cn)) {
- print "Making $nick join $cn\n";
- agent_join($nick, $cn);
- ircd::setmode($nick, $cn, $botchmode, $nick.(ircd::PREFIXAQ_DISABLE() ? ' '.$nick : '') );
+ agent_join($bot, $cn);
+ get_user_id ($bot);
+ my $bot2 = { NICK => $nick, ID => encodeUUID($bot->{ID}) };
+ print "!!!!!!!! BOT $nick " . $bot->{ID} . "\n";
+ ircd::setmode($bot2, $cn, $botchmode, $bot );
}
}
our $csnick_default = 'ChanServ';
our $csnick = $csnick_default;
+our $csUser = { NICK => $csnick, ID => "123AAAAAC" };
our ($cur_lock, $cnt_lock);
### CHANSERV COMMANDS ###
sub dispatch($$$) {
- my ($src, $dst, $msg) = @_;
-
+ my ($user, $dstUser, $msg) = @_;
+ my $src = $user->{NICK};
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
-
- my $user = { NICK => $src, AGENT => $dst };
- print "SRC $src\n";
+ $user->{AGENT} = $dstUser;
+ get_user_id ($user);
return if flood_check($user);
-
+ return unless (lc $dstUser->{NICK} eq lc $csnick);
if($cmd =~ /^register$/i) {
if(@args >= 1) {
my @args = split(/\s+/, $msg, 4);
$get_all_acc->finish();
unless($n) {
- #$check_auth_chan = $dbh->prepare("SELECT nickreg.nick, nicktext.data FROM nickreg, nicktext
- #WHERE nickreg.id=nicktext.nrid AND nicktext.type=(".nickserv::NTF_AUTH().") AND nicktext.chan=? AND nickreg.nick=?");
$check_auth_chan -> execute ($cn, $tnick);
- if ($check_auth_chan->fetchrow_array()) {
- push @reply, "\002$tnick\002 is awaiting authorization to be added to the $cn access list.\n";
+ if (my ($nick, $data) = $check_auth_chan->fetchrow_array()) {
+ my ($adder, $old, $level, $time) = split(/:/, $data);
+ push @reply, "\002$tnick\002 is awaiting authorization to be added to the $cn \002$levels[$level]\002 list.\n";
}
else {
push @reply, "\002$tnick\002 has no access to \002$cn\002.";
sub cs_setmodes($$$@) {
my ($user, $cmd, $chan, @args) = @_;
no warnings 'void';
- my $agent = $user->{AGENT} or $csnick;
+ my $agent = $user->{AGENT} or $csUser;
my $src = get_user_nick($user);
my $cn = $chan->{CHAN};
my $self;
my @targets = split(/\,/, $target);
foreach $target (@targets) {
- my $tuser = { NICK => $target };
+ my $tuser = { NICK => $target, UID => ircd::getUuid ($target) };
my $targetlevel = get_best_acc($tuser, $chan);
if(lc $target eq lc agent($chan) or adminserv::is_service($tuser)) {
if($ban) {
kickban($chan, $tuser, undef, $reason);
} else {
- ircd::kick(agent($chan), $cn, $target, $reason) unless adminserv::is_service($user);
+ ircd::kick(agent($chan), $cn, $tuser, $reason) unless adminserv::is_service($user);
}
}
$set_close->execute($cn, $reason, $oper, $type);
cr_set_flag($chan, (CRF_FREEZE | CRF_CLOSE | CRF_DRONE), 0); #unset flags
cr_set_flag($chan, CRF_HOLD, 1); #set flags
-
+ cr_set_flag($chan, $type, 1); #set flags
my $src = get_user_nick($user);
my $time = gmtime2(time);
my $cmsg = "is closed [$src $time]: $reason";
enforcer_join($chan) if (get_user_count($chan) <= 1);
ircd::setmode($agent, $cn, '+b', $mask);
ircd::flushmodes();
- ircd::kick($agent, $cn, $nick, $reason);
+ ircd::kick($agent, $cn, $user, $reason);
return 1;
}
foreach my $user (@$users) {
next if adminserv::is_ircop($user) or adminserv::is_svsop($user, adminserv::S_HELP());
- ircd::kick($agent, $cn, get_user_nick($user), $reason);
+ ircd::kick($agent, $cn, $user, $reason);
}
}
$get_chan_users->execute($cn);
while(my ($nick, $uid) = $get_chan_users->fetchrow_array) {
my $user = { NICK => $nick, ID => $uid };
- ircd::kick($agent, $cn, $nick, $reason)
+ ircd::kick($agent, $cn, $user, $reason)
unless adminserv::is_ircop($user) or adminserv::is_svsop($user, adminserv::S_HELP());
$i++;
}
$get_chan_users_mask->execute($cn, $nick, $ident, $host, $host, $host);
while(my ($nick, $uid) = $get_chan_users_mask->fetchrow_array) {
my $user = { NICK => $nick, ID => $uid };
- ircd::kick($agent, $cn, $nick, $reason)
+ ircd::kick($agent, $cn, $user, $reason)
unless adminserv::is_service($user);
$i++;
}
$get_chan_users_mask_noacc->execute($cn, $nick, $ident, $host, $host, $host);
while(my ($nick, $uid) = $get_chan_users_mask_noacc->fetchrow_array) {
my $user = { NICK => $nick, ID => $uid };
- ircd::kick($agent, $cn, $nick, $reason)
+ ircd::kick($agent, $cn, $user, $reason)
unless adminserv::is_service($user);
$i++;
}
$get_chan_users->execute($cn);
while(my ($nick, $uid) = $get_chan_users->fetchrow_array) {
- my $user = { NICK => $nick, ID => $uid };
+ my $user = { NICK => $nick };
+ get_user_id ($user);
my $opmodes = get_op($user, $chan);
for(my $i; $i < 5; $i++) {
if($opmodes & 2**$i) {
- push @modelist, ['-'.$opmodes[$i], $nick];
+ push @modelist, ['-'.$opmodes[$i], $user];
}
}
}
my ($chan, @userlist) = @_;
my $cn = $chan->{CHAN};
my $count;
- if (defined(&ircd::unban_nick)) {
- my @nicklist;
- foreach my $tuser (@userlist) {
- push @nicklist, get_user_nick($tuser);
- }
- ircd::unban_nick(agent($chan), $cn, @nicklist);
- #return scalar(@nicklist);
+ if (defined(&ircd::unban_users)) {
+ ircd::unban_users(@userlist);
}
-
foreach my $tuser (@userlist) {
my $tuid;
unless($tuid = get_user_id($tuser)) {
next;
}
-
my (@bans);
# We don't handle extended bans. Yet.
$find_bans_chan_user->execute($cn, $tuid, 0);
- print "tuid : $tuid\n";
while (my ($mask) = $find_bans_chan_user->fetchrow_array) {
$mask =~ tr/\%\_/\*\?/;
push @bans, $mask;
unless(defined($root)) {
(undef, $root) = get_best_acc($tuser, $chan, 2);
}
-
$get_nick_akick->execute($cn, $root);
my ($reason) = $get_nick_akick->fetchrow_array(); $get_nick_akick->finish();
-
return 0 if adminserv::is_svsop($tuser, adminserv::S_HELP());
+ if(defined($reason) && $reason =~ /\|/) {
+ ($reason, undef) = split(/ ?\| ?/, $reason, 2);
+ }
kickban($chan, $tuser, undef, "User has been banned from ".$cn.($reason?": $reason":''));
}
sub do_status($$) {
my ($user, $chan) = @_;
-
+ print "Do status!\n";
return 0 if cr_chk_flag($chan, (CRF_CLOSE | CRF_DRONE));
my $uid = get_user_id($user);
sub akickban(@) {
my ($cn, $knick, $bnick, $ident, $host, $reason, $bident) = @_;
- print "KNICK $knick\n";
my $target = { NICK => $knick };
my $chan = { CHAN => $cn };
return 0 if adminserv::is_svsop($target, adminserv::S_HELP());
$ident =~ tr/\%\_/\*\?/;
$host =~ tr/\%\_/\*\?/;
}
+ if(defined($reason) && $reason =~ /\|/) {
+ ($reason, undef) = split(/ ?\| ?/, $reason, 2);
+ }
return kickban($chan, $target, "$bnick!$ident\@$host", "User has been banned from ".$cn.($reason?": $reason":''));
}
push @cns, $cn;
}
- ircd::svsjoin($csnick, get_user_nick($user), @cns) if @cns;
+ ircd::svsjoin($csUser, $user, @cns) if @cns;
}
### DATABASE UTILITY FUNCTIONS ###
# If channel has OPGUARD, $doneg is true.
sub set_modes($$$;$) {
+ print "GI\n";
my ($user, $chan, $acc, $doneg) = @_;
my $cn = $chan->{CHAN};
if($masks[$sign] & 2**$i) {
$out .= $l[$i];
- push @args, $nick;
+ my $user_ = { NICK => $nick, AGENT => $csnick};
+ get_user_id ($user_);
+ push @args, $user_;
}
}
}
if(@args) {
- ircd::setmode(agent($chan), $cn, $out, join(' ', @args));
+ ircd::setmode_many(agent($chan), $cn, $out, @args);
}
}
my $noreply = $data->{NOREPLY};
my $acc = $data->{ACC};
my $overrideMsg = $data->{OVERRIDE_MSG};
- print "can_do user: " . Data::Dumper::Dumper($user) . "\n";
if(my $nick = __can_do($chan, $perm, $user, $acc)) {
# This is becoming increasingly complicated
# and checking if an override was used is becoming tricky.
my $nick;
my $cn = $chan->{CHAN};
$perm = uc $perm;
- print "user: " . Data::Dumper::Dumper($user) . "\n";
my $level;
unless(exists($chan->{"PERM::$perm"})) {
$level = $chan->{"PERM::$perm"} = get_level($chan, $perm);
}
}
$nick = 1 unless $nick;
-
+ print "ACcc $acc $level\n";
if($acc >= $level and !cr_chk_flag($chan, (CRF_CLOSE | CRF_FREEZE | CRF_DRONE))) {
set_lastused($cn, get_user_id($user)) if $user;
return (wantarray ? ($nick, 0) : $nick);
sub agent($) {
my ($chan) = @_;
- return $chan->{AGENT} if($chan->{AGENT});
+ if($chan->{AGENT}) {
+ my $a = $chan->{AGENT};
+ $a->{ID} = ircd::getUuid($a->{NICK});
+ return $a;
+ }
unless(initial_synced()) {
- return $csnick;
+ return $csUser;
}
-
$botserv::get_chan_bot->execute($chan->{CHAN});
- my ($agent) = $botserv::get_chan_bot->fetchrow_array;
- print "CHAN: " . $chan->{CHAN} . " bot " . $agent . "\n";
- $agent = $csnick unless $agent;
-
+ my $agentnick = $botserv::get_chan_bot->fetchrow_array;
+ my ($agent) = { NICK => $agentnick, ID => ircd::getUuid($agentnick)};
+ $agent = $csUser unless $agentnick;
return $chan->{AGENT} = $agent;
}
$drop_chantext->execute($cn);
$drop_nicktext->execute($cn); # Leftover channel auths
$drop->execute($cn);
- ircd::setmode($csnick, $cn, '-r');
+ ircd::setmode($csUser, $cn, '-r');
}
sub drop_nick_chans($) {
# Due to special casing of '0' this wrapper should be used
# by anyone handling a JOIN (not SJOIN, it's a JOIN) event.
# This is an RFC1459 requirement.
- my ($nick, $cn) = @_;
- my $user = { NICK => $nick };
+ my ($user, $cn) = @_;
my $chan = { CHAN => $cn };
if ($cn == 0) {
}
sub handle_sjoin($$$$$$$) {
-
+ print "wheeeeeeeeee\n";
my ($server, $cn, $ts, $chmodes, $chmodeparms, $userarray, $banarray, $exceptarray) = @_;
my $chan = { CHAN => $cn };
} else {
update_modes($cn, "$chmodes $chmodeparms") if $chmodes;
}
+ print "HANDLE SJOIN $cn\n";
+ print Dumper (@$userarray);
user_join_multi($chan, $userarray) if scalar @$userarray;
foreach my $ban (@$banarray) {
}
sub user_join_multi($$) {
- print "User join multi???\n";
my ($chan, $users) = @_;
my $cn = $chan->{CHAN};
my $seq = $ircline;
my ($reason, $opnick, $time) = get_close($chan);
my $cmsg = "$cn is closed: $reason";
my $preenforce = $enforcers{lc $chan};
-
if (cr_chk_flag($chan, CRF_CLOSE)) {
kickban_multi($chan, $users, $cmsg);
}
}
if(($count == 0 or !is_agent_in_chan($bot, $cn)) and initial_synced()) {
- unless (lc($bot) eq lc($csnick)) {
+ unless ($bot eq $csUser) {
unless(is_agent_in_chan($bot, $cn)) {
botserv::bot_join($chan);
}
}
}
- return unless synced() and not cr_chk_flag($chan, (CRF_CLOSE | CRF_DRONE));
-
+ #return unless synced() and not cr_chk_flag($chan, (CRF_CLOSE | CRF_DRONE));
+ return unless not cr_chk_flag($chan, (CRF_CLOSE | CRF_DRONE));
+ #commands aren't sent before synced() anyway
my $n;
- print "F\n";
foreach my $user (@$users) {
- print "Are we gettin there yet\n";
if(do_status($user, $chan)) {
$n++;
$user->{__DO_WELCOME} = 1;
sub user_part($$$) {
my ($nick, $cn, $reason) = @_;
-
my $user = ( ref $nick eq 'HASH' ? $nick : { NICK => $nick });
-
user_part_multi($user, [ $cn ], $reason);
}
# Other ircds may not do so.
# There is also KICK. some IRCds allow KICK #chan user1,user2,...
# Unreal it's _supposed_ to work, but it does not.
-
my ($user, $chanlist, $reason) = @_;
my @chans;
foreach my $cn (@$chanlist) {
push @chans, { CHAN => $cn };
-
}
my $uid = get_user_id($user);
sub process_kick($$$$) {
my ($src, $cn, $target, $reason) = @_;
- my $tuser = { NICK => $target };
+ my $tuser = { NICK => $target, ID => ircd::getUuid($target)};
user_part($tuser, $cn, 'Kicked by '.$src.' ('.$reason.')');
my $chan = { CHAN => $cn };
if ( !(is_agent($src) or $src =~ /\./ or adminserv::is_ircop({ NICK => $src })) and
({modes::splitmodes(get_modelock($chan))}->{Q}->[0] eq '+') )
{
- my $srcUser = { NICK => $src };
+ my $srcUser = { NICK => $src, ID => ircd::getUuid($src) };
#ircd::irckill(agent($chan), $src, "War script detected (kicked $target past +Q in $cn)");
nickserv::kline_user($srcUser, 300, "War script detected (kicked $target past +Q in $cn)");
# SVSJOIN won't work while they're banned, unless you invite.
- ircd::invite(agent($chan), $cn, $target);
- ircd::svsjoin(undef, $target, $cn);
+ ircd::invite(agent($chan), $cn, $tuser);
+ ircd::svsjoin(undef, $tuser, $cn);
unban_user($chan, $tuser);
}
}
sub chan_mode($$$$) {
- my ($src, $cn, $modes, $args) = @_;
- my $user = { NICK => $src };
+ my ($user, $cn, $modes, $args) = @_;
+ my $src;
+ if (ref($user) eq "HASH") {
+ $src = $user->{NICK};
+ }
+ else {
+ $src = $user;
+ }
my $chan = { CHAN => $cn };
my ($sign, $num);
-
# XXX This is not quite right, but maybe it's good enough.
my $mysync = ($src =~ /\./ ? 0 : 1);
if($mode eq '-') { $sign = 0; next; }
my $arg = shift(@args) if($mode =~ $scm or $mode =~ $ocm);
- my $auser = { NICK => $arg };
-
+ my $auser = { ID => $arg };
+ get_user_nick ($auser);
if($mode =~ /^[vhoaq]$/) {
next if $arg eq '';
next if is_agent($arg);
if($opguard and $sign == 1 and
!can_keep_op($user, $chan, $auser, $mode)
) {
- $unmodes .= $mode;
- push @unargs, $arg;
+ push @unargs, ["-" . $mode, $auser];
} else {
my $nid = get_user_id($auser) or next;
my ($r, $i);
#process_ban($cn, $arg, $src, 128, $sign);
}
}
- ircd::setmode(agent($chan), $cn, $unmodes, join(' ', @unargs)) if($opguard and @unargs);
+ ircd::setmode2(agent($chan), $cn, @unargs) if($opguard and @unargs);
}
sub process_ban($$$$) {
}
sub chan_topic {
- my ($src, $cn, $setter, $time, $topic) = @_;
+ my ($src, $cn, $suser, $time, $topic) = @_;
my $chan = { CHAN => $cn };
- my $suser = { NICK => $setter, AGENT => agent($chan) };
-
+ $suser -> {AGENT} = agent($chan);
+ my $setter = $suser -> {NICK};
return if cr_chk_flag($chan, CRF_CLOSE, 1);
if(current_message->{SYNC}) { # We don't need to undo our own topic changes.
+ print "Line 4720\n";
$set_topic1->execute($setter, $time, $cn);
$set_topic2->execute($cn, $topic);
return;
}
-
if(!synced()) {
+ print "Line 4726\n";
$get_topic->execute($cn);
my ($ntopic, $nsetter, $ntime) = $get_topic->fetchrow_array;
if($topic ne '' and $time == $ntime or can_do($chan, 'SETTOPIC', undef)) {
+ print "Line 4730\n";
$set_topic1->execute($setter, $time, $cn);
$set_topic2->execute($cn, $topic);
} else {
+ print "Line 4734\n";
ircd::settopic(agent($chan), $cn, $nsetter, $ntime, $ntopic);
}
}
-
- elsif(lc($src) ne lc($setter) or can_do($chan, 'SETTOPIC', $suser)) {
+ #lc($src) ne lc($setter) or - removed from previous line because
+ #i think it was breaking it for insp & idk what it did
+ #erry
+ elsif(can_do($chan, 'SETTOPIC', $suser)) {
+ print "LIne 4742\n";
+ print "condition : " . can_do($chan, 'SETTOPIC', $suser);
$set_topic1->execute($setter, $time, $cn);
$set_topic2->execute($cn, $topic);
} else {
+ print "Line 4747\n";
$get_topic->execute($cn);
my ($ntopic, $nsetter, $ntime) = $get_topic->fetchrow_array;
ircd::settopic(agent($chan), $cn, $nsetter, $ntime, $ntopic);
if($type == CRF_DRONE) {
chan_kill($chan, $cn.$cmsg);
} else {
+ my $user = { NICK => $opnick};
+ get_user_id ($user);
ircd::settopic(agent($chan), $cn, $opnick, $time, "Channel".$cmsg);
clear_users($chan, "Channel".$cmsg);
}
our $hsnick_default = 'HostServ';
our $hsnick = $hsnick_default;
-
+our $hsuser = { NICK => $hsnick, ID => "123AAAAAH" };
our (
$set_vhost, $get_vhost, $del_vhost,
$vhost_chgroot,
}
sub dispatch($$$) {
- my ($src, $dst, $msg) = @_;
+ my ($user, $dstUser, $msg) = @_;
+ my $src = $user->{NICK};
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
-
- my $user = { NICK => $src, AGENT => $dst };
-
+ $user->{AGENT} = $dstUser;
+ get_user_id ($user);
return if flood_check($user);
-
+ return unless (lc $dstUser->{NICK} eq lc $hsnick);
if(lc $cmd eq 'on') {
hs_on($user, $src, 0);
}
notice($user, "You don't have a vHost.") unless $identify;
return;
}
+
if ($vident) {
- ircd::chgident($hsnick, $src, $vident);
+ ircd::chgident($hsuser, $src, $vident);
}
- ircd::chghost($hsnick, $src, $vhost);
+ ircd::chghost($hsuser, $src, $vhost);
notice($user, "Your vHost has been changed to \002".($vident?"$vident\@":'')."$vhost\002");
}
my $src = get_user_nick($user);
# This requires a hack that is only known to work in UnrealIRCd 3.2.6 and later.
- ircd::reset_cloakhost($hsnick, $src);
+ ircd::reset_cloakhost($hsuser, $src);
notice($user, "vHost reset to cloakhost.");
}
our $msnick_default = 'MemoServ';
our $msnick = $msnick_default;
-
+our $msuser = { NICK => $msnick, ID => "123AAAAAE" };
our (
$send_memo, $send_chan_memo, $get_chan_recipients,
$add_ignore, $get_ignore_num, $del_ignore_nick, $list_ignore, $chk_ignore,
$wipe_ignore, $purge_ignore,
+ $get_first_unread
);
sub init() {
+ $get_first_unread = $dbh->prepare("SELECT memo.src, memo.chan, memo.time, memo.flag, memo.msg FROM memo, nickreg WHERE nickreg.nick=? AND memo.dstid=nickreg.id AND memo.flag=0 LIMIT 1");
$send_memo = $dbh->prepare("INSERT INTO memo SELECT ?, id, NULL, UNIX_TIMESTAMP(), NULL, ? FROM nickreg WHERE nick=?");
$send_chan_memo = $dbh->prepare("INSERT INTO memo SELECT ?, nickreg.id, ?, ?, NULL, ? FROM chanacc, nickreg
WHERE chanacc.chan=? AND chanacc.level >= ? AND chanacc.nrid=nickreg.id
### MEMOSERV COMMANDS ###
sub dispatch($$$) {
- my ($src, $dst, $msg) = @_;
+ my ($user, $dstUser, $msg) = @_;
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
-
- my $user = { NICK => $src, AGENT => $dst };
-
+ $user -> {AGENT} = $dstUser;
+ return unless (lc $dstUser->{NICK} eq lc $msnick);
+ get_user_id ($user);
return if flood_check($user);
if($cmd =~ /^send$/i) {
}
}
elsif($cmd =~ /^read$/i) {
- if(@args == 1 and (lc($args[0]) eq 'last' or $args[0] > 0)) {
+ if(@args == 1 and (lc($args[0]) eq 'last' or $args[0] > 0 or (lc($args[0]) eq 'unread'))) {
ms_read($user, $args[0]);
} else {
- notice($user, 'Syntax: READ <num|LAST>');
+ notice($user, 'Syntax: READ <num|LAST|UNREAD>');
}
}
elsif($cmd =~ /^list$/i) {
return;
}
@nums = ($num);
- } else {
+ }
+ elsif (lc($num) eq 'unread') {
+ $get_first_unread->execute($root);
+ $get_memo_full->execute($root, $num-1);
+ unless(($from, $chan, $time, $flag, $msg) = $get_first_unread->fetchrow_array) {
+ notice($user, "You have no unread memos.");
+ return;
+ }
+ $set_flag->execute(1, $from, $root, $chan, $time);
+ my @reply;
+ push @reply, "Memo \002$num\002 from \002$from\002 ".
+ ($chan ? "to \002$chan\002 " : "to \002$root\002 ").
+ "at ".gmtime2($time), $msg, ' --';
+ notice ($user, @reply);
+ return;
+ }
+ else {
@nums = makeSeqList($num);
}
my ($user, $root) = @_;
my (@nicks);
- unless(ref($user)) {
+ unless(ref($user) eq "HASH") {
$user = { NICK => $user };
}
$get_chan_recipients->execute($cn, $level);
while(my ($u) = $get_chan_recipients->fetchrow_array) {
- notice({ NICK => $u, AGENT => $msnick },
+ notice({ NICK => $u, AGENT => $msuser },
"You have a new memo from \002$src\002 to \002$cn\002. To read it, type: \002/ms read last\002");
}
}
my ($nick, $msg) = @_;
foreach my $u (get_nick_user_nicks $nick) {
- notice({ NICK => $u, AGENT => $msnick }, $msg);
+ notice({ NICK => $u, AGENT => $msuser }, $msg);
}
}
use SrSv::NickControl::Enforcer qw(%enforcers);
use SrSv::Email;
-use SrSv::IRCd::UUID;
+use SrSv::Insp::UUID;
use SrSv::Util qw( makeSeqList );
-use SrSv::IRCd::Send qw (getRevUuid getUuid setRevUuid setUuid);
+use SrSv::IRCd::Send qw (getRevUuid ircd::getUuid setRevUuid setUuid);
require SrSv::MySQL::Stub;
-
+use Data::Dumper;
use constant {
# Clone exception max limit.
# This number typically means infinite/no-limit.
our $nsnick_default = 'NickServ';
our $nsnick = $nsnick_default;
-
+our $nsuser = { NICK => $nsnick, ID => "123AAAAAB" }; #FIXME - erry
our $cur_lock;
our $cnt_lock = 0;
$set_vacation_ntf, $get_vacation_ntf,
$set_authcode_ntf, $get_authcode_ntf,
+ $nick_deleteChanUser, $nick_deleteNickCh, $nick_deleteNickId,
+ $id_delUser
);
sub init() {
$nick_check = $dbh->prepare("SELECT id FROM user WHERE nick=? AND online=0 AND time=?");
- $nick_checkExists = $dbh -> prepare ("SELECT nick FROM user WHERE id=?");
+ $nick_checkExists = $dbh -> prepare ("SELECT nick FROM user WHERE id=? AND time=?");
+ $nick_deleteChanUser = $dbh -> prepare ("DELETE FROM chanuser WHERE nickid=?");
+ $nick_deleteNickCh = $dbh -> prepare ("DELETE FROM nickchg WHERE nickid=?");
+ $nick_deleteNickId = $dbh -> prepare ("DELETE FROM nickid WHERE id=?");
+ $id_delUser = $dbh->prepare ("DELETE FROM user WHERE id=?");
$nick_create = $dbh->prepare("INSERT INTO user SET nick=?, time=?, inval=0, ident=?, host=?, vhost=?, server=?, modes=?,
gecos=?, flags=?, cloakhost=?, online=1");
$nick_create2 = $dbh->prepare("INSERT INTO user SET id=?, nick=?, time=?, inval=0, ident=?, host=?, vhost=?, server=?, modes=?,
# $nick_create = $dbh->prepare("INSERT INTO user SET id=(RAND()*294967293)+1, nick=?, time=?, inval=0, ident=?, host=?, vhost=?, server=?, modes=?, gecos=?, flags=?, cloakhost=?, online=1");
$nick_create_old = $dbh->prepare("UPDATE user SET nick=?, ident=?, host=?, vhost=?, server=?, modes=?, gecos=?,
flags=?, cloakhost=?, online=1 WHERE id=?");
- $nick_change = $dbh->prepare("UPDATE user SET nick=?, time=? WHERE nick=?");
+ $nick_change = $dbh->prepare("UPDATE user SET nick=? WHERE nick=?");
$nick_quit = $dbh->prepare("UPDATE user SET online=0, quittime=UNIX_TIMESTAMP() WHERE nick=?");
$nick_delete = $dbh->prepare("DELETE FROM user WHERE nick=?");
$nick_id_delete = $dbh->prepare("DELETE FROM nickid WHERE id=?");
}
sub dispatch($$$) {
- my ($src, $dst, $msg) = @_;
+ $nsuser = { NICK => $nsnick, ID => "123AAAAAB" }; #FIXME = erry
+ my ($user, $dstUser, $msg) = @_;
+ return unless (lc $dstUser->{NICK} eq lc $nsnick);
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
- my $id = ircd::getUuid ($src);
- $id = decodeUUID ($id);
- my $user = { NICK => $src, AGENT => $dst, ID => $id};
+ get_user_id ($user);
+ my $src = $user->{NICK};
+ $user->{AGENT} = $dstUser;
return if flood_check($user);
-
if($cmd =~ /^help$/i) {
sendhelp($user, 'nickserv', @args)
}
notice($user, "Cannot only change case of nick");
return;
}
- ircd::svsnick($nsnick, $src, $nick);
- ircd::setumode($nsnick, $nick, '+r');
+ ircd::svsnick($nsuser, $user, $nick);
+ ircd::setumode($nsuser, $user, '+r');
return 1;
}
}
$update_lastseen->execute($uid);
$logout->execute($uid);
delete($user->{NICKFLAGS});
- ircd::nolag($nsnick, '-', get_user_nick($user));
+ ircd::nolag($nsnick, '-', $user);
notice($user, 'You are now logged out');
services::ulog($nsnick, LOG_INFO(), "used NickServ LOGOUT", $user);
}
} else {
my $ghostbusters = @ghostbusters_quotes[int rand(scalar(@ghostbusters_quotes))];
- ircd::irckill($nsnick, $nick, "GHOST command used by $src ($ghostbusters)");
+ ircd::irckill($nsuser, $user, "GHOST command used by $src ($ghostbusters)");
notice($user, "Your ghost has been disconnected");
services::ulog($nsnick, LOG_INFO(), "used NickServ GHOST on $nick", $user);
#nick_delete($nick);
else {
$identify->execute($uid, $src); $identify->finish();
notice($user, 'You are now registered and identified.');
- ircd::setumode($nsnick, $src, '+r');
+ ircd::setumode($nsuser, $user, '+r');
}
$id_update->execute($src, $uid); $id_update->finish();
- services::ulog($nsnick, LOG_INFO(), "registered $src (email: $email)".
+ services::ulog($nsuser, LOG_INFO(), "registered $src (email: $email)".
(services_conf_validate_email ? ' requires email validation code' : ''),
$user);
} else {
$del_nicktext->execute(NTF_UMODE, $target); $del_nicktext->finish(); # don't allow dups
$set_umode_ntf->execute($modes, $target); $set_umode_ntf->finish();
foreach my $usernick (get_nick_user_nicks $target) {
- ircd::setumode($nsnick, $usernick, $modes)
+ ircd::setumode($nsuser, $user, $modes)
}
my @out;
}
$set_watch->execute($mask, time(), $root);
- ircd::svswatch($nsnick, $src, "+$mask");
+ ircd::svswatch($nsuser, $user, "+$mask");
notice($user, "\002$mask\002 added to \002$target\002's watch list.");
return;
}
return;
}
$del_watch->execute($root, $mask);
- ircd::svswatch($nsnick, $src, "-$mask");
+ ircd::svswatch($nsuser, $user, "-$mask");
notice($user, "\002$mask\002 removed from \002$target\002's watch list.");
}
elsif ($cmd =~ /^list$/i) {
$expiry = 0;
};
$set_silence->execute($mask, time(), $expiry, $comment, $root);
- ircd::svssilence($nsnick, $src, "+$mask");
+ ircd::svssilence($nsuser, $user, "+$mask");
notice($user, "\002$mask\002 added to \002$target\002's SILENCE list.");
}
elsif ($cmd =~ /^del(ete)?$/i) {
push @out_masks, "-$mask";
push @reply, "\002$mask\002 removed from \002$target\002's SILENCE list.";
}
- ircd::svssilence($nsnick, $src, @out_masks);
+ ircd::svssilence($nsuser, $user, @out_masks);
notice($user, @reply);
}
elsif ($cmd =~ /^list$/i) {
$nick = get_root_nick($nick);
foreach my $t (get_nick_user_nicks $nick) {
- ircd::notice($nsnick, $t, (ref $msg ? @$msg : $msg)) unless(lc $t eq lc $src);
+ my $user = { NICK => $nick, AGENT => $nsuser };
+ get_user_id ($user);
+ ircd::notice($nsuser, $user, (ref $msg ? @$msg : $msg)) unless(lc $t eq lc $src);
if(is_alias_of($nick, $t)) {
- ircd::setumode($nsnick, $t, '-r');
+ ircd::setumode($nsuser, $user, '-r');
}
}
# For a single alias:
sub unidentify_single($$) {
my ($nick, $msg) = @_;
-
+ my $user = { NICK => $nick, AGENT => $nsuser };
+ get_user_id ($user);
if(is_online($nick)) {
- ircd::setumode($nsnick, $nick, '-r');
+ ircd::setumode($nsuser, $user, '-r');
}
}
my ($c) = $count_clones->fetchrow_array;
if($c > $lim) {
- ircd::irckill($nsnick, $src, "Session Limit Exceeded");
+ ircd::irckill($nsuser, $user, "Session Limit Exceeded");
return 1;
}
}
sub kill_user($$) {
my ($user, $reason) = @_;
- ircd::irckill(get_user_agent($user) || main_conf_local, get_user_nick($user), $reason);
+ ircd::irckill(get_user_agent($user) || main_conf_local, $user, $reason);
}
sub kline_user($$$) {
$get_umode_ntf->finish();
if(adminserv::get_svs_level($root)) {
$umodes = modes::merge_umodes('+h', $umodes);
- ircd::nolag($nsnick, '+', $src);
+ ircd::nolag($nsuser, '+', $user);
}
$umodes = modes::merge_umodes('+r', $umodes) if(is_identified($user, $src));
hostserv::hs_on($user, $root, 1);
if(my @chans = get_autojoin_ntf($nick)) {
- ircd::svsjoin($nsnick, $src, @chans);
+ ircd::svsjoin($nsuser, $user, @chans);
}
- nickserv::do_svssilence($user, $root);
- nickserv::do_svswatch($user, $root);
-
- chanserv::akick_alluser($user);
- chanserv::set_modes_allchan($user, $flags & NRF_NEVEROP);
- chanserv::fix_private_join_before_id($user);
-
- services::ulog($nsnick, LOG_INFO(), "identified to nick $nick (root: $root)", $user);
-
- memoserv::notify($user, $root);
- notify_auths($user, $root) if $flags & NRF_AUTH;
my $enforced;
if(enforcer_quit($nick)) {
}
if (lc($src) eq lc($nick)) {
- ircd::setumode($nsnick, $src, $umodes);
+ ircd::setumode($nsuser, $user, $umodes);
$update_nickalias_last->execute($nick); $update_nickalias_last->finish();
}
elsif($svsnick) {
- ircd::svsnick($nsnick, $src, $nick);
- ircd::setumode($nsnick, $nick, modes::merge_umodes('+r', $umodes) );
+ ircd::svsnick($nsuser, $user, $nick);
+ ircd::setumode($nsuser, $user, modes::merge_umodes('+r', $umodes) );
# the update _should_ be taken care of in nick_change()
#$update_nickalias_last->execute($nick); $update_nickalias_last->finish();
}
elsif(defined $umodes) {
- ircd::setumode($nsnick, $src, $umodes);
+ ircd::setumode($nsuser, $user, $umodes);
}
+ nickserv::do_svssilence($user, $root);
+ nickserv::do_svswatch($user, $root);
+
+ chanserv::akick_alluser($user);
+ chanserv::set_modes_allchan($user, $flags & NRF_NEVEROP);
+ chanserv::fix_private_join_before_id($user);
+
+ services::ulog($nsnick, LOG_INFO(), "identified to nick $nick (root: $root)", $user);
+
+ memoserv::notify($user, $root);
+ notify_auths($user, $root) if $flags & NRF_AUTH;
return ($enforced ? 2 : 1);
}
sub guestnick($) {
my ($nick) = @_;
- print "NICK $nick\n";
$set_guest->execute(1, $nick);
my $randnick = 'Guest'.int(rand(10)).int(rand(10)).int(rand(10)).int(rand(10)).int(rand(10));
#Prevent collisions.
while (is_online($randnick)) {
- print "Already online!\n";
$randnick = 'Guest'.int(rand(10)).int(rand(10)).int(rand(10)).int(rand(10)).int(rand(10));
}
- print "RANDNICK $randnick\n";
- ircd::svsnick($nsnick, $nick, $randnick);
+ my $user = { NICK => $nick, AGENT => $nsuser };
+ get_user_id ($user);
+ ircd::svsnick($nsuser, $user, $randnick);
return $randnick;
}
foreach my $user (get_nick_users $nick) {
$user->{AGENT} = $nsnick;
- ircd::svssilence($nsnick, get_user_nick($user), map ( { '-'.$_->[0] } @entries) );
+ $user->{ID} = ircd::getUuid($nick);
+ ircd::svssilence($nsuser, $user, map ( { '-'.$_->[0] } @entries) );
#notice($user, "The following SILENCE entries have expired: ".
# join(', ', map ( { $_->[0] } @entries) ));
notice($user, map( { "The following SILENCE entry has expired: \002".$_->[0]."\002 ".$_->[1] } @entries ) );
push @silences, "+$mask";
}
$get_silences->finish;
- ircd::svssilence($nsnick, $target, @silences);
+ ircd::svssilence($nsuser, $user, @silences);
return;
}
push @watches, "+$mask";
}
$get_watches->finish;
- ircd::svswatch($nsnick, $target, @watches);
+ ircd::svswatch($nsuser, $user, @watches);
return;
}
$get_umode_ntf->execute($rootnick);
my ($umodes) = $get_umode_ntf->fetchrow_array; $get_umode_ntf->finish();
- ircd::setumode($nsnick, $target, $umodes) if $umodes;
+ ircd::setumode($nsuser, $user, $umodes) if $umodes;
return
}
sub notify_auths($$) {
- my ($user, $nick) = @_;
-
+ my $user = @_;
+ my $nick = get_user_nick ($user);
$get_num_nicktext_type->execute($nick, NTF_AUTH);
my ($count) = $get_num_nicktext_type->fetchrow_array(); $get_num_nicktext_type->finish();
notice($user, "$nick has $count channel authorizations awaiting action.",
return if nr_chk_flag($nick, NRF_EMAILREG());
my $lev = protect_level($nick);
- my $user = { NICK => $nick, AGENT => $nsnick };
-
+ my $user = { NICK => $nick, AGENT => $nsuser };
+ get_user_id ($user);
notice($user,
"This nickname is registered and protected. If it is your",
"nick, type \002/msg NickServ IDENTIFY <password>\002. Otherwise,",
sub warn_countdown($) {
my ($cookie) = @_;
my ($nick, $rem) = split(/ /, $cookie);
- my $user = { NICK => $nick, AGENT => $nsnick };
-
+ my $user = { NICK => $nick, AGENT => $nsuser };
+ get_user_id($user);
if (is_identified($user, $nick)) {
+ print "Line 2778\n";
$update_nickalias_last->execute($nick); $update_nickalias_last->finish();
return;
}
- elsif(!(is_online($nick)) or !(is_registered($nick))) { return; }
+ elsif(!(is_online($nick)) or !(is_registered($nick))) { print "Line 2782\n"; return; }
if($rem == 0) {
notice($user, 'Your nick is now being changed.');
$get_umodes->execute($uid);
my ($umodes) = $get_umodes->fetchrow_array;
$get_umodes->finish();
+ print "UMODES $umodes\n";
return $umodes;
};
$get_nick_inval->execute($id);
my ($nick, $inval) = $get_nick_inval->fetchrow_array;
if($inval > 3) {
- ircd::irckill($nsnick, $nick, 'Too many invalid passwords.');
+ ircd::irckill($nsuser, $user, 'Too many invalid passwords.');
# unnecessary as irckill calls the quit handler.
#nick_delete($nick);
return 0;
my $nick = get_user_nick($user);
if(is_registered($nick)) {
if(is_identified($user, $nick)) {
- ircd::setumode($nsnick, $nick, '+r');
+ ircd::setumode($nsuser, $user, '+r');
$update_nickalias_last->execute($nick); $update_nickalias_last->finish();
return 1;
} else {
add_timer('fix_vhosts', 5, __PACKAGE__, 'nickserv::fix_vhosts');
$get_hostless_nicks->execute();
while (my ($nick) = $get_hostless_nicks->fetchrow_array) {
- ircd::notice($nsnick, main_conf_diag, "HOSTLESS NICK $nick");
+ ircd::notice($nsuser, main_conf_diag, "HOSTLESS NICK $nick");
ircd::userhost($nick);
ircd::userip($nick);
}
### IRC EVENTS ###
sub nick_create {
- my ($nick, $time, $ident, $host, $vhost, $server, $svsstamp, $modes, $gecos, $ip, $cloakhost) = @_;
- my $user = { NICK => $nick };
+ my ($user, $time, $ident, $host, $vhost, $server, $svsstamp, $modes, $gecos, $ip, $cloakhost) = @_;
+ my $nick = get_user_nick ($user);
get_lock($nick);
if ($vhost eq '*') {
if ({modes::splitumodes($modes)}->{x} eq '+') {
}
my $id;
- if ($id = get_user_id( { NICK => $nick } )) {
+ if ($id = get_user_id( $user )) {
#$id = decodeUUID ($id);
- $nick_checkExists->execute ($id);
+ $nick_checkExists->execute ($id, $time);
my $exists = $nick_checkExists -> fetchrow_array();
my $flags = (synced() ? UF_FINISHED() : 0);
unless (defined($exists)) {
+ $nick_deleteChanUser -> execute ($id);
+ $nick_deleteNickCh -> execute ($id);
+ $nick_deleteNickId -> execute ($id);
+ $id_delUser -> execute ($id);
$nick_create2 -> execute ($id, $nick, $time, $ident, $host, $vhost, $server, $modes, $gecos, $flags, $cloakhost);
}
else {
$nick_create_old->execute ($nick, $ident, $host, $vhost, $server, $modes, $gecos, $flags, $cloakhost, $id);
}
+ $add_nickchg->execute($ircline, $nick, $nick);
+ release_lock($nick);
check_identify($user);
- return $id
+ return $id;
}
if($svsstamp) {
$get_user_nick->execute($svsstamp);
while($i < 10 and !$nick_create->execute($nick, $time, $ident, $host, $vhost, $server, $modes, $gecos, $flags, $cloakhost)) { $i++ }
$id = get_user_id( { NICK => $nick } ); # There needs to be a better way to do this
}
- ircd::setsvsstamp($nsnick, $nick, $id) unless $svsstamp == $id;
+ ircd::setsvsstamp($nsuser, $user, $id) unless $svsstamp == $id;
$add_nickchg->execute($ircline, $nick, $nick);
}
sub nick_delete($$) {
- my ($nick, $quit) = @_;
- my $user = { NICK => $nick };
-
+ my ($user, $quit) = @_;
+ my $nick = $user->{NICK};
get_lock($nick);
-
my $id = get_user_id($user);
-
$del_nickchg_id->execute($id); $del_nickchg_id->finish();
-
$quit_update->execute($quit, $id); $quit_update->finish();
$update_lastseen->execute($id); $update_lastseen->finish();
-
$get_quit_empty_chans->execute($id);
-
$chan_user_partall->execute($id); $chan_user_partall->finish();
#$nick_chan_delete->execute($id); $nick_chan_delete->finish();
$nick_quit->execute($nick); $nick_quit->finish();
-
release_lock($nick);
-
while(my ($cn) = $get_quit_empty_chans->fetchrow_array) {
chanserv::channel_emptied({CHAN => $cn});
}
}
sub nick_change($$$) {
- my ($old, $new, $time) = @_;
-
+ my ($user, $new, $time) = @_;
+ my $old = $user->{NICK};
return if(lc $old eq lc $new);
-
+ print "NICK CHANGE: $old -> $new ($time)\n";
get_lock($old);
nick_cede($new);
- print "Nick change called $old -> $new\n";
- $nick_change->execute($new, $time, $old);
+ $nick_change->execute($new, $old);
$add_nickchg->execute($ircline, $new, $new);
release_lock($old);
if($new =~ /^guest/i) {
if($get_guest->fetchrow_array) {
$set_guest->execute(0, $new);
} else {
- print "Huuuuuuuuuuuh?\n";
guestnick($new);
}
return;
}
- ircd::setumode($nsnick, $new, '-r')
+ my $user = { NICK => $new, AGENT => $nsuser };
+ get_user_id($user);
+ ircd::setumode($nsuser, $user, '-r')
unless check_identify({ NICK => $new });
}
-
+sub handle_oper($) {
+ my ($user) = @_;
+ my $nick = $user->{NICK};
+ get_lock($nick);
+ my $id = get_user_id($user);
+ $get_umodes->execute($id);
+ my ($omodes) = $get_umodes->fetchrow_array;
+ $set_umodes->execute(modes::add($omodes, "o", 0), $id);
+ #this is _safe_. even an oper block with no privs gets +o
+ #it's just not passed to srsv for some reason, all we get is :UID opertype X
+}
sub umode($$) {
- my ($nick, $modes) = @_;
- my $user = { NICK => $nick };
-
+ my ($user, $modes) = @_;
+ my $nick = $user->{NICK};
get_lock($nick);
my $id = get_user_id($user);
our $osnick_default = 'OperServ';
our $osnick = $osnick_default;
-
+our $osuser = { NICK => $osnick, ID => "123AAAAAD" };
my %newstypes = (
u => 'User',
o => 'Oper'
}
sub dispatch($$$) {
- my ($src, $dst, $msg) = @_;
+ my ($user, $dstUser, $msg) = @_;
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
-
- my $user = { NICK => $src, AGENT=> $dst };
-
+ $user -> {AGENT} = $dstUser;
+ my $src = $user -> {NICK};
+ return unless (lc $dstUser->{NICK} eq lc $osnick);
+ get_user_id ($user);
services::ulog($osnick, LOG_INFO(), "cmd: [$msg]", $user);
return if flood_check($user);
- unless(adminserv::is_svsop($user) or adminserv::is_ircop($user)) {
+ unless(defined(adminserv::is_svsop($user)) or adminserv::is_ircop($user)) {
notice($user, $err_deny);
- ircd::globops($osnick, "\002$src\002 failed access to $osnick $msg");
+ ircd::globops($osuser, "\002$src\002 failed access to $osnick $msg");
return;
}
notice($user, "You don't have the right access");
return $event::SUCCESS;
}
- ircd::svsjoin($osnick, $target, @chans);
+ ircd::svsjoin($osuser, $target, @chans);
}
sub os_fpart($$@) {
}
$reason = join(' ', @params) if @params;
- ircd::svspart($osnick, $target, $reason, @chans);
+ ircd::svspart($osuser, $target, $reason, @chans);
}
sub os_qline_add($$$$) {
return $event::SUCCESS;
}
nickserv::enforcer_quit($newnick);
- ircd::svsnick($osnick, $curnick, $newnick);
+ ircd::svsnick($osuser, $curnick, $newnick);
notice($user, $curnick.' changed to '.$newnick);
return $event::SUCCESS;
}
my $hostmask = $hostname;
$hostmask =~ s/\*/\%/g;
my $ret = $del_clone_exceptname->execute($hostmask);
- ircd::notice($osnick, main_conf_diag, "hostname: $hostname; hostmask: $hostmask");
+ ircd::notice($osuser, main_conf_diag, "hostname: $hostname; hostmask: $hostmask");
if($ret == 1) {
notice($user, "\002$hostname\002 successfully deleted from the hostname exception list");
return;
}
foreach my $tuser (chanserv::get_users_nochans($noid)) {
- $tuser->{AGENT} = $osnick;
+ $tuser->{AGENT} = $osuser;
nickserv::kill_user($tuser,
"Killed by \002".get_user_nick($user)."\002".
(@args ? ": ".join(' ', @args) : '')
return;
}
foreach my $tuser (chanserv::get_users_nochans($noid)) {
- $tuser->{AGENT} = $osnick;
+ $tuser->{AGENT} = $osuser;
nickserv::kline_user($tuser, services_conf_chankilltime,
"K:Lined by \002".get_user_nick($user)."\002".
(@args ? ": ".join(' ', @args) : '')
elsif($cmd =~ /^(msg|message|notice)$/i) {
notice($user, "Must have message to send") unless(@args);
foreach my $tuser (chanserv::get_users_nochans($noid)) {
- $tuser->{AGENT} = $osnick;
+ $tuser->{AGENT} = $osuser;
notice($tuser,
"Automated message from \002".get_user_nick($user),
join(' ', @args)
}
foreach my $tuser (chanserv::get_users_nochans($noid)) {
- $tuser->{AGENT} = $osnick;
- ircd::svsjoin($osnick, get_user_nick($tuser), $args[0]);
+ $tuser->{AGENT} = $osuser;
+ ircd::svsjoin($osuser, get_user_nick($tuser), $args[0]);
}
}
else {
return $event::SUCCESS;
}
- ircd::svskill($osnick, $target, $reason);
+ ircd::svskill($osuser, $target, $reason);
}
return $event::SUCCESS;
}
foreach my $target (split(',', $targets)) {
- my $tuser = { NICK => $target, AGENT => $osnick };
+ my $tuser = { NICK => $target, AGENT => $osuser };
if (!get_user_id($tuser)) {
notice($user, $target.' is not online.');
return $event::SUCCESS;
}
unless($zline) {
if(!$remove) {
- ircd::kline($opernick, $ident, $host, $expiry, $reason);
+ ircd::kline(ircd::getUuid($osnick), $ident, $host, $expiry, $reason);
} else {
ircd::unkline($opernick, $ident, $host);
}
return;
}
if(!$remove) {
- ircd::zline($opernick, $host, $expiry, $reason);
+ ircd::zline($osnick, $host, $expiry, $reason);
} else {
ircd::unzline($opernick, $host);
}
}
foreach my $tuser (get_clones($target)) {
next unless is_online($tuser);
- $tuser->{AGENT} = $osnick;
+ $tuser->{AGENT} = $osuser;
nickserv::kill_user($tuser,
"Killed by \002".get_user_nick($user)."\002".
(@args ? ": ".join(' ', @args) : '')
}
foreach my $tuser (get_clones($target)) {
next unless is_online($tuser);
- $tuser->{AGENT} = $osnick;
+ $tuser->{AGENT} = $osuser;
nickserv::kline_user($tuser, services_conf_chankilltime,
"K:Lined by \002".get_user_nick($user)."\002".
(@args ? ": ".join(' ', @args) : '')
notice($user, "Must have message to send") unless(@args);
foreach my $tuser (get_clones($target)) {
next unless is_online($tuser);
- $tuser->{AGENT} = $osnick;
+ $tuser->{AGENT} = $osuser;
notice($tuser,
"Automated message from \002".get_user_nick($user),
join(' ', @args)
foreach my $tuser (get_clones($target)) {
next unless is_online($tuser);
- $tuser->{AGENT} = $osnick;
- ircd::svsjoin($osnick, get_user_nick($tuser), $args[0]);
+ $tuser->{AGENT} = $osuser;
+ ircd::svsjoin($osuser, get_user_nick($tuser), $args[0]);
}
}
else {
projects / irc / SurrealServices / srsv.git / commitdiff
