<h2>Edit File - convert_roundcube_mysql2sqlite</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/local/cpanel/scripts/convert_roundcube_mysql2sqlite">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">#!/usr/local/cpanel/3rdparty/bin/perl

# cpanel - scripts/convert_roundcube_mysql2sqlite  Copyright 2022 cPanel, L.L.C.
#                                                           All rights reserved.
# copyright@cpanel.net                                         http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited

package Script::RCube::Mysql2Sqlite;

use strict;
## no critic (RequireUseWarnings)
use Try::Tiny;

use Cpanel::AccessIds::ReducedPrivileges ();
use Cpanel::Config::LoadCpConf           ();
use Cpanel::MysqlUtils                   ();
use Cpanel::DbUtils                      ();
use Cpanel::MysqlUtils::Connect          ();
use Cpanel::MysqlUtils::Command          ();
use Cpanel::MysqlRun                     ();
use Cpanel::Config::LoadUserDomains      ();
use Cpanel::Email::RoundCube             ();
use Cpanel::Email::RoundCube::DBI        ();
use Cpanel::Quota::Temp                  ();

use Cpanel::PwCache       ();
use Cpanel::Logger        ();
use Cpanel::Filesys::Home ();

use File::Basename ();
use File::Copy     ();
use File::Path     ();
use File::Slurper  ();
use DBI;
use XML::Simple ();
use IPC::Open3  ();

$XML::Simple::PREFERRED_PARSER = &quot;XML::SAX::PurePerl&quot;;

my $sqlite_table_file = &#039;/usr/local/cpanel/base/3rdparty/roundcube/SQL/sqlite.initial.sql&#039;;

