# tho MIME's is probably faster
use MIME::Base64;
use Data::Dumper;
+use SrSv::Insp::UUID;
# FIXME
use constant {
# Wait For
foreach my $prefix (@ops) {
$op |= $opmodes{$prefix};
}
- my $user = {ID => $id, __OP=>$op};
+ my $user = {ID => $id, __OP=>$op}; #ID'S are _already_ decoded in FJOIN!
get_user_nick ($user);
push @users, $user;
$i++;
}
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, $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);
- 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))));
+ $_[0] =~ /^(:\S+) UID (\S+) (\d+) (\S+) (\S+) (\S+) (\S+) (\S+) (\d+) (\S+) :(.*)$/;
+ my ($server, $uid, $stamp, $nick, $host, $vhost, $ident, $IP, $ts, $modes, $gecos) = ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12);
+ print "UID $uid " . decodeUUID($uid) . "\n";
+ my $user = { NICK => $nick, ID => decodeUUID($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($) {
my $event;
sub JOIN($) {
$_[0] =~ /^:(\S+) (?:C|JOIN) (\S+)$/;
- my $user = { ID => $1 };
+ my $user = { ID => decodeUUID($1) };
get_user_nick ($user);
return ('JOIN', undef, 1, WF_CHAN, $user, $2);
}
foreach my $user (@users) {
my @params = split (",",$user);
push (@status, $params[0]);
- push (@ids, $params[1]);
+ push (@ids, decodeUUID($params[1]));
}
return ('SJOIN', undef, undef, WF_CHAN, parse_fjoin($server, $channel, $ts, $modes, \@ids, \@status));
}
my $user;
if($_[0] =~ /^:(\S+) (?:D|PART) (\S+) :(.*)$/) {
- $user = {ID => $1};
+ $user = {ID => decodeUUID($1)};
get_user_nick ($user);
return ('PART', undef, 0, WF_CHAN, $user, $2, $3);
}
elsif($_[0] =~ /^:(\S+) (?:D|PART) (\S+)$/) {
- $user = {ID => $1};
+ $user = {ID => decodeUUID($1)};
get_user_nick ($user);
return ('PART', undef, 0, WF_CHAN, $user, $2, undef);
}
#: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);
+ my $user;
+ print "FMODE ID $id " . length($id);
+ if (length($id) > 3) { #UID
+ print "FFFFFFFFFFF\n";
+ $user = {ID => decodeUUID($id)};
+ get_user_nick ($user);
+ }
+ else { #SID
+ $user = $id;
+ }
+ my $name;
+ my $argz = $5;
+ my @args = split(/ /, $argz);
+ my $modes = $4;
+ print "============MODES $modes=================\n";
+ print "5: $4\n";
+ print "6: $5\n";
+ my @modes = split(//, $modes);
+ my @userargs;
+ foreach my $mode (@modes) {
+ if($mode eq '+' or $mode eq '-') { next; }
+ if ($mode !~ /^[vhoaq]$/) { next; }
+ my $arg = shift (@args);
+ next if $arg eq '';
+ my $id = decodeUUID($arg);
+ my $tuser = {ID=>$id};
+ get_user_nick ($tuser);
+ push @userargs, $tuser;
+ }
+ return ('MODE', undef, 1, WF_ALL, $user, $2, $4, $5, @userargs);
}
}
sub MODE($) {
my $user;
-
- if($_[0] =~ /^(@|:)(\S+) (?:G|MODE) (#\S+) (\S+) (.*)(?: \d+)?$/) {
+ if($_[0] =~ /^(@|:)(\S+) (?:G|MODE) (#\S+) (.*)(?: \d+)?$/) {
my $name;
if ($1 eq '@') {
$name = $servernum[b64toi($2)];
}
else {
$name = $2;
- $user = { ID=>$name};
+ $user = { ID=>decodeUUID($name)};
get_user_nick ($user);
}
- return ('MODE', undef, 1, WF_ALL, $user, $3, $4, $5);
+ my $argz = $6;
+ my @args = split(/ /, $argz);
+ my $modes = $5;
+ print "============MODES $modes=================\n";
+ print "5: $5\n";
+ print "6: $6\n";
+ my @modes = split(//, $modes);
+ my $newargs = "";
+ foreach my $mode (@modes) {
+ if($mode eq '+' or $mode eq '-') { next; }
+ my $arg = shift (@args);
+ next if $arg eq '';
+ my $id = encodeUUID($arg);
+ my $tuser = {ID=>$id};
+ my $nick = get_user_nick ($tuser);
+ print "!!!!!!!!!!!1!!!!!$nick\n";
+ $newargs .= ($newargs eq ""?$nick:" $nick"); # what an awful way to do it.
+ }
+ my $arguements;
+ if ($newargs eq "") {
+ $arguements = $argz;
+ }
+ else {
+ $arguements = $newargs;
+ }
+ return ('MODE', undef, 1, WF_ALL, $user, $3, $4, $arguements);
}
elsif($_[0] =~ /^:(\S+) (?:G|MODE) (\S+) :(\S+)$/) {
# We shouldn't ever get this, as UMODE2 is preferred
- $user = { ID => $1 };
+ $user = { ID => decodeUUID($1) };
get_user_nick ($user);
return ('UMODE', 0, 0, WF_ALL, $user, $3);
}
}
+
sub MESSAGE($) {
my ($event, @args);
if($_[0] =~ /^(@|:)(\S+) (?:\!|PRIVMSG) (\S+) :(.*)$/) {
}
else {
$name = $2;
- $srcUser = {ID=>$name};
+ $srcUser = {ID=>decodeUUID($name)};
unless (get_user_nick ($srcUser)) {
$srcUser = {NICK=>$name};
get_user_id ($name);
}
}
my $dest = $3;
- $dstUser = {ID=>$dest};
+ $dstUser = {ID=>($dest)};
unless (get_user_nick ($dstUser)) {
$dstUser = {NICK=>$dest};
}
sub AWAY($) {
if($_[0] =~ /^:(\S+) (?:6|AWAY) :(.*)$/) {
- my $user = {ID=>$1};
+ my $user = {ID=>decodeUUID($1)};
get_user_nick($user);
return ('AWAY', undef, undef, WF_ALL, $user, $2);
}
elsif($_[0] =~ /^:(\S+) (?:6|AWAY)$/) {
- my $user = {ID => $1};
+ my $user = {ID => decodeUUID($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 $user = {ID => $1};
+ my $user = {ID => decodeUUID($1)};
get_user_nick ($user);
- ircd::setRevUuid ($1, $2);
- ircd::setUuid ($2, $1);
+ set_user_nick (decodeUUID($1), $2);
+ set_user_id ($2, decodeUUID($1));
return ('NICKCHANGE', undef, undef, WF_NICK, $user, $2, $3);
}
}
sub QUIT($) {
if ($_[0] =~ /^:(\S+) QUIT :Killed \((\S+) \((.*)\)\)$/) {
#:583AAAAAH QUIT :Killed (erry (die))
- my $victim = {ID=>$1};
+ my $victim = {ID=>decodeUUID($1)};
get_user_nick ($victim);
my $murderer = {NICK=>$2};
get_user_id ($murderer);
return ('KILL', 0, 1, WF_NICK, $murderer, $victim, $reason, undef);
}
elsif ($_[0] =~ /^:(\S+) QUIT :(.*)$/) {
- my $user = {ID=>$1};
+ my $user = {ID=>decodeUUID($1)};
get_user_nick ($user);
return ('QUIT', 0, undef, WF_NICK, $user, $2);
}
}
sub OPERQUIT ($) {
if ($_[0] =~ /^:(\S+) QUIT :(.*)$/) {
- my $user = {ID=>$1};
+ my $user = {ID=>decodeUUID($1)};
get_user_nick ($user);
return ('QUIT', 0, undef, WF_NICK, $user, $2);
}
#And yes, for (some?) opers it's OPERQUIT not QUIT
#Joy, JOY, JOY!
$_[0] =~ /^:(\S+) KILL (\S+) :(.*)$/;
- my $murderer = {ID=>$1};
+ my $murderer = {ID=>decodeUUID($1)};
get_user_nick ($murderer);
- my $victim = {ID=>$2};
+ my $victim = {ID=>decodeUUID($2)};
get_user_nick ($victim);
return ("KILL", 0, 1, WF_NICK, $murderer, $victim, $3, undef);
}
else {
$name = $2;
}
- my $user = {ID => $name};
+ my $user = {ID => decodeUUID($name)};
unless (get_user_nick ($user)) {
$user = {NICK => $name};
get_user_id ($user);
sub TOPIC($) {
if ($_[0] =~ /^:(\S+) TOPIC (\S+) :(.*)$/) {
#:583AAAAAF TOPIC #erry :Welcome to erry(world|net). Have a cookie.
- my $setter = { ID => $1 };
+ my $setter = { ID => decodeUUID($1) };
get_user_nick ($setter);
return ('TOPIC', 0, 1, WF_ALL, $setter, $2, $setter, 0, $3);
}
#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 };
+ my $user = { ID => decodeUUID($1) };
get_user_nick ($user);
return ("OPERUP", 0, 0, WF_ALL, $user);
}
OPERTYPE => \&OPERTYPE,
OPERQUIT => \&OPERQUIT, #Opers are so special, they get their own QUIT. SOme of the time.
CAPAB => \&CAPAB,
+ FMODE => \&FMODE
);
}
use SrSv::Debug;
use SrSv::Log;
use Exporter 'import';
-our @EXPORT = qw (agent_doconn getRevUuid getUuid setRevUuid setUuid);
+our @EXPORT = qw (agent_doconn getAgentRevUuid getAgentUuid setAgentRevUuid setAgentUuid);
# FIXME
use constant {
MAXBUFLEN => 510,
use SrSv::Unreal::Base64 qw(itob64 b64toi);
use SrSv::Text::Format qw( wordwrap );
-
+use SrSv::User '/./';
use SrSv::Agent;
-use SrSv::Process::InParent qw(update_userkill getRevUuid getUuid setRevUuid SetUUid);
+use SrSv::Process::InParent qw(update_userkill getAgentRevUuid getAgentUuid setAgentRevUuid setAgentUuid);
our %defer_mode;
our %preconnect_defer_mode;
addhandler('VERSION', undef(), undef(), 'ircd::version', 1);
addhandler('SERVER', undef(), undef(), 'ircd::handle_server', 1);
addhandler('ENDBURST',undef(),undef(),'ircd::endburst',1);
-sub getRevUuid($) {
+sub encodeUUID_ ($) {
+ my ($user) = @_;
+ if (ref ($user) ne "HASH") {
+ Carp::confess ("encodeUUID_ called on non-hash " . $user);
+ return;
+ }
+ if (defined ($user->{e_ID})) {
+ return $user->{e_ID};
+ }
+ if (!defined($user->{ID})) {
+ Carp::confess ("encodeUUID_ called on a user w/o id " , Dumper ($user));
+ return;
+ }
+ my $nick = $user->{NICK};
+ if (!defined ($nick)) {
+ $nick = get_user_nick ($user);
+ }
+ if (is_agent ($nick)) {
+ return $user->{e_ID} = $user->{ID};
+ }
+ return $user->{e_ID} = encodeUUID ($user->{ID});
+}
+sub getAgentRevUuid($) {
my $id = $_[0];
my $nick = $reverse_uuids{$id};
$uuids{lc $nick} = $id;
return $nick;
}
-sub getUuid($) {
+sub getAgentUuid($) {
my $nick = lc $_[0];
my $id = $uuids{$nick};
return $id;
}
-sub setRevUuid ($$) {
+sub setAgentRevUuid ($$) {
my ($id, $nick) = @_;
$reverse_uuids{$id} = lc $nick;
}
-sub setUuid ($$) {
+sub setAgentUuid ($$) {
my ($nick, $id) = @_;
$uuids{lc $nick} = $id;
}
my ($src, $chan, $target, $reason) = @_;
$src = $main_conf{local} unless initial_synced();
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
ircsend(":$srcId KICK $chan $targetId :$reason");
callfuncs('KICK', 0, 2, [$srcId, $chan, $targetId, $reason]);
}
sub invite($$$) {
my ($src, $chan, $target) = @_;
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
ircsend(":$srcId INVITE $targetId $chan 0");
}
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});
+ $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
}
else { # /notice #channel This probably sucks. Blame erry :(
$targetId = $dst;
my ($src, $dst, $cmd, @toks) = @_;
my $target = $dst; #lazy erry
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
privmsg($srcId, $targetId, "\x01".join(' ', ($cmd, @toks))."\x01");
}
my ($src, $dst, $cmd, @toks) = @_;
my $target = $dst; #lazy erry
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
notice($srcId, $targetId, "\x01".join(' ', ($cmd, @toks))."\x01");
}
my ($src, $dst, $modes) = @_;
my $target = $dst; #lazy erry
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
ircsend(":$srcId SVSMODE $targetId $modes");
callfuncs('UMODE', 0, undef, [$dst, $modes]);
}
my $srcId;
if (initial_synced()) {
if (ref($src) eq "HASH") {
+ if ($src->{NICK} && !$src->{ID}) {
+ get_user_id ($src);
+ }
$srcId = ($src->{ID}?$src->{ID}:($src->{UUID}?$src->{UUID}:$src->{NICK}));
}
else {
}
my $targetId;
if (ref ($target) eq "HASH") {
- $targetId = ($target->{UID}?$target->{UID}:($target->{ID}?encodeUUID($target->{ID}):$target->{NICK}));
+ $targetId = ($target->{UID}?$target->{UID}:($target->{ID}?encodeUUID_($target):$target->{NICK}));
}
else {
$targetId = $target;
}
- callfuncs('MODE', undef, 1, [$srcId, $dst, $modes, $targetId]);
+ callfuncs('MODE', undef, 1, [$srcId, $dst, $modes, $targetId, $target]);
print "$ircline -- setmode($srcId, $dst, $modes, $targetId)\n" if DEBUG;
ircsend(":$srcId MODE $dst $modes $targetId");
}
}
my $parms = "";
foreach my $target (@targets) {
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
$parms .= ($parms eq ""?"":" ") . $targetId;
}
- callfuncs('MODE', undef, 1, [$srcId, $dst, $modes, $parms]);
+ callfuncs('MODE', undef, 1, [$srcId, $dst, $modes, $parms, @targets]);
print "$ircline -- setmode($srcId, $dst, $modes, $parms)\n" ;
ircsend(":$srcId MODE $dst $modes $parms");
}
sub unkline ($$$) {
my ($setter, $ident, $host) = @_;
my $line = "TKL - G $ident $host $setter";
- my $setId = getUuid($setter);
+ my $setId = getAgentUuid($setter);
if ($setId) { $setter = $setId; }
#:583AAAAAE DELLINE G test@test.com
my $line = ":$setter DELLINE G $ident\@$host";
sub zline ($$$$) {
my ($setter, $host, $expiry, $reason) = @_;
$setter=$main_conf{local} unless defined($setter);
- my $setId = getUuid($setter);
+ my $setId = getAgentUuid($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";
sub unzline ($$) {
my ($setter, $host) = @_;
- my $setId = getUuid($setter);
+ my $setId = getAgentUuid($setter);
if ($setId) { $setter = $setId; }
my $line = ":$setter DELLINE Z $host";
ircsend($line);
my ($src, $target, $reason) = @_;
$src = $main_conf{local} unless initial_synced();
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
my $srcNick = $target->{NICK};
return 0 unless update_userkill($targetId);
ircsendimm(":$srcId KILL $targetId :($reason)");
# warning, if misused, this can KILL the user
# with a collision
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
ircsend(":$srcId SVSNICK $targetId $newnick ".time);
}
# *** We do not track this info nor care.
my ($src, $target, @watchlist) = @_;
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
my $base_str = ":$srcId SVSWATCH $targetId ";
my $send_str = $base_str;
while (@watchlist) {
# *** We do not track this info nor care.
my ($src, $target, @silencelist) = @_;
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
my $base_str = ":$srcId SVSSILENCE $targetId ";
my $send_str = $base_str;
while (@silencelist) {
sub svsjoin($$@) {
my ($src, $target, @chans) = @_;
- while(my @chanList = splice(@chans, 0, 10)) {
- # split into no more than 10 at a time.
- __svsjoin($src, $target, @chanList);
+ foreach my $chan (@chans) {
+ # insp only allows one at the time.
+ __svsjoin($src, $target, $chan);
}
}
sub __svsjoin($$@) {
- my ($src, $target, @chans) = @_;
+ my ($src, $target, $chan) = @_;
# a note. a JOIN is returned back to us on success
# so no need to process this command.
# similar for svspart.
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
- ircsend(($srcId?":$srcId":'')." SVSJOIN $targetId ".join(',', @chans));
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
+ ircsend(($srcId?":$srcId":'')." SVSJOIN $targetId $chan");
}
sub svspart($$$@) {
my ($src, $target, $reason, @chans) = @_;
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
ircsend(($srcId ? ":$srcId" : '')." SVSPART $targetId ".join(',', @chans).
($reason ? " :$reason" : ''));
}
sub chghost($$$) {
my ($src, $target, $vhost) = @_;
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
ircsend(($srcId?":$srcId ":'')." CHGHOST $targetId $vhost");
callfuncs('CHGHOST', 0, 1, [$srcId, $targetId, $vhost]);
}
sub chgident($$$) {
my ($src, $target, $ident) = @_;
my $srcId = ($src->{ID}?$src->{ID}:$src->{NICK});
- my $targetId = ($target->{ID}?encodeUUID($target->{ID}):$target->{NICK});
+ my $targetId = ($target->{ID}?encodeUUID_($target):$target->{NICK});
ircsend(($src?":$srcId ":'')." CHGIDENT $targetId $ident");
callfuncs('CHGIDENT', 0, 1, [$srcId, $targetId, $ident]);
}
my ($agent, $chan) = @_;
my $srcId;
if (ref($agent) ne "HASH") {
- $srcId = getUuid($agent);
+ $srcId = getAgentUuid($agent);
if (!$srcId) {
$srcId = $agent;
}
my ($agent, $chan, $reason) = @_;
my $srcId;
if (ref($agent) ne "HASH") {
- $srcId = getUuid($agent);
+ $srcId = getAgentUuid($agent);
if (!$srcId) {
$srcId = $agent;
}
my $char = chr($count);
my $uuid = $main_conf{numeric} . "AAAAA" . $char; #FIXME - erry
ircsend(":" . $main_conf{numeric} . " UID" . " $uuid " . time . " $nick $host $host $ident 127.0.0.1 ". (time+5) . " $modes " . ":$gecos" );
- setUuid($nick,$uuid);
- setRevUuid($uuid, $nick);
+ setAgentUuid($nick,$uuid);
+ setAgentRevUuid($uuid, $nick);
$count++;
}
return $sidN;
}
sub decodeUUID($) {
+ local $SIG{__WARN__} = sub { ircd::debug (split($/, Carp::longmess(@_))) };
my ($UUID) = @_;
my @chars = split(//, $UUID);
#my @sidC = @chars[0..2];
}
}
sub encodeUUID($) {
+ local $SIG{__WARN__} = sub { ircd::debug (split($/, Carp::longmess(@_))) };
my ($int) = @_;
my $SID_int = ($int & (SID_BITMASK)) >> UID_BITS;
my $UID_int = $int & UID_BITMASK;
my $prefix;
$prefix = "\002\00304" if($level > LOG_INFO);
$prefix .= $levels[$level];
- my $rsuser = { NICK => $main::rsnick, ID => ircd::getUuid($main::rsnick) };
+ my $rsuser = { NICK => $main::rsnick, ID => ircd::getAgentUuid($main::rsnick) };
ircd::privmsg($rsuser, main_conf_diag, "$prefix\: ($service) $text");
write_log('diag', '<'.$main::rsnick.'>', "$prefix\: ($service) $text");
}
flood_inc flood_check get_flood_level
kill_user kline_user
__flood_expire
+ set_user_id set_user_nick
),
keys(%constants));
my @flood = qw( flood_inc flood_check get_flood_level );
$get_user_flags, $set_user_flag, $unset_user_flag, $set_user_flag_all,
$get_host, $get_vhost, $get_cloakhost,
+ $set_user_id, $set_user_nick
+
);
proc_init {
$get_host = $dbh->prepare("SELECT ident, host FROM user WHERE id=?");
$get_vhost = $dbh->prepare("SELECT ident, vhost FROM user WHERE id=?");
$get_cloakhost = $dbh->prepare("SELECT 1, cloakhost FROM user WHERE id=?");
+ $set_user_id = $dbh->prepare("UPDATE user SET id=? WHERE nick=?");
+ $set_user_nick = $dbh->prepare("UPDATE user SET nick=? WHERE id=?");
};
require SrSv::MySQL::Stub;
import SrSv::MySQL::Stub {
__get_user_info => ['ROW', "SELECT ident, host, vhost, gecos, server, time, quittime
FROM user WHERE id=?"],
};
-
+sub set_user_nick($$) {
+ my ($id, $nick) = @_;
+ $set_user_nick -> execute ($id, $nick);
+}
+sub set_user_id ($$) {
+ my ($nick, $id) = @_;
+ $set_user_id -> execute ($nick, $id);
+}
sub get_flood_level($) {
my ($user) = @_;
my ($id, $n);
unless(ref($user) eq 'HASH') {
print "USER $user\mn";
- Carp::confess("invalid get_user_id call");
+ die("invalid get_user_id call");
}
my $nick = $user->{NICK};
if($nick eq '') {
print "USER " . Dumper($user);
- Carp::confess("get_user_id called on empty string");
+ die("get_user_id called on empty string");
}
- my $properId = ircd::getUuid ($user->{NICK});
- print "PROPERID $properId\n";
- if ($properId != undef) {
- print "CALLING DECODE\n";
- $properId = decodeUUID($properId);
- return $user->{ID} = $properId;
+ if (is_agent ($user->{NICK})) {
+ my $properId = ircd::getAgentUuid ($user->{NICK});
+ if ($properId != undef) {
+ $properId = ($properId);
+ return $user->{ID} = $properId;
+ }
}
return undef if(is_agent($user->{NICK}) and not $enforcers{lc $user->{NICK}});
if(exists($user->{ID})) { return $user->{ID}; }
die("invalid get_user_nick call");
}
if (exists($user->{ID})) {
- if (my $nick = ircd::getRevUuid ($user->{ID})) {
+ if (my $nick = ircd::getAgentRevUuid ($user->{ID})) {
return $user->{NICK} = $nick;
}
}
if(exists($user->{NICK}) and is_online($user->{NICK})) {
- my $realnick = ircd::getRevUuid($user->{NICK});
- if ($realnick) {
- $user->{ID} = $user->{NICK};
- $user->{NICK} = $realnick;
- return $realnick;
- }
- else {
- return $user->{NICK};
- }
+ return $user->{NICK};
}
# Possible bug? This next bit only works to chase the nick-change
};
our $rsnick = 'ServServ';
-our $rsUser = { NICK => $rsnick, ID => 1 };
+our $rsUser = { NICK => $rsnick, ID => ircd::getAgentUuid($rsnick) };
addhandler('STATS', undef, undef, 'core::stats');
sub stats($$) {
my ($src, $token) = @_;
addhandler('PRIVMSG', undef, 'servserv', 'core::dispatch', 1);
sub dispatch {
+ our $rsUser = { NICK => $rsnick, ID => ircd::getAgentUuid($rsnick) };
my ($user, $dstUser, $msg) = @_;
return unless (lc $dstUser->{NICK} eq lc $rsnick);
- $user->{AGENT} = $dstUser;
+ $user->{AGENT} = $rsUser;
my $src = $user->{NICK};
my $dst = $dstUser->{NICK};
if(!adminserv::is_ircop($user)) {
use modules::serviceslibs::botserv;
use modules::serviceslibs::memoserv;
use modules::serviceslibs::hostserv;
-
+use modules::nullserv;
*conf = \%services_conf; # only used in some help docs
our @agents = (
addhandler('NICKCONN', undef, undef, 'services::ev_nickconn');
sub ev_nickconn {
+ print "NICKCONN\n";
nickserv::nick_create(@_[0,2..4,8,5..7,9,10,11]);
}
our $asnick_default = 'AdminServ';
our $asnick = $asnick_default;
-our $asuser = { NICK => $asnick, ID => "123AAAAAG" };
+our $asuser = { NICK => $asnick, ID => ircd::getAgentUuid($asnick) };
our (@levels, @defflags);
BEGIN {
### ADMINSERV COMMANDS ###
sub dispatch($$$) {
+ $asuser = { NICK => $asnick, ID => ircd::getAgentUuid($asnick) };
my ($user, $dstUser, $msg) = @_;
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
- $user -> {AGENT} = $dstUser;
- my $src = $user->{NICK};
return unless (lc $dstUser->{NICK} eq lc $asnick);
+ $user -> {AGENT} = $asuser;
+ my $src = $user->{NICK};
services::ulog($asuser, LOG_INFO(), "cmd: [$msg]", $user);
unless(is_svsop($user) or is_ircop($user)) {
our $bsnick_default = 'BotServ';
our $bsnick = $bsnick_default;
our $botchmode;
-our $bsuser = { NICK => $bsnick, ID => "123AAAAAF" };
+our $bsuser = { NICK => $bsnick, ID => ircd::getAgentUuid($bsnick) };
*agent = \&chanserv::agent;
};
sub dispatch($$$) {
+ $bsuser = { NICK => $bsnick, ID => ircd::getAgentUuid($bsnick) };
my ($user, $dstUser, $msg) = @_;
- $user -> {AGENT} = $dstUser;
+ $user -> {AGENT} = $bsuser;
my $src = $user->{NICK};
my $dst = $dstUser->{NICK};
if(lc $dstUser->{NICK} eq lc $bsnick or lc $dstUser->{NICK} eq lc $bsnick_default ) {
if($bot) {
$assign_bot->execute($bot, $cn);
- my $botUser = { NICK=>$bot, ID=>ircd::getUuid($bot) };
+ my $botUser = { NICK=>$bot, ID=>ircd::getAgentUUID ($bot) };
bot_join($chan, $botUser);
notice($user, "\002$bot\002 now assigned to \002$cn\002.");
} else {
get_user_id ($bot);
my $rsuser = { NICK => $main::rsnick };
get_user_id ($rsuser);
- $rsuser->{ID} = encodeUUID($rsuser->{ID});
+ $rsuser->{ID} = ($rsuser->{ID});
ircd::setmode($rsuser, main_conf_diag, '+h', $bot);
notice($user, "Bot $botnick connected.");
}
my $rsnick = $main::rsnick;
my $rsuser = { NICK => $main::rsnick };
get_user_id ($rsuser);
- $rsuser->{ID} = encodeUUID($rsuser->{ID});
+ $rsuser->{ID} = ($rsuser->{ID});
my $bot = { NICK => $botnick };
get_user_id ($bot);
ircd::setmode($rsuser, main_conf_diag, '+h', $bot);
$get_bots_chans->execute($oldnick);
while(my ($cn) = $get_bots_chans->fetchrow_array()) {
my $chan = { CHAN => $cn };
- my $botUser = { NICK=>$botnick, ID=>ircd::getUuid($botnick) };
+ my $botUser = { NICK=>$botnick, ID=>ircd::getAgentUuid($botnick) };
bot_join($chan, $botUser)
if chanserv::get_user_count($chan) or cr_chk_flag($chan, CRF_BOTSTAY(), 1);
}
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, ID=>ircd::getUuid($nick) };
+ my $bot = { NICK => $nick, ID=>ircd::getAgentUuid($nick) };
agent_join($nick, main_conf_diag);
my $rsuser = { NICK => $main::rsnick };
get_user_id ($rsuser);
while(my ($cn, $nick) = $get_botchans->fetchrow_array) {
my $chan = { CHAN => $cn };
if(chanserv::get_user_count($chan)) {
- my $botUser = { NICK=>$nick, ID=>ircd::getUuid($nick) };
+ my $botUser = { NICK=>$nick };
+ get_user_id ($botUser);
bot_join($chan, $botUser);
}
elsif(cr_chk_flag($chan, CRF_BOTSTAY(), 1)) {
- my $botUser = { NICK=>$nick, ID=>ircd::getUuid($nick) };
+ my $botUser = { NICK=>$nick, ID=>ircd::getAgentUuid($nick) };
bot_join($chan, $botUser);
my $modelock = chanserv::get_modelock($chan);
ircd::setmode(main_conf_local, $cn, $modelock) if $modelock;
my $nick = $bot->{NICK};
unless(is_agent_in_chan($nick, $cn)) {
agent_join($bot, $cn);
- my $bot2 = { NICK => $nick, ID => ircd::getUuid($nick), UID=>ircd::getUuid($nick) };
+ my $bot2 = { NICK => $nick, ID => ircd::getAgentUuid($nick), UID=>ircd::getAgentUuid($nick) };
if(!ircd::PREFIXAQ_DISABLE() && $IRCd_capabilities{"FOUNDER"} ne "" && $IRCd_capabilities{"ADMIN"} ne "") {
$botchmode = '+q';
} else {
our $csnick_default = 'ChanServ';
our $csnick = $csnick_default;
-our $csUser = { NICK => $csnick, ID => "123AAAAAC" };
+our $csUser = { NICK => $csnick, ID => ircd::getAgentUuid($csnick) };
our ($cur_lock, $cnt_lock);
);
sub dispatch($$$) {
+ our $csUser = { NICK => $csnick, ID => ircd::getAgentUuid($csnick) };
my ($user, $dstUser, $msg) = @_;
my $src = $user->{NICK};
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
- $user->{AGENT} = $dstUser;
+ $user->{AGENT} = $csUser;
get_user_id ($user);
return if flood_check($user);
return unless (lc $dstUser->{NICK} eq lc $csnick);
}
}
get_user_id ($tuser);
- push @modes, [($de ? '-' : '+').$l[$level], $tuser->{ID}];
+ push @modes, [($de ? '-' : '+').$l[$level], $tuser];
$count++;
}
my @targets = split(/\,/, $target);
foreach $target (@targets) {
- my $tuser = { NICK => $target, UID => ircd::getUuid ($target) };
+ my $tuser = { NICK => $target };
+ get_user_id ($tuser);
my $targetlevel = get_best_acc($tuser, $chan);
if(lc $target eq lc agent($chan) or adminserv::is_service($tuser)) {
if($chan->{AGENT}) {
my $a = $chan->{AGENT};
- $a->{ID} = ircd::getUuid($a->{NICK});
+ $a->{ID} = ircd::getAgentUuid($a->{NICK});
return $a;
}
}
$botserv::get_chan_bot->execute($chan->{CHAN});
my $agentnick = $botserv::get_chan_bot->fetchrow_array;
- my ($agent) = { NICK => $agentnick, ID => ircd::getUuid($agentnick)};
+ my ($agent) = { NICK => $agentnick, ID => ircd::getAgentUuid($agentnick)};
$agent = $csUser unless $agentnick;
return $chan->{AGENT} = $agent;
}
my $seq = $ircline;
my $multi_tradeoff = 2; # could use some synthetic-benchmark tuning
foreach my $user (@$users) {
- print "USER " . Dumper($user);
+ if ($user->{ID} && !$user->{NICK}) {
+ get_user_nick ($user); # INSP
+ }
$user->{__ID} = get_user_id($user);
unless (defined($user->{__ID})) {
# This does happen occasionally. it's a BUG.
sub process_kick($$$$) {
my ($src, $cn, $target, $reason) = @_;
- my $tuser = { NICK => $target, ID => ircd::getUuid($target)};
+ my $tuser = { NICK => $target };
+ get_user_id ($tuser);
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, ID => ircd::getUuid($src) };
+ my $srcUser = { NICK => $src };
+ get_user_id ($srcUser);
#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.
}
}
-sub chan_mode($$$$) {
- my ($user, $cn, $modes, $args) = @_;
+sub chan_mode($$$$@) {
+ my ($user, $cn, $modes, $args, @userargs) = @_;
+ print "CHAN_MODE $user $cn $modes $args\n";
my $src;
if (ref($user) eq "HASH") {
$src = $user->{NICK};
if($mode eq '-') { $sign = 0; next; }
my $arg = shift(@args) if($mode =~ $scm or $mode =~ $ocm);
- my $auser;
- if ($IRCd_capabilities {"INSP"} == 1) { #FIXME this is awful
- $auser = { ID => $arg };
- }
- else {
- $auser = { NICK => $arg };
- }
if($mode =~ /^[vhoaq]$/) {
next if $arg eq '';
next if is_agent($arg);
+ my $auser = shift (@userargs);
+ if (!defined($auser)) {
+ if ($IRCd_capabilities{INSP}) {
+ $auser = {ID=>$arg};
+ get_user_nick ($auser);
+ }
+ else {
+ $auser = { NICK => $arg };
+ get_user_id ($auser);
+ }
+ }
$num = 0 if $mode eq 'v';
$num = 1 if $mode eq 'h';
$num = 2 if $mode eq 'o';
$num = 3 if $mode eq 'a';
$num = 4 if $mode eq 'q';
-
if($opguard and $sign == 1 and
!can_keep_op($user, $chan, $auser, $mode)
) {
push @unargs, ["-" . $mode, $auser];
} else {
my $nid;
- if (!$auser->{ID} && $auser->{NICK}) {
- $nid = get_user_id($auser) or next;
- }
- elsif ($auser->{ID} && !$auser->{NICK}) {
- $nid = decodeUUID($auser->{ID});
- get_user_nick ($auser);
- }
+ $nid = get_user_id($auser) or next;
my ($r, $i);
do {
if($sign) {
our $hsnick_default = 'HostServ';
our $hsnick = $hsnick_default;
-our $hsuser = { NICK => $hsnick, ID => "123AAAAAH" };
+our $hsuser = { NICK => $hsnick, ID => ircd::getAgentUuid($hsnick) };
sub init() {
import SrSv::DB::StubGen (
dbh => $dbh,
}
sub dispatch($$$) {
+ $hsuser = { NICK => $hsnick, ID => ircd::getAgentUuid($hsnick) };
my ($user, $dstUser, $msg) = @_;
my $src = $user->{NICK};
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
- $user->{AGENT} = $dstUser;
+ $user->{AGENT} = $hsuser;
get_user_id ($user);
return if flood_check($user);
return unless (lc $dstUser->{NICK} eq lc $hsnick);
our $msnick_default = 'MemoServ';
our $msnick = $msnick_default;
-our $msuser = { NICK => $msnick, ID => "123AAAAAE" };
+our $msuser = { NICK => $msnick, ID => ircd::getAgentUuid($msnick) };
our (
$send_memo, $send_chan_memo, $get_chan_recipients,
### MEMOSERV COMMANDS ###
sub dispatch($$$) {
+ $msuser = { NICK => $msnick, ID => ircd::getAgentUuid($msnick) };
my ($user, $dstUser, $msg) = @_;
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
- $user -> {AGENT} = $dstUser;
+ $user -> {AGENT} = $msuser;
return unless (lc $dstUser->{NICK} eq lc $msnick);
get_user_id ($user);
return if flood_check($user);
use SrSv::Email;
use SrSv::Insp::UUID;
use SrSv::Util qw( makeSeqList );
-use SrSv::IRCd::Send qw (getRevUuid ircd::getUuid setRevUuid setUuid);
+use SrSv::IRCd::Send qw (getAgentRevUuid ircd::getAgentUuid);
use SrSv::Debug;
use SrSv::NickReg::NickText;
our $nsnick_default = 'NickServ';
our $nsnick = $nsnick_default;
-our $nsuser = { NICK => $nsnick, ID => "123AAAAAB" }; #FIXME - erry
+our $nsuser = { NICK => $nsnick, ID => ircd::getAgentUuid($nsnick) }; #FIXME - erry
our $cur_lock;
our $cnt_lock = 0;
);
sub dispatch($$$) {
- $nsuser = { NICK => $nsnick, ID => "123AAAAAB" }; #FIXME = erry
+ $nsuser = { NICK => $nsnick, ID => ircd::getAgentUuid($nsnick) };
my ($user, $dstUser, $msg) = @_;
return unless (lc $dstUser->{NICK} eq lc $nsnick);
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
- print "NICKSERV: USER " . $user . "\n";
get_user_id ($user);
my $src = $user->{NICK};
- $user->{AGENT} = $dstUser;
+ $user->{AGENT} = $nsuser;
return if flood_check($user);
if(!defined($high_priority_cmds{lc $cmd}) &&
!adminserv::is_svsop($user) &&
foreach my $user (get_nick_users $nick) {
$user->{AGENT} = $nsnick;
- $user->{ID} = ircd::getUuid($nick);
+ get_user_id ($user);
ircd::svssilence($nsuser, $user, map ( { '-'.$_->[0] } @entries) );
#notice($user, "The following SILENCE entries have expired: ".
# join(', ', map ( { $_->[0] } @entries) ));
sub warn_countdown($) {
my ($cookie) = @_;
my ($nick, $rem) = split(/ /, $cookie);
+ $nsuser = { NICK => $nsnick, ID => ircd::getAgentUuid($nsnick) };
my $user = { NICK => $nick, AGENT => $nsuser };
get_user_id($user);
if (is_identified($user, $nick)) {
$nick_checkExists->execute ($id, $time);
my $exists = $nick_checkExists -> fetchrow_array();
my $flags = (synced() ? UF_FINISHED() : 0);
- print "FFFF\n";
unless (defined($exists)) {
$nick_deleteChanUser -> execute ($id);
$nick_deleteNickCh -> execute ($id);
our $osnick_default = 'OperServ';
our $osnick = $osnick_default;
-our $osuser = { NICK => $osnick, ID => "123AAAAAD" };
+our $osuser = { NICK => $osnick, ircd::getAgentUuid($osnick) };
my %newstypes = (
u => 'User',
o => 'Oper'
}
sub dispatch($$$) {
+ $osuser = { NICK => $osnick, ircd::getAgentUuid($osnick) };
my ($user, $dstUser, $msg) = @_;
$msg =~ s/^\s+//;
my @args = split(/\s+/, $msg);
my $cmd = shift @args;
- $user -> {AGENT} = $dstUser;
+ $user -> {AGENT} = $osuser;
my $src = $user -> {NICK};
return unless (lc $dstUser->{NICK} eq lc $osnick);
get_user_id ($user);
}
unless($zline) {
if(!$remove) {
- ircd::kline(ircd::getUuid($osnick), $ident, $host, $expiry, $reason);
+ ircd::kline(($osuser), $ident, $host, $expiry, $reason);
} else {
ircd::unkline($opernick, $ident, $host);
}
projects / irc / SurrealServices / srsv.git / commitdiff
