src/PVE/API2/Firewall/Aliases.pm

   1 package PVE::API2::Firewall::AliasesBase;
   2
   3 use strict;
   4 use warnings;
   5 use PVE::Exception qw(raise raise_param_exc);
   6 use PVE::JSONSchema qw(get_standard_option);
   7
   8 use PVE::Firewall;
   9
  10 use base qw(PVE::RESTHandler);
  11
  12 my $api_properties = {
  13     cidr => {
  14         description => "Network/IP specification in CIDR format.",
  15         type => 'string', format => 'IPv4orCIDR',
  16     },
  17     name => get_standard_option('pve-fw-alias'),
  18     rename => get_standard_option('pve-fw-alias', {
  19         description => "Rename an existing alias.",
  20         optional => 1,
  21     }),
  22     comment => {
  23         type => 'string',
  24         optional => 1,
  25     },
  26 };
  27
  28 sub load_config {
  29     my ($class, $param) = @_;
  30
  31     die "implement this in subclass";
  32
  33     #return ($fw_conf, $rules);
  34 }
  35
  36 sub save_aliases {
  37     my ($class, $param, $fw_conf, $aliases) = @_;
  38
  39     die "implement this in subclass";
  40 }
  41
  42 my $additional_param_hash = {};
  43
  44 sub additional_parameters {
  45     my ($class, $new_value) = @_;
  46
  47     if (defined($new_value)) {
  48         $additional_param_hash->{$class} = $new_value;
  49     }
  50
  51     # return a copy
  52     my $copy = {};
  53     my $org = $additional_param_hash->{$class} || {};
  54     foreach my $p (keys %$org) { $copy->{$p} = $org->{$p}; }
  55     return $copy;
  56 }
  57
  58 my $aliases_to_list = sub {
  59     my ($aliases) = @_;
  60
  61     my $list = [];
  62     foreach my $k (sort keys %$aliases) {
  63         push @$list, $aliases->{$k};
  64     }
  65     return $list;
  66 };
  67
  68 sub register_get_aliases {
  69     my ($class) = @_;
  70
  71     my $properties = $class->additional_parameters();
  72
  73     $class->register_method({
  74         name => 'get_aliases',
  75         path => '',
  76         method => 'GET',
  77         description => "List aliases",
  78         parameters => {
  79             additionalProperties => 0,
  80             properties => $properties,
  81         },
  82         returns => {
  83             type => 'array',
  84             items => {
  85                 type => "object",
  86                 properties => {
  87                     name => { type => 'string' },
  88                     cidr => { type => 'string' },
  89                     comment => {
  90                         type => 'string',
  91                         optional => 1,
  92                     },
  93                     digest => get_standard_option('pve-config-digest', { optional => 0} ),
  94                 },
  95             },
  96             links => [ { rel => 'child', href => "{name}" } ],
  97         },
  98         code => sub {
  99             my ($param) = @_;
 100
 101             my ($fw_conf, $aliases) = $class->load_config($param);
 102
 103             my $list = &$aliases_to_list($aliases);
 104
 105             return PVE::Firewall::copy_list_with_digest($list);
 106         }});
 107 }
 108
 109 sub register_create_alias {
 110     my ($class) = @_;
 111
 112     my $properties = $class->additional_parameters();
 113
 114     $properties->{name} = $api_properties->{name};
 115     $properties->{cidr} = $api_properties->{cidr};
 116     $properties->{comment} = $api_properties->{comment};
 117
 118     $class->register_method({
 119         name => 'create_alias',
 120         path => '',
 121         method => 'POST',
 122         description => "Create IP or Network Alias.",
 123         protected => 1,
 124         parameters => {
 125             additionalProperties => 0,
 126             properties => $properties,
 127         },
 128         returns => { type => "null" },
 129         code => sub {
 130             my ($param) = @_;
 131
 132             my ($fw_conf, $aliases) = $class->load_config($param);
 133
 134             my $name = lc($param->{name});
 135
 136             raise_param_exc({ name => "alias '$param->{name}' already exists" })
 137                 if defined($aliases->{$name});
 138
 139             my $data = { name => $param->{name}, cidr => $param->{cidr} };
 140             $data->{comment} = $param->{comment} if $param->{comment};
 141
 142             $aliases->{$name} = $data;
 143
 144             $class->save_aliases($param, $fw_conf, $aliases);
 145
 146             return undef;
 147         }});
 148 }
 149
 150 sub register_read_alias {
 151     my ($class) = @_;
 152
 153     my $properties = $class->additional_parameters();
 154
 155     $properties->{name} = $api_properties->{name};
 156
 157     $class->register_method({
 158         name => 'read_alias',
 159         path => '{name}',
 160         method => 'GET',
 161         description => "Read alias.",
 162         parameters => {
 163             additionalProperties => 0,
 164             properties => $properties,
 165         },
 166         returns => { type => "object" },
 167         code => sub {
 168             my ($param) = @_;
 169
 170             my ($fw_conf, $aliases) = $class->load_config($param);
 171
 172             my $name = lc($param->{name});
 173
 174             raise_param_exc({ name => "no such alias" })
 175                 if !defined($aliases->{$name});
 176
 177             return $aliases->{$name};
 178         }});
 179 }
 180
 181 sub register_update_alias {
 182     my ($class) = @_;
 183
 184     my $properties = $class->additional_parameters();
 185
 186     $properties->{name} = $api_properties->{name};
 187     $properties->{rename} = $api_properties->{rename};
 188     $properties->{cidr} = $api_properties->{cidr};
 189     $properties->{comment} = $api_properties->{comment};
 190     $properties->{digest} = get_standard_option('pve-config-digest');
 191
 192     $class->register_method({
 193         name => 'update_alias',
 194         path => '{name}',
 195         method => 'PUT',
 196         description => "Update IP or Network alias.",
 197         protected => 1,
 198         parameters => {
 199             additionalProperties => 0,
 200             properties => $properties,
 201         },
 202         returns => { type => "null" },
 203         code => sub {
 204             my ($param) = @_;
 205
 206             my ($fw_conf, $aliases) = $class->load_config($param);
 207
 208             my $list = &$aliases_to_list($aliases);
 209
 210             my (undef, $digest) = PVE::Firewall::copy_list_with_digest($list);
 211
 212             PVE::Tools::assert_if_modified($digest, $param->{digest});
 213
 214             my $name = lc($param->{name});
 215
 216             raise_param_exc({ name => "no such alias" }) if !$aliases->{$name};
 217
 218             my $data = { name => $param->{name}, cidr => $param->{cidr} };
 219             $data->{comment} = $param->{comment} if $param->{comment};
 220
 221             $aliases->{$name} = $data;
 222
 223             my $rename = lc($param->{rename});
 224
 225             if ($rename && ($name ne $rename)) {
 226                 raise_param_exc({ name => "alias '$param->{rename}' already exists" })
 227                     if defined($aliases->{$rename});
 228                 $aliases->{$name}->{name} = $param->{rename};
 229                 $aliases->{$rename} = $aliases->{$name};
 230                 delete $aliases->{$name};
 231             }
 232
 233             $class->save_aliases($param, $fw_conf, $aliases);
 234
 235             return undef;
 236         }});
 237 }
 238
 239 sub register_delete_alias {
 240     my ($class) = @_;
 241
 242     my $properties = $class->additional_parameters();
 243
 244     $properties->{name} = $api_properties->{name};
 245     $properties->{cidr} = $api_properties->{cidr};
 246     $properties->{digest} = get_standard_option('pve-config-digest');
 247
 248     $class->register_method({
 249         name => 'remove_alias',
 250         path => '{name}',
 251         method => 'DELETE',
 252         description => "Remove IP or Network alias.",
 253         protected => 1,
 254         parameters => {
 255             additionalProperties => 0,
 256             properties => $properties,
 257         },
 258         returns => { type => "null" },
 259         code => sub {
 260             my ($param) = @_;
 261
 262             my ($fw_conf, $aliases) = $class->load_config($param);
 263
 264             my $list = &$aliases_to_list($aliases);
 265             my (undef, $digest) = PVE::Firewall::copy_list_with_digest($list);
 266             PVE::Tools::assert_if_modified($digest, $param->{digest});
 267
 268             my $name = lc($param->{name});
 269             delete $aliases->{$name};
 270
 271             $class->save_aliases($param, $fw_conf, $aliases);
 272
 273             return undef;
 274         }});
 275 }
 276
 277 sub register_handlers {
 278     my ($class) = @_;
 279
 280     $class->register_get_aliases();
 281     $class->register_create_alias();
 282     $class->register_read_alias();
 283     $class->register_update_alias();
 284     $class->register_delete_alias();
 285 }
 286
 287 package PVE::API2::Firewall::ClusterAliases;
 288
 289 use strict;
 290 use warnings;
 291
 292 use base qw(PVE::API2::Firewall::AliasesBase);
 293
 294 sub load_config {
 295     my ($class, $param) = @_;
 296
 297     my $fw_conf = PVE::Firewall::load_clusterfw_conf();
 298     my $aliases = $fw_conf->{aliases};
 299
 300     return ($fw_conf, $aliases);
 301 }
 302
 303 sub save_aliases {
 304     my ($class, $param, $fw_conf, $aliases) = @_;
 305
 306     $fw_conf->{aliases} = $aliases;
 307     PVE::Firewall::save_clusterfw_conf($fw_conf);
 308 }
 309
 310 __PACKAGE__->register_handlers();
 311
 312 1;