Admin.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/>.

=pod 

=head1 NAME 

I<admin.pm> - This module includes administrative function for the lists.

=head1 DESCRIPTION 

Central module for creating and editing lists.

=cut 

package Sympa::Admin;

use strict;
use warnings;
use Encode qw();
use English qw(-no_match_vars);
use File::Copy qw();
use IO::Scalar;

use Conf;
use Sympa::Constants;
use Sympa::Language;
use Sympa::List;
use Sympa::LockedFile;
use Log;
use Sympa::Regexps;
use Sympa::Robot;
use Sympa::Scenario;
use SDM;
use tools;
use tt2;
use Sympa::User;

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

=pod 

=head1 SUBFUNCTIONS 

This is the description of the subfunctions contained by admin.pm 

=cut 

=pod 

=head2 sub create_list_old(HASHRef,STRING,STRING)

Creates a list. Used by the create_list() sub in sympa.pl and the do_create_list() sub in wwsympa.fcgi.

=head3 Arguments 

=over 

=item * I<$param>, a ref on a hash containing parameters of the config list. The following keys are mandatory:

=over 4

=item - I<$param-E<gt>{'listname'}>,

=item - I<$param-E<gt>{'subject'}>,

=item - I<$param-E<gt>{'owner'}>, (or owner_include): array of hashes, with key email mandatory

=item - I<$param-E<gt>{'owner_include'}>, array of hashes, with key source mandatory

=back

=item * I<$template>, a string containing the list creation template

=item * I<$robot>, a string containing the name of the robot the list will be hosted by.

=back 

=head3 Return 

=over 

=item * I<undef>, if something prevents the list creation

=item * I<a reference to a hash>, if the list is normally created. This hash contains two keys:

=over 4

=item - I<list>, the list object corresponding to the list just created

=item - I<aliases>, undef if not applicable; 1 (if ok) or $aliases : concatenated string of aliases if they are not installed or 1 (in status open)

=back

=back 

=head3 Calls 

=item * check_owner_defined

=item * check_topics

=item * install_aliases

=item * list_check_smtp

=item * Conf::get_robot_conf

=item * Sympa::List::create_shared

=item * Sympa::List::has_include_data_sources

=item * Sympa::List::sync_include

=item * tools::search_fullpath

=item * Log::do_log

=item * tools::get_search_path

=item * tt2::parse_tt2 

=back 

=cut 

