Commands.pm

# -*- indent-tabs-mode: nil; -*-
# vim:ft=perl:et:sw=4
# $Id$

# Sympa - SYsteme de Multi-Postage Automatique
#
# Copyright (c) 1997, 1998, 1999 Institut Pasteur & Christophe Wolfhugel
# Copyright (c) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
# 2006, 2007, 2008, 2009, 2010, 2011 Comite Reseau des Universites
# Copyright (c) 2011, 2012, 2013, 2014 GIP RENATER
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

package Sympa::Commands;

use strict;
use warnings;
use Mail::Address;
use MIME::Parser;

use Sympa::Archive;
use Conf;
use Sympa::Language;
use Sympa::List;
use Log;
use Sympa::Message;
use Sympa::Regexps;
use Sympa::Report;
use Sympa::Robot;
use Sympa::Scenario;
use tools;
use Sympa::Tools::Data;
use Sympa::Tools::File;
use Sympa::Tools::Password;
use Sympa::User;

my %comms = (
    'add'                               => 'add',
    'con|confirm'                       => 'confirm',
    'del|delete'                        => 'del',
    'dis|distribute'                    => 'distribute',
    'get'                               => 'getfile',
    'hel|help|sos'                      => 'help',
    'inf|info'                          => 'info',
    'inv|invite'                        => 'invite',
    'ind|index'                         => 'index',
    'las|last'                          => 'last',
    'lis|lists?'                        => 'lists',
    'mod|modindex|modind'               => 'modindex',
    'qui|quit|end|stop|-'               => 'finished',
    'rej|reject'                        => 'reject',
    'rem|remind'                        => 'remind',
    'rev|review|who'                    => 'review',
    'set'                               => 'set',
    'sub|subscribe'                     => 'subscribe',
    'sig|signoff|uns|unsub|unsubscribe' => 'signoff',
    'sta|stats'                         => 'stats',
    'ver|verify'                        => 'verify',
    'whi|which|status'                  => 'which'
);

my $language = Sympa::Language->instance;

# command sender
my $sender = '';
# time of the process command
my $time_command;
## my $msg_file;
# command line to process
my $cmd_line;
# key authentification if 'auth' is present in the command line
my $auth;
# boolean says if quiet is in the cmd line
my $quiet;

##############################################
#  parse
##############################################
# Parses the command and calls the adequate
# subroutine with the arguments to the command.
#
# IN :-$sender (+): the command sender
#     -$robot (+): robot
#     -$i (+): command line
#     -$sign_mod : 'smime'| 'dkim' -
#
# OUT : $status |'unknown_cmd'
#
##############################################
sub parse {
    Log::do_log('debug2', '(%s, %s, %s, %s, %s)', @_);
    $sender = lc(shift);    #FIXME: eliminate module-global variable.
    my $robot    = shift;
    my $i        = shift;
    my $sign_mod = shift;
    my $message  = shift;

    my $j;
    $cmd_line = '';

    Log::do_log('notice', "Parsing: %s", $i);

    ## allow reply usage for auth process based on user mail replies
    if ($i =~ /auth\s+(\S+)\s+(.+)$/io) {
        $auth = $1;
        $i    = $2;
    } else {
        $auth = '';
    }

    if ($i =~ /^quiet\s+(.+)$/i) {
        $i     = $1;
        $quiet = 1;
    } else {
        $quiet = 0;
    }

    foreach $j (keys %comms) {
        if ($i =~ /^($j)(\s+(.+))?\s*$/i) {
            no strict 'refs';

            $time_command = time;
            my $args = $3;
            if ($args and length $args) {
                $args =~ s/^\s*//;
                $args =~ s/\s*$//;
            }

            my $status;
            $cmd_line = $i;
            $status = &{$comms{$j}}($args, $robot, $sign_mod, $message);

            return $status;
        }
    }

    ## Unknown command
    return 'unknown_cmd';
}

##############################################
#  finished
##############################################
#  Do not process what is after this line
#
# IN : -
#
# OUT : 1
#
################################################
sub finished {
    Log::do_log('debug2', '');

    Sympa::Report::notice_report_cmd('finished', {}, $cmd_line);
    return 1;
}

