[pve-manager.git] / PVE / REST.pm

package PVE::REST;

use warnings;
use strict;
use PVE::Cluster;
use PVE::SafeSyslog;
use PVE::Tools;
use PVE::API2;
use Apache2::Const;
use mod_perl2;
use JSON;
use LWP::UserAgent;
use HTTP::Request::Common;
use HTTP::Status qw(:constants :is status_message);
use HTML::Entities;
use PVE::Exception qw(raise raise_perm_exc);
use PVE::JSONSchema;
use PVE::AccessControl;
use PVE::RPCEnvironment;
use URI::Escape;

use Data::Dumper; # fixme: remove

# my $MaxRequestsPerChild = 200;

my $cookie_name = 'PVEAuthCookie';

my $baseuri = "/api2";

# http://perl.apache.org/docs/2.0/api/Apache2/SubProcess.html

my $debug_enabled;
sub enable_debug {
    $debug_enabled = 1;
}

sub debug_msg {
    return if !$debug_enabled;
    syslog('info', @_);
}

sub extract_auth_cookie {
    my ($cookie) = @_;

    return undef if !$cookie;

    my $ticket = ($cookie =~ /(?:^|\s)$cookie_name=([^;]*)/)[0];

    if ($ticket && $ticket =~ m/^PVE%3A/) {
	$ticket = uri_unescape($ticket);
    }

    return $ticket;
}

sub create_auth_cookie {
    my ($ticket) = @_;

    return "${cookie_name}=$ticket; path=/; secure;";
}

sub format_response_data {
    my($format, $res, $uri) = @_;

    my $data = $res->{data};
    my $info = $res->{info};

    my ($ct, $raw);

    if ($format eq 'json') {
	$ct = 'application/json;charset=UTF-8';
	$raw = to_json($data, {utf8 => 1, allow_nonref => 1});
    } elsif ($format eq 'html') {
	$ct = 'text/html;charset=UTF-8';
	$raw = "<html><body>";
	if (!is_success($res->{status})) {
	    my $msg = $res->{message} || '';
	    $raw .= "<h1>ERROR $res->{status} $msg</h1>";
	}
	my $lnk = PVE::JSONSchema::method_get_child_link($info);
	if ($lnk && $data && $data->{data} && is_success($res->{status})) {

	    my $href = $lnk->{href};
	    if ($href =~ m/^\{(\S+)\}$/) {
		my $prop = $1;
		$uri =~ s/\/+$//; # remove trailing slash
		foreach my $elem (sort {$a->{$prop} cmp $b->{$prop}} @{$data->{data}}) {
		    next if !ref($elem);

		    if (defined(my $value = $elem->{$prop})) {
			if ($value ne '') {
			    if (scalar(keys %$elem) > 1) {
				my $tv = to_json($elem, {allow_nonref => 1, canonical => 1});
				$raw .= "<a href='$uri/$value'>$value</a> <pre>$tv</pre><br>";
			    } else {
				$raw .= "<a href='$uri/$value'>$value</a><br>";
			    }
			}
		    }
		}
	    }
	} else {
	    $raw .= "<pre>";
	    $raw .= encode_entities(to_json($data, {allow_nonref => 1, pretty => 1}));
	    $raw .= "</pre>";
	}
	$raw .= "</body></html>";

    } elsif ($format eq 'png') {
	$ct = 'image/png';

	# fixme: better to revove that whole png thing ?

	my $filename;
	$raw = '';

	if ($data && ref($data) && ref($data->{data}) && 
	    $data->{data}->{filename} && defined($data->{data}->{image})) {
	    $filename = $data->{data}->{filename};
	    $raw = $data->{data}->{image};
	}
	    
    } elsif ($format eq 'extjs') {
	$ct = 'application/json;charset=UTF-8';
	$raw = to_json($data, {utf8 => 1, allow_nonref => 1});
    } elsif ($format eq 'htmljs') {
	# we use this for extjs file upload forms
	$ct = 'text/html;charset=UTF-8';
	$raw = encode_entities(to_json($data, {allow_nonref => 1}));
    } else {
	$ct = 'text/plain;charset=UTF-8';
	$raw = to_json($data, {utf8 => 1, allow_nonref => 1, pretty => 1});
    }

    return wantarray ? ($raw, $ct) : $raw;
}

