use warnings;
use POSIX qw(EINTR EEXIST EOPNOTSUPP);
use IO::Socket::IP;
-use Socket qw(AF_INET AF_INET6 AI_ALL AI_V4MAPPED);
+use Socket qw(AF_INET AF_INET6 AI_ALL AI_V4MAPPED AI_CANONNAME SOCK_DGRAM);
use IO::Select;
use File::Basename;
use File::Path qw(make_path);
our @EXPORT_OK = qw(
$IPV6RE
$IPV4RE
-lock_file
+lock_file
lock_file_full
-run_command
-file_set_contents
+run_command
+file_set_contents
file_get_contents
file_read_firstline
dir_glob_regex
if (!rename($tmpname, $filename)) {
my $msg = "close (rename) atomic file '$filename' failed: $!\n";
unlink $tmpname;
- die $msg;
+ die $msg;
}
}
my $fh = IO::File->new($filename, "r") ||
die "can't open '$filename' - $!\n";
- my $content = safe_read_from($fh, $max);
+ my $content = safe_read_from($fh, $max, 0, $filename);
close $fh;
}
sub safe_read_from {
- my ($fh, $max, $oneline) = @_;
+ my ($fh, $max, $oneline, $filename) = @_;
$max = 32768 if !$max;
+ my $subject = defined($filename) ? "file '$filename'" : 'input';
+
my $br = 0;
my $input = '';
my $count;
while ($count = sysread($fh, $input, 8192, $br)) {
$br += $count;
- die "input too long - aborting\n" if $br > $max;
+ die "$subject too long - aborting\n" if $br > $max;
if ($oneline && $input =~ m/^(.*)\n/) {
$input = $1;
last;
}
- }
- die "unable to read input - $!\n" if !defined($count);
+ }
+ die "unable to read $subject - $!\n" if !defined($count);
return $input;
}
my $timeout;
my $oldtimeout;
my $pid;
- my $exitcode;
+ my $exitcode = -1;
my $outfunc;
my $errfunc;
my $output;
my $afterfork;
my $noerr;
+ my $keeplocale;
eval {
$afterfork = $param{$p};
} elsif ($p eq 'noerr') {
$noerr = $param{$p};
+ } elsif ($p eq 'keeplocale') {
+ $keeplocale = $param{$p};
} else {
die "got unknown parameter '$p' for run_command\n";
}
print STDERR "$laststderr\n" if $laststderr;
}
}
- $laststderr = shift;
+ $laststderr = shift;
};
}
my $writer = $input && $input =~ m/^<&/ ? $input : IO::File->new();
my $error = IO::File->new();
- # try to avoid locale related issues/warnings
- my $lang = $param{lang} || 'C';
-
my $orig_pid = $$;
eval {
- local $ENV{LC_ALL} = $lang;
+ local $ENV{LC_ALL} = 'C' if !$keeplocale;
# suppress LVM warnings like: "File descriptor 3 left open";
local $ENV{LVM_SUPPRESS_FD_WARNINGS} = "1";
# catch exec errors
if ($orig_pid != $$) {
warn "ERROR: $err";
- POSIX::_exit (1);
- kill ('KILL', $$);
+ POSIX::_exit (1);
+ kill ('KILL', $$);
}
die $err if $err;
&$logfunc($errlog) if $logfunc && $errlog;
waitpid ($pid, 0);
-
+
if ($? == -1) {
die "failed to execute\n";
} elsif (my $sig = ($? & 127)) {
my $listtxt = shift || '';
return split (/\0/, $listtxt) if $listtxt =~ m/\0/;
-
+
$listtxt =~ s/[,;]/ /g;
$listtxt =~ s/^\s+//;
$txt =~ s/^\s+//;
$txt =~ s/\s+$//;
-
+
return $txt;
}
my ($tmpl, $data) = @_;
return $tmpl if !$tmpl;
-
+
my $res = '';
while ($tmpl =~ m/([^{]+)?({([^}]+)})?/g) {
$res .= $1 if $1;
my $keymaphash = {
'dk' => ['Danish', 'da', 'qwerty/dk-latin1.kmap.gz', 'dk', 'nodeadkeys'],
'de' => ['German', 'de', 'qwertz/de-latin1-nodeadkeys.kmap.gz', 'de', 'nodeadkeys' ],
- 'de-ch' => ['Swiss-German', 'de-ch', 'qwertz/sg-latin1.kmap.gz', 'ch', 'de_nodeadkeys' ],
+ 'de-ch' => ['Swiss-German', 'de-ch', 'qwertz/sg-latin1.kmap.gz', 'ch', 'de_nodeadkeys' ],
'en-gb' => ['United Kingdom', 'en-gb', 'qwerty/uk.kmap.gz' , 'gb', undef],
'en-us' => ['U.S. English', 'en-us', 'qwerty/us-latin1.kmap.gz', 'us', undef ],
'es' => ['Spanish', 'es', 'qwerty/es.kmap.gz', 'es', 'nodeadkeys'],
'mk' => ['Macedonian', 'mk', 'qwerty/mk.kmap.gz', 'mk', 'nodeadkeys'],
'nl' => ['Dutch', 'nl', 'qwerty/nl.kmap.gz', 'nl', undef],
#'nl-be' => ['Belgium-Dutch', 'nl-be', ?, ?, ?],
- 'no' => ['Norwegian', 'no', 'qwerty/no-latin1.kmap.gz', 'no', 'nodeadkeys'],
+ 'no' => ['Norwegian', 'no', 'qwerty/no-latin1.kmap.gz', 'no', 'nodeadkeys'],
'pl' => ['Polish', 'pl', 'qwerty/pl.kmap.gz', 'pl', undef],
'pt' => ['Portuguese', 'pt', 'qwerty/pt-latin1.kmap.gz', 'pt', 'nodeadkeys'],
'pt-br' => ['Brazil-Portuguese', 'pt-br', 'qwerty/br-latin1.kmap.gz', 'br', 'nodeadkeys'],
my ($port, $timestamp) = ($1, $2);
if (($timestamp + $expiretime) > $ctime) {
$ports->{$port} = $timestamp; # not expired
- }
+ }
}
}
}
-
+
my $newport;
for (my $p = $range_start; $p < $range_end; $p++) {
last;
}
}
-
+
my $data = "";
foreach my $p (keys %$ports) {
$data .= "$p $ports->{$p}\n";
}
-
+
file_set_contents($filename, $data);
return $newport;
};
- my $p = lock_file($filename, 10, $code);
+ my $p = lock_file('/var/lock/pve-ports.lck', 10, $code);
die $@ if $@;
-
+
die "unable to find free port (${range_start}-${range_end})\n" if !$p;
return $p;
return next_unused_port(61000, 61099, $family);
}
-# NOTE: NFS syscall can't be interrupted, so alarm does
+# NOTE: NFS syscall can't be interrupted, so alarm does
# not work to provide timeouts.
# from 'man nfs': "Only SIGKILL can interrupt a pending NFS operation"
# So fork() before using Filesys::Df
# UPID helper
# We use this to uniquely identify a process.
-# An 'Unique Process ID' has the following format:
+# An 'Unique Process ID' has the following format:
# "UPID:$node:$pid:$pstart:$startime:$dtype:$id:$user"
sub upid_encode {
# Note: pstart can be > 32bit if uptime > 497 days, so this can result in
# more that 8 characters for pstart
- return sprintf("UPID:%s:%08X:%08X:%08X:%s:%s:%s:", $d->{node}, $d->{pid},
- $d->{pstart}, $d->{starttime}, $d->{type}, $d->{id},
+ return sprintf("UPID:%s:%08X:%08X:%08X:%s:%s:%s:", $d->{node}, $d->{pid},
+ $d->{pstart}, $d->{starttime}, $d->{type}, $d->{id},
$d->{user});
}
sub upid_open {
my ($upid) = @_;
- my ($task, $filename) = upid_decode($upid);
+ my ($task, $filename) = upid_decode($upid);
my $dirname = dirname($filename);
make_path($dirname);
die "getpwnam failed";
my $perm = 0640;
-
+
my $outfh = IO::File->new ($filename, O_WRONLY|O_CREAT|O_EXCL, $perm) ||
die "unable to create output file '$filename' - $!\n";
chown $wwwid, -1, $outfh;
return "unable to read tail (got $br bytes)";
}
-# useful functions to store comments in config files
+# useful functions to store comments in config files
sub encode_text {
my ($text) = @_;
return Encode::decode("utf8", uri_unescape($data));
}
+# depreciated - do not use!
+# we now decode all parameters by default
sub decode_utf8_parameters {
my ($param) = @_;
my $count = 0;
my $fh = IO::File->new($filename, "r");
- if (!$fh) {
+ if (!$fh) {
$count++;
push @$lines, { n => $count, t => "unable to open file - $!"};
return ($count, $lines);
}
sub dump_journal {
- my ($start, $limit, $since, $until) = @_;
+ my ($start, $limit, $since, $until, $service) = @_;
my $lines = [];
my $count = 0;
-
+
$start = 0 if !$start;
$limit = 50 if !$limit;
my $cmd = ['journalctl', '-o', 'short', '--no-pager'];
+ push @$cmd, '--unit', $service if $service;
push @$cmd, '--since', $since if $since;
push @$cmd, '--until', $until if $until;
run_command($cmd, outfunc => $parser);
my $dh = IO::Dir->new ($dir);
return wantarray ? () : undef if !$dh;
-
- while (defined(my $tmp = $dh->read)) {
+
+ while (defined(my $tmp = $dh->read)) {
if (my @res = $tmp =~ m/^($regex)$/) {
$dh->close;
return wantarray ? @res : $tmp;
&$func (@res);
}
}
- }
+ }
}
sub assert_if_modified {
return $res[0]->{family};
}
+# get the fully qualified domain name of a host
+# same logic as hostname(1): The FQDN is the name getaddrinfo(3) returns,
+# given a nodename as a parameter
+sub get_fqdn {
+ my ($nodename) = @_;
+
+ my $hints = {
+ flags => AI_CANONNAME,
+ socktype => SOCK_DGRAM
+ };
+
+ my ($err, @addrs) = Socket::getaddrinfo($nodename, undef, $hints);
+
+ die "getaddrinfo: $err" if $err;
+
+ return $addrs[0]->{canonname};
+}
+
# Parses any sane kind of host, or host+port pair:
# The port is always optional and thus may be undef.
sub parse_host_and_port {
die "systemd job never completed\n" if !$done;
}
+my $salt_starter = time();
+
+sub encrypt_pw {
+ my ($pw) = @_;
+
+ $salt_starter++;
+ my $salt = substr(Digest::SHA::sha1_base64(time() + $salt_starter + $$), 0, 8);
+
+ # crypt does not want '+' in salt (see 'man crypt')
+ $salt =~ s/\+/X/g;
+
+ return crypt(encode("utf8", $pw), "\$5\$$salt\$");
+}
+
1;