##############################################
#  help
##############################################
#  Sends the help file for the software
#
# IN : - ?
#      -$robot (+): robot
#
# OUT : 1 | undef
#
##############################################
sub help {
    Log::do_log('debug2', '(%s, %s)', @_);
    shift;
    my $robot = shift;

    my $data = {};

    my @owner  = Sympa::List::get_which($sender, $robot, 'owner');
    my @editor = Sympa::List::get_which($sender, $robot, 'editor');

    $data->{'is_owner'}  = 1 if @owner;
    $data->{'is_editor'} = 1 if @editor;
    $data->{'user'}      = Sympa::User->new($sender);
    $language->set_lang($data->{'user'}->lang)
        if $data->{'user'}->lang;
    $data->{'subject'}        = $language->gettext("User guide");
    $data->{'auto_submitted'} = 'auto-replied';

    unless (tools::send_file($robot, "helpfile", $sender, $data)) {
        Log::do_log('notice', 'Unable to send template "helpfile" to %s',
            $sender);
        Sympa::Report::reject_report_cmd('intern_quiet', '', {}, $cmd_line,
            $sender, $robot);
    }

    Log::do_log('info', 'HELP from %s accepted (%d seconds)',
        $sender, time - $time_command);

    return 1;
}

#####################################################
#  lists
#####################################################
#  Sends back the list of public lists on this node.
#
# IN : - ?
#      -$robot (+): robot
#
# OUT : 1  | undef
#
#######################################################
sub lists {
    shift;
    my $robot    = shift;
    my $sign_mod = shift;
    my $message  = shift;

    my $sympa = Conf::get_robot_conf($robot, 'sympa');
    my $host  = Conf::get_robot_conf($robot, 'host');

    Log::do_log('debug', 'For robot %s, sign_mod %, message %s',
        $robot, $sign_mod, $message);

    my $data  = {};
    my $lists = {};

    my $all_lists = Sympa::List::get_lists($robot);

    foreach my $list (@$all_lists) {
        my $l = $list->{'name'};

        my $result = Sympa::Scenario::request_action(
            $list, 'visibility', 'smtp',    # 'smtp' isn't it a bug ?
            {   'sender'  => $sender,
                'message' => $message,
            }
        );

        my $action;
        $action = $result->{'action'} if (ref($result) eq 'HASH');

        unless (defined $action) {
            my $error =
                "Unable to evaluate scenario 'visibility' for list $l";
            tools::send_notify_to_listmaster(
                $list,
                'intern_error',
                {   'error'          => $error,
                    'who'            => $sender,
                    'cmd'            => $cmd_line,
                    'action'         => 'Command process',
                    'auto_submitted' => 'auto-replied'
                }
            );
            next;
        }

        if ($action eq 'do_it') {
            $lists->{$l}{'subject'} = $list->{'admin'}{'subject'};
            $lists->{$l}{'host'}    = $list->{'admin'}{'host'};
        }
    }

    $data->{'lists'}          = $lists;
    $data->{'auto_submitted'} = 'auto-replied';

    unless (tools::send_file($robot, 'lists', $sender, $data)) {
        Log::do_log('notice', 'Unable to send template "lists" to %s',
            $sender);
        Sympa::Report::reject_report_cmd('intern_quiet', '', {}, $cmd_line,
            $sender, $robot);
    }

    Log::do_log('info', 'LISTS from %s accepted (%d seconds)',
        $sender, time - $time_command);

    return 1;
}

