void PlatformApiStub::update_application_list(const ApplicationListUpdate &update) {
protobuf::bridge::EventSequence seq;
auto event = seq.mutable_application_list_update();
for (const auto &a : update.applications) {
auto app = event->add_applications();
app->set_name(a.name);
app->set_package(a.package);
auto launch_intent = app->mutable_launch_intent();
launch_intent->set_action(a.launch_intent.action);
launch_intent->set_uri(a.launch_intent.uri);
launch_intent->set_type(a.launch_intent.type);
launch_intent->set_package(a.launch_intent.package);
launch_intent->set_component(a.launch_intent.component);
for (const auto &category : a.launch_intent.categories) {
auto c = launch_intent->add_categories();
*c = category;
}
app->set_icon(a.icon.data(), a.icon.size());
}
for (const auto &package : update.removed_applications) {
auto app = event->add_removed_applications();
app->set_name("unknown");
app->set_package(package);
}
rpc_channel_->send_event(seq);
}
void Pane::load_state(QSettings *s) {
QString uri = s->value("path", "").toString();
if (uri.isEmpty()) {
uri = Special_uri(Special_uri::places).uri();
}
set_uri(uri);
}
//////////////////////////////////////////////////////////////////////////
// meta
void MetaTask::RunImp()
{
std::string uri_str = uri();
std::string buckname = CString2string(_buckname);
buckname = MultiByteToUtf8(buckname);
set_uri(uri_str.append(URLEncode(buckname) + "/?meta"));
}
//////////////////////////////////////////////////////////////////////////
// delete bucket
void DeleteBucketTask::RunImp()
{
set_http_method(HTTP_METHOD_DELETE);
std::string uri_str = uri();
std::string buckname = CString2string(_buckname);
buckname = MultiByteToUtf8(buckname);
set_uri(uri_str.append(URLEncode(buckname) + "/"));
}
/** Rename */
virtual void set_path(const Raul::Path& new_path) {
_path = new_path;
const char* const new_sym = new_path.symbol();
if (new_sym[0] != '\0') {
_symbol = Raul::Symbol(new_sym);
}
set_uri(Node::path_to_uri(new_path));
}
//////////////////////////////////////////////////////////////////////////
// crate bucket
void CreateBucketTask::RunImp()
{
set_is_upload(true);
set_http_method(HTTP_METHOD_PUT);
std::string uri_str = uri();
std::string buckname = CString2string(_buckname);
buckname = MultiByteToUtf8(buckname);
set_uri(uri_str.append(URLEncode(buckname) + "/"));
}
void GetAclTask::RunImp()
{
std::string uri_str = uri();
std::string buckname = CString2string(_buckname);
buckname = MultiByteToUtf8(buckname);
std::string objname = CString2string(_objname);
objname = MultiByteToUtf8(objname);
set_uri(uri_str.append(URLEncode(buckname) + "/" + URLEncode(objname) + "?acl"));
}
void AclTask::RunImp()
{
set_http_method(HTTP_METHOD_PUT);
_content_type = "text/json";
add_header("Content-Type", _content_type);
std::string uri_str = uri();
std::string buckname = CString2string(_buckname);
buckname = MultiByteToUtf8(buckname);
std::string objname = CString2string(_objname);
objname = MultiByteToUtf8(objname);
set_uri(uri_str.append(URLEncode(buckname) + "/" + URLEncode(objname) + "?acl"));
}
//////////////////////////////////////////////////////////////////////////
// list bucket
void ListBucketTask::RunImp()
{
std::string prefix = CString2string(_prefix);
prefix = MultiByteToUtf8(prefix);
add_params("prefix", URLEncode(prefix));
add_params("delimiter", URLEncode("/"));
std::string uri_str = uri();
std::string buckname = CString2string(_buckname);
buckname = MultiByteToUtf8(buckname);
set_uri(uri_str.append(URLEncode(buckname) + "/"));
}
int jester::parse_options(int argc, char *argv[])
{
static const struct option longopts[] = {{"method", required_argument, NULL, 'm'},
{"uri", required_argument, NULL, 'u'},
{"data", required_argument, NULL, 'd'},
{"interactive", no_argument, NULL, 'i'},
{"content", required_argument, NULL, 'c'},
{"header", required_argument, NULL, 'h'},
{NULL, 0, NULL, 0}};
int opt;
std::shared_ptr<jest::arg_pair> pair;
while ((opt = getopt_long(argc, argv, "u:m:d:ih:", longopts, NULL)) != -1) {
switch (opt) {
case 'u':
set_uri(optarg);
break;
case 'm':
if (!set_method(optarg)) {
printf("Unknown HTTP method %s\n", optarg);
return EXIT_FAILURE;
}
break;
case 'd':
pair = jest::split_arg(optarg, "=");
if (!pair) {
printf("Data should be in key=value format.");
return EXIT_FAILURE;
}
append_data(*pair);
break;
case 'c':
set_content(optarg);
break;
case 'i':
set_interactive(true);
break;
case 'h':
pair = jest::split_arg(optarg, ":");
if (!pair) {
printf("header should be in key:value format.");
return EXIT_FAILURE;
}
append_header(*pair);
break;
default:
syntax(argv[0]);
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
//////////////////////////////////////////////////////////////////////////
// base
TaskBase::TaskBase()
: _running(FALSE)
, _id(_maxid++)
, _content_type("")
, _date("")
{
set_uri("/");
set_use_https(false);
set_host(S3_DEFAULT_HOSTNAME);
set_timeout(CMD_TASK_TIMEOUT_SECOND);
add_params("formatter", "json");
add_header("Accept-Encoding", "identity");
}
//////////////////////////////////////////////////////////////////////////
// download
void DownloadTask::RunImp()
{
set_timeout(-1);
set_is_download(true);
std::string uri_str = uri();
std::string buckname = CString2string(_buckname);
buckname = MultiByteToUtf8(buckname);
std::string folderfile = CString2string(_filename);
folderfile = MultiByteToUtf8(folderfile);
set_uri(uri_str.append(URLEncode(buckname) + "/" + URLEncode(folderfile)));
set_file_name(CString2string(_localpath + _T(DOWNLOAD_TEMP)));
}
//////////////////////////////////////////////////////////////////////////
// upload
void UploadTask::RunImp()
{
set_timeout(-1);
set_is_upload(true);
set_http_method(HTTP_METHOD_PUT);
std::string uri_str = uri();
std::string buckname = CString2string(_buckname);
buckname = MultiByteToUtf8(buckname);
std::string folderfile = CString2string(_filename);
folderfile = MultiByteToUtf8(folderfile);
set_uri(uri_str.append(URLEncode(buckname) + "/" + URLEncode(folderfile)));
set_file_name(CString2string(_localpath));
set_file_begin_pos(0);
set_file_size(-1);
}
inline void request::process(std::string::iterator begin, std::string::iterator
end)
{
std::string::iterator cursor_start = begin;
std::string::iterator cursor_end = std::find(begin,end,' ');
if (cursor_end == end) {
throw exception("Invalid request line1",status_code::bad_request);
}
set_method(std::string(cursor_start,cursor_end));
cursor_start = cursor_end+1;
cursor_end = std::find(cursor_start,end,' ');
if (cursor_end == end) {
throw exception("Invalid request line2",status_code::bad_request);
}
set_uri(std::string(cursor_start,cursor_end));
set_version(std::string(cursor_end+1,end));
}
//////////////////////////////////////////////////////////////////////////
// copy
void CopyTask::RunImp()
{
set_is_upload(true);
set_http_method(HTTP_METHOD_PUT);
std::string buckname = CString2string(_buckname);
buckname = MultiByteToUtf8(buckname);
std::string source = "/";
source.append(buckname + "/" + CString2string(_frompath));
source = MultiByteToUtf8(source);
add_header("x-amz-copy-source", URLEncode(source));
add_header("x-amz-metadata-directive", "COPY");
_amz_data.insert(StringMap::value_type("x-amz-copy-source", URLEncode(source)));
_amz_data.insert(StringMap::value_type("x-amz-metadata-directive", "COPY"));
std::string uri_str = uri();
std::string objname = CString2string(_topath);
objname = MultiByteToUtf8(objname);
set_uri(uri_str.append(URLEncode(buckname) + "/" + URLEncode(objname)));
}
int http_decoder::on_url(http_parser *parser, const char *at, std::size_t length) {
auto p = static_cast<http_decoder*>(parser->data);
assert(p);
assert(p->message_);
auto method = ::http_method_str(static_cast<http_method>(parser->method));
auto request = dynamic_cast<message::http::http_request *>(p->message_);
assert(request);
request->set_method(std::string(method));
// Note: a request sent proxy contains the first line as below:
// => GET http://example.com/some/resource HTTP/1.1
// so, we should convert it into the following before sending it
// to server:
// => GET /some/resource HTTP/1.1
std::string uri(at, length);
if (parser->method != HTTP_CONNECT) {
if (uri[0] != '/') {
const static std::string http("http://");
auto end = std::string::npos;
if(uri.compare(0, http.length(), http) != 0)
end = uri.find('/');
else
end = uri.find('/', http.length());
if(end == std::string::npos) {
uri = '/';
} else {
uri.erase(0, end);
}
}
}
request->set_uri(uri);
return 0;
}
/*
* Check if from user is a valid enum based user, and check to make sure
* that the src_ip == an srv record that maps to the enum from user.
*/
int is_from_user_enum_2(struct sip_msg* _msg, char* _suffix, char* _service)
{
struct ip_addr addr;
struct hostent* he;
unsigned short zp;
unsigned short proto;
char *user_s;
int user_len, i, j;
char name[MAX_DOMAIN_SIZE];
char uri[MAX_URI_SIZE];
struct sip_uri *furi;
struct sip_uri luri;
struct rdata* head;
str* suffix;
str* service;
struct rdata* l;
struct naptr_rdata* naptr;
str pattern, replacement, result;
char string[17];
if (parse_from_header(_msg) < 0) {
LM_ERR("Failed to parse From header\n");
return -1;
}
if(_msg->from==NULL || get_from(_msg)==NULL) {
LM_DBG("No From header\n");
return -1;
}
if ((furi = parse_from_uri(_msg)) == NULL) {
LM_ERR("Failed to parse From URI\n");
return -1;
}
suffix = (str*)_suffix;
service = (str*)_service;
if (is_e164(&(furi->user)) == -1) {
LM_ERR("From URI user is not an E164 number\n");
return -1;
}
/* assert: the from user is a valid formatted e164 string */
user_s = furi->user.s;
user_len = furi->user.len;
j = 0;
for (i = user_len - 1; i > 0; i--) {
name[j] = user_s[i];
name[j + 1] = '.';
j = j + 2;
}
memcpy(name + j, suffix->s, suffix->len + 1);
head = get_record(name, T_NAPTR);
if (head == 0) {
LM_DBG("No NAPTR record found for %s.\n", name);
return -3;
}
/* we have the naptr records, loop and find an srv record with */
/* same ip address as source ip address, if we do then true is returned */
for (l = head; l; l = l->next) {
if (l->type != T_NAPTR) continue; /*should never happen*/
naptr = (struct naptr_rdata*)l->rdata;
if (naptr == 0) {
LM_ERR("Null rdata in DNS response\n");
free_rdata_list(head);
return -4;
}
LM_DBG("ENUM query on %s: order %u, pref %u, flen %u, flags "
"'%.*s', slen %u, services '%.*s', rlen %u, "
"regexp '%.*s'\n",
name, naptr->order, naptr->pref,
naptr->flags_len, (int)(naptr->flags_len), ZSW(naptr->flags), naptr->services_len,
(int)(naptr->services_len), ZSW(naptr->services), naptr->regexp_len,
(int)(naptr->regexp_len), ZSW(naptr->regexp));
if (sip_match(naptr, service) != 0) {
if (parse_naptr_regexp(&(naptr->regexp[0]), naptr->regexp_len,
&pattern, &replacement) < 0) {
free_rdata_list(head); /*clean up*/
LM_ERR("Parsing of NAPTR regexp failed\n");
return -5;
}
#ifdef LATER
if ((pattern.len == 4) && (strncmp(pattern.s, "^.*$", 4) == 0)) {
LM_DBG("Resulted in replacement: '%.*s'\n",
replacement.len, ZSW(replacement.s));
retval = set_uri(_msg, replacement.s, replacement.len);
free_rdata_list(head); /*clean up*/
return retval;
}
#endif
result.s = &(uri[0]);
result.len = MAX_URI_SIZE;
/* Avoid making copies of pattern and replacement */
pattern.s[pattern.len] = (char)0;
replacement.s[replacement.len] = (char)0;
/* We have already checked the size of
_msg->parsed_uri.user.s */
memcpy(&(string[0]), user_s, user_len);
string[user_len] = (char)0;
if (reg_replace(pattern.s, replacement.s, &(string[0]),
&result) < 0) {
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
LM_ERR("Regexp replace failed\n");
free_rdata_list(head); /*clean up*/
return -6;
}
LM_DBG("Resulted in replacement: '%.*s'\n",
result.len, ZSW(result.s));
if(parse_uri(result.s, result.len, &luri) < 0)
{
LM_ERR("Parsing of URI <%.*s> failed\n",
result.len, result.s);
free_rdata_list(head); /*clean up*/
return -7;
}
pattern.s[pattern.len] = '!';
replacement.s[replacement.len] = '!';
zp = 0;
proto = PROTO_NONE;
he = sip_resolvehost(&luri.host, &zp, &proto,
(luri.type==SIPS_URI_T)?1:0 , 0);
hostent2ip_addr(&addr, he, 0);
if(ip_addr_cmp(&addr, &_msg->rcv.src_ip))
{
free_rdata_list(head);
return(1);
}
}
}
free_rdata_list(head); /*clean up*/
LM_DBG("FAIL\n");
/* must not have found the record */
return(-8);
}
void Pane::on_go_clicked() {
ui->list->setFocus();
set_uri(ui->address->text());
}
void Pane::go_parent() {
set_uri(directory->get_parent_uri());
}
