sandboxed-api/contrib/uriparser/utils/utils_uriparser.cc

287 lines
8.5 KiB
C++
Raw Normal View History

// Copyright 2022 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "contrib/uriparser/utils/utils_uriparser.h"
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <fstream>
#include <iostream>
#include <string>
#include "absl/cleanup/cleanup.h"
UriParser::~UriParser() {
if (GetStatus().ok()) {
api_.uriFreeUriMembersA(uri_.PtrBefore()).IgnoreError();
}
}
absl::Status UriParser::GetStatus() { return status_; }
absl::Status UriParser::ParseUri() {
SAPI_RETURN_IF_ERROR(sandbox_->Allocate(&uri_, true));
sapi::v::Struct<UriParserStateA> state;
state.mutable_data()->uri = reinterpret_cast<UriUriA*>(uri_.GetRemote());
SAPI_ASSIGN_OR_RETURN(
int ret, api_.uriParseUriA(state.PtrBefore(), c_uri_.PtrBefore()));
if (ret != 0) {
return absl::UnavailableError("Unable to parse uri");
}
SAPI_RETURN_IF_ERROR(sandbox_->TransferFromSandboxee(&uri_));
return absl::OkStatus();
}
absl::StatusOr<std::string> UriParser::FetchUriText(UriTextRangeA* ptr) {
if (ptr == nullptr) {
return "";
}
if (ptr->first == nullptr) {
return "";
}
size_t size = ptr->afterLast - ptr->first;
// Sometimes uriparser dosen't allocate new memory
// and sometimes it does.
SAPI_ASSIGN_OR_RETURN(
std::string uri,
sandbox_->GetCString(sapi::v::RemotePtr(const_cast<char*>(ptr->first))));
return uri.substr(0, size);
}
absl::StatusOr<std::string> UriParser::GetScheme() {
return FetchUriText(&uri_.mutable_data()->scheme);
}
absl::StatusOr<std::string> UriParser::GetUserInfo() {
return FetchUriText(&uri_.mutable_data()->userInfo);
}
absl::StatusOr<std::string> UriParser::GetHostText() {
return FetchUriText(&uri_.mutable_data()->hostText);
}
absl::StatusOr<std::string> UriParser::GetHostIP() {
char ipstr[INET6_ADDRSTRLEN] = "";
UriHostDataA* data = &uri_.mutable_data()->hostData;
if (uri_.mutable_data()->hostData.ip4) {
sapi::v::Struct<UriIp4> ip4;
ip4.SetRemote(uri_.mutable_data()->hostData.ip4);
SAPI_RETURN_IF_ERROR(sandbox_->TransferFromSandboxee(&ip4));
inet_ntop(AF_INET, ip4.mutable_data()->data, ipstr, sizeof(ipstr));
} else if (uri_.mutable_data()->hostData.ip6) {
sapi::v::Struct<UriIp6> ip6;
ip6.SetRemote(uri_.mutable_data()->hostData.ip6);
SAPI_RETURN_IF_ERROR(sandbox_->TransferFromSandboxee(&ip6));
inet_ntop(AF_INET6, ip6.mutable_data()->data, ipstr, sizeof(ipstr));
}
return std::string(ipstr);
}
absl::StatusOr<std::string> UriParser::GetPortText() {
return FetchUriText(&uri_.mutable_data()->portText);
}
absl::StatusOr<std::string> UriParser::GetQuery() {
return FetchUriText(&uri_.mutable_data()->query);
}
absl::StatusOr<std::string> UriParser::GetFragment() {
return FetchUriText(&uri_.mutable_data()->fragment);
}
absl::StatusOr<std::vector<std::string>> UriParser::GetPath() {
std::vector<std::string> ret;
UriPathSegmentA* pathHead = uri_.mutable_data()->pathHead;
if (pathHead == nullptr) {
return ret;
}
sapi::v::Struct<UriPathSegmentA> path_segment;
path_segment.SetRemote(pathHead);
while (path_segment.GetRemote() != nullptr) {
SAPI_RETURN_IF_ERROR(sandbox_->TransferFromSandboxee(&path_segment));
SAPI_ASSIGN_OR_RETURN(std::string seg,
FetchUriText(&path_segment.mutable_data()->text));
if (!seg.empty()) {
ret.push_back(seg);
}
path_segment.SetRemote(path_segment.mutable_data()->next);
}
return ret;
}
absl::Status UriParser::NormalizeSyntax() {
SAPI_ASSIGN_OR_RETURN(int dirty_parts,
api_.uriNormalizeSyntaxMaskRequiredA(uri_.PtrNone()));
return NormalizeSyntax(dirty_parts);
}
absl::Status UriParser::NormalizeSyntax(int norm_mask) {
SAPI_ASSIGN_OR_RETURN(int ret,
api_.uriNormalizeSyntaxExA(uri_.PtrAfter(), norm_mask));
if (ret != 0) {
return absl::UnavailableError("Unable to normalize");
}
return absl::OkStatus();
}
absl::StatusOr<std::string> UriParser::GetUri() { return GetUri(&uri_); }
absl::StatusOr<std::string> UriParser::GetUri(sapi::v::Struct<UriUriA>* uri) {
sapi::v::Int size;
int ret;
SAPI_ASSIGN_OR_RETURN(
ret, api_.uriToStringCharsRequiredA(uri->PtrNone(), size.PtrAfter()));
if (ret != 0) {
return absl::UnavailableError("Unable to get size");
}
sapi::v::Array<char> buf(size.GetValue() + 1);
sapi::v::NullPtr null_ptr;
SAPI_ASSIGN_OR_RETURN(ret, api_.uriToStringA(buf.PtrAfter(), uri->PtrNone(),
buf.GetSize(), &null_ptr));
if (ret != 0) {
return absl::UnavailableError("Unable to Recomposing URI");
}
return std::string(buf.GetData());
}
absl::StatusOr<std::string> UriParser::GetUriEscaped(bool space_to_plus,
bool normalize_breaks) {
SAPI_ASSIGN_OR_RETURN(std::string uri, GetUri());
// Be sure to allocate *6 times* the space of the input buffer for
// *6 times* for _normalizeBreaks == URI_TRUE_
int space = uri.length() * 6 + 1;
sapi::v::Array<char> bufout(space);
sapi::v::ConstCStr bufin(uri.c_str());
SAPI_RETURN_IF_ERROR(api_.uriEscapeA(bufin.PtrBefore(), bufout.PtrAfter(),
space_to_plus, normalize_breaks));
return std::string(bufout.GetData());
}
absl::StatusOr<std::string> UriParser::GetUriWithBase(const std::string& base) {
UriParser base_uri(sandbox_, base);
sapi::v::Struct<UriUriA> newuri;
SAPI_ASSIGN_OR_RETURN(int ret,
api_.uriAddBaseUriA(newuri.PtrAfter(), uri_.PtrNone(),
base_uri.uri_.PtrBefore()));
if (ret != 0) {
return absl::UnavailableError("Unable to add base");
}
absl::Cleanup newuri_cleanup = [this, &newuri] {
api_.uriFreeUriMembersA(newuri.PtrNone()).IgnoreError();
};
return GetUri(&newuri);
}
absl::StatusOr<std::string> UriParser::GetUriWithoutBase(
const std::string& base, bool domain_root_mode) {
UriParser base_uri(sandbox_, base);
sapi::v::Struct<UriUriA> newuri;
SAPI_ASSIGN_OR_RETURN(
int ret,
api_.uriRemoveBaseUriA(newuri.PtrAfter(), uri_.PtrNone(),
base_uri.uri_.PtrBefore(), domain_root_mode));
if (ret != 0) {
return absl::UnavailableError("Unable to remove base");
}
absl::Cleanup newuri_cleanup = [this, &newuri] {
api_.uriFreeUriMembersA(newuri.PtrNone()).IgnoreError();
};
return GetUri(&newuri);
}
absl::StatusOr<absl::btree_map<std::string, std::string>>
UriParser::GetQueryElements() {
absl::btree_map<std::string, std::string> outquery;
if (uri_.mutable_data()->query.first == nullptr) {
return outquery;
}
sapi::v::Array<void*> query_ptr(1);
sapi::v::Int query_count;
sapi::v::RemotePtr first(const_cast<char*>(uri_.mutable_data()->query.first));
sapi::v::RemotePtr afterLast(
const_cast<char*>(uri_.mutable_data()->query.afterLast));
SAPI_ASSIGN_OR_RETURN(
int ret,
api_.uriDissectQueryMallocA(query_ptr.PtrAfter(), query_count.PtrAfter(),
&first, &afterLast));
if (ret != 0) {
return absl::UnavailableError("Unable to get query list");
}
absl::Cleanup query_list_cleanup = [this, &query_ptr] {
sapi::v::RemotePtr rptr(query_ptr[0]);
api_.uriFreeQueryListA(&rptr).IgnoreError();
};
sapi::v::Struct<UriQueryListA> obj;
obj.SetRemote(query_ptr[0]);
for (int i = 0; i < query_count.GetValue(); ++i) {
SAPI_RETURN_IF_ERROR(sandbox_->TransferFromSandboxee(&obj));
obj.SetRemote(nullptr);
void* key_p = const_cast<char*>(obj.mutable_data()->key);
void* value_p = const_cast<char*>(obj.mutable_data()->value);
SAPI_ASSIGN_OR_RETURN(std::string key_s,
sandbox_->GetCString(sapi::v::RemotePtr(key_p)));
std::string value_s;
if (value_p != nullptr) {
SAPI_ASSIGN_OR_RETURN(value_s,
sandbox_->GetCString(sapi::v::RemotePtr(value_p)));
} else {
value_s = "";
}
outquery[key_s] = value_s;
obj.SetRemote(obj.mutable_data()->next);
}
obj.SetRemote(nullptr);
return outquery;
}