sub prepare_response_data {
    my ($format, $res) = @_;

    my $success = 1;
    my $new = {
	data => $res->{data},
    };
    if (scalar(keys %{$res->{errors}})) {
	$success = 0;
	$new->{errors} = $res->{errors};
    }

    if ($format eq 'extjs' || $format eq 'htmljs') {
	# HACK: extjs wants 'success' property instead of useful HTTP status codes
	if (is_error($res->{status})) {
	    $success = 0;
	    $new->{message} = $res->{message} || status_message($res->{status});
	    $new->{status} = $res->{status} || HTTP_OK;
	    $res->{message} = undef;
	    $res->{status} = HTTP_OK;
	}
	$new->{success} = $success;
    }

    if ($success && $res->{total}) {
	$new->{total} = $res->{total};
    }

    if ($success && $res->{changes}) {
	$new->{changes} = $res->{changes};
    }

    $res->{data} = $new;
}

sub create_http_request {
    my ($uri, $method, $params) = @_;

    # NOTE: HTTP::Request::Common::PUT is crap - so we use our own code
    # borrowed from HTTP::Request::Common::POST

    if  ($method eq 'POST' || $method eq 'PUT') {

	my $req = HTTP::Request->new($method => $uri);
	$req->header('Content-Type' => 'application/x-www-form-urlencoded'); 

	# We use a temporary URI object to format
	# the application/x-www-form-urlencoded content.
	my $url = URI->new('http:');
	$url->query_form(%$params);
	my $content = $url->query;
	if (defined($content)) {
	    $req->header('Content-Length' => length($content));
	    $req->content($content);
	} else {
	    $req->header('Content-Length' => 0);
	}

	return $req;
    }

    die "unknown method '$method'"; 
}

sub proxy_handler {
    my($r, $clientip, $host, $method, $abs_uri, $ticket, $token, $params) = @_;

    debug_msg("proxy start $method $host:$abs_uri");

    my $ua = LWP::UserAgent->new(
	# keep it simple - we are on internal network, and use tickets
	ssl_opts => { verify_hostname => 0 },
	# using the pve root CA file would  be another option
	# ssl_opts => { verify_hostname => 1 , SSL_ca_file => "/etc/pve/pve-root-ca.pem },
	protocols_allowed => [ 'http', 'https' ],
	timeout => 30,
	);

    $ua->default_header('cookie' => "${cookie_name}=$ticket") if $ticket;
    $ua->default_header('CSRFPreventionToken' => $token) if $token;
    $ua->default_header('PVEDisableProxy' => 'true');
    $ua->default_header('PVEClientIP' => $clientip);

    my $uri = URI->new();

    if ($host eq 'localhost') {
	$uri->scheme('http');
	$uri->host('localhost');
	$uri->port(85);
    } else {
	$uri->scheme('https');
	$uri->host($host);
	$uri->port(8006);
    }

    $uri->path($abs_uri);

    my $response;
    if ($method eq 'GET') {
	$uri->query_form($params);
	$response = $ua->request(HTTP::Request::Common::GET($uri));		    
    } elsif ($method eq 'POST' || $method eq 'PUT') {
	$response = $ua->request(create_http_request($uri, $method, $params));
    } elsif ($method eq 'DELETE') {
	$response = $ua->request(HTTP::Request::Common::DELETE($uri));
    } else {
	my $code = HTTP_NOT_IMPLEMENTED;
	$r->status_line("$code proxy method '$method' not implemented");
	return $code;
    }


    if (my $cookie = $response->header("Set-Cookie")) {
	$r->err_headers_out()->add("Set-Cookie" => $cookie);
    }

    my $ct = $response->header('Content-Type');

    my $code = $response->code;
    $r->status($code);

    if (my $message = $response->message) {
	$r->status_line("$code $message");
    }

    $r->content_type($ct) if $ct;
    my $raw = $response->decoded_content;

    # note: do not use err_headers_out(), because mod_deflate has a bug,
    # resulting in dup length (for exampe 'content-length: 89, 75')
    $r->headers_out()->add('Content-Length' , length($raw));
    $r->print($raw);

    debug_msg("proxy end $method $host:$abs_uri ($code)");

    return OK;
}

my $exc_to_res = sub {
    my ($err, $status) = @_;

    $status = $status || HTTP_INTERNAL_SERVER_ERROR;

    my $resp = {};
    if (ref($err) eq "PVE::Exception") {
	$resp->{status} = $err->{code} || $status;
	$resp->{errors} = $err->{errors} if $err->{errors};
	$resp->{message} = $err->{msg};
    } else {
	$resp->{status} = $status;
	$resp->{message} = $err;
    }

    return $resp;
};

