Viewing file:  feature-virt.pl (14.04 KB) -rwxrwxr-x
Select action/file-type:
 (+) |  (+) |  (+) | Code (+) | Session (+) |  (+) | SDB (+) |  (+) |  (+) |  (+) |  (+) |  (+) |
# Functions for setting up a virtual IP interface
# setup_virt(&domain)
# Bring up an interface for a domain, if the IP isn't already enabled
sub setup_virt
{
local ($d) = @_;
&obtain_lock_virt($d);
&foreign_require("net");
local @active = &net::active_interfaces();
if (!$d->{'virtalready'}) {
# Actually bring up
&$first_print(&text('setup_virt', $d->{'ip'}));
local ($iface) = grep { $_->{'fullname'} eq $config{'iface'} } @active;
if (!$iface) {
# Interface doesn't really exist!
&$second_print(&text('setup_virtmissing', $config{'iface'}));
return 0;
}
local $b;
local $vmin = $config{'iface_base'} || int($net::min_virtual_number);
local $vmax = -1;
foreach $b (@active) {
$vmax = $b->{'virtual'}
if ($b->{'virtual'} ne '' &&
$b->{'name'} eq $iface->{'name'} &&
$b->{'virtual'} > $vmax);
}
local $vwant = $vmax + 1;
if ($vwant < $vmin) {
$vwant = $vmin;
}
local $netmask = $d->{'netmask'} || $net::virtual_netmask ||
$iface->{'netmask'};
local $virt = { 'address' => $d->{'ip'},
'netmask' => $netmask,
'broadcast' => &net::compute_broadcast($d->{'ip'},
$netmask),
'name' => $iface->{'name'},
'virtual' => $vwant,
'up' => 1,
'desc' => "Virtualmin server $d->{'dom'}",
};
$virt->{'fullname'} = $virt->{'name'}.":".$virt->{'virtual'};
&net::save_interface($virt);
if (&auto_apply_interface()) {
&net::apply_network();
}
else {
&net::activate_interface($virt);
}
$d->{'iface'} = $virt->{'fullname'};
&$second_print(&text('setup_virtdone', $d->{'iface'}));
}
else {
# Just guess the interface
&$first_print(&text('setup_virt2', $d->{'ip'}));
local ($virt) = grep { $_->{'address'} eq $d->{'ip'} } @active;
$d->{'iface'} = $virt ? $virt->{'fullname'} : undef;
if ($d->{'iface'}) {
&$second_print(&text('setup_virtdone2', $d->{'iface'}));
}
else {
&$second_print(&text('setup_virtnotdone', $d->{'ip'}));
}
}
&build_local_ip_list();
&release_lock_virt($d);
®ister_post_action(\&restart_bind) if ($config{'dns'});
return 1;
}
# delete_virt(&domain)
# Take down the network interface for a domain
sub delete_virt
{
local ($d) = @_;
if (!$d->{'virtalready'}) {
&$first_print($text{'delete_virt'});
&obtain_lock_virt($d);
&foreign_require("net");
local ($biface) = grep { $_->{'address'} eq $d->{'ip'} }
&net::boot_interfaces();
local ($aiface) = grep { $_->{'address'} eq $d->{'ip'} }
&net::active_interfaces();
if (!$biface) {
&$second_print(&text('delete_noiface', $d->{'iface'}));
}
elsif ($biface->{'virtual'} ne '') {
&net::delete_interface($biface);
if (&auto_apply_interface()) {
&net::apply_network();
}
elsif ($aiface && $aiface->{'virtual'} ne '') {
&net::deactivate_interface($aiface)
}
&$second_print($text{'setup_done'});
}
else {
&$second_print(&text('delete_novirt', $biface->{'fullname'}));
}
&build_local_ip_list();
&release_lock_virt($d);
}
delete($d->{'iface'});
return 1;
}
# modify_virt(&domain, &old)
# Change the virtual IP address for a domain
sub modify_virt
{
local ($d, $oldd) = @_;
if ($d->{'ip'} ne $oldd->{'ip'} && $d->{'virt'} &&
!$d->{'virtalready'}) {
# Change IP on virtual interface
&$first_print($text{'save_virt'});
&obtain_lock_virt($d);
&foreign_require("net");
local ($biface) = grep { $_->{'address'} eq $oldd->{'ip'} }
&net::boot_interfaces();
local ($aiface) = grep { $_->{'address'} eq $oldd->{'ip'} }
&net::active_interfaces();
if ($biface) {
if ($biface->{'virtual'} ne '') {
$biface->{'address'} = $d->{'ip'};
&net::save_interface($biface);
}
if (&auto_apply_interface()) {
&net::apply_network();
}
elsif ($aiface->{'virtual'} ne '') {
$aiface->{'address'} = $d->{'ip'};
&net::activate_interface($aiface);
}
&$second_print($text{'setup_done'});
}
else {
&$second_print(&text('delete_novirt', $oldd->{'iface'}));
}
&build_local_ip_list();
&release_lock_virt($d);
®ister_post_action(\&restart_bind) if ($config{'dns'});
}
}
# clone_virt(&domain, &old-domain)
# No need to do anything here, as an IP address doesn't have any settings that
# need copying
sub clone_virt
{
return 1;
}
# validate_virt(&domain)
# Check for boot-time and active network interfaces
sub validate_virt
{
local ($d) = @_;
if (!$_[0]->{'virtalready'}) {
# Only check boot-time interface if added by Virtualmin
local @boots = &bootup_ip_addresses();
if (&indexof($d->{'ip'}, @boots) < 0) {
return &text('validate_evirtb', $d->{'ip'});
}
}
local @acts = &active_ip_addresses();
if (&indexof($d->{'ip'}, @acts) < 0) {
return &text('validate_evirta', $d->{'ip'});
}
return undef;
}
# check_virt_clash(ip)
# Returns 1 if some IP is already in use, 0 if not
sub check_virt_clash
{
# Check active and boot-time interfaces
local %allips = &interface_ip_addresses();
return 1 if ($allips{$_[0]});
# Do a quick ping test
local $pingcmd = $gconfig{'os_type'} =~ /-linux$/ ?
"ping -c 1 -t 1" : "ping";
local ($out, $timed_out) = &backquote_with_timeout(
$pingcmd." ".$_[0]." 2>&1", 2, 1);
return 1 if (!$timed_out && !$?);
return 0;
}
# virtual_ip_input(&templates, [reseller-name-list], [show-original],
# [default-mode])
# Returns HTML for selecting a virtual IP mode for a new server, or not
sub virtual_ip_input
{
local ($tmpls, $resel, $orig, $mode) = @_;
$mode ||= 0;
local $defip = &get_default_ip($resel);
local ($t, $anyalloc, $anychoose, $anyzone);
if (&running_in_zone() || &running_in_vserver()) {
# When running in a Solaris zone or VServer, you MUST select an
# existing active IP, as they are controlled from the host.
$anyzone = 1;
}
elsif (&can_use_feature("virt")) {
# Check if private IPs are allocated or manual, if we are
# allowed to choose them.
foreach $t (@$tmpls) {
local $tmpl = &get_template($t->{'id'});
if ($tmpl->{'ranges'} ne "none") { $anyalloc++; }
else { $anychoose++; }
}
}
local @opts;
if ($orig) {
# For restores - option to use original IP
push(@opts, [ -1, $text{'form_origip'} ]);
}
push(@opts, [ 0, &text('form_shared', $defip) ]);
local @shared = sort { $a cmp $b } &list_shared_ips();
if (@shared && &can_edit_sharedips()) {
# Can select from extra shared list
push(@opts, [ 3, $text{'form_shared2'},
&ui_select("sharedip", undef,
[ map { [ $_ ] } @shared ]) ]);
}
if ($anyalloc) {
# Can allocate
push(@opts, [ 2, &text('form_alloc') ]);
}
if ($anychoose) {
# Can enter arbitrary IP
push(@opts, [ 1, $text{'form_vip'},
&ui_textbox("ip", undef, 20)." ".
&ui_checkbox("virtalready", 1,
$text{'form_virtalready'}) ]);
}
if ($anyzone) {
# Can select an existing active IP
&foreign_require("net");
local @act = grep { $_->{'virtual'} ne '' }
&net::active_interfaces();
if (@act) {
push(@opts, [ 4, $text{'form_activeip'},
&ui_select("zoneip", undef,
[ map { [ $_->{'address'} ] } @act ]) ]);
}
else {
push(@opts, [ 4, $text{'form_activeip'},
&ui_textbox("zoneip", undef, 20) ]);
}
}
if ($mode == 5 && $anyalloc) {
# Use shared or allocated (for restores only)
push(@opts, [ 5, &text('form_allocmaybe') ]);
}
my %hasmodes = map { $_->[0], 1 } @opts;
if (!$hasmodes{$mode}) {
# Mode is not on the list .. use shared mode or none
$mode = $hasmodes{0} ? 0 : -2;
}
return &ui_radio_table("virt", $mode, \@opts, 1);
}
# parse_virtual_ip(&template, reseller)
# Parses the virtual IP input field, and returns the IP to use, virt flag,
# already flag and netmask. May call &error if the input is invalid.
sub parse_virtual_ip
{
local ($tmpl, $resel) = @_;
if ($in{'virt'} == 2) {
# Automatic IP allocation chosen .. select one from either the
# reseller's range, or the template
if ($resel) {
# Creating by or under a reseller .. use his range, if any
foreach my $r (split(/\s+/, $resel)) {
local %acl = &get_reseller_acl($r);
if ($acl{'ranges'}) {
local ($ip, $netmask) = &free_ip_address(\%acl);
$ip || &error(&text('setup_evirtalloc'));
return ($ip, 1, 0, $netmask);
}
}
}
$tmpl->{'ranges'} ne "none" || &error(&text('setup_evirttmpl'));
local ($ip, $netmask) = &free_ip_address($tmpl);
$ip || &error(&text('setup_evirtalloc'));
return ($ip, 1, 0, $netmask);
}
elsif ($in{'virt'} == 1) {
# Manual IP allocation chosen
$tmpl->{'ranges'} eq "none" || &error(&text('setup_evirttmpl2'));
&check_ipaddress($in{'ip'}) || &error($text{'setup_eip'});
local $clash = &check_virt_clash($in{'ip'});
if ($in{'virtalready'}) {
# Fail if the IP isn't yet active, or if claimed by another
# virtual server
$clash || &error(&text('setup_evirtclash2', $in{'ip'}));
local $already = &get_domain_by("ip", $in{'ip'});
$already && &error(&text('setup_evirtclash4',
$already->{'dom'}));
}
else {
# Fail if the IP *is* already active
$clash && &error(&text('setup_evirtclash'));
}
return ($in{'ip'}, 1, $in{'virtalready'});
}
elsif ($in{'virt'} == 3 && &can_edit_sharedips()) {
# On a shared virtual IP
&indexof($in{'sharedip'}, &list_shared_ips()) >= 0 ||
&error(&text('setup_evirtnoshared'));
return ($in{'sharedip'}, 0, 0);
}
elsif ($in{'virt'} == 4 && (&running_in_zone() || &running_in_vserver())) {
# On an active IP on a virtual machine that cannot bring up its
# own IP.
&check_ipaddress($in{'zoneip'}) || &error($text{'setup_eip'});
local $clash = &check_virt_clash($in{'zoneip'});
$clash || &error(&text('setup_evirtclash2', $in{'zoneip'}));
local $already = &get_domain_by("ip", $in{'ip'});
$already && &error(&text('setup_evirtclash4',
$already->{'dom'}));
return ($in{'zoneip'}, 1, 1);
}
elsif ($in{'virt'} == 5) {
# Allocate if needed, shared otherwise
local ($ip, $netmask) = &free_ip_address($tmpl);
return ($ip, 1, 0, $netmask);
}
else {
# Global shared IP
local $defip = &get_default_ip($resel);
return ($defip, 0, 0);
}
}
# show_template_virt(&tmpl)
# Outputs HTML for editing virtual IP related template options
sub show_template_virt
{
local ($tmpl) = @_;
# IP allocation ranges (v4 and possibly v6)
foreach my $ranges ("ranges", &supports_ip6() ? ( "ranges6" ) : ( )) {
local @ranges;
@ranges = &parse_ip_ranges($tmpl->{$ranges})
if ($tmpl->{$ranges} ne "none");
local @rfields = map { ($ranges."_start_".$_, $ranges."_end_".$_) }
(0..scalar(@ranges)+1);
local $rtable = &none_def_input($ranges, $tmpl->{$ranges},
$text{'tmpl_rangesbelow'}, 0, 0, undef, \@rfields);
local @table;
local $i = 0;
local $s = $ranges eq "ranges" ? 20 : 6;
foreach my $r (@ranges, [ ], [ ]) {
push(@table, [ &ui_textbox($ranges."_start_$i", $r->[0], 20),
&ui_textbox($ranges."_end_$i", $r->[1], 20),
&ui_opt_textbox($ranges."_mask_$i", $r->[2], $s,
$text{'default'}) ]);
$i++;
}
$rtable .= &ui_columns_table(
[ $text{'tmpl_ranges_start'}, $text{'tmpl_ranges_end'},
$text{'tmpl_ranges_mask'} ],
undef,
\@table,
undef,
1);
print &ui_table_row(&hlink($text{'tmpl_'.$ranges},
"template_".$ranges."_mode"), $rtable);
}
}
# parse_template_virt(&tmpl)
# Updates virtual IP related template options from %in
sub parse_template_virt
{
local ($tmpl) = @_;
# Save IPv4 and possibly v6 allocation ranges
foreach my $ranges ("ranges", &supports_ip6() ? ( "ranges6" ) : ( )) {
if ($in{$ranges.'_mode'} == 0) {
$tmpl->{$ranges} = "none";
}
elsif ($in{$ranges.'_mode'} == 1) {
$tmpl->{$ranges} = undef;
}
else {
local (@ranges, $start, $end);
for(my $i=0; defined($start = $in{$ranges."_start_$i"}); $i++) {
next if (!$start);
$end = $in{$ranges."_end_$i"};
$mask = $in{$ranges."_mask_${i}_def"} ? undef :
$in{$ranges."_mask_$i"};
if ($ranges eq "ranges") {
# IPv4 verification
&check_ipaddress($start) ||
&error(&text('tmpl_eranges_start', $start));
&check_ipaddress($end) ||
&error(&text('tmpl_eranges_end', $start));
local @start = split(/\./, $start);
local @end = split(/\./, $end);
$start[0] == $end[0] && $start[1] == $end[1] &&
$start[2] == $end[2] ||
&error(&text('tmpl_eranges_net',
$start));
$start[3] <= $end[3] ||
&error(&text('tmpl_eranges_lower',
$start));
!$mask || &check_ipaddress($mask) ||
&error(&text('tmpl_eranges_mask', $start));
}
else {
# v6 verification
&check_ip6address($start) ||
&error(&text('tmpl_eranges6_start',$start));
&check_ip6address($end) ||
&error(&text('tmpl_eranges6_end', $end));
!$mask || $mask =~ /^\d+$/ ||
&error(&text('tmpl_eranges_mask', $start));
}
push(@ranges, [ $start, $end, $mask ]);
}
@ranges || &error($text{'tmpl_e'.$ranges});
$tmpl->{$ranges} = &join_ip_ranges(\@ranges);
}
}
}
# build_local_ip_list()
# Create a local cache file of IPs on this system
sub build_local_ip_list
{
&foreign_require("net");
&open_lock_tempfile(IPCACHE, ">$module_config_directory/localips");
foreach my $a (&net::active_interfaces()) {
if ($a->{'address'}) {
&print_tempfile(IPCACHE, $a->{'address'},"\n");
}
}
&close_tempfile(IPCACHE);
}
# obtain_lock_virt(&domain)
# Signal that we are locking virtual IPs
sub obtain_lock_virt
{
# Lock the network config directory or file
&obtain_lock_anything();
if ($main::got_lock_virt == 0) {
&foreign_require("net");
$main::got_lock_virt_file = $net::network_interfaces_config ||
$net::network_config ||
"$module_config_directory/virtlock";
&lock_file($main::got_lock_virt_file);
if (&supports_ip6()) {
# Also lock file for IPv6
$main::got_lock_virt6_file = &ip6_interfaces_file();
&lock_file($main::got_lock_virt6_file)
if ($main::got_lock_virt6_file);
}
}
$main::got_lock_virt++;
}
# Release virtual IPs lock
sub release_lock_virt
{
# Unlock the network config directory or file
if ($main::got_lock_virt == 1) {
&unlock_file($main::got_lock_virt6_file)
if ($main::got_lock_virt6_file);
&unlock_file($main::got_lock_virt_file);
}
$main::got_lock_virt-- if ($main::got_lock_virt);
&release_lock_anything();
}
# can_reset_virt(&domain)
# Resetting the virtual IP is a bad idea, as it could cause re-allocation
sub can_reset_virt
{
return 0;
}
# auto_apply_interface()
# Returns 1 if changes should only be made to the boot-time interface config,
# and then applied
sub auto_apply_interface
{
&foreign_require("net");
return $net::net_mode eq "nm";
}
$done_feature_script{'virt'} = 1;
1;
|