Changes in / [1753ea0:7b4f3be]


Ignore:
Files:
1 deleted
7 edited

Legend:

Unmodified
Added
Removed

  • perl/lib/BarnOwl.pm

    rf2d71cfa rb120bd3  
    3838use BarnOwl::Completion;
    3939use BarnOwl::Help;
    40 use BarnOwl::AnyEvent;
    41 
    42 unshift @AnyEvent::REGISTRY, [BarnOwl => BarnOwl::AnyEvent::];
    43 require AnyEvent;
    4440
    4541use List::Util qw(max);

  • perl/modules/IRC/lib/BarnOwl/Message/IRC.pm

    r60b49a7 re04b7a1  
    6666sub action {shift->{action}}
    6767sub reason {shift->{reason}}
    68 sub old_nick {shift->{old_nick}};
    6968
    7069# display
    … …  
    8180}
    8281
    83 sub login_extra {
     82sub login_extra { 
    8483    my $self = shift;
    8584    if ($self->action eq "quit") {
    8685        return $self->reason;
    87     } elsif ($self->action eq 'nick change') {
    88         return "was: " . $self->old_nick;
    8986    } else {
    9087        return $self->channel;

  • perl/modules/IRC/lib/BarnOwl/Module/IRC.pm

    r5c6d661 r9620c8d  
    2020use BarnOwl::Module::IRC::Completion;
    2121
    22 use AnyEvent::IRC;
     22use Net::IRC;
    2323use Getopt::Long;
    2424use Encode;
    … …  
    3030# Hash alias -> BarnOwl::Module::IRC::Connection object
    3131our %ircnets;
     32our %channels;
     33our %reconnect;
    3234
    3335sub startup {
    … …  
    6870
    6971    register_commands();
     72    register_handlers();
    7073    BarnOwl::filter(qw{irc type ^IRC$ or ( type ^admin$ and adminheader ^IRC$ )});
    7174}
    … …  
    7376sub shutdown {
    7477    for my $conn (values %ircnets) {
    75         $conn->conn->disconnect('Quitting');
     78        $conn->conn->disconnect();
    7679    }
    7780}
    … …  
    9598        $list .= "\n";
    9699
    97         for my $chan (keys %{$conn->conn->{channel_list}}) {
     100        for my $chan (keys %channels) {
     101            next unless grep $_ eq $conn, @{$channels{$chan}};
    98102            $list .= "  $chan\n";
    99103        }
    … …  
    101105
    102106    return $list;
     107}
     108
     109#sub mainloop_hook {
     110#    return unless defined $irc;
     111#    eval {
     112#        $irc->do_one_loop();
     113#    };
     114#    return;
     115#}
     116
     117sub OwlProcess {
     118    return unless defined $irc;
     119    eval {
     120        $irc->do_one_loop();
     121    };
     122    return;
     123}
     124
     125
     126sub register_handlers {
     127    if(!$irc) {
     128        $irc = Net::IRC->new;
     129        $irc->timeout(0);
     130    }
    103131}
    104132
    … …  
    378406    }
    379407
    380     my $conn = BarnOwl::Module::IRC::Connection->new($alias, $host, $port, {
    381         nick      => $nick,
    382         user      => $username,
    383         real      => $ircname,
    384         password  => $password,
    385         SSL       => $ssl,
    386         timeout   => sub {0}
    387        });
    388     $ircnets{$alias} = $conn;
     408    my $conn = BarnOwl::Module::IRC::Connection->new($irc, $alias,
     409        Nick      => $nick,
     410        Server    => $host,
     411        Port      => $port,
     412        Username  => $username,
     413        Ircname   => $ircname,
     414        Port      => $port,
     415        Password  => $password,
     416        SSL       => $ssl
     417       );
     418
     419    if ($conn->conn->connected) {
     420        $conn->connected("Connected to $alias as $nick");
     421    } else {
     422        die("IRC::Connection->connect failed: $!");
     423    }
     424
    389425    return;
    390426}
    … …  
    393429    my $cmd = shift;
    394430    my $conn = shift;
    395     if ($conn->conn->{socket}) {
    396         $conn->did_quit(1);
    397         $conn->conn->disconnect("Goodbye!");
    398     } elsif ($conn->{reconnect_timer}) {
     431    if ($conn->conn->connected) {
     432        $conn->conn->disconnect;
     433    } elsif ($reconnect{$conn->alias}) {
    399434        BarnOwl::admin_message('IRC',
    400435                               "[" . $conn->alias . "] Reconnect cancelled");
    401436        $conn->cancel_reconnect;
    402         delete $ircnets{$conn->alias};
    403437    }
    404438}
    … …  
    429463    for my $body (@msgs) {
    430464        if ($body =~ /^\/me (.*)/) {
    431             $conn->me($to, Encode::encode('utf-8', $1));
     465            $conn->conn->me($to, Encode::encode('utf-8', $1));
    432466            $body = '* '.$conn->nick.' '.$1;
    433467        } else {
    434             $conn->conn->send_msg('privmsg', $to, Encode::encode('utf-8', $body));
     468            $conn->conn->privmsg($to, Encode::encode('utf-8', $body));
    435469        }
    436470        my $msg = BarnOwl::Message->new(
    … …  
    457491    my $target = shift;
    458492    $target ||= shift;
    459     $conn->conn->send_msg(mode => $target, @_);
     493    $conn->conn->mode($target, @_);
    460494    return;
    461495}
    … …  
    465499    my $conn = shift;
    466500    my $chan = shift or die("Usage: $cmd channel\n");
    467     $conn->conn->send_msg(join => $chan, @_);
     501    $channels{$chan} ||= [];
     502    push @{$channels{$chan}}, $conn;
     503    $conn->conn->join($chan, @_);
    468504    return;
    469505}
    … …  
    473509    my $conn = shift;
    474510    my $chan = shift;
    475     $conn->conn->send_msg(part => $chan);
     511    $channels{$chan} = [grep {$_ ne $conn} @{$channels{$chan} || []}];
     512    $conn->conn->part($chan);
    476513    return;
    477514}
    … …  
    481518    my $conn = shift;
    482519    my $nick = shift or die("Usage: $cmd <new nick>\n");
    483     $conn->conn->send_msg(nick => $nick);
     520    $conn->conn->nick($nick);
    484521    return;
    485522}
    … …  
    490527    my $chan = shift;
    491528    $conn->names_tmp([]);
    492     $conn->conn->send_msg(names => $chan);
     529    $conn->conn->names($chan);
    493530    return;
    494531}
    … …  
    498535    my $conn = shift;
    499536    my $who = shift || die("Usage: $cmd <user>\n");
    500     $conn->conn->send_msg(whois => $who);
     537    $conn->conn->whois($who);
    501538    return;
    502539}
    … …  
    505542    my $cmd = shift;
    506543    my $conn = shift;
    507     $conn->conn->send_msg('motd');
     544    $conn->conn->motd;
    508545    return;
    509546}
    … …  
    523560    my $conn = shift;
    524561    my $who = shift || die("Usage: $cmd <user>\n");
    525     $conn->conn->send_msg(who => $who);
     562    BarnOwl::error("WHO $cmd $conn $who");
     563    $conn->conn->who($who);
    526564    return;
    527565}
    … …  
    531569    my $conn = shift;
    532570    my $type = shift || die("Usage: $cmd <chiklmouy> [server] \n");
    533     $conn->conn->send_msg(stats => $type, @_);
     571    $conn->conn->stats($type, @_);
    534572    return;
    535573}
    … …  
    539577    my $conn = shift;
    540578    my $chan = shift;
    541     $conn->conn->send_msg(topic => $chan, @_ ? join(" ", @_) : undef);
     579    $conn->conn->topic($chan, @_ ? join(" ", @_) : undef);
    542580    return;
    543581}
    … …  
    546584    my $cmd = shift;
    547585    my $conn = shift;
    548     $conn->conn->send_msg(@_);
     586    $conn->conn->sl(join(" ", @_));
    549587    return;
    550588}
    … …  
    553591########################### Utilities/Helpers ##################################
    554592################################################################################
    555 
    556 sub find_channel {
    557     my $channel = shift;
    558     my @found;
    559     for my $conn (values %ircnets) {
    560         if($conn->conn->{channel_list}{lc $channel}) {
    561             push @found, $conn;
    562         }
    563     }
    564     return $found[0] if(scalar @found == 1);
    565 }
    566593
    567594sub mk_irc_command {
    … …  
    587614            $channel = $ARGV[0];
    588615            if(defined($channel) && $channel =~ /^#/) {
    589                 if(my $c = find_channel($channel)) {
     616                if($channels{$channel} && @{$channels{$channel}} == 1) {
    590617                    shift @ARGV;
    591                     $conn ||= $c;
     618                    $conn = $channels{$channel}[0] unless $conn;
    592619                }
    593620            } elsif ($m && $m->type eq 'IRC' && !$m->is_private) {
    … …  
    627654    my $allow_disconnected = shift;
    628655
    629     my $conn = $ircnets{$key};
    630     die("No such ircnet: $key\n") unless $conn;
    631     if ($conn->conn->{registered} || $allow_disconnected) {
    632         return $conn;
    633     }
    634     die("[@{[$conn->alias]}] Not currently connected.");
     656    return $ircnets{$key} if exists $ircnets{$key};
     657    return $reconnect{$key} if $allow_disconnected && exists $reconnect{$key};
     658    die("No such ircnet: $key\n")
    635659}
    636660

  • perl/modules/IRC/lib/BarnOwl/Module/IRC/Completion.pm

    rdace02a r955a36e  
    1111sub complete_networks { keys %BarnOwl::Module::IRC::ircnets }
    1212sub complete_dests    { keys %users, complete_channels() }
    13 sub complete_channels {
    14     my %channels;
    15     for my $conn (values %BarnOwl::Module::IRC::ircnets) {
    16         for my $chan (keys %{$conn->conn->{channel_list}}) {
    17             $channels{$chan} = 1;
    18         }
    19     }
    20     return keys %channels;
    21 }
     13sub complete_channels { keys %BarnOwl::Module::IRC::channels }
    2214sub complete_nicks    { keys %users }
    2315sub complete_servers  { keys %servers }

  • perl/modules/IRC/lib/BarnOwl/Module/IRC/Connection.pm

    r5c6d661 rfb6e8e3  
    1616=cut
    1717
    18 use AnyEvent::IRC::Client;
    19 use AnyEvent::IRC::Util qw(split_prefix prefix_nick encode_ctcp);
    20 
    21 use base qw(Class::Accessor);
    22 use Exporter 'import';
    23 __PACKAGE__->mk_accessors(qw(conn alias motd names_tmp whois_tmp
    24                              server autoconnect_channels
    25                              connect_args backoff did_quit));
    26 our @EXPORT_OK = qw(is_private);
     18use Net::IRC::Connection;
     19
     20use base qw(Class::Accessor Exporter);
     21__PACKAGE__->mk_accessors(qw(conn alias channels motd names_tmp whois_tmp));
     22our @EXPORT_OK = qw(&is_private);
    2723
    2824use BarnOwl;
    2925use Scalar::Util qw(weaken);
    3026
     27BEGIN {
     28    no strict 'refs';
     29    my @delegate = qw(nick server);
     30    for my $meth (@delegate) {
     31        *{"BarnOwl::Module::IRC::Connection::$meth"} = sub {
     32            shift->conn->$meth(@_);
     33        }
     34    }
     35};
     36
    3137sub new {
    3238    my $class = shift;
     39    my $irc = shift;
    3340    my $alias = shift;
    34     my $host  = shift;
    35     my $port  = shift;
    36     my $args  = shift;
    37     my $nick = $args->{nick};
    38     my $conn = AnyEvent::IRC::Client->new();
     41    my %args = (@_);
     42    my $conn = Net::IRC::Connection->new($irc, %args);
    3943    my $self = bless({}, $class);
    4044    $self->conn($conn);
    41     $self->autoconnect_channels([]);
    4245    $self->alias($alias);
    43     $self->server($host);
     46    $self->channels([]);
    4447    $self->motd("");
    4548    $self->names_tmp(0);
    46     $self->backoff(0);
    4749    $self->whois_tmp("");
    48     $self->did_quit(0);
    49 
    50     if(delete $args->{SSL}) {
    51         $conn->enable_ssl;
    52     }
    53     $self->connect_args([$host, $port, $args]);
    54     $conn->connect($host, $port, $args);
    55     $conn->{heap}{parent} = $self;
    56     weaken($conn->{heap}{parent});
    57 
    58     sub on {
    59         my $meth = "on_" . shift;
    60         return sub {
    61             my $conn = shift;
    62             return unless $conn->{heap}{parent};
    63             $conn->{heap}{parent}->$meth(@_);
    64         }
    65     }
    66 
    67     # $self->conn->add_default_handler(sub { shift; $self->on_event(@_) });
    68     $self->conn->reg_cb(registered => on("connect"),
    69                         connfail   => sub { BarnOwl::error("Connection to $host failed!") },
    70                         disconnect => on("disconnect"),
    71                         publicmsg  => on("msg"),
    72                         privatemsg => on("msg"),
    73                         irc_error  => on("error"));
    74     for my $m (qw(welcome yourhost created
    75                   luserclient luserop luserchannels luserme
    76                   error)) {
    77         $self->conn->reg_cb("irc_$m" => on("admin_msg"));
    78     }
    79     $self->conn->reg_cb(irc_375       => on("motdstart"),
    80                         irc_372       => on("motd"),
    81                         irc_376       => on("endofmotd"),
    82                         irc_join      => on("join"),
    83                         irc_part      => on("part"),
    84                         irc_quit      => on("quit"),
    85                         irc_433       => on("nickinuse"),
    86                         channel_topic => on("topic"),
    87                         irc_333       => on("topicinfo"),
    88                         irc_353       => on("namreply"),
    89                         irc_366       => on("endofnames"),
    90                         irc_311       => on("whois"),
    91                         irc_312       => on("whois"),
    92                         irc_319       => on("whois"),
    93                         irc_320       => on("whois"),
    94                         irc_318       => on("endofwhois"),
    95                         irc_mode      => on("mode"),
    96                         irc_401       => on("nosuch"),
    97                         irc_402       => on("nosuch"),
    98                         irc_403       => on("nosuch"),
    99                         nick_change   => on("nick"),
    100                         ctcp_action   => on("ctcp_action"),
    101                         'irc_*' => sub { BarnOwl::debug("IRC: " . $_[1]->{command} . " " .
    102                                                         join(" ", @{$_[1]->{params}})) });
     50
     51    $self->conn->add_default_handler(sub { shift; $self->on_event(@_) });
     52    $self->conn->add_handler(['msg', 'notice', 'public', 'caction'],
     53            sub { shift; $self->on_msg(@_) });
     54    $self->conn->add_handler(['welcome', 'yourhost', 'created',
     55                              'luserclient', 'luserop', 'luserchannels', 'luserme',
     56                              'error'],
     57            sub { shift; $self->on_admin_msg(@_) });
     58    $self->conn->add_handler(['myinfo', 'map', 'n_local', 'n_global',
     59            'luserconns'],
     60            sub { });
     61    $self->conn->add_handler(motdstart => sub { shift; $self->on_motdstart(@_) });
     62    $self->conn->add_handler(motd      => sub { shift; $self->on_motd(@_) });
     63    $self->conn->add_handler(endofmotd => sub { shift; $self->on_endofmotd(@_) });
     64    $self->conn->add_handler(join      => sub { shift; $self->on_join(@_) });
     65    $self->conn->add_handler(part      => sub { shift; $self->on_part(@_) });
     66    $self->conn->add_handler(quit      => sub { shift; $self->on_quit(@_) });
     67    $self->conn->add_handler(disconnect => sub { shift; $self->on_disconnect(@_) });
     68    $self->conn->add_handler(nicknameinuse => sub { shift; $self->on_nickinuse(@_) });
     69    $self->conn->add_handler(cping     => sub { shift; $self->on_ping(@_) });
     70    $self->conn->add_handler(topic     => sub { shift; $self->on_topic(@_) });
     71    $self->conn->add_handler(topicinfo => sub { shift; $self->on_topicinfo(@_) });
     72    $self->conn->add_handler(namreply  => sub { shift; $self->on_namreply(@_) });
     73    $self->conn->add_handler(endofnames=> sub { shift; $self->on_endofnames(@_) });
     74    $self->conn->add_handler(endofwhois=> sub { shift; $self->on_endofwhois(@_) });
     75    $self->conn->add_handler(mode      => sub { shift; $self->on_mode(@_) });
     76    $self->conn->add_handler(nosuchchannel => sub { shift; $self->on_nosuchchannel(@_) });
    10377
    10478    return $self;
    105 }
    106 
    107 sub nick {
    108     my $self = shift;
    109     return $self->conn->nick;
    11079}
    11180
    … …  
    11483    my $self = shift;
    11584    return $self->conn->socket;
    116 }
    117 
    118 sub me {
    119     my ($self, $to, $msg) = @_;
    120     $self->conn->send_msg('privmsg', $to,
    121                           encode_ctcp(['ACTION', $msg]))
    12285}
    12386
    … …  
    12992    my $self = shift;
    13093    my $evt = shift;
    131     my %args = (
     94    return BarnOwl::Message->new(
    13295        type        => 'IRC',
    13396        server      => $self->server,
    13497        network     => $self->alias,
     98        sender      => $evt->nick,
     99        hostname    => $evt->host,
     100        from        => $evt->from,
    135101        @_
    136102       );
    137     if ($evt) {
    138         my ($nick, $user, $host) = split_prefix($evt);
    139         $args{sender}   ||= $nick;
    140         $args{hostname} ||= $host if defined($host);
    141         $args{from}     ||= $evt->{prefix};
    142         $args{params}   ||= join(' ', @{$evt->{params}})
    143     }
    144     return BarnOwl::Message->new(%args);
    145103}
    146104
    147105sub on_msg {
    148     my ($self, $recipient, $evt) = @_;
    149     my $body = strip_irc_formatting($evt->{params}->[1]);
    150     $self->handle_message($recipient, $evt, $body);
    151 }
    152 
    153 sub on_ctcp_action {
    154     my ($self, $src, $target, $msg) = @_;
    155     my $body = strip_irc_formatting($msg);
    156     my $evt = {
    157         params => [$src],
    158         type   => 'privmsg',
    159         prefix => $src
    160        };
    161     $self->handle_message($target, $evt, "* $body");
    162 }
    163 
    164 sub handle_message {
    165     my ($self, $recipient, $evt, $body) = @_;
     106    my ($self, $evt) = @_;
     107    my ($recipient) = $evt->to;
     108    my $body = strip_irc_formatting([$evt->args]->[0]);
     109    my $nick = $self->nick;
     110    $body = '* '.$evt->nick.' '.$body if $evt->type eq 'caction';
    166111    my $msg = $self->new_message($evt,
    167112        direction   => 'in',
    168113        recipient   => $recipient,
    169         body        => $body,
    170         ($evt->{command}||'') eq 'notice' ?
     114        body => $body,
     115        $evt->type eq 'notice' ?
    171116          (notice     => 'true') : (),
    172117        is_private($recipient) ?
    173118          (private  => 'true') : (channel => $recipient),
    174119        replycmd    => BarnOwl::quote('irc-msg', '-a', $self->alias,
    175            (is_private($recipient) ? prefix_nick($evt) : $recipient)),
    176         replysendercmd => BarnOwl::quote('irc-msg', '-a', $self->alias, prefix_nick($evt)),
     120          (is_private($recipient) ? $evt->nick : $recipient)),
     121        replysendercmd => BarnOwl::quote('irc-msg', '-a', $self->alias, $evt->nick),
    177122       );
    178123
    … …  
    180125}
    181126
     127sub on_ping {
     128    my ($self, $evt) = @_;
     129    $self->conn->ctcp_reply($evt->nick, join (' ', ($evt->args)));
     130}
    182131
    183132sub on_admin_msg {
    184133    my ($self, $evt) = @_;
    185     return if BarnOwl::Module::IRC->skip_msg($evt->{command});
    186     BarnOwl::admin_message("IRC",
    187             BarnOwl::Style::boldify('IRC ' . $evt->{command} . ' message from '
     134    return if BarnOwl::Module::IRC->skip_msg($evt->type);
     135    BarnOwl::admin_message("IRC",
     136            BarnOwl::Style::boldify('IRC ' . $evt->type . ' message from '
    188137                . $self->alias) . "\n"
    189             . strip_irc_formatting(join ' ', cdr($evt->{params})));
     138            . strip_irc_formatting(join ' ', cdr($evt->args)));
    190139}
    191140
    192141sub on_motdstart {
    193142    my ($self, $evt) = @_;
    194     $self->motd(join "\n", cdr(@{$evt->{params}}));
     143    $self->motd(join "\n", cdr($evt->args));
    195144}
    196145
    197146sub on_motd {
    198147    my ($self, $evt) = @_;
    199     $self->motd(join "\n", $self->motd, cdr(@{$evt->{params}}));
     148    $self->motd(join "\n", $self->motd, cdr($evt->args));
    200149}
    201150
    202151sub on_endofmotd {
    203152    my ($self, $evt) = @_;
    204     $self->motd(join "\n", $self->motd, cdr(@{$evt->{params}}));
     153    $self->motd(join "\n", $self->motd, cdr($evt->args));
    205154    BarnOwl::admin_message("IRC",
    206155            BarnOwl::Style::boldify('MOTD for ' . $self->alias) . "\n"
    … …  
    210159sub on_join {
    211160    my ($self, $evt) = @_;
    212     my $chan = $evt->{params}[0];
    213161    my $msg = $self->new_message($evt,
    214162        loginout   => 'login',
    215163        action     => 'join',
    216         channel    => $chan,
    217         replycmd   => BarnOwl::quote('irc-msg', '-a', $self->alias, $chan),
    218         replysendercmd => BarnOwl::quote('irc-msg', '-a', $self->alias, prefix_nick($evt)),
     164        channel    => $evt->to,
     165        replycmd   => BarnOwl::quote('irc-msg', '-a', $self->alias, $evt->to),
     166        replysendercmd => BarnOwl::quote('irc-msg', '-a', $self->alias, $evt->nick),
    219167        );
    220168    BarnOwl::queue_message($msg);
     169    push @{$self->channels}, $evt->to;
    221170}
    222171
    223172sub on_part {
    224173    my ($self, $evt) = @_;
    225     my $chan = $evt->{params}[0];
    226174    my $msg = $self->new_message($evt,
    227175        loginout   => 'logout',
    228176        action     => 'part',
    229         channel    => $chan,
    230         replycmd   => BarnOwl::quote('irc-msg', '-a', $self->alias, $chan),
    231         replysendercmd => BarnOwl::quote('irc-msg', '-a', $self->alias, prefix_nick($evt)),
     177        channel    => $evt->to,
     178        replycmd   => BarnOwl::quote('irc-msg', '-a', $self->alias, $evt->to),
     179        replysendercmd => BarnOwl::quote('irc-msg', '-a', $self->alias, $evt->nick),
    232180        );
    233181    BarnOwl::queue_message($msg);
     182    $self->channels([ grep {$_ ne $evt->to} @{$self->channels}]);
    234183}
    235184
    … …  
    239188        loginout   => 'logout',
    240189        action     => 'quit',
    241         from       => $evt->{prefix},
    242         reason     => $evt->{params}->[0],
    243         replycmd   => BarnOwl::quote('irc-msg', '-a', $self->alias, prefix_nick($evt)),
    244         replysendercmd => BarnOwl::quote('irc-msg', '-a', $self->alias, prefix_nick($evt)),
     190        from       => $evt->to,
     191        reason     => [$evt->args]->[0],
     192        replycmd   => BarnOwl::quote('irc-msg', '-a', $self->alias, $evt->nick),
     193        replysendercmd => BarnOwl::quote('irc-msg', '-a', $self->alias, $evt->nick),
    245194        );
    246195    BarnOwl::queue_message($msg);
    … …  
    249198sub disconnect {
    250199    my $self = shift;
    251     $self->conn->disconnect;
     200    delete $BarnOwl::Module::IRC::ircnets{$self->alias};
     201    for my $k (keys %BarnOwl::Module::IRC::channels) {
     202        my @conns = grep {$_ ne $self} @{$BarnOwl::Module::IRC::channels{$k}};
     203        if(@conns) {
     204            $BarnOwl::Module::IRC::channels{$k} = \@conns;
     205        } else {
     206            delete $BarnOwl::Module::IRC::channels{$k};
     207        }
     208    }
     209    BarnOwl::remove_io_dispatch($self->{FD});
     210    $self->motd("");
    252211}
    253212
    254213sub on_disconnect {
    255     my ($self, $why) = @_;
     214    my ($self, $evt) = @_;
     215    $self->disconnect;
    256216    BarnOwl::admin_message('IRC',
    257                            "[" . $self->alias . "] Disconnected from server: $why");
    258     $self->motd("");
    259     if (!$self->did_quit) {
     217                           "[" . $self->alias . "] Disconnected from server");
     218    if ($evt->format and $evt->format eq "error") {
    260219        $self->schedule_reconnect;
    261220    } else {
    262         delete $BarnOwl::Module::IRC::ircnets{$self->alias};
    263     }
    264 }
    265 
    266 sub on_error {
    267     my ($self, $evt) = @_;
    268     BarnOwl::admin_message('IRC',
     221        $self->channels([]);
     222    }
     223}
     224
     225sub on_nickinuse {
     226    my ($self, $evt) = @_;
     227    BarnOwl::admin_message("IRC",
    269228                           "[" . $self->alias . "] " .
    270                            "Error: " . join(" ", @{$evt->{params}}));
    271 }
    272 
    273 sub on_nickinuse {
    274     my ($self, $evt) = @_;
    275     BarnOwl::admin_message("IRC",
    276                            "[" . $self->alias . "] " .
    277                            $evt->{params}->[1] . ": Nick already in use");
    278 }
    279 
    280 sub on_nick {
    281     my ($self, $old_nick, $new_nick, $is_me) = @_;
    282     if ($is_me) {
     229                           [$evt->args]->[1] . ": Nick already in use");
     230    $self->disconnect unless $self->motd;
     231}
     232
     233sub on_topic {
     234    my ($self, $evt) = @_;
     235    my @args = $evt->args;
     236    if (scalar @args > 1) {
    283237        BarnOwl::admin_message("IRC",
    284                                "[" . $self->alias . "] " .
    285                                "You are now known as $new_nick");
    286     } else {
    287         my $msg = $self->new_message('',
    288             loginout   => 'login',
    289             action     => 'nick change',
    290             from       => $new_nick,
    291             sender     => $new_nick,
    292             replycmd   => BarnOwl::quote('irc-msg', '-a', $self->alias,
    293                                          $new_nick),
    294             replysendercmd => BarnOwl::quote('irc-msg', '-a', $self->alias,
    295                                              $new_nick),
    296             old_nick   => $old_nick);
    297         BarnOwl::queue_message($msg);
    298     }
    299 }
    300 
    301 sub on_topic {
    302     my ($self, $channel, $topic, $who) = @_;
    303     if ($channel) {
    304         BarnOwl::admin_message("IRC",
    305                 "Topic for $channel on " . $self->alias . " is $topic");
     238                "Topic for $args[1] on " . $self->alias . " is $args[2]");
    306239    } else {
    307240        BarnOwl::admin_message("IRC",
    308                 "Topic changed to $channel");
     241                "Topic changed to $args[0]");
    309242    }
    310243}
    … …  
    312245sub on_topicinfo {
    313246    my ($self, $evt) = @_;
    314     my @args = @{$evt->{params}};
     247    my @args = $evt->args;
    315248    BarnOwl::admin_message("IRC",
    316249        "Topic for $args[1] set by $args[2] at " . localtime($args[3]));
    … …  
    324257    my ($self, $evt) = @_;
    325258    return unless $self->names_tmp;
    326     $self->names_tmp([@{$self->names_tmp},
    327                       map {prefix_nick($_)} split(' ', $evt->{params}[3])]);
     259    $self->names_tmp([@{$self->names_tmp}, split(' ', [$evt->args]->[3])]);
    328260}
    329261
    … …  
    340272    my ($self, $evt) = @_;
    341273    return unless $self->names_tmp;
    342     my $names = BarnOwl::Style::boldify("Members of " . $evt->{params}->[1] . ":\n");
     274    my $names = BarnOwl::Style::boldify("Members of " . [$evt->args]->[1] . ":\n");
    343275    for my $name (sort {cmp_user($a, $b)} @{$self->names_tmp}) {
    344276        $names .= "  $name\n";
    … …  
    350282sub on_whois {
    351283    my ($self, $evt) = @_;
    352     my %names = (
    353         311 => 'user',
    354         312 => 'server',
    355         319 => 'channels',
    356         330 => 'whowas',
    357        );
    358284    $self->whois_tmp(
    359         $self->whois_tmp . "\n" . $names{$evt->{command}} . ":\n  " .
    360         join("\n  ", cdr(cdr(@{$evt->{params}}))) . "\n"
    361        );
     285      $self->whois_tmp . "\n" . $evt->type . ":\n  " .
     286      join("\n  ", cdr(cdr($evt->args))) . "\n"
     287    );
    362288}
    363289
    … …  
    365291    my ($self, $evt) = @_;
    366292    BarnOwl::popless_ztext(
    367         BarnOwl::Style::boldify("/whois for " . $evt->{params}->[1] . ":\n") .
     293        BarnOwl::Style::boldify("/whois for " . [$evt->args]->[1] . ":\n") .
    368294        $self->whois_tmp
    369295    );
    … …  
    374300    my ($self, $evt) = @_;
    375301    BarnOwl::admin_message("IRC",
    376                            "[" . $self->alias . "] User " . (prefix_nick($evt)) . + " set mode " .
    377                            join(" ", cdr(@{$evt->{params}})) . " on " . $evt->{params}->[0]
     302                           "[" . $self->alias . "] User " . ($evt->nick) . + " set mode " .
     303                           join(" ", $evt->args) . "on " . $evt->to->[0]
    378304                          );
    379305}
    380306
    381 sub on_nosuch {
    382     my ($self, $evt) = @_;
    383     my %things = (401 => 'nick', 402 => 'server', 403 => 'channel');
     307sub on_nosuchchannel {
     308    my ($self, $evt) = @_;
    384309    BarnOwl::admin_message("IRC",
    385310                           "[" . $self->alias . "] " .
    386                            "No such @{[$things{$evt->{command}}]}: @{[$evt->{params}->[1]]}")
     311                           "No such channel: " . [$evt->args]->[1])
    387312}
    388313
    … …  
    398323sub schedule_reconnect {
    399324    my $self = shift;
    400     my $interval = $self->backoff;
    401     if ($interval) {
    402         $interval *= 2;
    403         $interval = 60*5 if $interval > 60*5;
    404     } else {
    405         $interval = 5;
    406     }
    407     $self->backoff($interval);
    408 
     325    my $interval = shift || 5;
     326    delete $BarnOwl::Module::IRC::ircnets{$self->alias};
     327    $BarnOwl::Module::IRC::reconnect{$self->alias} = $self;
    409328    my $weak = $self;
    410329    weaken($weak);
    … …  
    424343sub cancel_reconnect {
    425344    my $self = shift;
    426 
     345    delete $BarnOwl::Module::IRC::reconnect{$self->alias};
    427346    if (defined $self->{reconnect_timer}) {
    428347        $self->{reconnect_timer}->stop;
    429348    }
    430349    delete $self->{reconnect_timer};
    431 }
    432 
    433 sub on_connect {
    434     my $self = shift;
    435     $self->connected("Connected to " . $self->alias . " as " . $self->nick)
    436350}
    437351
    … …  
    441355    BarnOwl::admin_message("IRC", $msg);
    442356    $self->cancel_reconnect;
    443     if ($self->autoconnect_channels) {
    444         for my $c (@{$self->autoconnect_channels}) {
    445             $self->conn->send_msg(join => $c);
    446         }
    447         $self->autoconnect_channels([]);
    448     }
    449     $self->conn->enable_ping(60, sub {
    450                                  $self->on_disconnect("Connection timed out.");
    451                                  $self->schedule_reconnect;
    452                              });
    453     $self->backoff(0);
     357    $BarnOwl::Module::IRC::ircnets{$self->alias} = $self;
     358    my $fd = $self->getSocket()->fileno();
     359    BarnOwl::add_io_dispatch($fd, 'r', \&BarnOwl::Module::IRC::OwlProcess);
     360    $self->{FD} = $fd;
    454361}
    455362
    456363sub reconnect {
    457364    my $self = shift;
    458     my $backoff = $self->backoff;
    459 
    460     $self->autoconnect_channels([keys(%{$self->{channel_list}})]);
    461     $self->conn->connect(@{$self->connect_args});
     365    my $backoff = shift;
     366
     367    $self->conn->connect;
     368    if ($self->conn->connected) {
     369        $self->connected("Reconnected to ".$self->alias);
     370        my @channels = @{$self->channels};
     371        $self->channels([]);
     372        $self->conn->join($_) for @channels;
     373        return;
     374    }
     375
     376    $backoff *= 2;
     377    $backoff = 60*5 if $backoff > 60*5;
     378    $self->schedule_reconnect( $backoff );
    462379}
    463380

  • perlconfig.c

    rf2d71cfa rf25df21  
    403403  }
    404404
    405   sv_setpv(get_sv("BarnOwl::VERSION", TRUE), OWL_VERSION_STRING);
    406 
    407405  /* Add the system lib path to @INC */
    408406  inc = get_av("INC", 0);

  • select.c

    rfb96152 rd4927a7  
    11#include "owl.h"
    2 #include <sys/stat.h>
    32
    43static int dispatch_active = 0;
    … …  
    354353  owl_select_psa_gc();
    355354  return ret;
    356 }
    357 
    358 static void owl_select_prune_bad_fds(void) {
    359   owl_list *dl = owl_global_get_io_dispatch_list(&g);
    360   int len, i;
    361   struct stat st;
    362   owl_io_dispatch *d;
    363 
    364   len = owl_list_get_size(dl);
    365   for (i = 0; i < len; i++) {
    366     d = owl_list_get_element(dl, i);
    367     if (fstat(d->fd, &st) < 0 && errno == EBADF) {
    368       owl_function_debugmsg("Pruning defunct dispatch on fd %d.", d->fd);
    369       d->needs_gc = 1;
    370     }
    371   }
    372   owl_select_io_dispatch_gc();
    373355}
    374356
    … …  
    434416  ret = pselect(max_fd+1, &r, &w, &e, &timeout, &mask);
    435417
    436   if(ret < 0) {
    437     if (errno == EINTR) {
    438       if(owl_global_is_interrupted(&g)) {
    439         owl_select_handle_intr(NULL);
    440       }
    441     } else if (errno == EBADF) {
    442       /* Perl must have closed an fd on us without removing it first. */
    443       owl_select_prune_bad_fds();
     418  if(ret < 0 && errno == EINTR) {
     419    if(owl_global_is_interrupted(&g)) {
     420      owl_select_handle_intr(NULL);
    444421    }
    445422    sigprocmask(SIG_SETMASK, &mask, NULL);
Note: See TracChangeset for help on using the changeset viewer.