sub rest_handler {
    my ($rpcenv, $clientip, $method, $abs_uri, $rel_uri, $ticket, $token) = @_;

    # set environment variables
    $rpcenv->set_language('C'); # fixme:
    $rpcenv->set_client_ip($clientip);

    my $euid = $>;

    my $require_auth = 1;

    # explicitly allow some calls without auth
    if (($rel_uri eq '/access/domains' && $method eq 'GET') ||
	($rel_uri eq '/access/ticket' && $method eq 'POST')) {
	$require_auth = 0;
    }

    my ($username, $age);

    my $isUpload = 0;

    if ($require_auth) {

	eval {
	    die "No ticket\n" if !$ticket;

	    ($username, $age) = PVE::AccessControl::verify_ticket($ticket);

	    $rpcenv->set_user($username);

	    if ($method eq 'POST' && $rel_uri =~ m|^/nodes/([^/]+)/storage/([^/]+)/upload$|) {
		my ($node, $storeid) = ($1, $2);
		# we disable CSRF checks if $isUpload is set,
		# to improve security we check user upload permission here
		my $perm = { check => ['perm', "/storage/$storeid", ['Datastore.AllocateTemplate']] };
		$rpcenv->check_api2_permissions($perm, $username, {});
		$isUpload = 1;
	    }

	    # we skip CSRF check for file upload, because it is
	    # difficult to pass CSRF HTTP headers with native html forms,
	    # and it should not be necessary at all.
	    PVE::AccessControl::verify_csrf_prevention_token($username, $token)
		if !$isUpload && ($euid != 0) && ($method ne 'GET');
	};
	if (my $err = $@) {
	    return &$exc_to_res($err, HTTP_UNAUTHORIZED);
	}
    }

    # we are authenticated now

    my $uri_param = {};
    my ($handler, $info) = PVE::API2->find_handler($method, $rel_uri, $uri_param);
    if (!$handler || !$info) {
	return {
	    status => HTTP_NOT_IMPLEMENTED,
	    message => "Method '$method $abs_uri' not implemented",
	};
    }

    # Note: we need to delay CGI parameter parsing until
    # we are authenticated (avoid DOS (file upload) attacs)

    my $params;
    eval { $params = $rpcenv->parse_params($isUpload); };
    if (my $err = $@) {
	return { 
	    status => HTTP_BAD_REQUEST, 
	    message => "parameter parser failed: $err",
	};   
    }

    delete $params->{_dc}; # remove disable cache parameter

    foreach my $p (keys %{$params}) {
	if (defined($uri_param->{$p})) {
	    return {
		status => HTTP_BAD_REQUEST,
		message => "Parameter verification failed - duplicate parameter '$p'",
	    };
	}
	$uri_param->{$p} = $params->{$p};
    }

    # check access permissions
    eval { $rpcenv->check_api2_permissions($info->{permissions}, $username, $uri_param); };
    if (my $err = $@) {
	return &$exc_to_res($err, HTTP_FORBIDDEN);
    }

    if ($info->{proxyto}) {
	my $remip;
	eval {
	    my $pn = $info->{proxyto};
	    my $node = $uri_param->{$pn};
	    die "proxy parameter '$pn' does not exists" if !$node;

	    if ($node ne 'localhost' && $node ne PVE::INotify::nodename()) {
		die "unable to proxy file uploads" if $isUpload; 
		$remip = PVE::Cluster::remote_node_ip($node);
	    }
	};
	if (my $err = $@) {
	    return &$exc_to_res($err);
	}
	if ($remip) {
	    return { proxy => $remip, proxy_params => $params };
	}
    } 

    if ($info->{protected} && ($euid != 0)) {
	if ($isUpload) {
	    my $uinfo = $rpcenv->get_upload_info('filename');
	    $params->{tmpfilename} = $uinfo->{tmpfilename};
	}
	return { proxy => 'localhost' , proxy_params => $params }
    }

    my $resp = { 
	info => $info, # useful to format output
	status => HTTP_OK,
    }; 

    eval {
	$resp->{data} = $handler->handle($info, $uri_param);

	if (my $count = $rpcenv->get_result_attrib('total')) {
	    $resp->{total} = $count;
	}
	if (my $diff = $rpcenv->get_result_attrib('changes')) {
	    $resp->{changes} = $diff;
	}
    };
    if (my $err = $@) {
	return &$exc_to_res($err);
    }

    return $resp;
}

sub split_abs_uri {
    my ($abs_uri) = @_;

    my ($format, $rel_uri) = $abs_uri =~ m/^\Q$baseuri\E\/+(html|text|json|extjs|png|htmljs)(\/.*)?$/;
    $rel_uri = '/' if !$rel_uri;
 
    return wantarray ? ($rel_uri, $format) : $rel_uri;
}

my $known_methods = {
    GET => 1,
    POST => 1,
    PUT => 1,
    DELETE => 1,
};

my $request_count = 0;