########################################################
# create_list_old
########################################################
# Create a list : used by sympa.pl--create_list and
#                 wwsympa.fcgi--do_create_list
# without family concept
#
# IN  : - $param : ref on parameters of the config list
#         with obligatory :
#         $param->{'listname'}
#         $param->{'subject'}
#         $param->{'owner'} (or owner_include):
#          array of hash,with key email obligatory
#         $param->{'owner_include'} array of hash :
#              with key source obligatory
#       - $template : the create list template
#       - $robot : the list's robot
#       - $origin : the source of the command : web, soap or command_line
#              no longer used
# OUT : - hash with keys :
#          -list :$list
#          -aliases : undef if not applicable; 1 (if ok) or
#           $aliases : concated string of alias if they
#           are not installed or 1(in status open)
#######################################################
sub create_list_old {
    my ($param, $template, $robot, $origin, $user_mail) = @_;
    Log::do_log('debug', '(%s, %s)', $param->{'listname'}, $robot, $origin);

    ## obligatory list parameters
    foreach my $arg ('listname', 'subject') {
        unless ($param->{$arg}) {
            Log::do_log('err', 'Missing list param %s', $arg);
            return undef;
        }
    }
    # owner.email || owner_include.source
    unless (check_owner_defined($param->{'owner'}, $param->{'owner_include'}))
    {
        Log::do_log('err',
            'Problem in owner definition in this list creation');
        return undef;
    }

    # template
    unless ($template) {
        Log::do_log('err', 'Missing param "template"', $template);
        return undef;
    }
    # robot
    unless ($robot) {
        Log::do_log('err', 'Missing param "robot"', $robot);
        return undef;
    }

    ## check listname
    $param->{'listname'} = lc($param->{'listname'});
    my $listname_regexp = Sympa::Regexps::listname();

    unless ($param->{'listname'} =~ /^$listname_regexp$/i) {
        Log::do_log('err', 'Incorrect listname %s', $param->{'listname'});
        return undef;
    }

    my $regx = Conf::get_robot_conf($robot, 'list_check_regexp');
    if ($regx) {
        if ($param->{'listname'} =~ /^(\S+)-($regx)$/) {
            Log::do_log('err',
                'Incorrect listname %s matches one of service aliases',
                $param->{'listname'});
            return undef;
        }
    }

    if ($param->{'listname'} eq Conf::get_robot_conf($robot, 'email')) {
        Log::do_log('err',
            'Incorrect listname %s matches one of service aliases',
            $param->{'listname'});
        return undef;
    }

    ## Check listname on SMTP server
    my $res = list_check_smtp($param->{'listname'}, $robot);
    unless (defined $res) {
        Log::do_log('err', 'Can\'t check list %.128s on %s',
            $param->{'listname'}, $robot);
        return undef;
    }

    ## Check this listname doesn't exist already.
    if ($res
        || Sympa::List->new($param->{'listname'}, $robot, {'just_try' => 1}))
    {
        Log::do_log('err',
            'Could not create already existing list %s on %s for',
            $param->{'listname'}, $robot);
        foreach my $o (@{$param->{'owner'}}) {
            Log::do_log('err', $o->{'email'});
        }
        return undef;
    }

    ## Check the template supposed to be used exist.
    my $template_file = tools::search_fullpath($robot, 'config.tt2',
        subidr => 'create_list_templates/' . $template);
    unless (defined $template_file) {
        Log::do_log('err', 'No template %s found', $template);
        return undef;
    }

    ## Create the list directory
    my $list_dir;

    # a virtual robot
    if (-d "$Conf::Conf{'home'}/$robot") {
        unless (-d $Conf::Conf{'home'} . '/' . $robot) {
            unless (mkdir($Conf::Conf{'home'} . '/' . $robot, 0777)) {
                Log::do_log('err', 'Unable to create %s/%s: %s',
                    $Conf::Conf{'home'}, $robot, $?);
                return undef;
            }
        }
        $list_dir =
            $Conf::Conf{'home'} . '/' . $robot . '/' . $param->{'listname'};
    } else {
        $list_dir = $Conf::Conf{'home'} . '/' . $param->{'listname'};
    }

    ## Check the privileges on the list directory
    unless (mkdir($list_dir, 0777)) {
        Log::do_log('err', 'Unable to create %s: %s', $list_dir,
            $CHILD_ERROR);
        return undef;
    }

    ## Check topics
    if ($param->{'topics'}) {
        unless (check_topics($param->{'topics'}, $robot)) {
            Log::do_log('err', 'Topics param %s not defined in topics.conf',
                $param->{'topics'});
        }
    }

    ## Creation of the config file
    my $host = Conf::get_robot_conf($robot, 'host');
    ##FIXME:should be unneccessary
    $param->{'creation'}{'date'} =
        $language->gettext_strftime("%d %b %Y at %H:%M:%S", localtime time);
    $param->{'creation'}{'date_epoch'} = time;
    $param->{'creation_email'} = "listmaster\@$host"
        unless ($param->{'creation_email'});
    $param->{'status'} = 'open' unless ($param->{'status'});

    my $tt2_include_path = tools::get_search_path($robot,
        subdir => 'create_list_templates/' . $template);

    ## Lock config before openning the config file
    my $lock_fh = Sympa::LockedFile->new($list_dir . '/config', 5, '>');
    unless ($lock_fh) {
        Log::do_log('err', 'Impossible to create %s/config: %m', $list_dir);
        return undef;
    }
    ## Use an intermediate handler to encode to filesystem_encoding
    my $config = '';
    my $fd     = IO::Scalar->new(\$config);
    #FIXME: Check parse error
    tt2::parse_tt2($param, 'config.tt2', $fd, $tt2_include_path);
#    Encode::from_to($config, 'utf8', $Conf::Conf{'filesystem_encoding'});
    print $lock_fh $config;

    ## Unlock config file
    $lock_fh->close;

    ## Creation of the info file
    # remove DOS linefeeds (^M) that cause problems with Outlook 98, AOL, and
    # EIMS:
    $param->{'description'} =~ s/\r\n|\r/\n/g;

    ## info file creation.
    unless (open INFO, '>', "$list_dir/info") {
        Log::do_log('err', 'Impossible to create %s/info: %m', $list_dir);
    }
    if (defined $param->{'description'}) {
        Encode::from_to($param->{'description'},
            'utf8', $Conf::Conf{'filesystem_encoding'});
        print INFO $param->{'description'};
    }
    close INFO;

    ## Create list object
    my $list;
    unless ($list = Sympa::List->new($param->{'listname'}, $robot)) {
        Log::do_log('err', 'Unable to create list %s', $param->{'listname'});
        return undef;
    }

    ## Create shared if required
    if (defined $list->{'admin'}{'shared_doc'}) {
        $list->create_shared();
    }

    #log in stat_table to make statistics

    if ($origin eq "web") {
        Log::db_stat_log(
            {   'robot'     => $robot,
                'list'      => $param->{'listname'},
                'operation' => 'create list',
                'parameter' => '',
                'mail'      => $user_mail,
                'client'    => '',
                'daemon'    => 'wwsympa.fcgi'
            }
        );
    }

    my $return = {};
    $return->{'list'} = $list;

    if ($list->{'admin'}{'status'} eq 'open') {
        $return->{'aliases'} = install_aliases($list);
    } else {
        $return->{'aliases'} = 1;
    }

    ## Synchronize list members if required
    if ($list->has_include_data_sources()) {
        Log::do_log('notice', "Synchronizing list members...");
        $list->sync_include();
    }

    $list->save_config($param->{'creation_email'});
    return $return;
}

