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); }