You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

669 lines
21 KiB

9 years ago
/* Copyright (c) 2012 The Chromium Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file. */
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <unistd.h>
#ifdef _WIN32
#include "win/pthread.h"
#include <windows.h>
//static inline void sleep(unsigned ms) { Sleep(ms*1000); }
#else
#include <pthread.h>
#endif
9 years ago
static int initflag;
#ifndef __PNACL
#define PNACL_message printf
9 years ago
#else
void PNACL_message(const char* format, ...);
9 years ago
#endif
void OS_init();
9 years ago
void *OS_filestr(long *allocsizep,char *fname);
9 years ago
char *clonestr(char *);
void CHROMEAPP_MAIN(void *arg);
void *CHROMEAPP_NAME(void *arg)
{
if ( arg == 0 )
#ifdef __linux__
arg = 0;
#else
arg = 0;
#endif
while ( initflag == 0 )
usleep(1000000);
PNACL_message("%s start.(%s)\n",CHROMEAPP_STR,(char *)arg);
9 years ago
CHROMEAPP_MAIN(arg);
9 years ago
return(0);
}
#ifdef __PNACL
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <sys/ioctl.h>
#include <sys/mount.h>
#include <sys/param.h>
#include <sys/select.h>
#include <sys/stat.h>
#include "includes/ppapi/c/ppb.h"
#include "includes/ppapi/c/ppb_var.h"
#include "includes/ppapi/c/ppb_instance.h"
#include "includes/ppapi/c/ppb_messaging.h"
#include "includes/ppapi/c/ppb_var_array.h"
#include "includes/ppapi/c/ppb_var_dictionary.h"
#include "includes/ppapi/c/pp_errors.h"
#include "includes/ppapi/c/ppp_messaging.h"
#include "includes/ppapi/c/ppp_instance.h"
typedef int (*PSMainFunc_t)(int argc, char *argv[]);
#if defined(WIN32)
#define va_copy(d, s) ((d) = (s))
#endif
#ifndef __PNACL
/*int32_t PSGetInstanceId()
{
return(4);
}*/
#endif
typedef int (*HandleFunc)(struct PP_Var params,struct PP_Var* out_var,const char** error);
typedef struct { const char* name; HandleFunc function; } FuncNameMapping;
static PP_Instance g_instance = 0;
static PPB_GetInterface g_get_browser_interface = NULL;
static PPB_Messaging* g_ppb_messaging = NULL;
PPB_Var* g_ppb_var = NULL;
PPB_VarArray* g_ppb_var_array = NULL;
PPB_VarDictionary* g_ppb_var_dictionary = NULL;
int CHROMEAPP_HANDLER(struct PP_Var params,struct PP_Var *output,const char **out_error);
static FuncNameMapping g_function_map[] = { { CHROMEAPP_STR, CHROMEAPP_HANDLER }, { NULL, NULL } };
struct PP_Var CStrToVar(const char* str) { return g_ppb_var->VarFromUtf8(str, (int32_t)strlen(str)); }
char *VprintfToNewString(const char* format, va_list args)
{
va_list args_copy; int length; char *buffer; int result;
va_copy(args_copy, args);
length = vsnprintf(NULL, 0, format, args);
buffer = (char*)malloc(length + 1); // +1 for NULL-terminator.
result = vsnprintf(&buffer[0], length + 1, format, args_copy);
if ( result != length )
{
assert(0);
return NULL;
}
return buffer;
}
char *PrintfToNewString(const char *format, ...)
{
va_list args; char *result;
va_start(args, format);
result = VprintfToNewString(format, args);
va_end(args);
return result;
}
struct PP_Var VprintfToVar(const char* format, va_list args)
{
struct PP_Var var; char *string = VprintfToNewString(format, args);
var = g_ppb_var->VarFromUtf8(string, (int32_t)strlen(string));
free(string);
return var;
}
static const char *VarToCStr(struct PP_Var var)
{
uint32_t length; char *new_str; const char *str = g_ppb_var->VarToUtf8(var, &length);
if ( str == NULL )
return NULL;
new_str = (char*)malloc(length + 1);
memcpy(new_str, str, length); // str is NOT NULL-terminated. Copy using memcpy.
new_str[length] = 0;
return new_str;
}
struct PP_Var GetDictVar(struct PP_Var dict, const char* key)
{
struct PP_Var key_var = CStrToVar(key);
struct PP_Var value = g_ppb_var_dictionary->Get(dict, key_var);
g_ppb_var->Release(key_var);
return value;
}
void PNACL_message(const char* format, ...)
9 years ago
{
va_list args;
va_start(args, format);
#ifdef __PNACL
struct PP_Var var;
var = VprintfToVar(format, args);
g_ppb_messaging->PostMessage(g_instance, var);
g_ppb_var->Release(var);
#else
printf(format,args);
#endif
va_end(args);
}
9 years ago
void PostMessage(const char* format, ...)
{
va_list args;
va_start(args, format);
#ifdef __PNACL
struct PP_Var var;
var = VprintfToVar(format, args);
g_ppb_messaging->PostMessage(g_instance, var);
g_ppb_var->Release(var);
#else
printf(format,args);
#endif
va_end(args);
}
9 years ago
/**
* Given a message from JavaScript, parse it for functions and parameters.
*
* The format of the message is:
* {
* "cmd": <function name>,
* "args": [<arg0>, <arg1>, ...]
* }
*
* @param[in] message The message to parse.
* @param[out] out_function The function name.
* @param[out] out_params A PP_Var array.
* @return 0 if successful, otherwise 1.
*/
static int ParseMessage(struct PP_Var message,const char **out_function,struct PP_Var *out_params)
{
9 years ago
char *jsonstr=0;
9 years ago
if ( message.type != PP_VARTYPE_DICTIONARY )
9 years ago
{
PNACL_message("illegal message.%d != %d\n",message.type,PP_VARTYPE_DICTIONARY);
9 years ago
return(1);
9 years ago
}
9 years ago
struct PP_Var cmd_value = GetDictVar(message, "cmd");
*out_function = VarToCStr(cmd_value);
g_ppb_var->Release(cmd_value);
*out_params = GetDictVar(message, "args");
9 years ago
jsonstr = (char *)VarToCStr(*out_params);
PNACL_message("Parse.(%s) cmd.(%s) cmdtype.%d out.%d\n",*out_function,jsonstr!=0?jsonstr:"null",cmd_value.type,out_params->type);
if ( jsonstr != 0 )
9 years ago
{
PNACL_message("Parse.(%s) cmd.(%s)\n",*out_function,jsonstr);
if ( cmd_value.type != PP_VARTYPE_STRING )
return(1);
if ( out_params->type != PP_VARTYPE_ARRAY )
return(1);
9 years ago
9 years ago
return(0);
} else return(1);
9 years ago
}
static HandleFunc GetFunctionByName(const char* function_name)
{
FuncNameMapping* map_iter = g_function_map;
for (; map_iter->name; ++map_iter)
{
if (strcmp(map_iter->name, function_name) == 0)
return map_iter->function;
}
return NULL;
}
/**
* Handle as message from JavaScript on the worker thread.
*
* @param[in] message The message to parse and handle.
*/
static void HandleMessage(struct PP_Var message)
{
const char *function_name,*error; struct PP_Var params,result_var;
if ( ParseMessage(message, &function_name, &params) != 0 )
{
PNACL_message("Error: Unable to parse message");
9 years ago
return;
}
HandleFunc function = GetFunctionByName(function_name);
if ( function == 0 )
{
PNACL_message("Error: Unknown function \"%s\"", function_name); // Function name wasn't found.
9 years ago
return;
}
// Function name was found, call it.
int result = (*function)(params, &result_var, &error);
if ( result != 0 )
{
if ( error != NULL )
{
PNACL_message("Error: \"%s\" failed: %s.", function_name, error);
9 years ago
free((void*)error);
}
else PNACL_message("Error: \"%s\" failed.", function_name);
9 years ago
return;
}
// Function returned an output dictionary. Send it to JavaScript.
g_ppb_messaging->PostMessage(g_instance, result_var);
g_ppb_var->Release(result_var);
}
#define MAX_QUEUE_SIZE 256
// A mutex that guards |g_queue|.
static pthread_mutex_t g_queue_mutex;
// A condition variable that is signalled when |g_queue| is not empty.
static pthread_cond_t g_queue_not_empty_cond;
/** A circular queue of messages from JavaScript to be handled.
*
* If g_queue_start < g_queue_end:
* all elements in the range [g_queue_start, g_queue_end) are valid.
* If g_queue_start > g_queue_end:
* all elements in the ranges [0, g_queue_end) and
* [g_queue_start, MAX_QUEUE_SIZE) are valid.
* If g_queue_start == g_queue_end, and g_queue_size > 0:
* all elements in the g_queue are valid.
* If g_queue_start == g_queue_end, and g_queue_size == 0:
* No elements are valid. */
static struct PP_Var g_queue[MAX_QUEUE_SIZE];
static int g_queue_start = 0; // The index of the head of the queue
static int g_queue_end = 0; // The index of the tail of the queue, non-inclusive.
static int g_queue_size = 0;
// NOTE: this function assumes g_queue_mutex lock is held. @return non-zero if the queue is empty
static int IsQueueEmpty() { return g_queue_size == 0; }
// NOTE: this function assumes g_queue_mutex lock is held. @return non-zero if the queue is full
static int IsQueueFull() { return g_queue_size == MAX_QUEUE_SIZE; }
void InitializeMessageQueue()
{
pthread_mutex_init(&g_queue_mutex, NULL);
pthread_cond_init(&g_queue_not_empty_cond, NULL);
}
int EnqueueMessage(struct PP_Var message)
{
pthread_mutex_lock(&g_queue_mutex);
// We shouldn't block the main thread waiting for the queue to not be full, so just drop the message.
if ( IsQueueFull() != 0)
{
PNACL_message("EnqueueMessage: full Q, drop message\n");
9 years ago
pthread_mutex_unlock(&g_queue_mutex);
return(0);
}
g_queue[g_queue_end] = message;
g_queue_end = (g_queue_end + 1) % MAX_QUEUE_SIZE;
g_queue_size++;
pthread_cond_signal(&g_queue_not_empty_cond);
pthread_mutex_unlock(&g_queue_mutex);
return 1;
}
struct PP_Var DequeueMessage()
{
struct PP_Var message;
pthread_mutex_lock(&g_queue_mutex);
while ( IsQueueEmpty() != 0 )
pthread_cond_wait(&g_queue_not_empty_cond, &g_queue_mutex);
message = g_queue[g_queue_start];
g_queue_start = (g_queue_start + 1) % MAX_QUEUE_SIZE;
g_queue_size--;
pthread_mutex_unlock(&g_queue_mutex);
return(message);
}
/**
* A worker thread that handles messages from JavaScript.
* @param[in] user_data Unused.
* @return unused.
*/
void *HandleMessageThread(void *user_data)
{
while ( 1 )
{
struct PP_Var message = DequeueMessage();
HandleMessage(message);
g_ppb_var->Release(message);
}
}
#include <assert.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#undef mount
#undef umount
static PP_Bool Instance_DidCreate(PP_Instance instance,uint32_t argc,const char* argn[],const char* argv[])
{
int nacl_io_init_ppapi(PP_Instance instance, PPB_GetInterface get_interface);
9 years ago
static pthread_t g_handle_message_thread,chromeapp_thread;
9 years ago
long allocsize;
9 years ago
g_instance = instance;
// By default, nacl_io mounts / to pass through to the original NaCl
9 years ago
// filesystem (which doesn't do much). Let's remount it to a memfs filesystem.
9 years ago
OS_init();
InitializeMessageQueue();
pthread_create(&g_handle_message_thread, NULL, &HandleMessageThread, NULL);
pthread_create(&chromeapp_thread,NULL,&CHROMEAPP_NAME,OS_filestr(&allocsize,CHROMEAPP_CONF));
nacl_io_init_ppapi(instance,g_get_browser_interface);
umount("/");
9 years ago
mount("", "/", "memfs", 0, "");
mkdir("/tmp",0755);
mkdir("/DB",0755);
mount("","/tmp","html5fs",0,"type=TEMPORARY,expected_size=2000000000");
9 years ago
mount("","/DB","html5fs",0,"type=PERSISTENT,expected_size=10000000000");
9 years ago
/*mount("", // source. Use relative URL
"/http", // target
"httpfs", // filesystemtype
0, // mountflags
""); // data*/
PNACL_message("finished DidCreate %s\n",CHROMEAPP_STR);
9 years ago
initflag = 1;
return PP_TRUE;
}
static void Instance_DidDestroy(PP_Instance instance) { }
static void Instance_DidChangeView(PP_Instance instance,PP_Resource view_resource) { }
static void Instance_DidChangeFocus(PP_Instance instance, PP_Bool has_focus) { }
static PP_Bool Instance_HandleDocumentLoad(PP_Instance instance,PP_Resource url_loader)
{
// NaCl modules do not need to handle the document load function.
return PP_FALSE;
}
static void Messaging_HandleMessage(PP_Instance instance,struct PP_Var message)
{
if ( message.type != PP_VARTYPE_DICTIONARY ) // Special case for jspipe input handling
{
PNACL_message("Got unexpected message type: %d\n", message.type);
9 years ago
return;
}
struct PP_Var pipe_var = CStrToVar("pipe");
struct PP_Var pipe_name = g_ppb_var_dictionary->Get(message, pipe_var);
g_ppb_var->Release(pipe_var);
if ( pipe_name.type == PP_VARTYPE_STRING ) // Special case for jspipe input handling
{
char file_name[PATH_MAX];
snprintf(file_name, PATH_MAX, "/dev/%s", VarToCStr(pipe_name));
int fd = open(file_name, O_RDONLY);
g_ppb_var->Release(pipe_name);
if ( fd < 0 )
{
PNACL_message("Warning: opening %s failed.", file_name);
9 years ago
goto done;
}
//if ( ioctl(fd, NACL_IOC_HANDLEMESSAGE, &message) != 0 )
// PNACL_message("Error: ioctl on %s failed: %s", file_name, strerror(errno));
9 years ago
close(fd);
goto done;
}
g_ppb_var->AddRef(message);
if ( !EnqueueMessage(message) )
{
g_ppb_var->Release(message);
PNACL_message("Warning: dropped message because the queue was full.");
9 years ago
}
done:
g_ppb_var->Release(pipe_name);
}
#define GET_INTERFACE(var, type, name) \
var = (type*)(get_browser(name)); \
if (!var) { \
printf("Unable to get interface " name "\n"); \
return PP_ERROR_FAILED; \
}
//PP_EXPORT
int32_t PPP_InitializeModule(PP_Module a_module_id,PPB_GetInterface get_browser)
{
g_get_browser_interface = get_browser;
GET_INTERFACE(g_ppb_messaging, PPB_Messaging, PPB_MESSAGING_INTERFACE);
GET_INTERFACE(g_ppb_var, PPB_Var, PPB_VAR_INTERFACE);
GET_INTERFACE(g_ppb_var_array, PPB_VarArray, PPB_VAR_ARRAY_INTERFACE);
GET_INTERFACE(g_ppb_var_dictionary, PPB_VarDictionary, PPB_VAR_DICTIONARY_INTERFACE);
return PP_OK;
}
//PP_EXPORT
const void *PPP_GetInterface(const char* interface_name)
{
if ( strcmp(interface_name,PPP_INSTANCE_INTERFACE) == 0 )
{
static PPP_Instance instance_interface =
{
&Instance_DidCreate,
&Instance_DidDestroy,
&Instance_DidChangeView,
&Instance_DidChangeFocus,
&Instance_HandleDocumentLoad,
};
return &instance_interface;
}
else if ( strcmp(interface_name, PPP_MESSAGING_INTERFACE) == 0 )
{
static PPP_Messaging messaging_interface = { &Messaging_HandleMessage };
return &messaging_interface;
}
return NULL;
}
//PP_EXPORT
void PPP_ShutdownModule() { }
#define CHECK_PARAM_COUNT(name, expected) \
if (GetNumParams(params) != expected) { \
*out_error = PrintfToNewString(#name " takes " #expected " parameters." \
" Got %d", GetNumParams(params)); \
return 1; \
}
#define PARAM_STRING(index, var) \
char* var; \
uint32_t var##_len; \
if (GetParamString(params, index, &var, &var##_len, out_error)) { \
return 1; \
}
9 years ago
#define CREATE_RESPONSE(name) CreateResponse(output, name, out_error)
9 years ago
#define RESPONSE_STRING(var) AppendResponseString(output, var, out_error)
#define RESPONSE_INT(var) AppendResponseInt(output, var, out_error)
#define MAX_PARAMS 4
static char* g_ParamStrings[MAX_PARAMS];
/**
* Get the number of parameters.
* @param[in] params The parameter array.
* @return uint32_t The number of parameters in the array.
*/
static uint32_t GetNumParams(struct PP_Var params) {
return g_ppb_var_array->GetLength(params);
}
/**
* Create a response PP_Var to send back to JavaScript.
* @param[out] response_var The response PP_Var.
* @param[in] cmd The name of the function that is being executed.
* @param[out] out_error An error message, if this call failed.
*/
static void CreateResponse(struct PP_Var* response_var,
const char* cmd,
const char** out_error) {
PP_Bool result;
struct PP_Var dict_var = g_ppb_var_dictionary->Create();
struct PP_Var cmd_key = CStrToVar("cmd");
struct PP_Var cmd_value = CStrToVar(cmd);
result = g_ppb_var_dictionary->Set(dict_var, cmd_key, cmd_value);
g_ppb_var->Release(cmd_key);
g_ppb_var->Release(cmd_value);
if (!result) {
g_ppb_var->Release(dict_var);
*out_error =
PrintfToNewString("Unable to set \"cmd\" key in result dictionary");
return;
}
struct PP_Var args_key = CStrToVar("args");
struct PP_Var args_value = g_ppb_var_array->Create();
result = g_ppb_var_dictionary->Set(dict_var, args_key, args_value);
g_ppb_var->Release(args_key);
g_ppb_var->Release(args_value);
if (!result) {
g_ppb_var->Release(dict_var);
*out_error =
PrintfToNewString("Unable to set \"args\" key in result dictionary");
return;
}
*response_var = dict_var;
}
/**
* Append a PP_Var to the response dictionary.
* @param[in,out] response_var The response PP_var.
* @param[in] value The value to add to the response args.
* @param[out] out_error An error message, if this call failed.
*/
static void AppendResponseVar(struct PP_Var* response_var,
struct PP_Var value,
const char** out_error) {
struct PP_Var args_value = GetDictVar(*response_var, "args");
uint32_t args_length = g_ppb_var_array->GetLength(args_value);
PP_Bool result = g_ppb_var_array->Set(args_value, args_length, value);
if (!result) {
// Release the dictionary that was there before.
g_ppb_var->Release(*response_var);
// Return an error message instead.
*response_var = PP_MakeUndefined();
*out_error = PrintfToNewString("Unable to append value to result");
return;
}
}
/**
* Append a string to the response dictionary.
* @param[in,out] response_var The response PP_var.
* @param[in] value The value to add to the response args.
* @param[out] out_error An error message, if this call failed.
*/
static void AppendResponseString(struct PP_Var* response_var,
const char* value,
const char** out_error) {
struct PP_Var value_var = CStrToVar(value);
AppendResponseVar(response_var, value_var, out_error);
g_ppb_var->Release(value_var);
}
/**
* Get a parameter at |index| as a string.
* @param[in] params The parameter array.
* @param[in] index The index in |params| to get.
* @param[out] out_string The output string.
* @param[out] out_string_len The length of the output string.
* @param[out] out_error An error message, if this operation failed.
* @return int 0 if successful, otherwise 1.
*/
static int GetParamString(struct PP_Var params,
uint32_t index,
char** out_string,
uint32_t* out_string_len,
const char** out_error) {
if (index >= MAX_PARAMS) {
*out_error = PrintfToNewString("Param index %u >= MAX_PARAMS (%d)",
index, MAX_PARAMS);
return 1;
}
struct PP_Var value = g_ppb_var_array->Get(params, index);
if (value.type != PP_VARTYPE_STRING) {
*out_error =
PrintfToNewString("Expected param at index %d to be a string not.%d", index,value.type);
return 1;
}
uint32_t length;
const char* var_str = g_ppb_var->VarToUtf8(value, &length);
char* string = (char*)malloc(length + 1);
memcpy(string, var_str, length);
string[length] = 0;
/* Put the allocated string in g_ParamStrings. This keeps us from leaking
* each parameter string, without having to do manual cleanup in every
* Handle* function below.
*/
free(g_ParamStrings[index]);
g_ParamStrings[index] = string;
*out_string = string;
*out_string_len = length;
return 0;
}
int CHROMEAPP_HANDLER(struct PP_Var params,struct PP_Var *output,const char **out_error)
{
9 years ago
char *CHROMEAPP_JSON(char *,uint16_t port);
9 years ago
char *retstr;
PNACL_message("inside Handle_%s\n",CHROMEAPP_STR);
9 years ago
CHECK_PARAM_COUNT(CHROMEAPP_STR, 1);
9 years ago
PARAM_STRING(0,jsonstr);
9 years ago
if ( jsonstr == 0 )
retstr = clonestr("{\"error\":\"illegal null jsonstr received\"}");
9 years ago
else if ( (retstr= CHROMEAPP_JSON(jsonstr,7778)) == 0 )
9 years ago
retstr = clonestr("{\"error\":\"null return\"}");
9 years ago
CREATE_RESPONSE(CHROMEAPP_STR);
9 years ago
RESPONSE_STRING(retstr);
return 0;
}
int example_main()
{
PNACL_message("Started %s example main.\n",CHROMEAPP_STR);
9 years ago
while ( 1 )
{
sleep(777);
}
return 0;
}
PSMainFunc_t PSUserMainGet()
{
return(example_main);
}
9 years ago
9 years ago
#else
int main(int argc, const char * argv[])
{
char *jsonstr;
if ( argc < 2 )
jsonstr = 0;
else jsonstr = (char *)argv[1];
initflag = 1;
OS_init();
printf("%s main\n",CHROMEAPP_STR);
CHROMEAPP_NAME(jsonstr);
return 0;
}
#endif