sub handler {
     my($r) = @_;

     debug_msg("perl handler called");

     $request_count++;
     # we do not use KeepAlive, so this is not necessary
     # $r->child_terminate() if $request_count >= $MaxRequestsPerChild;

     my $method = $r->method;
     my $clientip = $r->connection->remote_ip();

     return HTTP_NOT_IMPLEMENTED
	 if !$known_methods->{$method};

     my $cookie = $r->headers_in->{Cookie};
     my $token = $r->headers_in->{CSRFPreventionToken};

     my $ticket = extract_auth_cookie($cookie);

     $r->no_cache (1);

     my $abs_uri = $r->uri;
     my ($rel_uri, $format) = split_abs_uri($abs_uri);
     return HTTP_NOT_IMPLEMENTED if !$format;

     my $rpcenv;
     my $res;

     eval { 
	 $rpcenv = PVE::RPCEnvironment::get();
	 $rpcenv->init_request(request_rec => $r); 
     };
     if (my $err = $@) {
	 syslog('err', $err);
	 $res = { status => HTTP_INTERNAL_SERVER_ERROR, message => $err };
     } else {
	 $res = rest_handler($rpcenv, $clientip, $method, $abs_uri, $rel_uri, 
			     $ticket, $token);
	 $rpcenv->set_user(undef); # clear after request
     }

     if ($res->{proxy}) {
	 if (($res->{proxy} ne 'localhost') && $r->headers_in->{'PVEDisableProxy'}) {
	     my $code = FORBIDDEN;
	     $r->status($code);
	     $r->status_line("$code proxy loop detected - aborted ");
	     return $res->{status};	     
	 } 
	 return proxy_handler($r, $clientip, $res->{proxy}, $method, 
			      $abs_uri, $ticket, $token, $res->{proxy_params});
     }

     prepare_response_data($format, $res);

     $r->status($res->{status} || HTTP_OK);
 
     if ($res->{message}) {
	 my ($firstline) = $res->{message} =~ m/\A(.*)$/m;
	 $r->status_line("$res->{status} $firstline");
     }

     my ($raw, $ct) = format_response_data($format, $res, $abs_uri);
     $r->content_type ($ct);

     # note: do not use err_headers_out(), because mod_deflate has a bug,
     # resulting in dup length (for exampe 'content-length: 89, 75')
     $r->headers_out()->add('Content-Length', length($raw));
     $r->print($raw);
    
     debug_msg("perl handler end $res->{status}");

     return OK;
}

1;
Commit	Line	Data
aff192e6 DM	1	package PVE::REST;
	2
	3	use warnings;
	4	use strict;
aff192e6 DM	5	use PVE::Cluster;
	6	use PVE::SafeSyslog;
	7	use PVE::Tools;
	8	use PVE::API2;
	9	use Apache2::Const;
aff192e6 DM	10	use mod_perl2;
aff192e6 DM	11	use JSON;
aff192e6 DM	12	use LWP::UserAgent;
	13	use HTTP::Request::Common;
	14	use HTTP::Status qw(:constants :is status_message);
	15	use HTML::Entities;
e4d554ba	16	use PVE::Exception qw(raise raise_perm_exc);
aff192e6 DM	17	use PVE::JSONSchema;
	18	use PVE::AccessControl;
	19	use PVE::RPCEnvironment;
e771ec50	20	use URI::Escape;
aff192e6 DM	21
	22	use Data::Dumper; # fixme: remove
	23
6c980a67 DM	24	# my $MaxRequestsPerChild = 200;
6c980a67 DM	25
aff192e6 DM	26	my $cookie_name = 'PVEAuthCookie';
	27
	28	my $baseuri = "/api2";
	29
	30	# http://perl.apache.org/docs/2.0/api/Apache2/SubProcess.html
	31
282184f5 DM	32	my $debug_enabled;
	33	sub enable_debug {
	34	$debug_enabled = 1;
	35	}
	36
	37	sub debug_msg {
	38	return if !$debug_enabled;
	39	syslog('info', @_);
	40	}
	41
