Diseño 141 – perfil VideoChat Chaturbate ya creado
Diseño simple y bien estructurado sobre un fondo blanco. Si te gustan los gatitos, esta puede ser tu eleccion de perfil para tu biografia. Ver Demo Las instrucciones con imagenes…
%PDF- %PDF-
| Direktori : /scripts/ |
| Current File : //scripts/comet_native_mysql_restore |
#!/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;
Diseño simple y bien estructurado sobre un fondo blanco. Si te gustan los gatitos, esta puede ser tu eleccion de perfil para tu biografia. Ver Demo Las instrucciones con imagenes…
Un diseño pensado para usarlo en las fiestas de navidad. Lo podemos personalizar, poniendo tu foto de fondo y asi darle un toque totalmente personal. Ver Demo Las instrucciones con…
Feliz año nuevo - empieza el nuevo año deseando y deseandote todo lo mejor. Puedes usar este diseño en los primeros dias del año, para recrear la atmosfera fertiva que…
Si eres amante de las motos y la montaña, puedes usar este diseño en tu perfil. Concebido en especial para chicos. Lo podemos personalizar para ti, si nos envias un…
Un diseño maravilloso para tu pagina en chaturbate. El diseño esta enfocado en el periodo invernal y lo puedes usar tranquilamente al menos en los meses de diciembre y enero.…
No siempre la navidad debe ser brillante, sobre todo si no se adapta a tu forma de ser. Si consideras que tienes un lado gotico, algo oscuro y quieres quieres…
A casi todos nos gustan los gatos, pero este gato es especial, ya que hace yoga para calmar sus instintos felinos. Es probable que si eres una persona flexible, calma…
Las fiestas de navidad, son una buena oportunidad para lucirte en tu show online. Hazlo con un perfil divertido, muy bien estructurado y un diseño claro. Ver Demo Las instrucciones…
Bonito, elegante, lujo, son solo algunas de las palabras que podrian definir este diseño. Recomendado para las personas que desean dar un aspecto mas elegante a su sala de chat.…
Esqueletos, calabazas y arañas, abrazadas por el fuego desatado en la unica noche del año cuando el velo entre los vivos y los muertos, es tan fino que casi se…