########################################################
# create_list
########################################################
# Create a list : used by sympa.pl--instantiate_family
# with family concept
#
# IN  : - $param : ref on parameters of the config list
#         with obligatory :
#         $param->{'listname'}
#         $param->{'subject'}
#         $param->{'owner'} (or owner_include):
#          array of hash,with key email obligatory
#         $param->{'owner_include'} array of hash :
#              with key source obligatory
#       - $family : the family object
#       - $robot : the list's robot  ** No longer used.
#       - $abort_on_error : won't create the list directory on
#          tt2 process error (usefull for dynamic lists that
#          throw exceptions)
# OUT : - hash with keys :
#          -list :$list
#          -aliases : undef if not applicable; 1 (if ok) or
#           $aliases : concated string of alias if they
#           are not installed or 1(in status open)
#######################################################
sub create_list {
    my ($param, $family, $dummy, $abort_on_error) = @_;
    Log::do_log('info', '(%s, %s, %s)', $param->{'listname'},
        $family->{'name'}, $param->{'subject'});

    ## mandatory list parameters
    foreach my $arg ('listname') {
        unless ($param->{$arg}) {
            Log::do_log('err', 'Missing list param %s', $arg);
            return undef;
        }
    }

    unless ($family) {
        Log::do_log('err', 'Missing param "family"');
        return undef;
    }

    #robot
    my $robot = $family->{'robot'};
    unless ($robot) {
        Log::do_log('err', 'Missing param "robot"');
        return undef;
    }

    ## check listname
    $param->{'listname'} = lc($param->{'listname'});
    my $listname_regexp = Sympa::Regexps::listname();

    unless ($param->{'listname'} =~ /^$listname_regexp$/i) {
        Log::do_log('err', 'Incorrect listname %s', $param->{'listname'});
        return undef;
    }

    my $regx = Conf::get_robot_conf($robot, 'list_check_regexp');
    if ($regx) {
        if ($param->{'listname'} =~ /^(\S+)-($regx)$/) {
            Log::do_log('err',
                'Incorrect listname %s matches one of service aliases',
                $param->{'listname'});
            return undef;
        }
    }
    if ($param->{'listname'} eq Conf::get_robot_conf($robot, 'email')) {
        Log::do_log('err',
            'Incorrect listname %s matches one of service aliases',
            $param->{'listname'});
        return undef;
    }

    ## Check listname on SMTP server
    my $res = list_check_smtp($param->{'listname'}, $robot);
    unless (defined $res) {
        Log::do_log('err', 'Can\'t check list %.128s on %s',
            $param->{'listname'}, $robot);
        return undef;
    }

    if ($res) {
        Log::do_log('err',
            'Could not create already existing list %s on %s for',
            $param->{'listname'}, $robot);
        foreach my $o (@{$param->{'owner'}}) {
            Log::do_log('err', $o->{'email'});
        }
        return undef;
    }

    ## template file
    my $template_file = tools::search_fullpath($family, 'config.tt2');
    unless (defined $template_file) {
        Log::do_log('err', 'No config template from family %s@%s',
            $family->{'name'}, $robot);
        return undef;
    }

    my $family_config =
        Conf::get_robot_conf($robot, 'automatic_list_families');
    $param->{'family_config'} = $family_config->{$family->{'name'}};
    my $conf;
    my $tt_result =
        tt2::parse_tt2($param, 'config.tt2', \$conf, [$family->{'dir'}]);
    unless (defined $tt_result || !$abort_on_error) {
        Log::do_log('err', 'Abort on tt2 error. List %s from family %s@%s',
            $param->{'listname'}, $family->{'name'}, $robot);
        return undef;
    }

    ## Create the list directory
    my $list_dir;

    if (-d "$Conf::Conf{'home'}/$robot") {
        unless (-d $Conf::Conf{'home'} . '/' . $robot) {
            unless (mkdir($Conf::Conf{'home'} . '/' . $robot, 0777)) {
                Log::do_log('err', 'Unable to create %s/%s: %s',
                    $Conf::Conf{'home'}, $robot, $?);
                return undef;
            }
        }
        $list_dir =
            $Conf::Conf{'home'} . '/' . $robot . '/' . $param->{'listname'};
    } else {
        $list_dir = $Conf::Conf{'home'} . '/' . $param->{'listname'};
    }

    unless (-r $list_dir || mkdir($list_dir, 0777)) {
        Log::do_log('err', 'Unable to create %s: %s', $list_dir,
            $CHILD_ERROR);
        return undef;
    }

    ## Check topics
    if (defined $param->{'topics'}) {
        unless (check_topics($param->{'topics'}, $robot)) {
            Log::do_log('err', 'Topics param %s not defined in topics.conf',
                $param->{'topics'});
        }
    }

    ## Lock config before openning the config file
    my $lock_fh = Sympa::LockedFile->new($list_dir . '/config', 5, '>');
    unless ($lock_fh) {
        Log::do_log('err', 'Impossible to create %s/config: %m', $list_dir);
        return undef;
    }
    #tt2::parse_tt2($param, 'config.tt2', $lock_fh, [$family->{'dir'}]);
    print $lock_fh $conf;

    ## Unlock config file
    $lock_fh->close;

    ## Creation of the info file
    # remove DOS linefeeds (^M) that cause problems with Outlook 98, AOL, and
    # EIMS:
    $param->{'description'} =~ s/\r\n|\r/\n/g;

    unless (open INFO, '>', "$list_dir/info") {
        Log::do_log('err', 'Impossible to create %s/info: %m', $list_dir);
    }
    if (defined $param->{'description'}) {
        print INFO $param->{'description'};
    }
    close INFO;

    ## Create associated files if a template was given.
    my @files_to_parse;
    foreach my $file (split ',',
        Conf::get_robot_conf($robot, 'parsed_family_files')) {
        $file =~ s{\s}{}g;
        push @files_to_parse, $file;
    }
    for my $file (@files_to_parse) {
        my $template_file = tools::search_fullpath($family, $file . ".tt2");
        if (defined $template_file) {
            my $file_content;
            my $tt_result = tt2::parse_tt2($param, $file . ".tt2",
                \$file_content, [$family->{'dir'}]);
            unless (defined $tt_result) {
                Log::do_log('err',
                    'Tt2 error. List %s from family %s@%s, file %s',
                    $param->{'listname'}, $family->{'name'}, $robot, $file);
            }
            unless (open FILE, '>', "$list_dir/$file") {
                Log::do_log('err', 'Impossible to create %s/%s: %m',
                    $list_dir, $file);
            }
            print FILE $file_content;
            close FILE;
        }
    }

    ## Create list object
    my $list;
    unless ($list = Sympa::List->new($param->{'listname'}, $robot)) {
        Log::do_log('err', 'Unable to create list %s', $param->{'listname'});
        return undef;
    }

    ## Create shared if required
    if (defined $list->{'admin'}{'shared_doc'}) {
        $list->create_shared();
    }

    ##FIXME:should be unneccessary
    $list->{'admin'}{'creation'}{'date'} =
        $language->gettext_strftime("%d %b %Y at %H:%M:%S", localtime time);
    $list->{'admin'}{'creation'}{'date_epoch'} = time;
    if ($param->{'creation_email'}) {
        $list->{'admin'}{'creation'}{'email'} = $param->{'creation_email'};
    } else {
        my $host = Conf::get_robot_conf($robot, 'host');
        $list->{'admin'}{'creation'}{'email'} = "listmaster\@$host";
    }
    if ($param->{'status'}) {
        $list->{'admin'}{'status'} = $param->{'status'};
    } else {
        $list->{'admin'}{'status'} = 'open';
    }
    $list->{'admin'}{'family_name'} = $family->{'name'};

    my $return = {};
    $return->{'list'} = $list;

    if ($list->{'admin'}{'status'} eq 'open') {
        $return->{'aliases'} = install_aliases($list);
    } else {
        $return->{'aliases'} = 1;
    }

    ## Synchronize list members if required
    if ($list->has_include_data_sources()) {
        Log::do_log('notice', "Synchronizing list members...");
        $list->sync_include();
    }

    return $return;
}