aff192e6 DM	42	sub extract_auth_cookie {
	43	my ($cookie) = @_;
	44
	45	return undef if !$cookie;
	46
e771ec50 DM	47	my $ticket = ($cookie =~ /(?:^\|\s)$cookie_name=([^;]*)/)[0];
	48
	49	if ($ticket && $ticket =~ m/^PVE%3A/) {
	50	$ticket = uri_unescape($ticket);
	51	}
	52
	53	return $ticket;
aff192e6 DM	54	}
	55
	56	sub create_auth_cookie {
	57	my ($ticket) = @_;
	58
	59	return "${cookie_name}=$ticket; path=/; secure;";
	60	}
	61
	62	sub format_response_data {
	63	my($format, $res, $uri) = @_;
	64
	65	my $data = $res->{data};
	66	my $info = $res->{info};
	67
	68	my ($ct, $raw);
	69
	70	if ($format eq 'json') {
d25e7431	71	$ct = 'application/json;charset=UTF-8';
aff192e6 DM	72	$raw = to_json($data, {utf8 => 1, allow_nonref => 1});
aff192e6 DM	73	} elsif ($format eq 'html') {
d25e7431	74	$ct = 'text/html;charset=UTF-8';
aff192e6 DM	75	$raw = "<html><body>";
	76	if (!is_success($res->{status})) {
	77	my $msg = $res->{message} \|\| '';
	78	$raw .= "<h1>ERROR $res->{status} $msg</h1>";
	79	}
	80	my $lnk = PVE::JSONSchema::method_get_child_link($info);
	81	if ($lnk && $data && $data->{data} && is_success($res->{status})) {
	82
	83	my $href = $lnk->{href};
	84	if ($href =~ m/^\{(\S+)\}$/) {
	85	my $prop = $1;
	86	$uri =~ s/\/+$//; # remove trailing slash
	87	foreach my $elem (sort {$a->{$prop} cmp $b->{$prop}} @{$data->{data}}) {
	88	next if !ref($elem);
	89
	90	if (defined(my $value = $elem->{$prop})) {
	91	if ($value ne '') {
	92	if (scalar(keys %$elem) > 1) {
	93	my $tv = to_json($elem, {allow_nonref => 1, canonical => 1});
	94	$raw .= "<a href='$uri/$value'>$value</a> <pre>$tv</pre><br>";
	95	} else {
	96	$raw .= "<a href='$uri/$value'>$value</a><br>";
	97	}
	98	}
	99	}
	100	}
	101	}
	102	} else {
	103	$raw .= "<pre>";
d25e7431	104	$raw .= encode_entities(to_json($data, {allow_nonref => 1, pretty => 1}));
aff192e6 DM	105	$raw .= "</pre>";
	106	}
	107	$raw .= "</body></html>";
	108
	109	} elsif ($format eq 'png') {
	110	$ct = 'image/png';
	111
	112	# fixme: better to revove that whole png thing ?
	113
	114	my $filename;
	115	$raw = '';
	116
	117	if ($data && ref($data) && ref($data->{data}) &&
0ba26fb5	118	$data->{data}->{filename} && defined($data->{data}->{image})) {
aff192e6	119	$filename = $data->{data}->{filename};
0ba26fb5	120	$raw = $data->{data}->{image};
aff192e6 DM	121	}
	122
	123	} elsif ($format eq 'extjs') {
d25e7431	124	$ct = 'application/json;charset=UTF-8';
aff192e6 DM	125	$raw = to_json($data, {utf8 => 1, allow_nonref => 1});
	126	} elsif ($format eq 'htmljs') {
	127	# we use this for extjs file upload forms
d25e7431 DM	128	$ct = 'text/html;charset=UTF-8';
d25e7431 DM	129	$raw = encode_entities(to_json($data, {allow_nonref => 1}));
aff192e6	130	} else {
d25e7431	131	$ct = 'text/plain;charset=UTF-8';
aff192e6 DM	132	$raw = to_json($data, {utf8 => 1, allow_nonref => 1, pretty => 1});
	133	}
	134
	135	return wantarray ? ($raw, $ct) : $raw;
	136	}
	137
	138	sub prepare_response_data {
	139	my ($format, $res) = @_;
	140
	141	my $success = 1;
	142	my $new = {
	143	data => $res->{data},
	144	};
	145	if (scalar(keys %{$res->{errors}})) {
	146	$success = 0;
	147	$new->{errors} = $res->{errors};
	148	}
	149
	150	if ($format eq 'extjs' \|\| $format eq 'htmljs') {
	151	# HACK: extjs wants 'success' property instead of useful HTTP status codes
	152	if (is_error($res->{status})) {
	153	$success = 0;
	154	$new->{message} = $res->{message} \|\| status_message($res->{status});
	155	$new->{status} = $res->{status} \|\| HTTP_OK;
	156	$res->{message} = undef;
	157	$res->{status} = HTTP_OK;
	158	}
	159	$new->{success} = $success;
	160	}
	161
	162	if ($success && $res->{total}) {
	163	$new->{total} = $res->{total};
	164	}
	165
3dff4a9f DM	166	if ($success && $res->{changes}) {
	167	$new->{changes} = $res->{changes};
	168	}
	169
aff192e6 DM	170	$res->{data} = $new;
	171	}
	172
	173	sub create_http_request {
	174	my ($uri, $method, $params) = @_;
	175
	176	# NOTE: HTTP::Request::Common::PUT is crap - so we use our own code
	177	# borrowed from HTTP::Request::Common::POST
	178
	179	if ($method eq 'POST' \|\| $method eq 'PUT') {
	180
	181	my $req = HTTP::Request->new($method => $uri);
	182	$req->header('Content-Type' => 'application/x-www-form-urlencoded');
	183
	184	# We use a temporary URI object to format
	185	# the application/x-www-form-urlencoded content.
	186	my $url = URI->new('http:');
	187	$url->query_form(%$params);
	188	my $content = $url->query;
	189	if (defined($content)) {
	190	$req->header('Content-Length' => length($content));
	191	$req->content($content);
	192	} else {
	193	$req->header('Content-Length' => 0);
	194	}
	195
	196	return $req;
	197	}
	198
	199	die "unknown method '$method'";
	200	}
	201
	202	sub proxy_handler {
	203	my($r, $clientip, $host, $method, $abs_uri, $ticket, $token, $params) = @_;
	204
282184f5	205	debug_msg("proxy start $method $host:$abs_uri");
aff192e6 DM	206
aff192e6 DM	207	my $ua = LWP::UserAgent->new(
c4113f6c	208	# keep it simple - we are on internal network, and use tickets
15d29886	209	ssl_opts => { verify_hostname => 0 },
c4113f6c DM	210	# using the pve root CA file would be another option
c4113f6c DM	211	# ssl_opts => { verify_hostname => 1 , SSL_ca_file => "/etc/pve/pve-root-ca.pem },
aff192e6 DM	212	protocols_allowed => [ 'http', 'https' ],
	213	timeout => 30,
	214	);
	215
	216	$ua->default_header('cookie' => "${cookie_name}=$ticket") if $ticket;
	217	$ua->default_header('CSRFPreventionToken' => $token) if $token;
	218	$ua->default_header('PVEDisableProxy' => 'true');
	219	$ua->default_header('PVEClientIP' => $clientip);
	220
	221	my $uri = URI->new();
	222
	223	if ($host eq 'localhost') {
	224	$uri->scheme('http');
	225	$uri->host('localhost');
	226	$uri->port(85);
	227	} else {
	228	$uri->scheme('https');
	229	$uri->host($host);
	230	$uri->port(8006);
	231	}
	232
	233	$uri->path($abs_uri);
	234
	235	my $response;
	236	if ($method eq 'GET') {
	237	$uri->query_form($params);
	238	$response = $ua->request(HTTP::Request::Common::GET($uri));
	239	} elsif ($method eq 'POST' \|\| $method eq 'PUT') {
	240	$response = $ua->request(create_http_request($uri, $method, $params));
	241	} elsif ($method eq 'DELETE') {
	242	$response = $ua->request(HTTP::Request::Common::DELETE($uri));
	243	} else {
	244	my $code = HTTP_NOT_IMPLEMENTED;
	245	$r->status_line("$code proxy method '$method' not implemented");
	246	return $code;
	247	}
	248
	249
	250	if (my $cookie = $response->header("Set-Cookie")) {
	251	$r->err_headers_out()->add("Set-Cookie" => $cookie);
	252	}
	253
	254	my $ct = $response->header('Content-Type');
	255
	256	my $code = $response->code;
	257	$r->status($code);
	258
	259	if (my $message = $response->message) {
	260	$r->status_line("$code $message");
	261	}
	262
	263	$r->content_type($ct) if $ct;
	264	my $raw = $response->decoded_content;
	265
	266	# note: do not use err_headers_out(), because mod_deflate has a bug,
	267	# resulting in dup length (for exampe 'content-length: 89, 75')
	268	$r->headers_out()->add('Content-Length' , length($raw));
	269	$r->print($raw);
	270
282184f5	271	debug_msg("proxy end $method $host:$abs_uri ($code)");
aff192e6 DM	272
	273	return OK;
	274	}
	275
