|
Server IP : 162.241.5.139 / Your IP : 216.73.217.5 Web Server : Apache System : Linux server.vda.uxz.mybluehostin.me 5.14.0-687.59.1.el9_8.x86_64 #1 SMP PREEMPT_DYNAMIC Wed Oct 21 06:02:14 EDT 2026 x86_64 User : dataincite ( 1006) PHP Version : 8.2.35 Disable Function : exec,passthru,shell_exec,system MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF Directory (0755) : /../scripts/ |
| [ Home ] | [ C0mmand ] | [ Upload File ] |
|---|
#!/usr/local/cpanel/3rdparty/bin/perl
# Copyright 2026 WebPros International, LLC
# All rights reserved.
# copyright@cpanel.net http://cpanel.net
# This code is subject to the cPanel license. Unauthorized copying is prohibited.
package scripts::comet_native_mysql_restore;
use cPstrict;
use Getopt::Long ();
use Cpanel::Logger ();
my $logger;
# A backtick-quoted identifier (capture = the raw name, `` still doubled).
# Declared up here: file-scope lexicals below the `exit run(...)` line are
# never initialized when the script is executed rather than loaded.
my $RX_IDENT = qr/`((?:[^`]|``)+)`/;
my $RX_IDENT_NC = qr/`(?:[^`]|``)+`/;
# A mysqldump-family SET pragma that assigns a quoted literal to sql_mode:
# (prefix up to the opening quote)(the mode list)(closing quote + comment end).
my $RX_SQL_MODE_SET = qr{\A((?:\s*--[^\n]*\n)*\s*/\*M?!\d{4,6}\s+SET\s[^']*?\bsql_mode\s*=\s*')([^']*)('\s*\*/\s*)\z}is;
sub _logger { return $logger ||= Cpanel::Logger->new(); }
=encoding utf-8
=head1 NAME
comet_native_mysql_restore - Import a Comet native MySQL snapshot stream (CPANEL-54620)
=head1 SYNOPSIS
comet_native_mysql_restore --newuser <cpanel_user> --db <name> [--db <name> ...]
=head1 DESCRIPTION
Restore-side import helper for the Native Account-Data Model
(C<databases_native_mysql> Protected Items). The Comet C<backup-tool> agent
executes this script once per restored C<< <db>.sql >> stream (a
C<RESTORETYPE_PROCESS_PERFILE> restore) and pipes the mysqldump/mariadb-dump
SQL text to its stdin.
The script filters the stream and imports it over cPanel's managed MySQL
admin connection — the same trust model as the legacy
C<restorepkg --from-stdin> database restore. MySQL credentials never appear
in the Comet restore request or on the command line.
Filtering, per the FACT-0019 spike findings (raw replay of DEFINER clauses
requires ALL PRIVILEGES precisely because dumps can carry cross-user
DEFINERs):
=over 4
=item * Every C<DEFINER=`x`@`y`> clause on a DDL line is REWRITTEN to
C<DEFINER=`<newuser>`@`localhost`> — the restore target owns every object it
restores. A bare strip would instead make the importing account the definer
of C<SQL SECURITY DEFINER> objects, which is an escalation hazard.
=item * C<USE> and C<CREATE DATABASE> statements are validated against the
authorized C<--db> list (which mirrors the fail-closed restore authorization
in C<ProtectedItemRestore>). A stream whose C<USE>/C<CREATE DATABASE> names
any other database aborts the import before the offending statement is
executed.
=item * Values the dump carries for B<generated> (C<VIRTUAL>/C<STORED>/
C<PERSISTENT>) columns are replaced with C<DEFAULT> (CPANEL-57349).
mariadb-dump writes the computed value of every generated column into its
C<INSERT>s; MariaDB ignores it under the dump's non-strict C<SQL_MODE>, but
MySQL 8 rejects any value other than C<DEFAULT> (error 3105), which failed
the whole database import. C<DEFAULT> is the one value both engines accept,
and the server recomputes the column either way. See
L</neutralize_generated_column_values>.
=item * A C<SET sql_mode> the target server rejects is re-run without the
modes it does not know, e.g. MariaDB's C<NO_AUTO_CREATE_USER> on MySQL 8
(CPANEL-57398). See L</execute_statement>.
=back
B<Trust model.> This helper imports vault content over cPanel's managed MySQL
admin connection, exactly as the legacy C<restorepkg --from-stdin> database
restore does; that admin-replay-of-vault-content is the security bar, and this
path holds parity with it, no more and no less. The C<USE>/C<CREATE DATABASE>
allowlist and the DEFINER rewrite are B<defense-in-depth>, B<not> a sandbox: a
deliberately tampered stream could still reach other databases through a
cross-database-qualified identifier (C<UPDATE `other`.`t` ...>), just as a
tampered legacy DB tarball could. What the native model changes is blast
radius — one snapshot now holds every tenant's databases — so the fail-closed
per-database authorization in C<ProtectedItemRestore> (which decides B<which>
streams are even fetched) is the real cross-tenant boundary, and this filter
backs it up. A dedicated least-privilege restore user (spike floor P1-R6) is
the planned hardening (waypoint 1b).
The admin handle is obtained with C<mysql_multi_statements> B<disabled>, so a
crafted single line that packs a second statement after an allowed leading
C<USE> (C<USE `ok`; DROP ...>) is rejected by the server rather than executed —
the one-statement-per-C<do()> assumption below then holds.
Statement splitting is C<DELIMITER>-aware, mirroring the parsing Comet's own
engine applies to these dumps (routines/triggers arrive inside DELIMITER
blocks). Only mysqldump-family streams are supported: data lines never embed
raw newlines (mysqldump escapes them), so line-anchored DDL detection is
sound.
Exits non-zero on any validation or import failure so the agent records the
restore as failed.
=cut
exit run(@ARGV) unless caller;
sub run (@argv) {
my ( $newuser, @dbs );
Getopt::Long::GetOptionsFromArray(
\@argv,
'newuser=s' => \$newuser,
'db=s@' => \@dbs,
) or return _usage();
return _usage() unless defined $newuser && @dbs;
# Fail-closed identity checks. The username becomes a quoted identifier in
# rewritten DEFINER clauses; the database names bound the import scope.
if ( !_is_valid_target_user($newuser) ) {
_logger()->error("comet_native_mysql_restore: refusing import: invalid or unknown target user");
return 1;
}
my %allowed_db;
for my $db (@dbs) {
if ( !_is_valid_backed_up_db_name($db) ) {
_logger()->error("comet_native_mysql_restore: refusing import: database name fails validation");
return 1;
}
$allowed_db{$db} = 1;
}
my $dbh = _admin_dbh();
# $statements counts every executed statement, including mysqldump's own
# SET-pragma header/footer lines; $meaningful_applied only goes true once
# something that actually restores content (not just a session-setting
# pragma) runs. A stream that is empty, comment-only, or truncated right
# after the header (so nothing is left mid-statement to trip the
# truncation die below) leaves both false -- that is "nothing was
# actually applied", not a successful restore.
my $meaningful_applied = 0;
my %exec_state = ( db => undef, dropped_modes => {} );
my $statements = eval {
import_sql_stream(
\*STDIN,
sub ($stmt) {
$meaningful_applied ||= !_is_header_pragma_statement($stmt);
execute_statement( $dbh, $stmt, \%exec_state );
return;
},
$newuser,
\%allowed_db,
);
};
if ( my $err = $@ ) {
# Never echo statement text (it is customer data); the error from DBI
# already carries the server-side context.
my $where = defined $exec_state{db} ? " (database '$exec_state{db}')" : '';
_logger()->error("comet_native_mysql_restore: import failed for user '$newuser'$where: $err");
return 1;
}
if ( !$statements || !$meaningful_applied ) {
_logger()->error("comet_native_mysql_restore: import failed for user '$newuser': the database dump contained no data (it may be empty or truncated)");
return 1;
}
_logger()->info( sprintf( "comet_native_mysql_restore: imported %d statement(s) for user '%s' (databases: %s)", $statements, $newuser, join( ',', sort keys %allowed_db ) ) );
return 0;
}
sub _usage {
print STDERR "usage: comet_native_mysql_restore --newuser <cpanel_user> --db <name> [--db <name> ...]\n";
return 1;
}
=head1 FUNCTIONS
=head2 import_sql_stream( $in_fh, $exec_cb, $newuser, \%allowed_db )
Reads a mysqldump-family SQL stream from C<$in_fh>, applies the DEFINER
rewrite and database-scope enforcement line-wise, splits it into statements
(honoring C<DELIMITER> changes), and calls C<$exec_cb> with each complete
statement (after L</neutralize_generated_column_values>). Returns the number
of statements executed. Dies on scope violations or when C<$exec_cb> dies.
=cut
sub import_sql_stream ( $in_fh, $exec_cb, $newuser, $allowed_db ) {
my $delim = ';';
my @pending;
my $statements = 0;
my %generated_state = ( db => '', tables => {}, warned => {} ); # generated-column rewrite
while ( my $line = readline $in_fh ) {
$line =~ s/\r?\n\z//;
# Client-side DELIMITER directive: switch and swallow (never sent to
# the server), exactly like the mysql client and Comet's own parser.
if ( $line =~ m/\ADELIMITER[ \t]+(\S+)/ ) {
$delim = $1;
next;
}
assert_line_in_database_scope( $line, $allowed_db );
$line = rewrite_definers_in_line( $line, $newuser );
push @pending, $line;
if ( _ends_with( $line, $delim ) ) {
my $stmt = join( "\n", @pending );
$stmt = substr( $stmt, 0, length($stmt) - length($delim) );
@pending = ();
# Comment-only / whitespace-only chunks need not hit the server.
if ( $stmt =~ m/\S/ && $stmt !~ m/\A(?:\s*--[^\n]*\n?)+\z/ ) {
neutralize_generated_column_values( \$stmt, \%generated_state );
$exec_cb->($stmt);
$statements++;
}
}
}
# Trailing content with no terminating delimiter is comment/whitespace
# residue in well-formed dumps; anything else is a truncated stream.
my $residue = join( "\n", @pending );
if ( $residue =~ m/\S/ && $residue !~ m/\A(?:\s*(?:--[^\n]*)?\n?)+\z/ ) {
die "SQL stream ended mid-statement (truncated restore stream?)\n";
}
return $statements;
}
=head2 execute_statement( $dbh, $stmt, \%state )
Runs one statement on C<$dbh>. C<\%state> is per-stream state, initialised
as C<< { db => undef, dropped_modes => {} } >>; C<db> tracks the last C<USE>
so a failure can name the database.
B<sql_mode values the target does not know (CPANEL-57398).> mysqldump-family
dumps wrap every trigger, routine and event in
C<< /*!50003 SET sql_mode = '<source modes>' */ >>. MariaDB's default
sql_mode includes C<NO_AUTO_CREATE_USER>, which MySQL 8 removed, so the
server rejects that C<SET> (error 1231) and the whole database import used to
fail. When such a C<SET sql_mode> statement fails, each listed mode is tried
on its own and the statement is re-run with only the modes this server
accepts. The target server is the authority: no engine or version list is
kept here. A same-engine import never fails the C<SET>, so it runs exactly as
before. The dropped modes are logged once each. If no mode was rejected (the
failure has another cause), the original error is raised as before; if the
filtered C<SET> still fails, its error is raised.
A failed MariaDB-only C<SEQUENCE> statement gets a message that names it,
because the target engine cannot hold that object at all.
=cut
sub execute_statement ( $dbh, $stmt, $state ) {
return _note_use( $stmt, $state ) if eval { $dbh->do($stmt); 1 };
my $err = $@;
if ( my ( $head, $modes, $tail ) = $stmt =~ $RX_SQL_MODE_SET ) {
my ( @kept, @dropped );
for my $mode ( grep { length } split /\s*,\s*/, $modes ) {
if ( _server_accepts_sql_mode( $dbh, $mode ) ) { push @kept, $mode }
else { push @dropped, $mode }
}
die $err unless @dropped; # not an unknown-mode failure
$dbh->do( $head . join( ',', @kept ) . $tail );
for my $mode ( grep { !$state->{dropped_modes}{$_}++ } @dropped ) {
_logger()->warn("comet_native_mysql_restore: this database server does not support the sql_mode value '$mode' used in the dump; triggers, routines, and events that used it are created without it");
}
return;
}
if ( $stmt =~ m/^\s*(?:CREATE|DROP)\s+(?:OR\s+REPLACE\s+)?SEQUENCE\b/mi ) {
die "the dump contains a SEQUENCE object, which exists only on MariaDB and cannot be created on this database server: $err";
}
die $err;
}
sub _note_use ( $stmt, $state ) {
$state->{db} = _unquote_ident($1) if $stmt =~ m/\A(?:\s*--[^\n]*\n)*\s*USE\s+$RX_IDENT/i;
return;
}
# A mode name is a bare word (never quoted text), so it is safe to inline.
# The probe changes the session sql_mode; the caller's filtered SET that
# follows replaces it.
sub _server_accepts_sql_mode ( $dbh, $mode ) {
return 0 unless $mode =~ m/\A\w+\z/;
return eval { $dbh->do("SET SESSION sql_mode = '$mode'"); 1 } ? 1 : 0;
}
=head2 rewrite_definers_in_line( $line, $newuser )
On DDL-context lines only, rewrites every C<DEFINER=user@host> to
C<DEFINER=`$newuser`@`localhost`>. Data lines (C<INSERT ...>) are returned
untouched, so string contents can never be corrupted.
Because a missed DEFINER on a C<SQL SECURITY DEFINER> object is a
privilege-escalation hole (not merely a cosmetic miss), the DDL-context gate
is deliberately broad: any line beginning with C<CREATE>/C<ALTER>
(case-insensitive) or a MySQL C</*!NNNNN> or MariaDB C</*M!NNNNN> versioned
conditional comment. mysqldump and mariadb-dump only ever emit a DEFINER
clause inside one of these forms; INSERT/data lines never begin this way, so
a C<DEFINER=> substring embedded in string data is never rewritten.
=cut
sub rewrite_definers_in_line ( $line, $newuser ) {
return $line unless $line =~ m{\A\s*(?:/\*M?!\d{4,6}|CREATE\b|ALTER\b)}i;
$line =~ s{
DEFINER \s* = \s*
(?: `[^`]*` | '[^']*' | "[^"]*" | [\w.-]+ ) # user part
\@
(?: `[^`]*` | '[^']*' | "[^"]*" | [\w.%-]+ ) # host part
}{DEFINER=`$newuser`\@`localhost`}xgi;
return $line;
}
=head2 neutralize_generated_column_values( \$stmt, \%state )
Rewrites C<$stmt> in place so that every value an C<INSERT>/C<REPLACE>
supplies for a generated column becomes C<DEFAULT> (CPANEL-57349).
C<\%state> is per-stream state, initialised as
C<< { db => '', tables => {}, warned => {} } >>. C<USE> sets the current
database. A C<CREATE TABLE> records that table's column layout under
database + table (only when the table has a generated column), and is itself
left unchanged. A later C<INSERT INTO `t` VALUES> or
C<INSERT INTO `t` (`a`, ...) VALUES> for a recorded table has the values at
the generated positions replaced. The other values are kept byte for byte.
Fail-safe: when the statement's shape is not understood (a tuple with the
wrong number of values, an unterminated string, a trailing clause, an
unexpected column list) the statement is left unchanged, which is exactly
the behaviour before this rewrite, and a warning names the table (once per
table, never any row data).
=cut
sub neutralize_generated_column_values ( $sref, $state ) {
# mysqldump folds the preceding `-- ...` comment banner into the statement.
$$sref =~ m/\A(?:\s*--[^\n]*\n)*\s*/gc;
my $keyword_at = pos($$sref) // 0;
$$sref =~ m/\G(CREATE|USE|INSERT|REPLACE)\b/gci or return;
my $keyword = uc $1;
if ( $keyword eq 'USE' ) {
$state->{db} = _unquote_ident($1) if $$sref =~ m/\G\s+$RX_IDENT/gc;
return;
}
if ( $keyword eq 'CREATE' ) {
return unless $$sref =~ m/\G\s+(?:TEMPORARY\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?$RX_IDENT\s*\(/gci;
my $key = "$state->{db}\0" . _unquote_ident($1);
my $layout = _generated_column_layout( substr( $$sref, $keyword_at ) );
if ($layout) { $state->{tables}{$key} = $layout }
else { delete $state->{tables}{$key} }
return;
}
# INSERT / REPLACE: nothing to do (and nothing copied) unless this stream
# has a table with a generated column.
return unless %{ $state->{tables} };
return unless $$sref =~ m/\G(?:\s+(?:IGNORE|LOW_PRIORITY|DELAYED|HIGH_PRIORITY))*\s+INTO\s+$RX_IDENT/gci;
my $table = _unquote_ident($1);
my $layout = $state->{tables}{"$state->{db}\0$table"} or return;
my @columns;
if ( $$sref =~ m/\G\s*\(\s*((?:$RX_IDENT_NC\s*,\s*)*$RX_IDENT_NC)\s*\)\s*VALUES\s*/gc ) {
@columns = map { _unquote_ident($_) } $1 =~ m/$RX_IDENT/g;
}
elsif ( $$sref =~ m/\G\s*VALUES\s*/gci ) {
@columns = @{ $layout->{positional} };
}
else {
return _warn_unchanged( $state, $table );
}
my %replace_idx = map { $_ => 1 } grep { $layout->{generated}{ $columns[$_] } } 0 .. $#columns;
return unless %replace_idx; # e.g. a MySQL-source dump, which already omits them
my $spans = _generated_value_spans( $sref, pos($$sref), scalar(@columns), \%replace_idx ) or return _warn_unchanged( $state, $table );
# One forward pass: splicing each span in place would re-shift the tail of
# a ~1 MB extended INSERT once per row (quadratic).
my ( $out, $at ) = ( '', 0 );
for my $span (@$spans) {
$out .= substr( $$sref, $at, $span->[0] - $at ) . 'DEFAULT';
$at = $span->[0] + $span->[1];
}
$$sref = $out . substr( $$sref, $at );
return;
}
sub _warn_unchanged ( $state, $table ) {
return if $state->{warned}{"$state->{db}\0$table"}++;
_logger()->warn("comet_native_mysql_restore: could not locate the generated-column values in an INSERT for table '$table'; importing it unchanged");
return;
}
# Column layout of a mysqldump-family CREATE TABLE (one column definition per
# line, each starting with its backtick-quoted name). Returns undef unless the
# table has at least one generated column. `positional` is the column order a
# column-list-less INSERT fills (INVISIBLE columns are skipped by the server).
sub _generated_column_layout ($create) {
my ( @positional, %generated );
for my $line ( split /\n/, $create ) {
next unless $line =~ m/\A\s*$RX_IDENT\s+(.*)\z/;
my ( $name, $definition ) = ( _unquote_ident($1), $2 );
# Judge the definition with string literals (DEFAULT/COMMENT text) and
# quoted identifiers (e.g. a column named `invisible`) removed.
$definition =~ s/'(?:[^'\\]|\\.|'')*'/''/g;
$definition =~ s/$RX_IDENT_NC/``/g;
# A generated expression is always parenthesised; this deliberately
# excludes system-versioning `GENERATED ALWAYS AS ROW START/END`.
$generated{$name} = 1
if $definition =~ m/\bGENERATED\s+ALWAYS\s+AS\s*\(/i
|| $definition =~ m/\bAS\s*\(.*\)\s*(?:VIRTUAL|STORED|PERSISTENT)\b/i;
push @positional, $name unless $definition =~ m/\bINVISIBLE\b/i;
}
return undef unless %generated; # callers test truthiness
return { positional => \@positional, generated => \%generated };
}
# Scans the VALUES tuples of $$sref from offset $start. Returns [ [offset, length], ... ]
# for every value whose 0-based column index is in \%replace_idx, or undef when
# the text is not a plain list of $ncols-wide tuples. A value is any run of
# quoted strings and bare tokens (numbers, NULL, 0x.., _binary '..', X'..');
# the scan is an iterative tokenizer so long strings never hit regex limits.
sub _generated_value_spans ( $sref, $start, $ncols, $replace_idx ) {
pos($$sref) = $start;
my @spans;
while (1) {
$$sref =~ m/\G\s*\(/gc or return undef;
my $col = 0;
while (1) {
$$sref =~ m/\G\s*/gc;
my ( $value_start, $value_end ) = ( pos($$sref), undef );
# Fast path for the common single-token value (number, NULL, 0x..,
# or a string with no escapes); anything else takes the loop below.
my $single_token = $$sref =~ m/\G(?:[^,()'\s]++|'[^'\\]*+')(?=\s*[,)])/gc;
$value_end = pos($$sref) if $single_token;
while ( !$single_token ) {
if ( $$sref =~ m/\G'/gc ) {
while (1) {
next if $$sref =~ m/\G[^'\\]+/gc;
next if $$sref =~ m/\G\\./gcs;
next if $$sref =~ m/\G''/gc;
last if $$sref =~ m/\G'/gc;
return undef; # unterminated string
}
$value_end = pos($$sref);
}
elsif ( $$sref =~ m/\G[^,()'\s]+/gc ) {
$value_end = pos($$sref);
}
elsif ( $$sref =~ m/\G\s+(?=[^,()\s])/gc ) {
# whitespace inside a value (e.g. `_binary 'x'`)
}
else {
last;
}
}
return undef unless defined $value_end; # empty value
push @spans, [ $value_start, $value_end - $value_start ] if $replace_idx->{$col};
$col++;
$$sref =~ m/\G\s*/gc;
next if $$sref =~ m/\G,/gc;
last if $$sref =~ m/\G\)/gc;
return undef; # nested paren / junk
}
return undef unless $col == $ncols;
next if $$sref =~ m/\G\s*,/gc;
last if $$sref =~ m/\G\s*\z/gc;
return undef; # trailing clause
}
return \@spans;
}
sub _unquote_ident ($quoted) {
( my $name = $quoted ) =~ s/``/`/g;
return $name;
}
=head2 assert_line_in_database_scope( $line, \%allowed_db )
Dies (fail-closed) when a line is a C<USE> or C<CREATE DATABASE> statement
naming a database outside the authorized set. mysqldump's C<--databases>
streams contain exactly one of each, naming the dumped database.
=cut
sub assert_line_in_database_scope ( $line, $allowed_db ) {
my $named;
# mysqldump/mariadb-dump always backtick-quote the database identifier in
# USE and CREATE DATABASE (never a bare, unquoted name), and a backtick
# can never appear inside a legal cPanel database name (see
# Cpanel::Validate::DB::Name), so matching everything between a pair of
# backticks is both sufficient and correct for the full range of legal
# names (hyphens, dots, spaces, etc. included) -- not just [A-Za-z0-9_].
if ( $line =~ m/\AUSE\s+`([^`]+)`\s*;?/i ) {
$named = $1;
}
elsif ( $line =~ m{\ACREATE\s+DATABASE\s+(?:/\*!\d+\s+IF\s+NOT\s+EXISTS\s*\*/\s*|IF\s+NOT\s+EXISTS\s+)?`([^`]+)`}i ) {
$named = $1;
}
return unless defined $named;
return if $allowed_db->{$named};
die "SQL stream references database '$named', which is outside the authorized restore scope (fail-closed)\n";
}
=head2 _is_header_pragma_statement( $stmt )
True when C<$stmt> is nothing but one of mysqldump/mariadb-dump's own
session-setting header/footer lines -- a bare C<SET> wrapped entirely in a
single MySQL/MariaDB versioned conditional comment, e.g.
C<< /*!40101 SET NAMES utf8mb4 */ >> or C<< /*!40103 SET TIME_ZONE=... */ >>.
Every mysqldump-family stream opens and closes with a run of these; none of
them restores any database content, so a dump that executed only these
(CPANEL-56040: an empty, comment-only, or header-truncated stream) must not
be reported as a successful restore even though each C<SET> itself
succeeded.
=cut
sub _is_header_pragma_statement ($stmt) {
# The stream's very first pragma is often glued, in the same statement,
# to the whole-line `-- ...` comment banner mysqldump prints ahead of
# it (those lines never end in the statement delimiter, so the splitter
# in import_sql_stream folds them into the next statement). Strip that
# leading comment banner before checking for the pragma shape.
return $stmt =~ m{\A(?:\s*--[^\n]*\n)*\s*/\*M?!\d{4,6}\s+SET\b.*\*/\s*\z}is ? 1 : 0;
}
sub _ends_with ( $line, $delim ) {
return length($line) >= length($delim)
&& substr( $line, -length($delim) ) eq $delim;
}
# The target must be an existing cPanel account; its name is embedded in
# quoted DEFINER identifiers. Validation + existence check, both fail-closed.
sub _is_valid_target_user ($newuser) {
return 0 unless defined $newuser && $newuser =~ m/\A[a-z0-9][a-z0-9_.-]{0,31}\z/;
require Cpanel::Config::HasCpUserFile;
return Cpanel::Config::HasCpUserFile::has_cpuser_file($newuser) ? 1 : 0;
}
# The backup side (Whostmgr::CometBackup::NativeMysql::compute_mysql_include_list)
# captures every database Cpanel::DB::Map::Reader reports the account owns --
# i.e. every name that was ever legal enough for cPanel to create, which is
# whatever Cpanel::Validate::DB::Name::verify_mysql_database_name_format
# accepts (hyphens, dots, spaces, etc. -- far broader than [A-Za-z0-9_]).
# Reusing that same core format check (rather than a stricter homegrown
# regex) is what keeps every backed-up database restorable; reserved-name
# checking is deliberately skipped here since we are restoring, not minting,
# a database.
sub _is_valid_backed_up_db_name ($db) {
return 0 unless defined $db && length $db;
require Cpanel::Validate::DB::Name;
return eval { Cpanel::Validate::DB::Name::verify_mysql_database_name_format($db); 1 } ? 1 : 0;
}
# Managed cPanel MySQL admin connection — the same connector the plugin uses
# to provision the backup user and re-apply grants. Isolated for mocking.
#
# mysql_multi_statements is DISABLED for the import handle: the default cPanel
# admin handle enables it, which would let a crafted line pack a second
# statement after an allowed leading USE ("USE `ok`; DROP ...") past the
# per-line scope check. With it off, the server rejects any such line, so each
# do() below executes exactly one statement.
sub _admin_dbh {
require Cpanel::MysqlUtils::Connect;
return Cpanel::MysqlUtils::Connect::get_dbi_handle( extra_args => { mysql_multi_statements => 0 } );
}
1;