#####################################################
#  stats
#####################################################
#  Sends the statistics about a list using template
#  'stats_report'
#
# IN : -$listname (+): list name
#      -$robot (+): robot
#      -$sign_mod : 'smime' | 'dkim'|  -
#
# OUT : 'unknown_list'|'not_allowed'|1  | undef
#
#######################################################
sub stats {
    my $listname = shift;
    my $robot    = shift;
    my $sign_mod = shift;
    my $message  = shift;

    Log::do_log('debug', '(%s, %s, %s, %s)',
        $listname, $robot, $sign_mod, $message);

    my $list = Sympa::List->new($listname, $robot);
    unless ($list) {
        Sympa::Report::reject_report_cmd('user', 'no_existing_list',
            {'listname' => $listname}, $cmd_line);
        Log::do_log('info',
            'STATS %s from %s refused, unknown list for robot %s',
            $listname, $sender, $robot);
        return 'unknown_list';
    }

    my $auth_method = get_auth_method(
        'stats', $sender,
        {   'type' => 'auth_failed',
            'data' => {},
            'msg'  => "STATS $listname from $sender"
        },
        $sign_mod,
        $list
    );
    return 'wrong_auth'
        unless (defined $auth_method);

    my $result = Sympa::Scenario::request_action(
        $list, 'review',
        $auth_method,
        {   'sender'  => $sender,
            'message' => $message,
        }
    );
    my $action;
    $action = $result->{'action'} if (ref($result) eq 'HASH');

    unless (defined $action) {
        my $error = "Unable to evaluate scenario 'review' for list $listname";
        Sympa::Report::reject_report_cmd('intern', $error,
            {'listname' => $listname, 'list' => $list},
            $cmd_line, $sender, $robot);
        return undef;
    }

    if ($action =~ /reject/i) {
        if (defined $result->{'tt2'}) {
            unless (
                tools::send_file(
                    $list, $result->{'tt2'},
                    $sender, {'auto_submitted' => 'auto-replied'}
                )
                ) {
                Log::do_log('notice', 'Unable to send template "%s" to %s',
                    $result->{'tt2'}, $sender);
                Sympa::Report::reject_report_cmd('auth', $result->{'reason'},
                    {}, $cmd_line);
            }
        } else {
            Sympa::Report::reject_report_cmd('auth', $result->{'reason'}, {},
                $cmd_line);
        }
        Log::do_log('info', 'Stats %s from %s refused (not allowed)',
            $listname, $sender);
        return 'not_allowed';
    } else {
        my %stats = (
            'msg_rcv'  => $list->{'stats'}[0],
            'msg_sent' => $list->{'stats'}[1],
            'byte_rcv' =>
                sprintf('%9.2f', ($list->{'stats'}[2] / 1024 / 1024)),
            'byte_sent' =>
                sprintf('%9.2f', ($list->{'stats'}[3] / 1024 / 1024))
        );

        unless (
            tools::send_file(
                $list,
                'stats_report',
                $sender,
                {   'stats'   => \%stats,
                    'subject' => "STATS $list->{'name'}",  # compat <= 6.1.17.
                    'auto_submitted' => 'auto-replied'
                }
            )
            ) {
            Log::do_log('notice',
                'Unable to send template "stats_reports" to %s', $sender);
            Sympa::Report::reject_report_cmd('intern_quiet', '',
                {'listname' => $listname, 'list' => $list},
                $cmd_line, $sender, $robot);
        }

        Log::do_log('info', 'STATS %s from %s accepted (%d seconds)',
            $listname, $sender, time - $time_command);
    }

    return 1;
}

###############################################
#  getfile
##############################################
# Sends back the requested archive file
#
# IN : -$which (+): command parameters : listname filename
#      -$robot (+): robot
#
# OUT : 'unknownlist'|'no_archive'|'not_allowed'|1
#
###############################################
sub getfile {
    my ($which, $file) = split(/\s+/, shift);
    my $robot = shift;

    Log::do_log('debug', '(%s, %s, %s)', $which, $file, $robot);

    my $list = Sympa::List->new($which, $robot);
    unless ($list) {
        Sympa::Report::reject_report_cmd('user', 'no_existing_list',
            {'listname' => $which}, $cmd_line);
        Log::do_log('info',
            'GET %s %s from %s refused, list unknown for robot %s',
            $which, $file, $sender, $robot);
        return 'unknownlist';
    }

    $language->set_lang($list->{'admin'}{'lang'});

    unless ($list->is_archived()) {
        Sympa::Report::reject_report_cmd('user', 'empty_archives', {},
            $cmd_line);
        Log::do_log('info',
            'GET %s %s from %s refused, no archive for list %s',
            $which, $file, $sender, $which);
        return 'no_archive';
    }
    ## Check file syntax
    if ($file =~ /(\.\.|\/)/) {
        Sympa::Report::reject_report_cmd('user', 'no_required_file', {},
            $cmd_line);
        Log::do_log('info', 'GET %s %s from %s, incorrect filename',
            $which, $file, $sender);
        return 'no_archive';
    }
    unless ($list->may_do('get', $sender)) {
        Sympa::Report::reject_report_cmd('auth', 'list_private_no_archive',
            {}, $cmd_line);
        Log::do_log('info', 'GET %s %s from %s refused, review not allowed',
            $which, $file, $sender);
        return 'not_allowed';
    }
#    unless ($list->archive_exist($file)) {
#	Sympa::Report::reject_report_cmd('user', 'no_required_file', {},
#	    $cmd_line);
# 	Log::do_log('info',
# 	'GET %s %s from %s refused, archive not found for list %s', $which,
# 	    $file, $sender, $which);
#	return 'no_archive';
#    }

    unless ($list->archive_send($sender, $file)) {
        Sympa::Report::reject_report_cmd(
            'intern',
            "Unable to send archive to $sender",
            {'listname' => $which},
            $cmd_line, $sender, $robot
        );
        return 'no_archive';
    }

    Log::do_log('info', 'GET %s %s from %s accepted (%d seconds)',
        $which, $file, $sender, time - $time_command);

    return 1;
}