f797e949 DM	276	my $exc_to_res = sub {
	277	my ($err, $status) = @_;
	278
	279	$status = $status \|\| HTTP_INTERNAL_SERVER_ERROR;
	280
	281	my $resp = {};
	282	if (ref($err) eq "PVE::Exception") {
	283	$resp->{status} = $err->{code} \|\| $status;
	284	$resp->{errors} = $err->{errors} if $err->{errors};
	285	$resp->{message} = $err->{msg};
	286	} else {
	287	$resp->{status} = $status;
	288	$resp->{message} = $err;
	289	}
	290
	291	return $resp;
	292	};
	293
aff192e6	294	sub rest_handler {
97ab5760	295	my ($rpcenv, $clientip, $method, $abs_uri, $rel_uri, $ticket, $token) = @_;
aff192e6	296
97ab5760 DM	297	# set environment variables
	298	$rpcenv->set_language('C'); # fixme:
	299	$rpcenv->set_client_ip($clientip);
aff192e6	300
aff192e6 DM	301	my $euid = $>;
	302
	303	my $require_auth = 1;
	304
	305	# explicitly allow some calls without auth
	306	if (($rel_uri eq '/access/domains' && $method eq 'GET') \|\|
	307	($rel_uri eq '/access/ticket' && $method eq 'POST')) {
	308	$require_auth = 0;
	309	}
	310
	311	my ($username, $age);
	312
97ab5760 DM	313	my $isUpload = 0;
97ab5760 DM	314
aff192e6 DM	315	if ($require_auth) {
	316
	317	eval {
	318	die "No ticket\n" if !$ticket;
	319
	320	($username, $age) = PVE::AccessControl::verify_ticket($ticket);
	321
97ab5760 DM	322	$rpcenv->set_user($username);
	323
	324	if ($method eq 'POST' && $rel_uri =~ m\|^/nodes/([^/]+)/storage/([^/]+)/upload$\|) {
	325	my ($node, $storeid) = ($1, $2);
e084c774 DM	326	# we disable CSRF checks if $isUpload is set,
	327	# to improve security we check user upload permission here
	328	my $perm = { check => ['perm', "/storage/$storeid", ['Datastore.AllocateTemplate']] };
40bbaac1	329	$rpcenv->check_api2_permissions($perm, $username, {});
97ab5760 DM	330	$isUpload = 1;
	331	}
	332
	333	# we skip CSRF check for file upload, because it is
	334	# difficult to pass CSRF HTTP headers with native html forms,
	335	# and it should not be necessary at all.
aff192e6	336	PVE::AccessControl::verify_csrf_prevention_token($username, $token)
97ab5760	337	if !$isUpload && ($euid != 0) && ($method ne 'GET');
aff192e6 DM	338	};
aff192e6 DM	339	if (my $err = $@) {
f797e949	340	return &$exc_to_res($err, HTTP_UNAUTHORIZED);
aff192e6 DM	341	}
aff192e6 DM	342	}
97ab5760 DM	343
	344	# we are authenticated now
	345
aff192e6 DM	346	my $uri_param = {};
	347	my ($handler, $info) = PVE::API2->find_handler($method, $rel_uri, $uri_param);
	348	if (!$handler \|\| !$info) {
	349	return {
	350	status => HTTP_NOT_IMPLEMENTED,
	351	message => "Method '$method $abs_uri' not implemented",
	352	};
	353	}
	354
97ab5760 DM	355	# Note: we need to delay CGI parameter parsing until
	356	# we are authenticated (avoid DOS (file upload) attacs)
	357
	358	my $params;
	359	eval { $params = $rpcenv->parse_params($isUpload); };
	360	if (my $err = $@) {
	361	return {
	362	status => HTTP_BAD_REQUEST,
	363	message => "parameter parser failed: $err",
	364	};
	365	}
	366
aff192e6 DM	367	delete $params->{_dc}; # remove disable cache parameter
	368
	369	foreach my $p (keys %{$params}) {
	370	if (defined($uri_param->{$p})) {
	371	return {
	372	status => HTTP_BAD_REQUEST,
	373	message => "Parameter verification failed - duplicate parameter '$p'",
	374	};
	375	}
	376	$uri_param->{$p} = $params->{$p};
	377	}
	378
	379	# check access permissions
40bbaac1	380	eval { $rpcenv->check_api2_permissions($info->{permissions}, $username, $uri_param); };
aff192e6	381	if (my $err = $@) {
f797e949	382	return &$exc_to_res($err, HTTP_FORBIDDEN);
aff192e6 DM	383	}
	384
	385	if ($info->{proxyto}) {
	386	my $remip;
	387	eval {
	388	my $pn = $info->{proxyto};
	389	my $node = $uri_param->{$pn};
	390	die "proxy parameter '$pn' does not exists" if !$node;
	391
97ab5760 DM	392	if ($node ne 'localhost' && $node ne PVE::INotify::nodename()) {
97ab5760 DM	393	die "unable to proxy file uploads" if $isUpload;
aff192e6 DM	394	$remip = PVE::Cluster::remote_node_ip($node);
	395	}
	396	};
	397	if (my $err = $@) {
f797e949	398	return &$exc_to_res($err);
aff192e6 DM	399	}
aff192e6 DM	400	if ($remip) {
97ab5760	401	return { proxy => $remip, proxy_params => $params };
aff192e6 DM	402	}
	403	}
	404
97ab5760 DM	405	if ($info->{protected} && ($euid != 0)) {
	406	if ($isUpload) {
	407	my $uinfo = $rpcenv->get_upload_info('filename');
	408	$params->{tmpfilename} = $uinfo->{tmpfilename};
	409	}
	410	return { proxy => 'localhost' , proxy_params => $params }
	411	}
aff192e6 DM	412
	413	my $resp = {
	414	info => $info, # useful to format output
	415	status => HTTP_OK,
	416	};
	417
	418	eval {
	419	$resp->{data} = $handler->handle($info, $uri_param);
	420
e09058af	421	if (my $count = $rpcenv->get_result_attrib('total')) {
aff192e6 DM	422	$resp->{total} = $count;
aff192e6 DM	423	}
e09058af	424	if (my $diff = $rpcenv->get_result_attrib('changes')) {
3dff4a9f DM	425	$resp->{changes} = $diff;
3dff4a9f DM	426	}
aff192e6	427	};
f797e949 DM	428	if (my $err = $@) {
f797e949 DM	429	return &$exc_to_res($err);
aff192e6 DM	430	}
aff192e6 DM	431
aff192e6 DM	432	return $resp;
	433	}
	434
	435	sub split_abs_uri {
	436	my ($abs_uri) = @_;
	437
d25e7431	438	my ($format, $rel_uri) = $abs_uri =~ m/^\Q$baseuri\E\/+(html\|text\|json\|extjs\|png\|htmljs)(\/.*)?$/;
aff192e6 DM	439	$rel_uri = '/' if !$rel_uri;
	440
	441	return wantarray ? ($rel_uri, $format) : $rel_uri;
	442	}
	443
	444	my $known_methods = {
	445	GET => 1,
	446	POST => 1,
	447	PUT => 1,
	448	DELETE => 1,
	449	};
	450
