struct PP_Var
ppb_url_util_dev_resolve_relative_to_url(struct PP_Var base_url, struct PP_Var relative_string,
struct PP_URLComponents_Dev *components)
{
reset_components(components);
struct PP_Var var = PP_MakeNull();
if (base_url.type != PP_VARTYPE_STRING) {
trace_warning("%s, base_url is not a string\n", __func__);
return PP_MakeNull();
}
if (relative_string.type != PP_VARTYPE_STRING) {
trace_warning("%s, relative_string is not a string\n", __func__);
return PP_MakeNull();
}
const char *s_base_url = ppb_var_var_to_utf8(base_url, NULL);
const char *s_relative_string = ppb_var_var_to_utf8(relative_string, NULL);
UriParserStateA ups;
UriUriA uri_base, uri_rel, uri_result;
ups.uri = &uri_base;
if (uriParseUriA(&ups, s_base_url) != URI_SUCCESS) {
trace_warning("%s, can't parse s_base_url\n", __func__);
goto err_1;
}
ups.uri = &uri_rel;
if (uriParseUriA(&ups, s_relative_string) != URI_SUCCESS) {
trace_warning("%s, can't parse s_relative_string\n", __func__);
goto err_2;
}
if (uriAddBaseUriA(&uri_result, &uri_rel, &uri_base) != URI_SUCCESS) {
trace_warning("%s, can't merge base and rel\n", __func__);
goto err_3;
}
int len;
uriToStringCharsRequiredA(&uri_result, &len);
len++;
char *str = malloc(len);
uriToStringA(str, &uri_result, len, NULL);
var = ppb_var_var_from_utf8_z(str);
free(str);
if (components)
parse_url_string(str, components);
err_3: uriFreeUriMembersA(&uri_result);
err_2: uriFreeUriMembersA(&uri_rel);
err_1: uriFreeUriMembersA(&uri_base);
return var;
}
struct PP_Var
ppb_url_response_info_get_property(PP_Resource response, PP_URLResponseProperty property)
{
struct pp_url_response_info_s *ri = pp_resource_acquire(response,PP_RESOURCE_URL_RESPONSE_INFO);
if (!ri) {
trace_error("%s, bad resource\n", __func__);
return PP_MakeUndefined();
}
struct pp_url_loader_s *ul = ri->url_loader;
struct PP_Var var = PP_MakeUndefined();
switch (property) {
case PP_URLRESPONSEPROPERTY_URL:
var = ppb_var_var_from_utf8_z(ul->url);
break;
case PP_URLRESPONSEPROPERTY_REDIRECTURL:
var = ppb_var_var_from_utf8_z(ul->redirect_url);
break;
case PP_URLRESPONSEPROPERTY_REDIRECTMETHOD:
// redirection is believed to be always GET
// TODO: check whenever it may be HEAD
var = ppb_var_var_from_utf8_z("GET");
break;
case PP_URLRESPONSEPROPERTY_STATUSCODE:
var.type = PP_VARTYPE_INT32;
var.value.as_int = ul->http_code;
break;
case PP_URLRESPONSEPROPERTY_STATUSLINE:
var = ppb_var_var_from_utf8_z(ul->status_line);
break;
case PP_URLRESPONSEPROPERTY_HEADERS:
var = ppb_var_var_from_utf8_z(ul->headers);
break;
}
pp_resource_release(response);
return var;
}
struct PP_Var
ppb_host_resolver_get_canonical_name(PP_Resource host_resolver)
{
// TODO: implement
struct pp_host_resolver_s *hr = pp_resource_acquire(host_resolver, PP_RESOURCE_HOST_RESOLVER);
if (!hr) {
trace_error("%s, bad resource\n", __func__);
return PP_MakeUndefined();
}
struct PP_Var var = ppb_var_var_from_utf8_z(hr->host);
pp_resource_release(host_resolver);
return var;
}
struct PP_Var
get_flashsetting_language(void)
{
char *lang = getenv("LANG");
if (!lang)
return ppb_var_var_from_utf8_z("en-US");
// make a working copy
lang = strdup(lang);
// cut character encoding if exists
char *ptr = strchr(lang, '.');
if (ptr)
*ptr = 0;
// replace _ by
ptr = strchr(lang, '_');
if (ptr)
*ptr = '-';
struct PP_Var res = ppb_var_var_from_utf8_z(lang);
free(lang);
return res;
}
static
void
p2n_has_method_comt(void *user_data, int32_t result)
{
struct has_method_param_s *p = user_data;
struct np_proxy_object_s *obj = (void *)p->npobj;
struct PP_Var exception = PP_MakeUndefined();
struct PP_Var method_name = ppb_var_var_from_utf8_z(p->name);
p->result = ppb_var_has_method(obj->ppobj, method_name, &exception);
ppb_var_release(method_name);
ppb_var_release(exception);
ppb_message_loop_post_quit_depth(p->m_loop, PP_FALSE, p->depth);
}
static
void
p2n_get_property_comt(void *user_data, int32_t result)
{
struct get_property_param_s *p = user_data;
struct np_proxy_object_s *obj = (void *)p->npobj;
struct PP_Var exception = PP_MakeUndefined();
struct PP_Var property_name = ppb_var_var_from_utf8_z(p->name);
struct PP_Var res = ppb_var_get_property(obj->ppobj, property_name, &exception);
p->result = true;
*p->np_result = pp_var_to_np_variant(res);
ppb_var_release(res);
ppb_var_release(exception);
ppb_message_loop_post_quit_depth(p->m_loop, PP_FALSE, p->depth);
}
struct PP_Var
ppb_url_util_dev_get_plugin_instance_url(PP_Instance instance,
struct PP_URLComponents_Dev *components)
{
reset_components(components);
struct pp_instance_s *pp_i = tables_get_pp_instance(instance);
if (!pp_i) {
trace_error("%s, bad instance\n", __func__);
return PP_MakeUndefined();
}
struct PP_Var var = ppb_var_var_from_utf8_z(pp_i->instance_url);
if (components)
parse_url_string(ppb_var_var_to_utf8(var, NULL), components);
return var;
}
static
void
p2n_invoke_comt(void *user_data, int32_t result)
{
struct invoke_param_s *p = user_data;
unsigned int k;
p->result = true;
struct np_proxy_object_s *obj = (void *)p->npobj;
struct PP_Var exception = PP_MakeUndefined();
struct PP_Var method_name = ppb_var_var_from_utf8_z(p->name);
struct PP_Var res;
struct PP_Var *pp_args = malloc(p->argCount * sizeof(*pp_args));
for (k = 0; k < p->argCount; k ++) {
pp_args[k] = np_variant_to_pp_var(p->args[k]);
}
res = ppb_var_call(obj->ppobj, method_name, p->argCount, pp_args, &exception);
for (k = 0; k < p->argCount; k ++)
ppb_var_release(pp_args[k]);
free(pp_args);
if (p->np_result) {
*p->np_result = pp_var_to_np_variant(res);
if (p->np_result->type == NPVariantType_Object) {
NPP npp = tables_get_npobj_npp_mapping(p->npobj);
tables_add_npobj_npp_mapping(p->np_result->value.objectValue, npp);
}
}
ppb_var_release(res);
ppb_var_release(method_name);
ppb_var_release(exception);
ppb_message_loop_post_quit_depth(p->m_loop, PP_FALSE, p->depth);
}
int32_t
ppb_url_loader_open_target(PP_Resource loader, PP_Resource request_info,
struct PP_CompletionCallback callback, const char *target)
{
struct pp_url_loader_s *ul = pp_resource_acquire(loader, PP_RESOURCE_URL_LOADER);
if (!ul) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
struct pp_url_request_info_s *ri = pp_resource_acquire(request_info,
PP_RESOURCE_URL_REQUEST_INFO);
if (!ri) {
trace_error("%s, bad resource\n", __func__);
pp_resource_release(loader);
return PP_ERROR_BADRESOURCE;
}
struct PP_Var full_url;
if (ri->is_immediate_javascript) {
full_url = ppb_var_var_from_utf8_z(ri->url);
} else {
struct PP_Var rel_url = ppb_var_var_from_utf8_z(ri->url);
full_url = ppb_url_util_dev_resolve_relative_to_document(ul->instance->id, rel_url, NULL);
ppb_var_release(rel_url);
}
ul->url = nullsafe_strdup(ppb_var_var_to_utf8(full_url, NULL));
ul->method = ri->method;
ul->read_pos = 0;
ul->request_headers = nullsafe_strdup(ri->headers);
ul->follow_redirects = ri->follow_redirects;
ul->stream_to_file = ri->stream_to_file;
ul->record_download_progress = ri->record_download_progress;
ul->record_upload_progress = ri->record_upload_progress;
ul->custom_referrer_url = nullsafe_strdup(ri->custom_referrer_url);
ul->allow_cross_origin_requests = ri->allow_cross_origin_requests;
ul->allow_credentials = ri->allow_credentials;
ul->custom_content_transfer_encoding = nullsafe_strdup(ri->custom_content_transfer_encoding);
ul->custom_user_agent = nullsafe_strdup(ri->custom_user_agent);
ul->target = nullsafe_strdup(target);
#define TRIM_NEWLINE(s) s = trim_nl(s)
TRIM_NEWLINE(ul->request_headers);
TRIM_NEWLINE(ul->custom_referrer_url);
TRIM_NEWLINE(ul->custom_content_transfer_encoding);
TRIM_NEWLINE(ul->custom_user_agent);
ul->post_len = ri->post_len;
if (ri->post_len > 0) {
ul->post_data = malloc(ri->post_len);
memcpy(ul->post_data, ri->post_data, ri->post_len);
}
ul->fd = open_temporary_file();
ul->ccb = callback;
ppb_var_release(full_url);
pp_resource_release(request_info);
struct url_loader_open_param_s *p = g_slice_alloc(sizeof(*p));
p->url = ul->url;
p->loader = loader;
p->instance_id = ul->instance->id;
p->method = ul->method;
p->request_headers = ul->request_headers;
p->custom_referrer_url = ul->custom_referrer_url;
p->custom_content_transfer_encoding = ul->custom_content_transfer_encoding;
p->custom_user_agent = ul->custom_user_agent;
p->target = ul->target;
p->post_len = ul->post_len;
p->post_data = ul->post_data;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_core_add_ref_resource(loader); // add ref to ensure data in ul remain accessible
pp_resource_release(loader);
ppb_message_loop_post_work(p->m_loop, PP_MakeCCB(_url_loader_open_comt, p), 0);
ppb_message_loop_run_nested(p->m_loop);
ppb_core_release_resource(loader);
int retval = p->retval;
g_slice_free1(sizeof(*p), p);
if (retval != NPERR_NO_ERROR)
return PP_ERROR_FAILED;
if (callback.func == NULL) {
int done = 0;
while (!done) {
ul = pp_resource_acquire(loader, PP_RESOURCE_URL_LOADER);
if (ul) {
done = ul->finished_loading;
pp_resource_release(loader);
} else {
break;
}
printf("waitin'\n");
usleep(10000);
}
return PP_OK;
}
return PP_OK_COMPLETIONPENDING;
}
struct PP_Var
ppb_char_set_get_default_char_set(PP_Instance instance)
{
char *lang = extract_relevant_part_from_locale_name(getenv("LANG"));
struct lang_encoding {
const char *lang;
const char *encoding;
};
static const struct lang_encoding pairs[] = {
{"am", "windows-1252"},
{"ar", "windows-1256"},
{"bg", "windows-1251"},
{"bn", "windows-1252"},
{"ca", "windows-1252"},
{"cs", "windows-1250"},
{"da", "windows-1252"},
{"de", "windows-1252"},
{"el", "ISO-8859-7"},
{"en", "windows-1252"},
{"es", "windows-1252"},
{"et", "windows-1257"},
{"fa", "windows-1256"},
{"fil", "windows-1252"},
{"fi", "windows-1252"},
{"fr", "windows-1252"},
{"gu", "windows-1252"},
{"he", "windows-1255"},
{"hi", "windows-1252"},
{"hr", "windows-1250"},
{"hu", "ISO-8859-2"},
{"id", "windows-1252"},
{"it", "windows-1252"},
{"ja", "Shift_JIS"},
{"kn", "windows-1252"},
{"ko", "windows-949"},
{"lt", "windows-1257"},
{"lv", "windows-1257"},
{"ml", "windows-1252"},
{"mr", "windows-1252"},
{"nb", "windows-1252"},
{"nl", "windows-1252"},
{"pl", "ISO-8859-2"},
{"pt", "windows-1252"},
{"pt", "windows-1252"},
{"ro", "ISO-8859-2"},
{"ru", "windows-1251"},
{"sk", "windows-1250"},
{"sl", "ISO-8859-2"},
{"sr", "windows-1251"},
{"sv", "windows-1252"},
{"sw", "windows-1252"},
{"ta", "windows-1252"},
{"te", "windows-1252"},
{"th", "windows-874"},
{"tr", "ISO-8859-9"},
{"uk", "windows-1251"},
{"vi", "windows-1258"},
{"zh-CN", "GBK"},
{"zh-TW", "Big5"},
};
const char *enc = "windows-1252";
for (uint32_t k = 0; k < sizeof(pairs)/sizeof(pairs[0]); k ++) {
if (strcasecmp(pairs[k].lang, lang) == 0) {
enc = pairs[k].encoding;
break;
}
}
struct PP_Var ret = ppb_var_var_from_utf8_z(enc);
free(lang);
return ret;
}
int32_t
ppb_video_capture_enumerate_devices(PP_Resource video_capture, struct PP_ArrayOutput output,
struct PP_CompletionCallback callback)
{
int32_t retval;
struct pp_video_capture_s *vc = pp_resource_acquire(video_capture, PP_RESOURCE_VIDEO_CAPTURE);
if (!vc) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
GArray *vc_devices = g_array_new(FALSE, TRUE, sizeof(PP_Resource));
struct dirent **namelist;
int n = scandir("/dev/v4l/by-path", &namelist, NULL, NULL);
if (n >= 0) {
for (int k = 0; k < n; k ++) {
if (strcmp(namelist[k]->d_name, ".") == 0)
continue;
if (strcmp(namelist[k]->d_name, "..") == 0)
continue;
char *fullpath = g_strdup_printf("/dev/v4l/by-path/%s", namelist[k]->d_name);
char *shortname = NULL;
if (video_device_is_usable(fullpath, &shortname)) {
PP_Resource device;
device = ppb_device_ref_create(vc->instance->id,
ppb_var_var_from_utf8_z(shortname),
ppb_var_var_from_utf8_z(fullpath),
PP_DEVICETYPE_DEV_VIDEOCAPTURE);
g_array_append_val(vc_devices, device);
free(shortname);
}
g_free(fullpath);
}
for (int k = 0; k < n; k ++)
free(namelist[k]);
free(namelist);
}
PP_Resource *devs = output.GetDataBuffer(output.user_data, vc_devices->len,
sizeof(PP_Resource));
if (!devs) {
retval = PP_ERROR_FAILED;
for (int k = 0; k < vc_devices->len; k ++)
ppb_core_release_resource(g_array_index(vc_devices, PP_Resource, k));
goto err;
}
for (int k = 0; k < vc_devices->len; k ++)
devs[k] = g_array_index(vc_devices, PP_Resource, k);
retval = PP_OK_COMPLETIONPENDING;
ppb_core_call_on_main_thread2(0, callback, PP_OK, __func__);
err:
pp_resource_release(video_capture);
g_array_free(vc_devices, TRUE);
return retval;
}
struct PP_Var
ppb_flash_get_command_line_args(PP_Module module)
{
return ppb_var_var_from_utf8_z(config.flash_command_line);
}