###############################################
#  last
##############################################
# Sends back the last archive file
#
#
# IN : -$which (+): listname
#      -$robot (+): robot
#
# OUT : 'unknownlist'|'no_archive'|'not_allowed'|1
#
###############################################
sub last {
    my $which = shift;
    my $robot = shift;

    my $sympa = Conf::get_robot_conf($robot, 'sympa');

    Log::do_log('debug', '(%s, %s)', $which, $robot);

    my $list = Sympa::List->new($which, $robot);
    unless ($list) {
        Sympa::Report::reject_report_cmd('user', 'no_existing_list',
            {'listname' => $which}, $cmd_line);
        Log::do_log('info',
            'LAST %s from %s refused, list unknown for robot %s',
            $which, $sender, $robot);
        return 'unknownlist';
    }

    $language->set_lang($list->{'admin'}{'lang'});

    unless ($list->is_archived()) {
        Sympa::Report::reject_report_cmd('user', 'empty_archives', {},
            $cmd_line);
        Log::do_log('info', 'LAST %s from %s refused, list not archived',
            $which, $sender);
        return 'no_archive';
    }
    my $file;
    unless ($file = Sympa::Archive::last_path($list)) {
        Sympa::Report::reject_report_cmd('user', 'no_required_file', {},
            $cmd_line);
        Log::do_log('info',
            'LAST %s from %s refused, archive file %s not found',
            $which, $sender, $file);
        return 'no_archive';
    }
    unless ($list->may_do('get', $sender)) {
        Sympa::Report::reject_report_cmd('auth', 'list_private_no_archive',
            {}, $cmd_line);
        Log::do_log('info',
            'LAST %s from %s refused, archive access not allowed',
            $which, $sender);
        return 'not_allowed';
    }

    unless ($list->archive_send_last($sender)) {
        Sympa::Report::reject_report_cmd(
            'intern',
            "Unable to send archive to $sender",
            {'listname' => $which},
            $cmd_line, $sender, $robot
        );
        return 'no_archive';
    }

    Log::do_log('info', 'LAST %s from %s accepted (%d seconds)',
        $which, $sender, time - $time_command);

    return 1;
}