6c980a67 DM	451	my $request_count = 0;
6c980a67 DM	452
aff192e6 DM	453	sub handler {
	454	my($r) = @_;
	455
282184f5	456	debug_msg("perl handler called");
aff192e6	457
6c980a67 DM	458	$request_count++;
	459	# we do not use KeepAlive, so this is not necessary
	460	# $r->child_terminate() if $request_count >= $MaxRequestsPerChild;
	461
aff192e6 DM	462	my $method = $r->method;
	463	my $clientip = $r->connection->remote_ip();
	464
	465	return HTTP_NOT_IMPLEMENTED
	466	if !$known_methods->{$method};
	467
aff192e6 DM	468	my $cookie = $r->headers_in->{Cookie};
	469	my $token = $r->headers_in->{CSRFPreventionToken};
	470
	471	my $ticket = extract_auth_cookie($cookie);
	472
	473	$r->no_cache (1);
	474
	475	my $abs_uri = $r->uri;
	476	my ($rel_uri, $format) = split_abs_uri($abs_uri);
	477	return HTTP_NOT_IMPLEMENTED if !$format;
	478
97ab5760 DM	479	my $rpcenv;
	480	my $res;
	481
	482	eval {
	483	$rpcenv = PVE::RPCEnvironment::get();
	484	$rpcenv->init_request(request_rec => $r);
	485	};
	486	if (my $err = $@) {
	487	syslog('err', $err);
	488	$res = { status => HTTP_INTERNAL_SERVER_ERROR, message => $err };
	489	} else {
	490	$res = rest_handler($rpcenv, $clientip, $method, $abs_uri, $rel_uri,
	491	$ticket, $token);
bd733366	492	$rpcenv->set_user(undef); # clear after request
97ab5760	493	}
aff192e6 DM	494
	495	if ($res->{proxy}) {
	496	if (($res->{proxy} ne 'localhost') && $r->headers_in->{'PVEDisableProxy'}) {
	497	my $code = FORBIDDEN;
	498	$r->status($code);
	499	$r->status_line("$code proxy loop detected - aborted ");
	500	return $res->{status};
	501	}
	502	return proxy_handler($r, $clientip, $res->{proxy}, $method,
97ab5760	503	$abs_uri, $ticket, $token, $res->{proxy_params});
aff192e6 DM	504	}
	505
	506	prepare_response_data($format, $res);
	507
aff192e6 DM	508	$r->status($res->{status} \|\| HTTP_OK);
	509
	510	if ($res->{message}) {
	511	my ($firstline) = $res->{message} =~ m/\A(.*)$/m;
	512	$r->status_line("$res->{status} $firstline");
	513	}
	514
	515	my ($raw, $ct) = format_response_data($format, $res, $abs_uri);
	516	$r->content_type ($ct);
	517
	518	# note: do not use err_headers_out(), because mod_deflate has a bug,
	519	# resulting in dup length (for exampe 'content-length: 89, 75')
	520	$r->headers_out()->add('Content-Length', length($raw));
	521	$r->print($raw);
	522
282184f5	523	debug_msg("perl handler end $res->{status}");
aff192e6 DM	524
	525	return OK;
	526	}
	527
	528	1;