########################################################
# update_list
########################################################
# update a list : used by sympa.pl--instantiate_family
# with family concept when the list already exists
#
# IN  : - $list : the list to update
#       - $param : ref on parameters of the new
#          config list with obligatory :
#         $param->{'listname'}
#         $param->{'subject'}
#         $param->{'owner'} (or owner_include):
#          array of hash,with key email obligatory
#         $param->{'owner_include'} array of hash :
#              with key source obligatory
#       - $family : the family object
#       - $robot : the list's robot
#
# OUT : - $list : the updated list or undef
#######################################################
sub update_list {
    my ($list, $param, $family, $robot) = @_;
    Log::do_log('info', '(%s, %s, %s)', $param->{'listname'},
        $family->{'name'}, $param->{'subject'});

    ## mandatory list parameters
    foreach my $arg ('listname') {
        unless ($param->{$arg}) {
            Log::do_log('err', 'Missing list param %s', $arg);
            return undef;
        }
    }

    ## template file
    my $template_file = tools::search_fullpath($family, 'config.tt2');
    unless (defined $template_file) {
        Log::do_log('err', 'No config template from family %s@%s',
            $family->{'name'}, $robot);
        return undef;
    }

    ## Check topics
    if (defined $param->{'topics'}) {
        unless (check_topics($param->{'topics'}, $robot)) {
            Log::do_log('err', 'Topics param %s not defined in topics.conf',
                $param->{'topics'});
        }
    }

    ## Lock config before openning the config file
    my $lock_fh = Sympa::LockedFile->new($list->{'dir'} . '/config', 5, '>');
    unless ($lock_fh) {
        Log::do_log('err', 'Impossible to create %s/config: %s',
            $list->{'dir'}, $!);
        return undef;
    }
    #FIXME: Check parse error
    tt2::parse_tt2($param, 'config.tt2', $lock_fh, [$family->{'dir'}]);
    ## Unlock config file
    $lock_fh->close;

    ## Create list object
    unless ($list = Sympa::List->new($param->{'listname'}, $robot)) {
        Log::do_log('err', 'Unable to create list %s', $param->{'listname'});
        return undef;
    }

    ##FIXME:should be unneccessary
    $list->{'admin'}{'creation'}{'date'} =
        $language->gettext_strftime("%d %b %Y at %H:%M:%S", localtime time);
    $list->{'admin'}{'creation'}{'date_epoch'} = time;
    if ($param->{'creation_email'}) {
        $list->{'admin'}{'creation'}{'email'} = $param->{'creation_email'};
    } else {
        my $host = Conf::get_robot_conf($robot, 'host');
        $list->{'admin'}{'creation'}{'email'} = "listmaster\@$host";
    }

    if ($param->{'status'}) {
        $list->{'admin'}{'status'} = $param->{'status'};
    } else {
        $list->{'admin'}{'status'} = 'open';
    }
    $list->{'admin'}{'family_name'} = $family->{'name'};

    ## Create associated files if a template was given.
    my @files_to_parse;
    foreach my $file (split ',',
        Conf::get_robot_conf($robot, 'parsed_family_files')) {
        $file =~ s{\s}{}g;
        push @files_to_parse, $file;
    }
    for my $file (@files_to_parse) {
        my $template_file = tools::search_fullpath($family, $file . ".tt2");
        if (defined $template_file) {
            my $file_content;
            my $tt_result = tt2::parse_tt2($param, $file . ".tt2",
                \$file_content, [$family->{'dir'}]);
            unless (defined $tt_result) {
                Log::do_log('err',
                    'Tt2 error. List %s from family %s@%s, file %s',
                    $param->{'listname'}, $family->{'name'}, $robot, $file);
            }
            unless (open FILE, '>', "$list->{'dir'}/$file") {
                Log::do_log('err', 'Impossible to create %s/%s: %s',
                    $list->{'dir'}, $file, $!);
            }
            print FILE $file_content;
            close FILE;
        }
    }

    ## Synchronize list members if required
    if ($list->has_include_data_sources()) {
        Log::do_log('notice', "Synchronizing list members...");
        $list->sync_include();
    }

    return $list;
}