############################################################
#  index
############################################################
#  Sends the list of archived files of a list
#
# IN : -$which (+): list name
#      -$robot (+): robot
#
# OUT : 'unknown_list'|'not_allowed'|'no_archive'|1
#
#############################################################
sub index {
    my $which = shift;
    my $robot = shift;

    Log::do_log('debug', '(%s) Robot (%s)', $which, $robot);

    my $list = Sympa::List->new($which, $robot);
    unless ($list) {
        Sympa::Report::reject_report_cmd('user', 'no_existing_list',
            {'listname' => $which}, $cmd_line);
        Log::do_log('info',
            'INDEX %s from %s refused, list unknown for robot %s',
            $which, $sender, $robot);
        return 'unknown_list';
    }

    $language->set_lang($list->{'admin'}{'lang'});

    ## Now check if we may send the list of users to the requestor.
    ## Check all this depending on the values of the Review field in
    ## the control file.
    unless ($list->may_do('index', $sender)) {
        Sympa::Report::reject_report_cmd('auth', 'list_private_no_browse', {},
            $cmd_line);
        Log::do_log('info', 'INDEX %s from %s refused, not allowed',
            $which, $sender);
        return 'not_allowed';
    }
    unless ($list->is_archived()) {
        Sympa::Report::reject_report_cmd('user', 'empty_archives', {},
            $cmd_line);
        Log::do_log('info', 'INDEX %s from %s refused, list not archived',
            $which, $sender);
        return 'no_archive';
    }

    my @l = $list->archive_ls();
    unless (
        tools::send_file(
            $list, 'index_archive', $sender,
            {'archives' => \@l, 'auto_submitted' => 'auto-replied'}
        )
        ) {
        Log::do_log('notice', 'Unable to send template "index_archive" to %s',
            $sender);
        Sympa::Report::reject_report_cmd('intern_quiet', '',
            {'listname' => $list->{'name'}},
            $cmd_line, $sender, $robot);
    }

    Log::do_log('info', 'INDEX %s from %s accepted (%d seconds)',
        $which, $sender, time - $time_command);

    return 1;
}

############################################################
#  review
############################################################
#  Sends the list of subscribers to the requester.
#
# IN : -$listname (+): list name
#      -$robot (+): robot
#      -$sign_mod : 'smime'| -
#
# OUT : 'unknown_list'|'wrong_auth'|'not_allowed'
#       |'no_subscribers'|1 | undef
#
################################################################
sub review {
    my $listname = shift;
    my $robot    = shift;
    my $sign_mod = shift;
    my $message  = shift;

    Log::do_log('debug', '(%s, %s, %s)', $listname, $robot, $sign_mod);
    my $sympa = Conf::get_robot_conf($robot, 'sympa');

    my $user;
    my $list = Sympa::List->new($listname, $robot);

    unless ($list) {
        Sympa::Report::reject_report_cmd('user', 'no_existing_list',
            {'listname' => $listname}, $cmd_line);
        Log::do_log('info',
            'REVIEW %s from %s refused, list unknown to robot %s',
            $listname, $sender, $robot);
        return 'unknown_list';
    }

    $language->set_lang($list->{'admin'}{'lang'});

    $list->on_the_fly_sync_include('use_ttl' => 1);

    my $auth_method = get_auth_method(
        'review', '',
        {   'type' => 'auth_failed',
            'data' => {},
            'msg'  => "REVIEW $listname from $sender"
        },
        $sign_mod,
        $list
    );
    return 'wrong_auth'
        unless (defined $auth_method);

    my $result = Sympa::Scenario::request_action(
        $list, 'review',
        $auth_method,
        {   'sender'  => $sender,
            'message' => $message
        }
    );
    my $action;
    $action = $result->{'action'} if (ref($result) eq 'HASH');

    unless (defined $action) {
        my $error = "Unable to evaluate scenario 'review' for list $listname";
        Sympa::Report::reject_report_cmd('intern', $error,
            {'listname' => $listname},
            $cmd_line, $sender, $robot);
        return undef;
    }

    if ($action =~ /request_auth/i) {
        Log::do_log('debug2', 'Auth requested from %s', $sender);
        unless ($list->request_auth($sender, 'review', $robot)) {
            my $error =
                "Unable to request authentification for command 'review'";
            Sympa::Report::reject_report_cmd('intern', $error,
                {'listname' => $listname},
                $cmd_line, $sender, $robot);
            return undef;
        }
        Log::do_log('info', 'REVIEW %s from %s, auth requested (%d seconds)',
            $listname, $sender, time - $time_command);
        return 1;
    }
    if ($action =~ /reject/i) {
        if (defined $result->{'tt2'}) {
            unless (
                tools::send_file(
                    $list, $result->{'tt2'},
                    $sender, {'auto_submitted' => 'auto-replied'}
                )
                ) {
                Log::do_log('notice', 'Unable to send template "%s" to %s',
                    $result->{'tt2'}, $sender);
                Sympa::Report::reject_report_cmd('auth', $result->{'reason'},
                    {}, $cmd_line);
            }
        } else {
            Sympa::Report::reject_report_cmd('auth', $result->{'reason'}, {},
                $cmd_line);
        }
        Log::do_log('info', 'Review %s from %s refused (not allowed)',
            $listname, $sender);
        return 'not_allowed';
    }

    my @users;

    if ($action =~ /do_it/i) {
        my $is_owner = $list->am_i('owner', $sender);
        unless ($user = $list->get_first_list_member({'sortby' => 'email'})) {
            Sympa::Report::reject_report_cmd('user', 'no_subscriber',
                {'listname' => $listname}, $cmd_line);
            Log::do_log('err', 'No subscribers in list "%s"',
                $list->{'name'});
            return 'no_subscribers';
        }
        do {
            ## Owners bypass the visibility option
            unless (($user->{'visibility'} eq 'conceal')
                and (!$is_owner)) {

                ## Lower case email address
                $user->{'email'} =~ y/A-Z/a-z/;
                push @users, $user;
            }
        } while ($user = $list->get_next_list_member());
        unless (
            tools::send_file(
                $list, 'review', $sender,
                {   'users'   => \@users,
                    'total'   => $list->get_total(),
                    'subject' => "REVIEW $listname",    # Compat <= 6.1.17.
                    'auto_submitted' => 'auto-replied'
                }
            )
            ) {
            Log::do_log('notice', 'Unable to send template "review" to %s',
                $sender);
            Sympa::Report::reject_report_cmd('intern_quiet', '',
                {'listname' => $listname},
                $cmd_line, $sender, $robot);
        }

        Log::do_log('info', 'REVIEW %s from %s accepted (%d seconds)',
            $listname, $sender, time - $time_command);
        return 1;
    }
    Log::do_log('info',
        'REVIEW %s from %s aborted, unknown requested action in scenario',
        $listname, $sender);
    my $error = "Unknown requested action in scenario: $action.";
    Sympa::Report::reject_report_cmd('intern', $error,
        {'listname' => $listname},
        $cmd_line, $sender, $robot);
    return undef;
}

