int32_t
ppb_url_loader_read_response_body(PP_Resource loader, void *buffer, int32_t bytes_to_read,
struct PP_CompletionCallback callback)
{
struct url_loader_read_task_s *rt;
int32_t read_bytes = PP_ERROR_FAILED;
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;
}
if (ul->fd == -1) {
trace_error("%s, fd==-1\n", __func__);
pp_resource_release(loader);
return PP_ERROR_FAILED;
}
if (ul->read_tasks) {
// schedule task instead of immediate reading if there is another task
// in the queue already
goto schedule_read_task;
}
read_bytes = -1;
off_t ofs = lseek(ul->fd, ul->read_pos, SEEK_SET);
if (ofs != (off_t)-1)
read_bytes = RETRY_ON_EINTR(read(ul->fd, buffer, bytes_to_read));
if (read_bytes < 0)
read_bytes = PP_ERROR_FAILED;
else
ul->read_pos += read_bytes;
if (read_bytes == 0 && !ul->finished_loading) {
// no data ready, schedule read task
goto schedule_read_task;
}
pp_resource_release(loader);
if (callback.flags & PP_COMPLETIONCALLBACK_FLAG_OPTIONAL)
return read_bytes;
ppb_message_loop_post_work_with_result(ppb_message_loop_get_current(), callback, 0, read_bytes,
0, __func__);
return PP_OK_COMPLETIONPENDING;
schedule_read_task:
rt = g_slice_alloc(sizeof(*rt));
rt->url_loader = loader;
rt->buffer = buffer;
rt->bytes_to_read = bytes_to_read;
rt->ccb = callback;
rt->ccb_ml = ppb_message_loop_get_current();
ul->read_tasks = g_list_append(ul->read_tasks, rt);
pp_resource_release(loader);
return PP_OK_COMPLETIONPENDING;
}
PP_Resource
ppb_flash_menu_create(PP_Instance instance_id, const struct PP_Flash_Menu *menu_data)
{
struct pp_instance_s *pp_i = tables_get_pp_instance(instance_id);
if (!pp_i) {
trace_error("%s, bad instance\n", __func__);
return 0;
}
PP_Resource flash_menu = pp_resource_allocate(PP_RESOURCE_FLASH_MENU, pp_i);
if (pp_resource_get_type(flash_menu) != PP_RESOURCE_FLASH_MENU) {
trace_error("%s, resource allocation failure\n", __func__);
return 0;
}
struct flash_menu_create_param_s *p = g_slice_alloc0(sizeof(*p));
p->flash_menu = flash_menu;
p->menu_data = menu_data;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(flash_menu_create_comt, p), 0,
PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
g_slice_free1(sizeof(*p), p);
return flash_menu;
}
int32_t
ppb_host_resolver_resolve(PP_Resource host_resolver, const char *host, uint16_t port,
const struct PP_HostResolver_Private_Hint *hint,
struct PP_CompletionCallback callback)
{
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_ERROR_BADRESOURCE;
}
hr->host = nullsafe_strdup(host);
struct async_network_task_s *task = async_network_task_create();
task->type = ASYNC_NETWORK_HOST_RESOLVE;
task->resource = host_resolver;
task->host = nullsafe_strdup(host);
task->port = port;
task->callback = callback;
task->callback_ml = ppb_message_loop_get_current();
pp_resource_release(host_resolver);
async_network_task_push(task);
return PP_OK_COMPLETIONPENDING;
}
static
struct PP_Var
n2p_call(void *object, struct PP_Var method_name, uint32_t argc, struct PP_Var *argv,
struct PP_Var *exception)
{
if (method_name.type != PP_VARTYPE_STRING) {
trace_error("%s, method_name is not a string\n", __func__);
// TODO: fill exception
return PP_MakeUndefined();
}
struct call_param_s *p = g_slice_alloc(sizeof(*p));
p->object = object;
p->method_name = method_name;
p->argc = argc;
p->argv = argv;
p->exception = exception;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(n2p_call_comt, p), 0, PP_OK,
p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
struct PP_Var result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
static
bool
n2p_has_property(void *object, struct PP_Var name, struct PP_Var *exception)
{
if (name.type != PP_VARTYPE_STRING) {
trace_error("%s, name is not a string\n", __func__);
// TODO: fill exception
return false;
}
struct has_property_param_s *p = g_slice_alloc(sizeof(*p));
p->object = object;
p->name = name;
p->exception = exception;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(n2p_has_property_comt, p), 0,
PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
bool result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
int32_t
ppb_flash_message_loop_run(PP_Resource flash_message_loop)
{
struct pp_flash_message_loop_s *fml =
pp_resource_acquire(flash_message_loop, PP_RESOURCE_FLASH_MESSAGE_LOOP);
if (!fml) {
trace_error("%s, bad resource\n", __func__);
return PP_ERROR_BADRESOURCE;
}
PP_Resource message_loop = ppb_message_loop_get_current();
fml->running = 1;
fml->message_loop = message_loop;
fml->depth = ppb_message_loop_get_depth(message_loop) + 1;
pp_resource_ref(flash_message_loop); // prevent destroy of running loop
pp_resource_release(flash_message_loop);
// launching nested loop without depth increase to prevent hang up of previously pushed tasks
ppb_message_loop_run_int(message_loop, ML_NESTED);
fml = pp_resource_acquire(flash_message_loop, PP_RESOURCE_FLASH_MESSAGE_LOOP);
if (fml) {
fml->running = 0;
pp_resource_release(flash_message_loop);
}
pp_resource_unref(flash_message_loop);
return PP_OK;
}
struct PP_Var
ppb_instance_private_execute_script(PP_Instance instance, struct PP_Var script,
struct PP_Var *exception)
{
if (script.type != PP_VARTYPE_STRING) {
trace_error("%s, 'script' is not a string\n", __func__);
// TODO: fill exception
return PP_MakeUndefined();
}
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 execute_script_param_s p;
p.script = script;
p.pp_i = pp_i;
p.m_loop = ppb_message_loop_get_current();
p.depth = ppb_message_loop_get_depth(p.m_loop) + 1;
ppb_var_add_ref(script);
ppb_message_loop_post_work(p.m_loop, PP_MakeCompletionCallback(_execute_script_comt, &p), 0);
ppb_message_loop_run_int(p.m_loop, 1);
ppb_var_release(script);
return p.result;
}
TRACE_WRAPPER
PP_Resource
trace_ppb_message_loop_get_current(void)
{
trace_info("[PPB] {full} %s\n", __func__+6);
return ppb_message_loop_get_current();
}
static
void
n2p_deallocate(void *object)
{
struct deallocate_param_s *p = g_slice_alloc(sizeof(*p));
p->object = object;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(n2p_deallocate_comt, p), 0, PP_OK,
p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
g_slice_free1(sizeof(*p), p);
}
struct PP_Var
ppb_flash_get_proxy_for_url(PP_Instance instance, const char *url)
{
struct get_proxy_for_url_param_s *p = g_slice_alloc(sizeof(*p));
p->instance_id = instance;
p->url = url;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(get_proxy_for_url_comt, p), 0,
PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
struct PP_Var result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
static
struct PP_Var
n2p_construct(void *object, uint32_t argc, struct PP_Var *argv, struct PP_Var *exception)
{
struct construct_param_s *p = g_slice_alloc(sizeof(*p));
p->object = object;
p->argc = argc;
p->argv = argv;
p->exception = exception;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(n2p_construct_comt, p), 0, PP_OK,
p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
struct PP_Var result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
PP_Bool
ppb_flash_is_rect_topmost(PP_Instance instance, const struct PP_Rect *rect)
{
if (!rect)
return PP_FALSE;
struct topmost_rect_param_s *p = g_slice_alloc(sizeof(*p));
p->instance = instance;
p->rect = *rect;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(topmost_rect_comt, p), 0, PP_OK,
p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
PP_Bool result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
int32_t
ppb_url_loader_finish_streaming_to_file(PP_Resource loader, struct PP_CompletionCallback callback)
{
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;
}
if (!ul->stream_to_file) {
trace_error("%s, not streaming to file\n", __func__);
pp_resource_release(loader);
return PP_ERROR_FAILED;
}
ul->stream_to_file_ccb = callback;
ul->stream_to_file_ccb_ml = ppb_message_loop_get_current();
// TODO: handle callback.func == NULL case
pp_resource_release(loader);
return PP_OK_COMPLETIONPENDING;
}
struct PP_Var
ppb_flash_clipboard_read_data(PP_Instance instance_id, PP_Flash_Clipboard_Type clipboard_type,
uint32_t format)
{
if (!clipboard_type_and_format_are_supported(clipboard_type, format, __func__))
return PP_MakeUndefined();
struct clipboard_read_data_param_s *p = g_slice_alloc(sizeof(*p));
p->clipboard_type = clipboard_type;
p->format = format;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(clipboard_read_data_comt, p), 0,
PP_OK, p->depth, __func__);
ppb_message_loop_run_nested(p->m_loop);
struct PP_Var result = p->result;
g_slice_free1(sizeof(*p), p);
return result;
}
struct PP_Var
ppb_url_util_dev_get_document_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 get_document_url_param_s p;
p.npp = pp_i->npp;
p.m_loop = ppb_message_loop_get_current();
p.depth = ppb_message_loop_get_depth(p.m_loop) + 1;
p.np_window_obj = pp_i->np_window_obj;
ppb_message_loop_post_work(p.m_loop, PP_MakeCompletionCallback(_get_document_url_comt, &p), 0);
ppb_message_loop_run_int(p.m_loop, 1);
if (components)
parse_url_string(ppb_var_var_to_utf8(p.result, NULL), components);
return p.result;
}
int32_t
ppb_url_loader_follow_redirect(PP_Resource loader, struct PP_CompletionCallback callback)
{
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;
}
char *new_url = nullsafe_strdup(ul->redirect_url);
free_and_nullify(ul, url);
free_and_nullify(ul, redirect_url);
free_and_nullify(ul, status_line);
free_and_nullify(ul, headers);
free_and_nullify(ul, request_headers);
if (ul->fd >= 0) {
close(ul->fd);
ul->fd = -1;
}
// abort further handling of the NPStream
if (ul->np_stream) {
ul->np_stream->pdata = NULL;
ul->np_stream = NULL;
}
ul->fd = open_temporary_file();
ul->url = new_url;
ul->read_pos = 0;
ul->method = PP_METHOD_GET;
ul->ccb = callback;
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 = NULL;
p->post_len = 0;
p->post_data = NULL;
p->m_loop = ppb_message_loop_get_current();
p->depth = ppb_message_loop_get_depth(p->m_loop) + 1;
ppb_message_loop_post_work(p->m_loop, PP_MakeCCB(_url_loader_open_comt, p), 0);
ppb_message_loop_run_nested(p->m_loop);
pp_resource_release(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;
}
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;
}
PP_Bool
ppb_core_is_main_thread(void)
{
return ppb_message_loop_get_current() == ppb_message_loop_get_for_main_thread();
}
static
uintptr_t
load_ppp_module()
{
if (module_dl_handler) {
// already loaded
return 0;
}
// allocate auxiliary instance
if (!aux_instance) {
aux_instance = calloc(1, sizeof(*aux_instance));
if (!aux_instance)
return 1;
aux_instance->id = tables_generate_new_pp_instance_id();
tables_add_pp_instance(aux_instance->id, aux_instance);
}
// allocate message loop for browser thread
if (ppb_message_loop_get_current() == 0) {
PP_Resource message_loop = ppb_message_loop_create(aux_instance->id);
ppb_message_loop_attach_to_current_thread(message_loop);
ppb_message_loop_proclaim_this_thread_browser();
}
// allocate message loop for plugin thread (main thread)
if (ppb_message_loop_get_for_main_thread() == 0) {
pthread_barrier_init(&aux_instance->main_thread_barrier, NULL, 2);
pthread_create(&aux_instance->main_thread, NULL, fresh_wrapper_main_thread, aux_instance);
pthread_detach(aux_instance->main_thread);
pthread_barrier_wait(&aux_instance->main_thread_barrier);
pthread_barrier_destroy(&aux_instance->main_thread_barrier);
}
fpp_config_initialize();
if (tried_files) {
g_list_free_full(tried_files, g_free);
tried_files = NULL;
}
if (fpp_config_get_plugin_path()) {
const char *ptr = fpp_config_get_plugin_path();
const char *last = strchr(ptr, ':');
uintptr_t ret;
// parse ':'-separated list
while (last != NULL) {
// try entries one by one
char *entry = strndup(ptr, last - ptr);
ret = do_load_ppp_module(entry);
free(entry);
if (ret == 0)
return 0;
ptr = last + 1;
last = strchr(ptr, ':');
}
// and the last entry
ret = do_load_ppp_module(ptr);
if (ret == 0)
return 0;
goto failure;
}
// try all paths
const char **path_list = fpp_config_get_plugin_path_list();
while (*path_list) {
gchar *fname = g_strdup_printf("%s/%s", *path_list, fpp_config_get_plugin_file_name());
uintptr_t ret = do_load_ppp_module(fname);
g_free(fname);
if (ret == 0)
return 0;
path_list ++;
}
failure:
config.quirks.plugin_missing = 1;
use_fallback_version_strings();
trace_error("%s, can't find %s\n", __func__, fpp_config_get_plugin_file_name());
return 1;
}