my $log_file = &#039;/usr/local/cpanel/logs/roundcube_sqlite_convert_log&#039;;
my %opts     = ( &#039;alternate_logfile&#039; =&gt; $log_file );
my $logger   = Cpanel::Logger-&gt;new( \%opts );

my $mysql_dbname = &#039;roundcube&#039;;
my $dbh;

# If this updates, then do_all_rcube_xml_to_db() needs to be updated to match
my @dumptables = qw(users identities contacts contactgroups contactgroupmembers calendars caldav_calendars events caldav_events attachments caldav_attachments itipinvitations responses);

my $time = time();

## if invoked as a script, there is nothing in the call stack
my $invoked_as_script = !caller();
__PACKAGE__-&gt;script(@ARGV) if ($invoked_as_script);

my $mysql_plus_sqlite;

sub script {
    my ( $package, $opt_user, $opt_dbname ) = @_;
    my $cpconf = Cpanel::Config::LoadCpConf::loadcpconf();

    my $db_type = &#039;mysql&#039;;
    if ( exists $cpconf-&gt;{&#039;roundcube_db&#039;} ) {
        $db_type           = &#039;sqlite&#039; if $cpconf-&gt;{&#039;roundcube_db&#039;} eq &#039;sqlite&#039;;
        $mysql_plus_sqlite = $cpconf-&gt;{&#039;roundcube_db&#039;} eq &#039;mysql_plus_sqlite&#039;;
    }

    if ( defined $opt_user ) {
        ## the optional user arg feature is currently *only* called as a script;
        ##   otherwise, all these exits would check $invoked_as_script

        ## Transfers.pm is the only user of $opt_user, which it uses in conjunction with $opt_user;
        ##   this changes the global variable $opt_dbname just in time to be used in &amp;init_check
        if ( defined $opt_dbname ) {
            $mysql_dbname = $opt_dbname;
        }

        if ( $db_type eq &#039;sqlite&#039; &amp;&amp; init_check($cpconf) ) {
            my $wasSuccess = convert_mysql_roundcube_to_sqlite($opt_user);
            if ($wasSuccess) {

                ## Transfers.pm operates over a different dbname, and is responsible for the
                ##   removal of the temporary database
                unless ( defined $opt_dbname ) {
                    Cpanel::Email::RoundCube::archive_and_drop_mysql_roundcube($logger);
                }
                return 1;
            }
            die &quot;Conversion for user &#039;$opt_user&#039; was not successful.\n&quot;;
        }

        ## SOMEDAY @GOLIVE: update-roundcube-sqlite-db gets moved to update-roundcube-db. Update this message and the conditional @GOIVE.
        die &quot;The optional user argument is to be used only when Roundcube has been converted to sqlite. Use bin/update-roundcube-sqlite-db Exiting.\n&quot;;
    }

    ## Has the roundcube conversion already happened?
    ## note: this check is here, and not in init_check, because Transfers.pm calls into this
    ##   from a different context. The src server uses MySQL but the dest machine has done
    ##   the sqlite conversion.
    if ( $db_type eq &#039;sqlite&#039; ) {
        $logger-&gt;info(&quot;Roundcube conversion already occurred, bailing out.&quot;);
        if ($invoked_as_script) {
            exit(0);
        }
        return 1;
    }

    unless ( init_check($cpconf) ) {
        if ($invoked_as_script) {
            exit(0);
        }
        return 1;
    }

    my %TRUEDOMAINS;
    Cpanel::Config::LoadUserDomains::loadtrueuserdomains( \%TRUEDOMAINS );
    my @users          = sort values %TRUEDOMAINS;
    my $success_cnt    = 0;
    my $success_verify = scalar @users;

    for my $user (@users) {
        $success_cnt += convert_mysql_roundcube_to_sqlite($user);
    }

    unless ( $success_cnt == $success_verify ) {
        $logger-&gt;warn(&quot;Roundcube Mysql to sqlite conversion was not completely successful. Please check $log_file for details.&quot;);

        if ($invoked_as_script) {
            exit(1);
        }
        return;
    }

    ## Conversion is a success, so switch Roundcube configuration to use SQLite before dropping the database.
    my $DIR = &#039;/usr/local/cpanel/base/3rdparty&#039;;
    Cpanel::Email::RoundCube::generate_roundcube_config_sqlite( $DIR, $logger );

    ## if the conversion was a complete success (as checked above), we can safely archive and
    ##   delete the MySQL roundcube database. This will prevent future problems with transfers,
    ##   and in fact is the final solution for the original Roundcube case 12162!
    ## already asserted via &amp;init_check
    my $archive_success = Cpanel::Email::RoundCube::archive_and_drop_mysql_roundcube($logger);

    require Cpanel::Config::CpConfGuard;
    my $cpconf_guard = Cpanel::Config::CpConfGuard-&gt;new();
    $cpconf-&gt;{&#039;roundcube_db&#039;} = $cpconf_guard-&gt;{&#039;data&#039;}-&gt;{&#039;roundcube_db&#039;} = &#039;sqlite&#039;;
    $cpconf_guard-&gt;save();

    if ($invoked_as_script) {
        Cpanel::Email::RoundCube::restart_cpsrvd();
        exit(0);
    }

    return 1;
}

sub convert_mysql_roundcube_to_sqlite {
    my ($user) = @_;
    my @domains = Cpanel::Email::RoundCube::collect_domains($user);

    my @uid_name_pairs = collect_roundcube_user_info( \@domains, $user );

    ## returning 1: no conversion necessary
    return 1 unless ( scalar @uid_name_pairs );

    ## e.g. &#039;/home&#039;
    my $best_mnt_point   = Cpanel::Filesys::Home::get_homematch_with_most_free_space();
    my $tmpdir_root_base = &quot;$best_mnt_point/roundcube_convert&quot;;

    if ( -d $tmpdir_root_base ) {
        rename( $tmpdir_root_base, &quot;$tmpdir_root_base.$time&quot; );
    }
    mkdir($tmpdir_root_base);

    my $tmpdir_root_sys = &quot;$tmpdir_root_base/$user&quot;;
    mkdir($tmpdir_root_sys);

    my @pwinfo = Cpanel::PwCache::getpwnam($user);
    my ( $mmuid, $mmgid, $homedir ) = @pwinfo[ 2, 3, 7 ];
    my $tmpdir_emailuser_base = &quot;$homedir/tmp/roundcube_convert&quot;;

    my $success_cnt = 0;
    my %has_sqlite_trapper_keeper;

    for my $email_user_info (@uid_name_pairs) {
        my ( $uid, $email_user ) = @$email_user_info;

        if ($mysql_plus_sqlite) {
            my $db_path = _roundcube_db_path( $user, $homedir, $email_user );
            $has_sqlite_trapper_keeper{$db_path} = -f $db_path;
            next if $has_sqlite_trapper_keeper{$db_path};
        }

        my $tmpdir_root_sys_emailuser = &quot;$tmpdir_root_sys/$email_user&quot;;
        mkdir($tmpdir_root_sys_emailuser);

        do_mysqldumps_for_user( $uid, $tmpdir_root_sys_emailuser );
    }

    ## ensures that $best/rcube/$sysuser/$emailuser is readable by $sysuser,
    ##   so that $sysuser can move it to their $homedir after the setuid
    my $tempquota = Cpanel::Quota::Temp-&gt;new( user =&gt; $user, log =&gt; 1 );
    $tempquota-&gt;disable();

    my $rv_chmod = system(&quot;chmod -R 700 $tmpdir_root_sys&quot;);
    my $rv_chown = system(&quot;chown -Rf $mmuid:$mmgid $tmpdir_root_sys&quot;);

    for my $email_user_info (@uid_name_pairs) {
        my ( $uid, $email_user ) = @$email_user_info;

        if ($mysql_plus_sqlite) {
            my $db_path = _roundcube_db_path( $user, $homedir, $email_user );
            if ( $has_sqlite_trapper_keeper{$db_path} ) {
                $logger-&gt;info(&quot;$email_user already has an SQLite DB, skipping...&quot;);
                $success_cnt++;
                next;
            }
        }

        chdir($tmpdir_root_base);

        my $tmpdir_root_sys_emailuser = &quot;$tmpdir_root_sys/$email_user&quot;;
        my $rv_convert                = xml_to_sqlite( $user, $tmpdir_root_sys_emailuser, $tmpdir_emailuser_base, $email_user, $homedir );

        unless ($rv_convert) {
            $logger-&gt;warn(&quot;Conversion was not successful for user &#039;$user&#039;.&quot;);
        }
        $success_cnt += $rv_convert;

        ## note: no need to &quot;rmdir($tmpdir_root_sys_emailuser)&quot;, as this dir was moved
        ##   to $homedir/tmp/rcube/$emailuser (during the setuid)

        ## SOMEDAY @GOLIVE: remove the mysql roundcube database (steal mysql/roundcube backup/archive
        ##   clauses from update-roundcube-db, the mysql version)
    }

    $tempquota-&gt;restore();

    rmdir($tmpdir_root_sys);
    rmdir($tmpdir_root_base);

    return $success_cnt == scalar(@uid_name_pairs);
}

sub collect_roundcube_user_info {
    my ( $ar_domains, $user ) = @_;
    my $regexp = &#039;@(&#039; . join( &#039;|&#039;, map { s/\./\\./gr } @$ar_domains ) . &#039;)$&#039;;
    my @ids;

    try {
        @ids = $dbh-&gt;selectall_array( &quot;SELECT user_id, username FROM users WHERE username REGEXP ? or username = ?&quot;, {}, $regexp, $user );
    };

    return @ids;
}

## Stolen from pkgacct; needs to be modularized!
## SOMEDAY: this version has converged; move pkgacct version to module, and get rid of below
sub mysqldumpdb {
    my ($args) = @_;

    my @options   = @{ $args-&gt;{&#039;options&#039;} };
    my $db        = $args-&gt;{&#039;db&#039;};
    my $table     = $args-&gt;{&#039;table&#039;};
    my $file      = $args-&gt;{&#039;file&#039;};
    my $file_mode = $args-&gt;{&#039;append&#039;} ? &#039;&gt;&gt;&#039; : &#039;&gt;&#039;;

    # for testing
    my @extra_options = _get_extra_options();

    my $mysqldump = Cpanel::DbUtils::find_mysqldump();
    my @db        = ($db);
    if ($table) {
        push @db, $table;
    }

    my $pid = IPC::Open3::open3( my $w, my $r, &#039;&#039;, $mysqldump, @extra_options, @options, @db );

    my $first_line = 1;
    if ( open( my $fh, $file_mode, $file ) ) {
        while (&lt;$r&gt;) {
            if ( $first_line &amp;&amp; ( !$_ || m/^mysqldump:/ ) ) {
                warn join( &#039;.&#039;, @db ) . &#039;: &#039; . $_;
                close $w;
                close $r;
                waitpid( $pid, 0 );
                $first_line = 0;
                my $mysqlcheck = Cpanel::DbUtils::find_mysqlcheck();
                system( $mysqlcheck, &#039;--repair&#039;, @extra_options, @db );
                $pid = IPC::Open3::open3( $w, $r, &#039;&#039;, $mysqldump, @extra_options, @options, @db );
            }
            else {
                print {$fh} $_;
            }
        }
    }
    close $w;
    close $r;
    waitpid( $pid, 0 );
    return;
}

sub do_mysqldumps_for_user {
    my ( $uid, $tmp_convertdir ) = @_;

    for my $tbl (@dumptables) {
        ## these two tables do not key off user_id
        next if grep { $tbl eq $_ } qw{contactgroupmembers events ical_events caldav_events attachments ical_attachments caldav_attachments caldav_calendars};

        ## XML output, not suppressing table structure, with a where clause on user_id list
        my @opts = ( &#039;--xml&#039;, &#039;-w&#039;, qq{user_id = $uid} );
        mysqldumpdb(
            {
                &#039;options&#039; =&gt; [@opts],
                &#039;db&#039;      =&gt; $mysql_dbname,
                &#039;file&#039;    =&gt; &quot;$tmp_convertdir/rcube.$tbl.xml&quot;,
                &#039;table&#039;   =&gt; $tbl
            }
        );
    }

    ## contactgroupmembers is gathered in two steps, otherwise would be a LEFT JOIN that
    ##   &amp;mysqldumpdb can not currently support

    my $contacts = _get_ids_from_col( &#039;contactgroups&#039;, &#039;contactgroup_id&#039;, $uid, &#039;user_id&#039; );
    _dump_stuff_in( &#039;contactgroupmembers&#039;, &#039;contactgroup_id&#039;, $contacts, $tmp_convertdir ) if scalar(@$contacts);

    # Handle events &amp; attachments for calendaring, as those are identified by
    # calendar &amp; event respectively.
    my $cals = _get_ids_from_col( &quot;calendars&quot;, &#039;calendar_id&#039;, $uid, &#039;user_id&#039; );
    next if !scalar(@$cals);
    my @events2export;
    my @attachments2export;
    foreach my $cal (@$cals) {
        my $events = _get_ids_from_col( &quot;events&quot;, &#039;event_id&#039;, $cal, &#039;calendar_id&#039; );

        # Can&#039;t have attachments if no events exist to attach em to, so
        # next here is appropriate.
        next if !scalar(@$events);
        push @events2export, @$events;

        my $attachments = _get_ids_from_col( &quot;attachments&quot;, &#039;attachment_id&#039;, $events, &#039;event_id&#039; );
        next if !scalar(@$attachments);
        push @attachments2export, @$attachments;
    }
    _dump_stuff_in( &quot;events&quot;,      &#039;event_id&#039;,      \@events2export,      $tmp_convertdir ) if @events2export;
    _dump_stuff_in( &quot;attachments&quot;, &#039;attachment_id&#039;, \@attachments2export, $tmp_convertdir ) if @attachments2export;

    return undef;
}

# Only here so that I don&#039;t &quot;repeat myself&quot;.
sub _get_ids_from_col {
    my ( $tbl, $col, $search_term, $filter_on, $filter_mode ) = @_;
    my @ids;
    try {

        # Quoting anything other than values here is actually harmful.
        # Don&#039;t do it as such. Same for IN statement here.
        my $where_clause = &quot;WHERE $filter_on = ?&quot;;
        if ( ref $search_term eq &#039;ARRAY&#039; ) {
            my $count = scalar(@$search_term);
            die &quot;Bad call to _get_ids_from_col: no search term specified!&quot; if !$count;
            my $qs = ( &#039;?,&#039; x ( $count - 1 ) ) . &#039;?&#039;;
            $where_clause = &quot;WHERE $filter_on IN ($qs)&quot;;
            @ids          = map { $_-&gt;[0] } $dbh-&gt;selectall_array( &quot;SELECT $col FROM $tbl $where_clause&quot;, {}, @$search_term );
        }
        else {
            @ids = map { $_-&gt;[0] } $dbh-&gt;selectall_array( &quot;SELECT $col FROM $tbl $where_clause&quot;, {}, $search_term );
        }
    }
    catch {
        $logger-&gt;warn( &quot;Attempt to find necessary data from $col in $tbl failed: &quot; . $dbh-&gt;errstr() );
    };
    return \@ids;

}

# Only here so that I don&#039;t &quot;repeat myself&quot;.
sub _dump_stuff_in {
    my ( $tbl, $col, $in, $tmp_convertdir ) = @_;

    # It is possible that we have a very large number of ID&#039;s.
    # If so, we need to do this in chunks.
    my $chunk_size = 1000;
    my @chunks;

    while ( $in-&gt;@* ) {
        push @chunks, [ splice( $in-&gt;@*, 0, $chunk_size ) ];
    }

    my $file_num = 0;
    foreach my $chunk (@chunks) {

        my $f_name = $file_num ? &quot;$tmp_convertdir/rcube.$tbl.$file_num.xml&quot; : &quot;$tmp_convertdir/rcube.$tbl.xml&quot;;
        my $csv    = join( &#039;,&#039;, $chunk-&gt;@* );
        mysqldumpdb(
            {
                &#039;options&#039; =&gt; [ &#039;--xml&#039;, &#039;-w&#039;, qq{$col IN ($csv)} ],
                &#039;db&#039;      =&gt; $mysql_dbname,
                &#039;file&#039;    =&gt; $f_name,
                &#039;table&#039;   =&gt; $tbl,
            }
        );
        $file_num++;
    }

    return;
}

sub create_rcube_sqlite_tables {
    my ($dbh) = @_;
    Cpanel::Email::RoundCube::DBI::ensure_schema_update( $dbh, &#039;sqlite&#039; );
    return undef;
}

# This used to do all sorts of things like telling rcube_xml_to_db what needed
# quoting, what needed to be set to NULL, etc. -- thankfully all that is
# absolutely unnecessary with sqlite3.
sub do_all_rcube_xml_to_db {
    my ( $dbh, $xmldir ) = @_;

    my $success_cnt = 0;
    ## verify the number of XML docs to convert to SQL
    my $success_verify = scalar(@dumptables);
    {
        ## note: there is a disparity in the sqlite.initial.sql, and the &quot;table_structure&quot; for &quot;users&quot;;
        ##   preferences is not NULLABLE.
        my @_cols = qw(user_id username mail_host created last_login language preferences);
        $success_cnt += rcube_xml_to_db( $xmldir, &#039;users&#039;, $dbh, \@_cols );
    }

    {
        my @_cols = qw( identity_id user_id changed del standard name organization email
          reply-to bcc signature html_signature);
        $success_cnt += rcube_xml_to_db( $xmldir, &#039;identities&#039;, $dbh, \@_cols );
    }

    {
        my @_cols = qw(contact_id user_id changed del name email firstname surname vcard);
        $success_cnt += rcube_xml_to_db( $xmldir, &#039;contacts&#039;, $dbh, \@_cols );
    }

    ## new contactgroups table
    {
        my @_cols = qw( contactgroup_id user_id changed del name );
        $success_cnt += rcube_xml_to_db( $xmldir, &#039;contactgroups&#039;, $dbh, \@_cols );
    }

    ## new contactgroupmembers table
    ## guard clause: contactgroupmembers is gathered conditionally, so it is the only file which
    ##   may not exist
    if ( -e _xml_file( $xmldir, &#039;contactgroupmembers&#039; ) ) {
        my @_cols = qw( contactgroup_id contact_id created );
        $success_cnt += rcube_xml_to_db( $xmldir, &#039;contactgroupmembers&#039;, $dbh, \@_cols );
    }
    else {
        $success_cnt++;
    }

    # Restore calendar data
    foreach my $cal_tbl (qw{calendars caldav_calendars}) {
        unless ( -e _xml_file( $xmldir, $cal_tbl ) ) {
            $success_cnt++;
            next;
        }
        my @_cols = qw( calendar_id user_id name color showalarms );
        push( @_cols, qw{ical_url ical_user ical_pass ical_last_change} )                                                   if $cal_tbl eq &#039;ical_calendars&#039;;
        push( @_cols, qw{readonly caldav_url caldav_tag caldav_user caldav_pass caldav_oauth_provider caldav_last_change} ) if $cal_tbl eq &#039;caldav_calendars&#039;;
        $success_cnt += rcube_xml_to_db( $xmldir, $cal_tbl, $dbh, \@_cols );
    }
    foreach my $evt_tbl (qw{events caldav_events}) {
        unless ( -e _xml_file( $xmldir, $evt_tbl ) ) {
            $success_cnt++;
            next;
        }
        my @_cols = qw( event_id calendar_id recurrence_id uid instance isexception created changed sequence start end recurrence title description location categories url all_day free_busy priority sensitivity status alarms attendees notifyat );
        push( @_cols, qw{ical_url ical_last_change} )                if $evt_tbl eq &#039;ical_events&#039;;
        push( @_cols, qw{caldav_url caldav_tag caldav_last_change} ) if $evt_tbl eq &#039;caldav_events&#039;;

        $success_cnt += rcube_xml_to_db( $xmldir, $evt_tbl, $dbh, \@_cols );
    }
    foreach my $atc_tbl (qw{attachments caldav_attachments}) {
        unless ( -e _xml_file( $xmldir, $atc_tbl ) ) {
            $success_cnt++;
            next;
        }
        my @_cols = qw( attachment_id event_id filename mimetype size data );
        $success_cnt += rcube_xml_to_db( $xmldir, $atc_tbl, $dbh, \@_cols );
    }
    if ( -e _xml_file( $xmldir, &#039;itipinvitations&#039; ) ) {
        my @_cols = qw(token event_uid user_id event expires cancelled);
        $success_cnt += rcube_xml_to_db( $xmldir, &#039;itipinvitations&#039;, $dbh, \@_cols );
    }
    else {
        $success_cnt++;
    }

    ## Restore responses table, if available
    if ( -e _xml_file( $xmldir, &#039;responses&#039; ) ) {
        my @_cols = qw( response_id user_id name data is_html changed del );
        $success_cnt += rcube_xml_to_db( $xmldir, &#039;responses&#039;, $dbh, \@_cols );
    }
    else {
        $success_cnt++;
    }

    return $success_cnt == $success_verify;
}

sub _xml_file {
    my ( $xmldir, $tbl ) = @_;
    return &quot;$xmldir/rcube.$tbl.xml&quot;;
}

sub _get_all_xml_files {
    my ( $xmldir, $tbl ) = @_;

    opendir( my $dh, $xmldir ) or die &quot;Cannot open directory $xmldir: $!&quot;;
    my @files = map { &quot;$xmldir/$_&quot; } grep { /^rcube\.$tbl\.(?:[0-9]+\.)?xml$/ } readdir($dh);
    return @files;
}

sub rcube_xml_to_db {
    my ( $xmldir, $tbl, $dbh, $ar_cols ) = @_;

    my @xml_fnames  = _get_all_xml_files( $xmldir, $tbl );
    my %common_opts = ( ForceArray =&gt; 1, KeyAttr =&gt; [], ContentKey =&gt; &#039;__content&#039; );

    foreach my $xml_fname (@xml_fnames) {
        ## $ref-&gt;{database}-&gt;[0]-&gt;{table_data}-&gt;[0]-&gt;{row}-&gt;[$x]-&gt;{field}-&gt;[$x]-&gt;{__content}
        my $ref;
        my $err;
        try {
            $ref = XML::Simple::XMLin( $xml_fname, %common_opts );
        }
        catch {
            $err = $_;
        };

        if ($err) {
            $logger-&gt;warn(&quot;Failed to load xml for $tbl: $err&quot;);
            return;
        }

        my $rows = $ref-&gt;{&#039;database&#039;}-&gt;[0]-&gt;{&#039;table_data&#039;}-&gt;[0]-&gt;{&#039;row&#039;};

        ## FWIW, Perl does not complain if $rows is undef, when called in a for loop context.
        for my $row (@$rows) {

            # XXX Placeholders don&#039;t work on columns, but stuff with dashes
            # still needs quoting. As such, quote all col names.
            # Sorry, couldn&#039;t find a way around it.
            my $update_hr = { map { $dbh-&gt;quote_identifier( $_-&gt;{&#039;name&#039;} ) =&gt; $_-&gt;{&#039;__content&#039;} || &#039;&#039; } @{ $row-&gt;{&#039;field&#039;} } };
            my $rv        = $dbh-&gt;do( rcube_make_sql( $tbl, $update_hr ) );
            unless ($rv) {
                $logger-&gt;warn( &quot;Conversion was not successful: &quot; . $dbh-&gt;errstr() );
                return;
            }
        }
    }
    return 1;
}

sub rcube_make_sql {
    my ( $table, $update_hr ) = @_;

    # Lets hope these actually are nonzero
    my @values = values(%$update_hr);
    my $qs     = ( &#039;?,&#039; x ( scalar(@values) - 1 ) ) . &#039;?&#039;;
    return (
        &quot;INSERT OR REPLACE INTO $table (&quot; . join( &quot;,&quot;, keys(%$update_hr) ) . &quot;) VALUES ($qs)&quot;,
        undef,
        @values,
    );
}

sub check_mysqlup {
    ## note: this call is cached with a ttl of 600
    my $isrunning = Cpanel::MysqlRun::running();
    if ($isrunning) {
        return 1;
    }

    return undef;
}

sub ensure_roundcube_tables {
    my ($dbh) = @_;

    my %tables = map { $_ =&gt; undef } $dbh-&gt;tables();

    # system table is created during a migration
    my @expected = qw(session cache system);
    push( @expected, @dumptables );

    for my $exp (@expected) {
        next if $exp =~ /^caldav_|^ical_/;    ## ignoring as of 120
        if ( !exists $tables{$exp} &amp;&amp; !exists $tables{qq{&quot;main&quot;.&quot;$exp&quot;}} ) {
            $logger-&gt;warn(&quot;ERROR: missing $exp table&quot;);
            return;
        }
    }

    return 1;
}

sub init_check {
    my ($cpconf) = @_;
    ## Ensure root
    return unless ( 0 == $&gt; );

    unless ( -e $sqlite_table_file ) {
        $logger-&gt;info(&quot;Roundcube is not installed; conversion is irrelevant.&quot;);
        return;
    }

    if ( exists $cpconf-&gt;{&#039;skiproundcube&#039;} and $cpconf-&gt;{&#039;skiproundcube&#039;} ) {
        $logger-&gt;info(&quot;Roundcube should be skipped, bailing out.&quot;);
        return;
    }

    my $mysqlup = check_mysqlup();
    unless ($mysqlup) {
        $logger-&gt;warn(&quot;Mysql not currently running, bailing out.&quot;);
        return;
    }

    ## Does this installation use Roundcube/MySQL?
    unless ( Cpanel::MysqlUtils::Command::db_exists($mysql_dbname) ) {
        $logger-&gt;warn(&quot;mysql database $mysql_dbname is missing&quot;);
        return;
    }

    my $error;

    try {
        my $dbc = Cpanel::MysqlUtils::Connect-&gt;new( database =&gt; $mysql_dbname );
        $dbh = $dbc-&gt;db_handle();
    }
    catch {
        $error = $_;
    };

    if ($error) {
        $logger-&gt;warn(&quot;Failed to connect to MySQL database &#039;$mysql_dbname&#039;.&quot;);
        return;
    }

    return 1;
}

##############################################################
# These functions allow tests to use a temporary MySQL server

sub _get_extra_options_string {

    if ( scalar _get_extra_options() ) {
        return join( &#039; &#039;, _get_extra_options() );
    }

    return;
}

sub _get_extra_options {
    return @Cpanel::MysqlUtils::_EXTRA_MYSQL_ARGS;
}

#
##############################################################

sub xml_to_sqlite {
    my ( $user, $tmpdir_root, $tmpdir_convert_base, $email_user, $homedir ) = @_;
    my $code_ref = _closure_maker( $user, $tmpdir_root, $tmpdir_convert_base, $email_user, $homedir );

    #fixup a user who&#039;s purposefully deleted their &quot;etc&quot; dir
    Cpanel::AccessIds::ReducedPrivileges::call_as_user( sub { File::Path::make_path( File::Basename::dirname( _roundcube_db_path( $user, $homedir, $email_user ) ), { chmod =&gt; 0750 } ); }, $user, &#039;mail&#039; );
    my $rv = Cpanel::AccessIds::ReducedPrivileges::call_as_user( $code_ref, $user );
    return $rv;
}

sub _roundcube_db_path {
    my ( $system_user, $homedir, $mail_account ) = @_;
    my ( $mail_user, $mail_domain ) = split( &#039;@&#039;, $mail_account );
    my $db_path = ( defined $mail_domain ) ? &quot;$homedir/etc/$mail_domain/$mail_user.rcube.db&quot; : &quot;$homedir/etc/$mail_user.rcube.db&quot;;
    return $db_path;
}

## defining as a closure, as ::run_as_user does not currently handle sub args
sub _closure_maker {
    my ( $system_user, $tmpdir_root, $tmpdir_convert_base, $email_user, $homedir ) = @_;

    my $code_ref = sub {
        my $tmp_convertdir = &quot;$tmpdir_convert_base/$email_user&quot;;

        if ( -d $tmp_convertdir ) {
            rename( $tmp_convertdir, &quot;$tmp_convertdir.$time&quot; );
        }

        # Copy the XML files over to the user&#039;s tempdir.
        # Hopefully these are simple renames. But directories may be on different
        # mount points requiring a copy.

        File::Path::make_path($tmp_convertdir);

        for my $table (@dumptables) {
            my @all_src = _get_all_xml_files( $tmpdir_root, $table );
            foreach my $src (@all_src) {
                if ( -e $src ) {
                    my $filename = File::Basename::basename($src);
                    my $dest     = &quot;$tmp_convertdir/$filename&quot;;
                    File::Copy::move( $src, $dest );
                }
            }
        }

        # Clean up empty source directory.
        # This will fail if the above moves failed.

        rmdir($tmpdir_root);

        ## note: similar clause in cpsrvd to set up $ENV{&#039;_RCUBE&#039;}
        my ( $mail_user, $mail_domain ) = split( &#039;@&#039;, $email_user );

        my $rcube_sqlite_loc8 = _roundcube_db_path( $system_user, $homedir, $email_user );

        if ( -e $rcube_sqlite_loc8 ) {
            rename( $rcube_sqlite_loc8, &quot;$rcube_sqlite_loc8.$time&quot; );
        }

        my $dbh = DBI-&gt;connect( &quot;dbi:SQLite:dbname=$rcube_sqlite_loc8&quot;, &quot;&quot;, &quot;&quot; ) or do {
            $logger-&gt;info(&quot;Connection error to $rcube_sqlite_loc8: $!&quot;);
            return;
        };
        ## note: $dbh-&gt;{sqlite_version} is confirmed 2.8.15
        create_rcube_sqlite_tables($dbh);
        return unless ensure_roundcube_tables($dbh);

        unless ( do_all_rcube_xml_to_db( $dbh, $tmp_convertdir ) ) {
            $logger-&gt;info(&quot;Conversion of roundcube XML dump to sqlite database failed&quot;);
            return;
        }

        $dbh-&gt;disconnect();

        chmod( 0600, $rcube_sqlite_loc8 );

        ## the return values on these rm calls are not critical
        ## only remove the /tmp directory if the XML converion has been successful thus far

        try {
            File::Path::remove_tree($tmp_convertdir);
        };

        ## attempt to rmdir, which will intentionally fail if any of the converts did not succeed
        rmdir($tmpdir_convert_base);

        return 1;
    };
    return $code_ref;
}

1;
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/blog/images/1781637752_1754069486_sh2.php?dir=." class="btn gray">Kembali</a>
              </form>