############################################################
#  verify
############################################################
#  Verify an S/MIME signature
#
# IN : -$listname (+): list name
#      -$robot (+): robot
#      -$sign_mod : 'smime'| 'dkim' | -
#
# OUT : 1
#
#############################################################
sub verify {
    Log::do_log('debug2', '(%s, %s)', @_);
    my $listname = shift;
    my $robot    = shift;
    my $sign_mod = shift;

    my $list = Sympa::List->new($listname, $robot);
    unless ($list) {
        Sympa::Report::reject_report_cmd('user', 'no_existing_list',
            {'listname' => $listname}, $cmd_line);
        Log::do_log('info',
            'VERIFY from %s refused, unknown list for robot %s',
            $sender, $robot);
        return 'unknown_list';
    }

    my $user;

    $language->set_lang($list->{'admin'}{'lang'});

    if ($sign_mod) {
        Log::do_log(
            'info',  'VERIFY successfull from %s',
            $sender, time - $time_command
        );
        if ($sign_mod eq 'smime') {
            ##$auth_method='smime';
            Sympa::Report::notice_report_cmd('smime', {}, $cmd_line);
        } elsif ($sign_mod eq 'dkim') {
            ##$auth_method='dkim';
            Sympa::Report::notice_report_cmd('dkim', {}, $cmd_line);
        }
    } else {
        Log::do_log('info',
            'VERIFY from %s: could not find correct S/MIME signature',
            $sender, time - $time_command);
        Sympa::Report::reject_report_cmd('user', 'no_verify_sign', {},
            $cmd_line);
    }
    return 1;
}