########################################################
# rename_list
########################################################
# Rename a list or move a list to another virtual host
#
# IN  : - list
#       - new_listname
#       - new_robot
#       - mode  : 'copy'
#       - auth_method
#       - user_email
#       - remote_host
#       - remote_addr
#       - options : 'skip_authz' to skip authorization scenarios eval
#
# OUT via reference :
#       - aliases
#       - status : 'pending'
#
# OUT : - scalar
#           undef  : error
#           1      : success
#           string : error code
#######################################################
sub rename_list {
    my (%param) = @_;
    Log::do_log('info', '',);

    my $list         = $param{'list'};
    my $robot        = $list->{'domain'};
    my $old_listname = $list->{'name'};

    # check new listname syntax
    my $new_listname    = lc($param{'new_listname'});
    my $listname_regexp = Sympa::Regexps::listname();

    unless ($new_listname =~ /^$listname_regexp$/i) {
        Log::do_log('err', 'Incorrect listname %s', $new_listname);
        return 'incorrect_listname';
    }

    ## Evaluate authorization scenario unless run as listmaster (sympa.pl)
    my ($result, $r_action, $reason);
    unless ($param{'options'}{'skip_authz'}) {
        $result = Sympa::Scenario::request_action(
            $param{'new_robot'},
            'create_list',
            $param{'auth_method'},
            {   'sender'      => $param{'user_email'},
                'remote_host' => $param{'remote_host'},
                'remote_addr' => $param{'remote_addr'}
            }
        );

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

        unless ($r_action =~ /do_it|listmaster/) {
            Log::do_log('err', 'Authorization error');
            return 'authorization';
        }
    }

    ## Check listname on SMTP server
    my $res = list_check_smtp($param{'new_listname'}, $param{'new_robot'});
    unless (defined($res)) {
        Log::do_log('err', 'Can\'t check list %.128s on %.128s',
            $param{'new_listname'}, $param{'new_robot'});
        return 'internal';
    }

    if ($res
        || ($list->{'name'} ne $param{'new_listname'})
        &&    ## Do not test if listname did not change
        (   Sympa::List->new(
                $param{'new_listname'}, $param{'new_robot'},
                {'just_try' => 1}
            )
        )
        ) {
        Log::do_log(
            'err',
            'Could not rename list %s on %s: new list %s on %s already existing list',
            $list->{'name'},
            $robot,
            $param{'new_listname'},
            $param{'new_robot'}
        );
        return 'list_already_exists';
    }

    my $regx = Conf::get_robot_conf($param{'new_robot'}, 'list_check_regexp');
    if ($regx) {
        if ($param{'new_listname'} =~ /^(\S+)-($regx)$/) {
            Log::do_log('err',
                'Incorrect listname %s matches one of service aliases',
                $param{'new_listname'});
            return 'incorrect_listname';
        }
    }

    unless ($param{'mode'} eq 'copy') {
        $list->savestats();

        ## Dump subscribers
        $list->_save_list_members_file(
            "$list->{'dir'}/subscribers.closed.dump");

        $param{'aliases'} = remove_aliases($list, $list->{'domain'});
    }

    ## Rename or create this list directory itself
    my $new_dir;
    ## Default robot
    if (-d "$Conf::Conf{'home'}/$param{'new_robot'}") {
        $new_dir =
              $Conf::Conf{'home'} . '/'
            . $param{'new_robot'} . '/'
            . $param{'new_listname'};
    } elsif ($param{'new_robot'} eq $Conf::Conf{'domain'}) {
        $new_dir = $Conf::Conf{'home'} . '/' . $param{'new_listname'};
    } else {
        Log::do_log('err', 'Unknown robot %s', $param{'new_robot'});
        return 'unknown_robot';
    }

    ## If we are in 'copy' mode, create en new list
    if ($param{'mode'} eq 'copy') {
        unless (
            $list = clone_list_as_empty(
                $list->{'name'},        $list->{'domain'},
                $param{'new_listname'}, $param{'new_robot'},
                $param{'user_email'}
            )
            ) {
            Log::do_log('err', 'Unable to load %s while renaming',
                $param{'new_listname'});
            return 'internal';
        }
    }

    # set list status to pending if creation list is moderated
    if ($r_action =~ /listmaster/) {
        $list->{'admin'}{'status'} = 'pending';
        tools::send_notify_to_listmaster(
            $list,
            'request_list_renaming',
            {   'new_listname' => $param{'new_listname'},
                'old_listname' => $old_listname,
                'email'        => $param{'user_email'},
                'mode'         => $param{'mode'}
            }
        );
        $param{'status'} = 'pending';
    }

    ## Save config file for the new() later to reload it
    $list->save_config($param{'user_email'});

    ## This code should be in Sympa::List::rename()
    unless ($param{'mode'} eq 'copy') {
        unless (File::Copy::move($list->{'dir'}, $new_dir)) {
            Log::do_log('err', 'Unable to rename %s to %s: %m',
                $list->{'dir'}, $new_dir);
            return 'internal';
        }

        ## Rename archive
        my $arc_dir =
            Conf::get_robot_conf($robot, 'arc_path') . '/'
            . $list->get_list_id();
        my $new_arc_dir =
              Conf::get_robot_conf($param{'new_robot'}, 'arc_path') . '/'
            . $param{'new_listname'} . '@'
            . $param{'new_robot'};
        if (-d $arc_dir && $arc_dir ne $new_arc_dir) {
            unless (File::Copy::move($arc_dir, $new_arc_dir)) {
                Log::do_log('err', 'Unable to rename archive %s', $arc_dir);
                # continue even if there is some troubles with archives
                # return undef;
            }
        }

        ## Rename bounces
        my $bounce_dir = $list->get_bounce_dir();
        my $new_bounce_dir =
              Conf::get_robot_conf($param{'new_robot'}, 'bounce_path') . '/'