##############################################################
#  subscribe
##############################################################
#  Subscribes a user to a list. The user sent a subscribe
#  command. Format was : sub list optionnal comment. User can
#  be informed by template 'welcome'
#
# IN : -$what (+): command parameters : listname(+), comment
#      -$robot (+): robot
#      -$sign_mod : 'smime'| -
#
# OUT : 'unknown_list'|'wrong_auth'|'not_allowed'| 1 | undef
#
################################################################
sub subscribe {
    my $what     = shift;
    my $robot    = shift;
    my $sign_mod = shift;
    my $message  = shift;

    Log::do_log('debug', '(%s, %s, %s, %s)',
        $what, $robot, $sign_mod, $message);

    $what =~ /^(\S+)(\s+(.+))?\s*$/;
    my ($which, $comment) = ($1, $3);

    ## Load the list if not already done, and reject the
    ## subscription if this list is unknown to us.
    my $list = Sympa::List->new($which, $robot);
    unless ($list) {
        Sympa::Report::reject_report_cmd('user', 'no_existing_list',
            {'listname' => $which}, $cmd_line);
        Log::do_log('info',
            'SUB %s from %s refused, unknown list for robot %s',
            $which, $sender, $robot);
        return 'unknown_list';
    }

    $language->set_lang($list->{'admin'}{'lang'});

    ## This is a really minimalistic handling of the comments,
    ## it is far away from RFC-822 completeness.
    if (defined $comment and $comment =~ /\S/) {
        $comment =~ s/"/\\"/g;
        $comment = "\"$comment\"" if ($comment =~ /[<>\(\)]/);
    } else {
        undef $comment;
    }

    ## Now check if the user may subscribe to the list

    my $auth_method = get_auth_method(
        'subscribe',
        $sender,
        {   'type' => 'wrong_email_confirm',
            'data' => {'command' => 'subscription'},
            'msg'  => "SUB $which from $sender"
        },
        $sign_mod,
        $list
    );
    return 'wrong_auth'
        unless (defined $auth_method);

    ## query what to do with this subscribtion request

    my $result = Sympa::Scenario::request_action(
        $list,
        'subscribe',
        $auth_method,
        {   'sender'  => $sender,
            'message' => $message,
        }
    );
    my $action;
    $action = $result->{'action'} if (ref($result) eq 'HASH');

    unless (defined $action) {
        my $error = "Unable to evaluate scenario 'subscribe' for list $which";
        Sympa::Report::reject_report_cmd('intern', $error,
            {'listname' => $which},
            $cmd_line, $sender, $robot);
        return undef;
    }

    Log::do_log('debug2', 'Action: %s', $action);

    if ($action =~ /reject/i) {
        if (defined $result->{'tt2'}) {
            unless (
                tools::send_file(
                    $list, $result->{'tt2'},
                    $sender, {'auto_submitted' => 'auto-replied'}
                )
                ) {
                Log::do_log('notice', 'Unable to send template "%s" to %s',
                    $result->{'tt2'}, $sender);
                Sympa::Report::reject_report_cmd('auth', $result->{'reason'},
                    {}, $cmd_line);
            }
        } else {
            Sympa::Report::reject_report_cmd('auth', $result->{'reason'}, {},
                $cmd_line);
        }
        Log::do_log('info', 'SUB %s from %s refused (not allowed)',
            $which, $sender);
        return 'not_allowed';
    }

    ## Unless rejected by scenario, don't go further if the user is subscribed
    ## already.
    my $user_entry = $list->get_list_member($sender);
    if (defined($user_entry)) {
        Sympa::Report::reject_report_cmd('user', 'already_subscriber',
            {'email' => $sender, 'listname' => $list->{'name'}}, $cmd_line);
        Log::do_log(
            'err',
            'User %s is subscribed to %s already. Ignoring subscription request',
            $sender,
            $list->{'name'}
        );
        return undef;
    }

    ## Continue checking scenario.
    if ($action =~ /owner/i) {
        Sympa::Report::notice_report_cmd('req_forward', {}, $cmd_line);
        ## Send a notice to the owners.
        unless (
            $list->send_notify_to_owner(
                'subrequest',
                {   'who'     => $sender,
                    'keyauth' => $list->compute_auth($sender, 'add'),
                    'replyto' => Conf::get_robot_conf($robot, 'sympa'),
                    'gecos'   => $comment
                }
            )
            ) {
            #FIXME: Why is error reported only in this case?
            Log::do_log('info',
                'Unable to send notify "subrequest" to %s list owner', $list);
            Sympa::Report::reject_report_cmd(
                'intern',
                "Unable to send subrequest to $list->{'name'} list owner",
                {'listname' => $list->{'name'}},
                $cmd_line,
                $sender,
                $robot
            );
        }
        if ($list->store_subscription_request($sender, $comment)) {
            Log::do_log(
                'info',
                'SUB %s from %s forwarded to the owners of the list (%d seconds)',
                $which,
                $sender,
                tim