nsresult
Key::EncodeJSValInternal(JSContext* aCx, const jsval aVal,
uint8_t aTypeOffset, uint16_t aRecursionDepth)
{
NS_ENSURE_TRUE(aRecursionDepth < MaxRecursionDepth, NS_ERROR_DOM_INDEXEDDB_DATA_ERR);
MOZ_STATIC_ASSERT(eMaxType * MaxArrayCollapse < 256,
"Unable to encode jsvals.");
if (JSVAL_IS_STRING(aVal)) {
nsDependentJSString str;
if (!str.init(aCx, aVal)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
EncodeString(str, aTypeOffset);
return NS_OK;
}
if (JSVAL_IS_INT(aVal)) {
EncodeNumber((double)JSVAL_TO_INT(aVal), eFloat + aTypeOffset);
return NS_OK;
}
if (JSVAL_IS_DOUBLE(aVal)) {
double d = JSVAL_TO_DOUBLE(aVal);
if (MOZ_DOUBLE_IS_NaN(d)) {
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
EncodeNumber(d, eFloat + aTypeOffset);
return NS_OK;
}
if (!JSVAL_IS_PRIMITIVE(aVal)) {
JS::Rooted<JSObject*> obj(aCx, JSVAL_TO_OBJECT(aVal));
if (JS_IsArrayObject(aCx, obj)) {
aTypeOffset += eMaxType;
if (aTypeOffset == eMaxType * MaxArrayCollapse) {
mBuffer.Append(aTypeOffset);
aTypeOffset = 0;
}
NS_ASSERTION((aTypeOffset % eMaxType) == 0 &&
aTypeOffset < (eMaxType * MaxArrayCollapse),
"Wrong typeoffset");
uint32_t length;
if (!JS_GetArrayLength(aCx, obj, &length)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
for (uint32_t index = 0; index < length; index++) {
JS::Rooted<JS::Value> val(aCx);
if (!JS_GetElement(aCx, obj, index, val.address())) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
nsresult rv = EncodeJSValInternal(aCx, val, aTypeOffset,
aRecursionDepth + 1);
if (NS_FAILED(rv)) {
return rv;
}
aTypeOffset = 0;
}
mBuffer.Append(eTerminator + aTypeOffset);
return NS_OK;
}
if (JS_ObjectIsDate(aCx, obj)) {
if (!js_DateIsValid(obj)) {
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
EncodeNumber(js_DateGetMsecSinceEpoch(obj), eDate + aTypeOffset);
return NS_OK;
}
}
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
static JSBool SMJS_FUNCTION(upnp_service_call_action)
{
u32 i=1;
GPAC_ActionUDTA *act_udta = NULL;
char *action_name = NULL;
SMJS_OBJ
SMJS_ARGS
GPAC_ServiceItem *service = (GPAC_ServiceItem *)JS_GetPrivate(c, obj);
if (!service || !argc || !JSVAL_IS_STRING(argv[0]) ) return JS_FALSE;
action_name = SMJS_CHARS(c, argv[0]);
PLT_ActionDesc* action_desc = service->m_service->FindActionDesc(action_name);
SMJS_FREE(c, action_name);
if (action_desc == NULL) return JS_FALSE;
PLT_ActionReference action;
NPT_CHECK_SEVERE(
service->m_device->m_pUPnP->m_pGenericController->m_CtrlPoint->CreateAction(
service->m_device->m_device,
service->m_service->GetServiceType(),
action_name,
action)
);
if ((argc>=2) && JSVAL_IS_OBJECT(argv[1])) {
JSObject *list = JSVAL_TO_OBJECT(argv[1]);
u32 i, count;
JS_GetArrayLength(c, list, (jsuint*) &count);
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[UPnP] Calling %s(", action_name));
i=0;
while (i+2<=count) {
NPT_Result res;
jsval an_arg;
char *param_val, *_param_val = NULL;
char szParamVal[1024];
JS_GetElement(c, list, (jsint) i, &an_arg);
char *param_name = SMJS_CHARS(c, an_arg);
JS_GetElement(c, list, (jsint) i+1, &an_arg);
param_val = "";
if (JSVAL_IS_STRING(an_arg)) {
param_val = _param_val = SMJS_CHARS(c, an_arg);
} else if (JSVAL_IS_BOOLEAN(an_arg)) {
param_val = (char *) ((JSVAL_TO_BOOLEAN(an_arg) == JS_TRUE) ? "true" : "false");
}
else if (JSVAL_IS_INT(argv[1])) {
sprintf(szParamVal, "%d", JSVAL_TO_INT(an_arg));
param_val = szParamVal;
}
else if (JSVAL_IS_NUMBER(an_arg)) {
jsdouble v;
JS_ValueToNumber(c, an_arg, &v);
sprintf(szParamVal, "%g", v);
param_val = szParamVal;
}
if (!param_name || !param_val) res = NPT_FAILURE;
else {
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, (" %s(%s)", param_name, param_val));
res = action->SetArgumentValue(param_name, param_val);
}
SMJS_FREE(c, param_name);
SMJS_FREE(c, _param_val);
if (res != NPT_SUCCESS) return JS_FALSE;
i+=2;
}
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, (" )\n"));
}
if ((argc==3) && JSVAL_IS_OBJECT(argv[2])) {
act_udta = new GPAC_ActionUDTA();
act_udta->udta = argv[2];
gf_js_add_root(c, &act_udta->udta, GF_JSGC_VAL);
}
service->m_device->m_pUPnP->m_pGenericController->m_CtrlPoint->InvokeAction(action, act_udta);
return JS_TRUE;
}
/*
* call-seq:
* each {| element | block }
* each {| name, value | block }
*
* Calls <em>block</em> with each item in this JavaScript array, or with
* each +name+/+value+ pair (like a Hash) for any other JavaScript
* object.
*/
static VALUE
each(VALUE self)
{
RubyLandProxy* proxy;
Data_Get_Struct(self, RubyLandProxy, proxy);
JSContext * context = johnson_get_current_context(proxy->runtime);
PREPARE_RUBY_JROOTS(context, 5);
jsval proxy_value;
JCHECK(get_jsval_for_proxy(proxy, &proxy_value));
JROOT(proxy_value);
JSObject* value = JSVAL_TO_OBJECT(proxy_value);
JROOT(value);
// arrays behave like you'd expect, indexes in order
if (JS_IsArrayObject(context, value))
{
jsuint length;
JCHECK(JS_GetArrayLength(context, value, &length));
jsuint i = 0;
for (i = 0; i < length; ++i)
{
jsval element;
JCHECK(JS_GetElement(context, value, (signed) i, &element));
CALL_RUBY_WRAPPER(rb_yield, CONVERT_TO_RUBY(proxy->runtime, element));
}
}
else
{
// not an array? behave like each on Hash; yield [key, value]
JSIdArray* ids = JS_Enumerate(context, value);
JCHECK(ids);
JCLEANUP(destroy_id_array, ids);
int i;
for (i = 0; i < ids->length; ++i)
{
jsval js_key, js_value;
JCHECK(JS_IdToValue(context, ids->vector[i], &js_key));
JROOT(js_key);
if (JSVAL_IS_STRING(js_key))
{
// regular properties have string keys
JCHECK(JS_GetProperty(context, value,
JS_GetStringBytes(JSVAL_TO_STRING(js_key)), &js_value));
}
else
{
// it's a numeric property, use array access
JCHECK(JS_GetElement(context, value,
JSVAL_TO_INT(js_key), &js_value));
}
JROOT(js_value);
VALUE key = CONVERT_TO_RUBY(proxy->runtime, js_key);
VALUE value = CONVERT_TO_RUBY(proxy->runtime, js_value);
CALL_RUBY_WRAPPER(rb_yield, rb_ary_new3(2L, key, value));
JUNROOT(js_value);
JUNROOT(js_key);
}
}
JRETURN_RUBY(self);
}
JSBool js_cocos2dx_extension_WebSocket_constructor(JSContext *cx, uint32_t argc, jsval *vp)
{
jsval *argv = JS_ARGV(cx, vp);
if (argc == 1 || argc == 2)
{
std::string url;
do {
JSBool ok = jsval_to_std_string(cx, argv[0], &url);
JSB_PRECONDITION2( ok, cx, JS_FALSE, "Error processing arguments");
} while (0);
JSObject *obj = JS_NewObject(cx, js_cocos2dx_websocket_class, js_cocos2dx_websocket_prototype, NULL);
cocos2d::extension::WebSocket* cobj = new cocos2d::extension::WebSocket();
JSB_WebSocketDelegate* delegate = new JSB_WebSocketDelegate();
delegate->setJSDelegate(obj);
if (argc == 2)
{
std::vector<std::string> protocols;
if (JSVAL_IS_STRING(argv[1]))
{
std::string protocol;
do {
JSBool ok = jsval_to_std_string(cx, argv[1], &protocol);
JSB_PRECONDITION2( ok, cx, JS_FALSE, "Error processing arguments");
} while (0);
protocols.push_back(protocol);
}
else if (argv[1].isObject())
{
JSBool ok = JS_TRUE;
JSObject* arg2 = JSVAL_TO_OBJECT(argv[1]);
JSB_PRECONDITION(JS_IsArrayObject( cx, arg2 ), "Object must be an array");
uint32_t len = 0;
JS_GetArrayLength(cx, arg2, &len);
for( uint32_t i=0; i< len;i++ )
{
jsval valarg;
JS_GetElement(cx, arg2, i, &valarg);
std::string protocol;
do {
ok = jsval_to_std_string(cx, valarg, &protocol);
JSB_PRECONDITION2( ok, cx, JS_FALSE, "Error processing arguments");
} while (0);
protocols.push_back(protocol);
}
}
cobj->init(*delegate, url, &protocols);
}
else
{
cobj->init(*delegate, url);
}
JS_DefineProperty(cx, obj, "URL", argv[0]
, NULL, NULL, JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_READONLY);
//protocol not support yet (always return "")
JS_DefineProperty(cx, obj, "protocol", c_string_to_jsval(cx, "")
, NULL, NULL, JSPROP_ENUMERATE | JSPROP_PERMANENT | JSPROP_READONLY);
// link the native object with the javascript object
js_proxy_t *p = jsb_new_proxy(cobj, obj);
JS_AddNamedObjectRoot(cx, &p->obj, "WebSocket");
JS_SET_RVAL(cx, vp, OBJECT_TO_JSVAL(obj));
return JS_TRUE;
}
JS_ReportError(cx, "wrong number of arguments: %d, was expecting %d", argc, 0);
return JS_FALSE;
}
NS_IMETHODIMP
IDBDatabase::Transaction(const jsval& aStoreNames,
PRUint16 aMode,
JSContext* aCx,
PRUint8 aOptionalArgCount,
nsIIDBTransaction** _retval)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
if (IndexedDatabaseManager::IsShuttingDown()) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (mClosed) {
return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
}
if (mRunningVersionChange) {
return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
}
if (aOptionalArgCount) {
if (aMode != nsIIDBTransaction::READ_WRITE &&
aMode != nsIIDBTransaction::READ_ONLY) {
return NS_ERROR_DOM_INDEXEDDB_NON_TRANSIENT_ERR;
}
}
else {
aMode = nsIIDBTransaction::READ_ONLY;
}
nsresult rv;
nsTArray<nsString> storesToOpen;
if (!JSVAL_IS_PRIMITIVE(aStoreNames)) {
JSObject* obj = JSVAL_TO_OBJECT(aStoreNames);
// See if this is a JS array.
if (JS_IsArrayObject(aCx, obj)) {
jsuint length;
if (!JS_GetArrayLength(aCx, obj, &length)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (!length) {
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
}
storesToOpen.SetCapacity(length);
for (jsuint index = 0; index < length; index++) {
jsval val;
JSString* jsstr;
nsDependentJSString str;
if (!JS_GetElement(aCx, obj, index, &val) ||
!(jsstr = JS_ValueToString(aCx, val)) ||
!str.init(aCx, jsstr)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
storesToOpen.AppendElement(str);
}
NS_ASSERTION(!storesToOpen.IsEmpty(),
"Must have something here or else code below will "
"misbehave!");
}
else {
// Perhaps some kind of wrapped object?
nsIXPConnect* xpc = nsContentUtils::XPConnect();
NS_ASSERTION(xpc, "This should never be null!");
nsCOMPtr<nsIXPConnectWrappedNative> wrapper;
rv = xpc->GetWrappedNativeOfJSObject(aCx, obj, getter_AddRefs(wrapper));
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
if (wrapper) {
nsISupports* wrappedObject = wrapper->Native();
NS_ENSURE_TRUE(wrappedObject, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
// We only accept DOMStringList.
nsCOMPtr<nsIDOMDOMStringList> list = do_QueryInterface(wrappedObject);
if (list) {
PRUint32 length;
rv = list->GetLength(&length);
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
if (!length) {
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
}
storesToOpen.SetCapacity(length);
for (PRUint32 index = 0; index < length; index++) {
nsString* item = storesToOpen.AppendElement();
NS_ASSERTION(item, "This should never fail!");
rv = list->Item(index, *item);
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
}
NS_ASSERTION(!storesToOpen.IsEmpty(),
"Must have something here or else code below will "
"misbehave!");
}
}
}
}
// If our list is empty here then the argument must have been an object that
// we don't support or a primitive. Either way we convert to a string.
if (storesToOpen.IsEmpty()) {
JSString* jsstr;
nsDependentJSString str;
if (!(jsstr = JS_ValueToString(aCx, aStoreNames)) ||
!str.init(aCx, jsstr)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
storesToOpen.AppendElement(str);
}
// Now check to make sure the object store names we collected actually exist.
DatabaseInfo* info = Info();
for (PRUint32 index = 0; index < storesToOpen.Length(); index++) {
if (!info->ContainsStoreName(storesToOpen[index])) {
return NS_ERROR_DOM_INDEXEDDB_NOT_FOUND_ERR;
}
}
nsRefPtr<IDBTransaction> transaction =
IDBTransaction::Create(this, storesToOpen, aMode, false);
NS_ENSURE_TRUE(transaction, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
transaction.forget(_retval);
return NS_OK;
}
// Convert from a jsval to an AtNode
static AtSmartPtr<AtNode> ConvertNode(JSContext* cx, jsval node)
{
AtSmartPtr<AtNode> obj (new AtNode());
// Non-objects get converted into strings
if (!JSVAL_IS_OBJECT(node))
{
JSString* str = JS_ValueToString(cx, node);
if (!str)
return obj; // error
size_t valueLen;
const jschar* valueChars = JS_GetStringCharsAndLength(str, &valueLen);
if (!valueChars)
return obj; // error
wxString valueWx(reinterpret_cast<const char*>(valueChars), wxMBConvUTF16(), valueLen*2);
obj->value = valueWx.c_str();
// Annotate numbers/booleans specially, to allow round-tripping
if (JSVAL_IS_NUMBER(node))
{
obj->children.insert(AtNode::child_pairtype(
"@number", AtSmartPtr<AtNode>(new AtNode())
));
}
else if (JSVAL_IS_BOOLEAN(node))
{
obj->children.insert(AtNode::child_pairtype(
"@boolean", AtSmartPtr<AtNode>(new AtNode())
));
}
return obj;
}
JSObject* it = JS_NewPropertyIterator(cx, JSVAL_TO_OBJECT(node));
if (!it)
return obj; // error
while (true)
{
jsid idp;
jsval val;
if (! JS_NextProperty(cx, it, &idp) || ! JS_IdToValue(cx, idp, &val))
return obj; // error
if (val == JSVAL_VOID)
break; // end of iteration
if (! JSVAL_IS_STRING(val))
continue; // ignore integer properties
JSString* name = JSVAL_TO_STRING(val);
size_t len = JS_GetStringLength(name);
jschar* chars = JS_GetStringChars(name);
wxString nameWx(reinterpret_cast<char*>(chars), wxMBConvUTF16(), len*2);
std::string nameStr(nameWx.ToUTF8().data());
jsval vp;
if (!JS_GetPropertyById(cx, JSVAL_TO_OBJECT(node), idp, &vp))
return obj; // error
// Unwrap arrays into a special format like <$name><item>$i0</item><item>...
// (This assumes arrays aren't nested)
if (JSVAL_IS_OBJECT(vp) && JS_IsArrayObject(cx, JSVAL_TO_OBJECT(vp)))
{
AtSmartPtr<AtNode> child(new AtNode());
child->children.insert(AtNode::child_pairtype(
"@array", AtSmartPtr<AtNode>(new AtNode())
));
jsuint arrayLength;
if (!JS_GetArrayLength(cx, JSVAL_TO_OBJECT(vp), &arrayLength))
return obj; // error
for (jsuint i = 0; i < arrayLength; ++i)
{
jsval val;
if (!JS_GetElement(cx, JSVAL_TO_OBJECT(vp), i, &val))
return obj; // error
child->children.insert(AtNode::child_pairtype(
"item", ConvertNode(cx, val)
));
}
obj->children.insert(AtNode::child_pairtype(
nameStr, child
));
}
else
{
obj->children.insert(AtNode::child_pairtype(
nameStr, ConvertNode(cx, vp)
));
}
}
return obj;
}
static void
format_frame(JSContext* cx, JSStackFrame* fp,
GString *buf, int num)
{
JSPropertyDescArray call_props = { 0, NULL };
JSObject* call_obj = NULL;
char* funname_str = NULL;
const char* filename = NULL;
guint32 lineno = 0;
guint32 named_arg_count = 0;
JSFunction* fun = NULL;
JSScript* script;
guchar* pc;
guint32 i;
gboolean is_string;
jsval val;
(void)JS_EnterLocalRootScope(cx);
if (!JS_IsScriptFrame(cx, fp)) {
g_string_append_printf(buf, "%d [native frame]\n", num);
goto out;
}
/* get the info for this stack frame */
script = JS_GetFrameScript(cx, fp);
pc = JS_GetFramePC(cx, fp);
if (script && pc) {
filename = JS_GetScriptFilename(cx, script);
lineno = (guint32) JS_PCToLineNumber(cx, script, pc);
fun = JS_GetFrameFunction(cx, fp);
if (fun) {
JSString* funname = JS_GetFunctionId(fun);
if (funname)
funname_str = gjs_string_get_ascii(cx, STRING_TO_JSVAL(funname));
}
call_obj = JS_GetFrameCallObject(cx, fp);
if (call_obj) {
if (!JS_GetPropertyDescArray(cx, call_obj, &call_props))
call_props.array = NULL;
}
}
/* print the frame number and function name */
if (funname_str) {
g_string_append_printf(buf, "%d %s(", num, funname_str);
g_free(funname_str);
}
else if (fun)
g_string_append_printf(buf, "%d anonymous(", num);
else
g_string_append_printf(buf, "%d <TOP LEVEL>", num);
for (i = 0; i < call_props.length; i++) {
char *name = NULL;
char *value = NULL;
JSPropertyDesc* desc = &call_props.array[i];
if(desc->flags & JSPD_ARGUMENT) {
name = jsvalue_to_string(cx, desc->id, &is_string);
if(!is_string) {
g_free(name);
name = NULL;
}
value = jsvalue_to_string(cx, desc->value, &is_string);
g_string_append_printf(buf, "%s%s%s%s%s%s",
named_arg_count ? ", " : "",
name ? name :"",
name ? " = " : "",
is_string ? "\"" : "",
value ? value : "?unknown?",
is_string ? "\"" : "");
named_arg_count++;
}
g_free(name);
g_free(value);
}
/* print any unnamed trailing args (found in 'arguments' object) */
if (call_obj != NULL &&
JS_GetProperty(cx, call_obj, "arguments", &val) &&
JSVAL_IS_OBJECT(val)) {
guint32 k;
guint32 arg_count;
JSObject* args_obj = JSVAL_TO_OBJECT(val);
if (JS_GetArrayLength(cx, args_obj, &arg_count) &&
arg_count > named_arg_count) {
for (k = named_arg_count; k < arg_count; k++) {
if (JS_GetElement(cx, args_obj, k, &val)) {
char *value = jsvalue_to_string(cx, val, &is_string);
g_string_append_printf(buf, "%s%s%s%s",
k ? ", " : "",
is_string ? "\"" : "",
value ? value : "?unknown?",
is_string ? "\"" : "");
g_free(value);
}
}
}
}
/* print filename and line number */
g_string_append_printf(buf, "%s@%s:%d\n",
fun ? ")" : "",
filename ? filename : "",
lineno);
out:
if (call_props.array)
JS_PutPropertyDescArray(cx, &call_props);
JS_LeaveLocalRootScope(cx);
}
void js_debug_property(JSContext *cx, jsval vp) {
func(" vp mem address %p", &vp);
int tag = JSVAL_TAG(vp);
func(" type tag is %i: %s",tag,
(tag==0x0)?"object":
(tag==0x1)?"integer":
(tag==0x2)?"double":
(tag==0x4)?"string":
(tag==0x6)?"boolean":
"unknown");
switch(tag) {
case 0x0:
{
JSObject *obj = JSVAL_TO_OBJECT(vp);
jsval val;
if( JS_IsArrayObject(cx, obj) ) {
jsuint len; JS_GetArrayLength(cx, obj, &len);
func(" object is an array of %u elements", len);
for(jsuint c = 0; c<len; c++) {
func(" dumping element %u:",c);
JS_GetElement(cx, obj, c, &val);
if(val == JSVAL_VOID)
func(" content is VOID");
else
js_debug_property(cx, val);
}
} else {
func(" object type is unknown to us (not an array?)");
}
}
break;
case 0x1:
{
JS_PROP_INT(num, vp);
func(" Sint[ %i ] Uint[ %u ]",
num, num);
}
break;
case 0x2:
{
JS_PROP_DOUBLE(num, vp);
func(" double is %.4f",num);
}
break;
case 0x4:
{
char *cap = NULL;
JS_PROP_STRING(cap);
func(" string is \"%s\"",cap);
}
break;
case 0x6:
{
bool b = false;
b = JSVAL_TO_BOOLEAN(vp);
func(" boolean is %i",b);
}
break;
default:
func(" tag %u is unhandled, probably double");
JS_PROP_DOUBLE(num, vp);
func(" Double [ %.4f ] - Sint[ %i ] - Uint[ %u ]",
num, num, num);
}
}
static JSBool
setDash_func(JSContext *context,
unsigned argc,
jsval *vp)
{
jsval *argv = JS_ARGV(context, vp);
JSObject *obj = JS_THIS_OBJECT(context, vp);
guint i;
cairo_t *cr;
JSObject *dashes;
double offset;
JSBool retval = JS_FALSE;
guint len;
GArray *dashes_c = NULL;
if (!gjs_parse_args(context, "setDash", "of", argc, argv,
"dashes", &dashes, "offset", &offset))
return JS_FALSE;
JS_AddObjectRoot(context, &dashes);
if (!JS_IsArrayObject(context, dashes)) {
gjs_throw(context, "dashes must be an array");
goto out;
}
if (!JS_GetArrayLength(context, dashes, &len)) {
gjs_throw(context, "Can't get length of dashes");
goto out;
}
dashes_c = g_array_sized_new (FALSE, FALSE, sizeof(double), len);
for (i = 0; i < len; ++i) {
jsval elem;
double b;
elem = JSVAL_VOID;
if (!JS_GetElement(context, dashes, i, &elem)) {
goto out;
}
if (JSVAL_IS_VOID(elem))
continue;
if (!JS_ValueToNumber(context, elem, &b))
goto out;
if (b <= 0) {
gjs_throw(context, "Dash value must be positive");
goto out;
}
g_array_append_val(dashes_c, b);
}
cr = gjs_cairo_context_get_context(context, obj);
cairo_set_dash(cr, (double*)dashes_c->data, dashes_c->len, offset);
JS_SET_RVAL(context, vp, JSVAL_VOID);
retval = JS_TRUE;
out:
if (dashes_c != NULL)
g_array_free (dashes_c, TRUE);
JS_RemoveObjectRoot(context, &dashes);
return retval;
}
JSBool netlocalgroupaddmembers(JSContext * cx, JSObject * obj, uintN argc, jsval * argv, jsval * rval)
{
JS_BeginRequest(cx);
if(argc < 2)
{
JS_ReportError(cx, "Must pass members to be added.");
JS_EndRequest(cx);
return JS_FALSE;
}
LOCALGROUP_MEMBERS_INFO_0 * members;
DWORD * lookupResult;
DWORD memberCount = 0;
JSString * groupName = JS_ValueToString(cx, argv[0]);
argv[0] = STRING_TO_JSVAL(groupName);
if(JSVAL_IS_OBJECT(argv[1]) && JS_IsArrayObject(cx, JSVAL_TO_OBJECT(argv[1])))
{
JSObject * memberArray;
JS_ValueToObject(cx, argv[1], &memberArray);
argv[1] = OBJECT_TO_JSVAL(memberArray);
JS_GetArrayLength(cx, memberArray, (jsuint*)&memberCount);
members = (LOCALGROUP_MEMBERS_INFO_0*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LOCALGROUP_MEMBERS_INFO_0) * memberCount);
lookupResult = (DWORD*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DWORD) * memberCount);
JS_EnterLocalRootScope(cx);
for(DWORD i = 0; i < memberCount; i++)
{
jsval curMemberVal;
JSString * curMemberString;
JS_GetElement(cx, memberArray, (jsint)i, &curMemberVal);
curMemberString = JS_ValueToString(cx, curMemberVal);
members[i].lgrmi0_sid = convert_jsstring_to_sid(cx, curMemberString, &lookupResult[i]);
}
JS_LeaveLocalRootScope(cx);
}
else
{
JSString * memberString = JS_ValueToString(cx, argv[1]);
argv[1] = STRING_TO_JSVAL(memberString);
members = (LOCALGROUP_MEMBERS_INFO_0*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(LOCALGROUP_MEMBERS_INFO_0));
lookupResult = (DWORD*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DWORD));
members->lgrmi0_sid = convert_jsstring_to_sid(cx, memberString, lookupResult);
memberCount = 1;
}
for(DWORD i = 0; i < memberCount; i++)
{
if(lookupResult[i] == 0)
{
JS_YieldRequest(cx);
lookupResult[i] = NetLocalGroupAddMembers(NULL, (LPWSTR)JS_GetStringChars(groupName), 0, (LPBYTE)&members[i], 1);
}
}
JSObject * retArray = JS_NewArrayObject(cx, 0, NULL);
*rval = OBJECT_TO_JSVAL(retArray);
for(DWORD i = 0; i < memberCount; i++)
{
jsval curResultVal;
JS_NewNumberValue(cx, lookupResult[i], &curResultVal);
JS_DefineElement(cx, retArray, i, curResultVal, NULL, NULL, 0);
HeapFree(GetProcessHeap(), 0, members[i].lgrmi0_sid);
}
HeapFree(GetProcessHeap(), 0, members);
HeapFree(GetProcessHeap(), 0, lookupResult);
JS_EndRequest(cx);
return JS_TRUE;
}
NS_IMETHODIMP
SmsManager::Send(const jsval& aNumber, const nsAString& aMessage, jsval* aReturn)
{
nsresult rv;
nsIScriptContext* sc = GetContextForEventHandlers(&rv);
NS_ENSURE_STATE(sc);
JSContext* cx = sc->GetNativeContext();
NS_ASSERTION(cx, "Failed to get a context!");
if (!aNumber.isString() &&
!(aNumber.isObject() && JS_IsArrayObject(cx, &aNumber.toObject()))) {
return NS_ERROR_INVALID_ARG;
}
JSObject* global = sc->GetNativeGlobal();
NS_ASSERTION(global, "Failed to get global object!");
JSAutoRequest ar(cx);
JSAutoCompartment ac(cx, global);
if (aNumber.isString()) {
return Send(cx, global, aNumber.toString(), aMessage, aReturn);
}
// Must be an object then.
if (!aNumber.isObject()) {
return NS_ERROR_FAILURE;
}
JSObject& numbers = aNumber.toObject();
uint32_t size;
if (!JS_GetArrayLength(cx, &numbers, &size)) {
return NS_ERROR_FAILURE;
}
JS::AutoValueVector requests(cx);
if (!requests.resize(size)) {
return NS_ERROR_FAILURE;
}
JSString *str;
for (uint32_t i = 0; i < size; ++i) {
jsval number;
if (!JS_GetElement(cx, &numbers, i, &number)) {
return NS_ERROR_INVALID_ARG;
}
str = JS_ValueToString(cx, number);
if (!str) {
return NS_ERROR_FAILURE;
}
nsresult rv = Send(cx, global, str, aMessage, &requests[i]);
NS_ENSURE_SUCCESS(rv, rv);
}
JSObject* obj = JS_NewArrayObject(cx, requests.length(), requests.begin());
if (!obj) {
return NS_ERROR_FAILURE;
}
aReturn->setObject(*obj);
return NS_OK;
}
JSBool systemExecute(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{// begin systemExecute
// default return value
*rval = INT_TO_JSVAL(-1);
if(argc != 3)
return JS_FALSE;
if(JSVAL_IS_STRING(argv[0]) == false || JSVAL_IS_OBJECT(argv[1]) == false || JSVAL_IS_BOOLEAN(argv[2]) == false)
return JS_FALSE;
char *pExecutable = JS_GetStringBytes(JSVAL_TO_STRING(argv[0]));
JSObject *pArgs = JSVAL_TO_OBJECT(argv[1]);
bool bWait = JSVAL_TO_BOOLEAN(argv[2]);
int status = 0;
jsuint nArgsLength = 0;
jsval jsValue;
struct stat sbFileInfo;
if(JS_IsArrayObject(cx, pArgs) == false)
return JS_FALSE;
JS_GetArrayLength(cx,pArgs,&nArgsLength);
char **args = new char *[JSVAL_TO_INT(nArgsLength)+2];
args[0] = pExecutable;
args[JSVAL_TO_INT(nArgsLength)+1] = NULL;
for(jsuint i = 1;i <= nArgsLength;i++)
{
if(JS_GetElement(cx, pArgs, i, &jsValue) == JS_FALSE)
{// begin failure to get item
JS_ReportError(cx, "exec() JS_GetElement failed to get an array item.");
return JS_FALSE;
}// end failure to get item
args[JSVAL_TO_INT(i)] = JS_GetStringBytes(JSVAL_TO_STRING(jsValue));
}
if(getuid() == 0)
{// begin running as root
JS_ReportError(cx, "exec() disallowed while running as root.");
return JS_FALSE;
}// end running as root
if(stat(pExecutable , &sbFileInfo) != 0)
{// begin can't stat file
JS_ReportError(cx, "exec() Can't stat \"%s\" errno(%i).", pExecutable, errno);
return JS_FALSE;
}// end can't stat file
if((sbFileInfo.st_mode & S_ISUID) == S_ISUID || (sbFileInfo.st_mode & S_ISGID) == S_ISGID)
{// begin setuid/setgid files disallowed
JS_ReportError(cx, "exec() disallowed execution of \"%s\" since it is a setuid/setgid file.", pExecutable);
return JS_FALSE;
}// end setuid/setgid files disallowed
enterLock();
// clear file descriptor table of forked process and fork
#if defined( __linux__) || defined(__macosx__) || defined(__APPLE__)
pid_t pidRtn = fork();
#elif defined(__FreeBSD__) || defined(__OpenBSD__)
pid_t pidRtn = rfork(RFPROC|RFCFDG);
#endif
if(pidRtn == 0)
{// begin child process
#if defined( __linux__) || defined(__macosx__) || defined(__APPLE__)
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
#endif
char **pEnv = environ;
//char *pEnv[] = {NULL};
execve(pExecutable,args,pEnv);
printf("Error: execve failure errno(%d)\n",errno);
_exit(errno);
}// end child process
else if(bWait && pidRtn != -1)
{// begin wait for execution to finish
printf("Waiting on pid %d...",pidRtn);
do
{// begin wait for child
waitpid(pidRtn,&status,WUNTRACED);
}// end wait for child
while(WIFEXITED(status) == false && WIFSIGNALED(status) == false);
printf("Done...\n");
}// end wait for execution to finish
else if(pidRtn == -1)
{// begin rfork failure
printf("Error: execve failure errno(%d)\n",errno);
}// end rfork failure
leaveLock();
// cleanup
delete []args;
if(pidRtn != -1)
*rval = INT_TO_JSVAL(WEXITSTATUS(status)); // success return child's exit status
else
*rval = INT_TO_JSVAL(-1); // failure
return JS_TRUE;
}// end systemExecute
nsresult WebCL_getVariantsFromJSArray (JSContext *cx, nsIVariant* aVariant,
nsTArray<nsIVariant*> & aResultOut)
{
D_METHOD_START;
nsresult rv;
NS_ENSURE_ARG_POINTER (aVariant);
PRUint16 variantType = 0;
rv = aVariant->GetDataType (&variantType);
switch (variantType)
{
// Accept VTYPE_ARRAY, VTYPE_EMPTY_ARRAY
case nsIDataType::VTYPE_ARRAY:
case nsIDataType::VTYPE_EMPTY_ARRAY:
// Array detected
break;
case nsIDataType::VTYPE_INTERFACE:
case nsIDataType::VTYPE_INTERFACE_IS:
// Might be a proxy object holding the array
break;
default:
D_LOG (LOG_LEVEL_ERROR, "Argument aVariant is not an array (type: %u).", variantType);
return NS_ERROR_INVALID_ARG;
}
if (!cx)
{
nsCOMPtr<nsIThreadJSContextStack> stack = do_GetService ("@mozilla.org/js/xpc/ContextStack;1", &rv);
NS_ENSURE_SUCCESS (rv, rv);
cx = stack->GetSafeJSContext ();
NS_ENSURE_TRUE (cx, NS_ERROR_FAILURE);
}
nsCOMPtr<nsIXPConnect> xpc = do_GetService (nsIXPConnect::GetCID (), &rv);
NS_ENSURE_SUCCESS (rv, rv);
js::Value jsVal;
rv = xpc->VariantToJS(cx, JS_GetGlobalObject(cx), aVariant, &jsVal);
NS_ENSURE_SUCCESS (rv, rv);
if ( !jsVal.isObject ())
{
D_LOG (LOG_LEVEL_ERROR, "Argument aVariant is not a JSObject.");
return NS_ERROR_INVALID_ARG;
}
JSObject* jsArrObj = jsVal.toObjectOrNull ();
if (jsArrObj && js::IsObjectProxy (jsArrObj))
{
jsArrObj = js::UnwrapObject (jsArrObj);
}
if (!jsArrObj || !JS_IsArrayObject (cx, jsArrObj))
{
D_LOG (LOG_LEVEL_ERROR, "Argument aVariant is not a JS Array Object.");
return NS_ERROR_INVALID_ARG;
}
nsTArray <nsIVariant*> res;
JS_BeginRequest (cx);
JSBool ok = JS_TRUE;
uint32_t jsArrLen = 0;
ok = JS_GetArrayLength(cx, jsArrObj, &jsArrLen);
if (!ok)
{
JS_EndRequest(cx);
D_LOG (LOG_LEVEL_ERROR, "Failed to get array length.");
return NS_ERROR_FAILURE;
}
res.SetCapacity (jsArrLen);
for (uint32_t i = 0; i < jsArrLen; ++i)
{
jsval elem;
JSBool ok = JS_GetElement (cx, jsArrObj, i, &elem);
if (ok)
{
nsCOMPtr<nsIVariant> variant;
rv = xpc->JSValToVariant (cx, &elem, getter_AddRefs(variant));
if (NS_SUCCEEDED (rv))
{
res.AppendElement (variant);
NS_ADDREF (variant);
}
else
{
D_LOG (LOG_LEVEL_WARNING,
"Failed to convert element at position %d to nsIVariant. (rv %d)",
i+1, rv);
}
}
else
{
D_LOG (LOG_LEVEL_WARNING,
"Failed to get element at position %d to nsIVariant. (rv %d)",
i+1, rv);
}
}
JS_EndRequest(cx);
aResultOut.SwapElements (res);
return NS_OK;
}
static JSBool SMJS_FUNCTION(upnp_action_send_reply)
{
u32 i=1;
SMJS_OBJ
SMJS_ARGS
GPAC_GenericDevice *device = (GPAC_GenericDevice *)JS_GetPrivate(c, obj);
if (!device) return JS_FALSE;
if (argc && JSVAL_IS_OBJECT(argv[0]) ) {
JSObject *list = JSVAL_TO_OBJECT(argv[0]);
u32 i, count;
JS_GetArrayLength(c, list, (jsuint*) &count);
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[UPnP] Calling response %s(", (char *) device->act_ref->GetActionDesc().GetName()));
i=0;
while (i+2<=count) {
jsval an_arg;
NPT_Result res;
char *param_val, *_param_val = NULL;
char szParamVal[1024];
JS_GetElement(c, list, (jsint) i, &an_arg);
char *param_name = SMJS_CHARS(c, an_arg);
JS_GetElement(c, list, (jsint) i+1, &an_arg);
param_val = "";
if (JSVAL_IS_STRING(an_arg)) {
param_val = _param_val = SMJS_CHARS(c, an_arg);
} else if (JSVAL_IS_BOOLEAN(an_arg)) {
param_val = (char *) ((JSVAL_TO_BOOLEAN(an_arg) == JS_TRUE) ? "true" : "false");
}
else if (JSVAL_IS_INT(argv[1])) {
sprintf(szParamVal, "%d", JSVAL_TO_INT(an_arg));
param_val = szParamVal;
}
else if (JSVAL_IS_NUMBER(an_arg)) {
jsdouble v;
JS_ValueToNumber(c, an_arg, &v);
sprintf(szParamVal, "%g", v);
param_val = szParamVal;
}
if (!param_name || !param_val) res = NPT_FAILURE;
else {
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, (" %s(%s)", param_name, param_val));
res = device->act_ref->SetArgumentValue(param_name, param_val);
}
SMJS_FREE(c, param_name);
SMJS_FREE(c, _param_val);
if (res != NPT_SUCCESS) return JS_FALSE;
i+=2;
}
GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, (" )\n"));
}
//notify we are ready
if (device->m_pSema) {
gf_sema_notify(device->m_pSema, 1);
}
return JS_TRUE;
}
static JSBool
do_import(JSContext *context,
JSObject *obj,
Importer *priv,
const char *name)
{
char *filename;
char *native_filename;
char *full_path;
char *dirname = NULL;
jsval search_path_val;
JSObject *search_path;
JSObject *module_obj = NULL;
guint32 search_path_len;
guint32 i;
JSBool result;
GPtrArray *directories;
if (strcmp(name, MODULE_INIT_PROPERTY) == 0) {
return JS_FALSE;
}
if (!gjs_object_require_property(context, obj, "importer", "searchPath", &search_path_val)) {
return JS_FALSE;
}
if (!JSVAL_IS_OBJECT(search_path_val)) {
gjs_throw(context, "searchPath property on importer is not an object");
return JS_FALSE;
}
search_path = JSVAL_TO_OBJECT(search_path_val);
if (!JS_IsArrayObject(context, search_path)) {
gjs_throw(context, "searchPath property on importer is not an array");
return JS_FALSE;
}
if (!JS_GetArrayLength(context, search_path, &search_path_len)) {
gjs_throw(context, "searchPath array has no length");
return JS_FALSE;
}
result = JS_FALSE;
filename = g_strdup_printf("%s.js", name);
native_filename = g_strdup_printf("%s."G_MODULE_SUFFIX, name);
full_path = NULL;
directories = NULL;
/* First try importing an internal module like byteArray */
if (gjs_is_registered_native_module(context, obj, name) &&
import_native_file(context, obj, name, NULL)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"successfully imported module '%s'", name);
result = JS_TRUE;
goto out;
}
for (i = 0; i < search_path_len; ++i) {
jsval elem;
elem = JSVAL_VOID;
if (!JS_GetElement(context, search_path, i, &elem)) {
/* this means there was an exception, while elem == JSVAL_VOID
* means no element found
*/
goto out;
}
if (JSVAL_IS_VOID(elem))
continue;
if (!JSVAL_IS_STRING(elem)) {
gjs_throw(context, "importer searchPath contains non-string");
goto out;
}
g_free(dirname);
dirname = NULL;
if (!gjs_string_to_utf8(context, elem, &dirname))
goto out; /* Error message already set */
/* Ignore empty path elements */
if (dirname[0] == '\0')
continue;
/* Try importing __init__.js and loading the symbol from it */
if (full_path)
g_free(full_path);
full_path = g_build_filename(dirname, MODULE_INIT_FILENAME,
NULL);
module_obj = load_module_init(context, obj, full_path);
if (module_obj != NULL) {
jsval obj_val;
if (gjs_object_get_property(context,
module_obj,
name,
&obj_val)) {
if (!JSVAL_IS_VOID(obj_val) &&
JS_DefineProperty(context, obj,
name, obj_val,
NULL, NULL,
GJS_MODULE_PROP_FLAGS & ~JSPROP_PERMANENT)) {
result = JS_TRUE;
goto out;
}
}
}
/* Second try importing a directory (a sub-importer) */
if (full_path)
g_free(full_path);
full_path = g_build_filename(dirname, name,
NULL);
if (g_file_test(full_path, G_FILE_TEST_IS_DIR)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"Adding directory '%s' to child importer '%s'",
full_path, name);
if (directories == NULL) {
directories = g_ptr_array_new();
}
g_ptr_array_add(directories, full_path);
/* don't free it twice - pass ownership to ptr array */
full_path = NULL;
}
/* If we just added to directories, we know we don't need to
* check for a file. If we added to directories on an earlier
* iteration, we want to ignore any files later in the
* path. So, always skip the rest of the loop block if we have
* directories.
*/
if (directories != NULL) {
continue;
}
/* Third, if it's not a directory, try importing a file */
g_free(full_path);
full_path = g_build_filename(dirname, filename,
NULL);
if (g_file_test(full_path, G_FILE_TEST_EXISTS)) {
if (import_file(context, obj, name, full_path)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"successfully imported module '%s'", name);
result = JS_TRUE;
}
/* Don't keep searching path if we fail to load the file for
* reasons other than it doesn't exist... i.e. broken files
* block searching for nonbroken ones
*/
goto out;
}
/* Finally see if it's a native module */
g_free(full_path);
full_path = g_build_filename(dirname, native_filename,
NULL);
if (g_file_test(full_path, G_FILE_TEST_EXISTS)) {
if (import_native_file(context, obj, name, full_path)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"successfully imported module '%s'", name);
result = JS_TRUE;
}
/* Don't keep searching path if we fail to load the file for
* reasons other than it doesn't exist... i.e. broken files
* block searching for nonbroken ones
*/
goto out;
}
gjs_debug(GJS_DEBUG_IMPORTER,
"JS import '%s' not found in %s",
name, dirname);
}
if (directories != NULL) {
/* NULL-terminate the char** */
g_ptr_array_add(directories, NULL);
if (import_directory(context, obj, name,
(const char**) directories->pdata)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"successfully imported directory '%s'", name);
result = JS_TRUE;
}
}
out:
if (directories != NULL) {
char **str_array;
/* NULL-terminate the char**
* (maybe for a second time, but doesn't matter)
*/
g_ptr_array_add(directories, NULL);
str_array = (char**) directories->pdata;
g_ptr_array_free(directories, FALSE);
g_strfreev(str_array);
}
g_free(full_path);
g_free(filename);
g_free(native_filename);
g_free(dirname);
if (!result &&
!JS_IsExceptionPending(context)) {
/* If no exception occurred, the problem is just that we got to the
* end of the path. Be sure an exception is set.
*/
gjs_throw(context, "No JS module '%s' found in search path", name);
}
return result;
}
nsresult
Key::EncodeJSVal(JSContext* aCx, const jsval aVal, PRUint8 aTypeOffset)
{
PR_STATIC_ASSERT(eMaxType * MaxArrayCollapse < 256);
if (JSVAL_IS_STRING(aVal)) {
nsDependentJSString str;
if (!str.init(aCx, aVal)) {
return NS_ERROR_OUT_OF_MEMORY;
}
EncodeString(str, aTypeOffset);
return NS_OK;
}
if (JSVAL_IS_INT(aVal)) {
EncodeNumber((double)JSVAL_TO_INT(aVal), eFloat + aTypeOffset);
return NS_OK;
}
if (JSVAL_IS_DOUBLE(aVal)) {
double d = JSVAL_TO_DOUBLE(aVal);
if (DOUBLE_IS_NaN(d)) {
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
EncodeNumber(d, eFloat + aTypeOffset);
return NS_OK;
}
if (!JSVAL_IS_PRIMITIVE(aVal)) {
JSObject* obj = JSVAL_TO_OBJECT(aVal);
if (JS_IsArrayObject(aCx, obj)) {
aTypeOffset += eMaxType;
if (aTypeOffset == eMaxType * MaxArrayCollapse) {
mBuffer.Append(aTypeOffset);
aTypeOffset = 0;
}
NS_ASSERTION((aTypeOffset % eMaxType) == 0 &&
aTypeOffset < (eMaxType * MaxArrayCollapse),
"Wrong typeoffset");
jsuint length;
if (!JS_GetArrayLength(aCx, obj, &length)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
for (jsuint index = 0; index < length; index++) {
jsval val;
if (!JS_GetElement(aCx, obj, index, &val)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
nsresult rv = EncodeJSVal(aCx, val, aTypeOffset);
NS_ENSURE_SUCCESS(rv, rv);
aTypeOffset = 0;
}
mBuffer.Append(eTerminator + aTypeOffset);
return NS_OK;
}
if (JS_ObjectIsDate(aCx, obj)) {
EncodeNumber(js_DateGetMsecSinceEpoch(aCx, obj), eDate + aTypeOffset);
return NS_OK;
}
}
return NS_ERROR_DOM_INDEXEDDB_DATA_ERR;
}
/*
* Like JSEnumerateOp, but enum provides contextual information as follows:
*
* JSENUMERATE_INIT: allocate private enum struct in state_p, return number
* of elements in *id_p
* JSENUMERATE_NEXT: return next property id in *id_p, and if no new property
* free state_p and set to JSVAL_NULL
* JSENUMERATE_DESTROY : destroy state_p
*
* Note that in a for ... in loop, this will be called first on the object,
* then on its prototype.
*
*/
static JSBool
importer_new_enumerate(JSContext *context,
JSObject **object,
JSIterateOp enum_op,
jsval *state_p,
jsid *id_p)
{
ImporterIterator *iter;
switch (enum_op) {
case JSENUMERATE_INIT_ALL:
case JSENUMERATE_INIT: {
Importer *priv;
JSObject *search_path;
jsval search_path_val;
guint32 search_path_len;
guint32 i;
if (state_p)
*state_p = JSVAL_NULL;
if (id_p)
*id_p = INT_TO_JSID(0);
priv = priv_from_js(context, *object);
if (!priv)
/* we are enumerating the prototype properties */
return JS_TRUE;
if (!gjs_object_require_property(context, *object, "importer", "searchPath", &search_path_val))
return JS_FALSE;
if (!JSVAL_IS_OBJECT(search_path_val)) {
gjs_throw(context, "searchPath property on importer is not an object");
return JS_FALSE;
}
search_path = JSVAL_TO_OBJECT(search_path_val);
if (!JS_IsArrayObject(context, search_path)) {
gjs_throw(context, "searchPath property on importer is not an array");
return JS_FALSE;
}
if (!JS_GetArrayLength(context, search_path, &search_path_len)) {
gjs_throw(context, "searchPath array has no length");
return JS_FALSE;
}
iter = importer_iterator_new();
for (i = 0; i < search_path_len; ++i) {
char *dirname = NULL;
char *init_path;
const char *filename;
jsval elem;
GDir *dir = NULL;
elem = JSVAL_VOID;
if (!JS_GetElement(context, search_path, i, &elem)) {
/* this means there was an exception, while elem == JSVAL_VOID
* means no element found
*/
importer_iterator_free(iter);
return JS_FALSE;
}
if (JSVAL_IS_VOID(elem))
continue;
if (!JSVAL_IS_STRING(elem)) {
gjs_throw(context, "importer searchPath contains non-string");
importer_iterator_free(iter);
return JS_FALSE;
}
if (!gjs_string_to_utf8(context, elem, &dirname)) {
importer_iterator_free(iter);
return JS_FALSE; /* Error message already set */
}
init_path = g_build_filename(dirname, MODULE_INIT_FILENAME,
NULL);
load_module_elements(context, *object, iter, init_path);
g_free(init_path);
dir = g_dir_open(dirname, 0, NULL);
if (!dir) {
g_free(dirname);
continue;
}
while ((filename = g_dir_read_name(dir))) {
char *full_path;
/* skip hidden files and directories (.svn, .git, ...) */
if (filename[0] == '.')
continue;
/* skip module init file */
if (strcmp(filename, MODULE_INIT_FILENAME) == 0)
continue;
full_path = g_build_filename(dirname, filename, NULL);
if (g_file_test(full_path, G_FILE_TEST_IS_DIR)) {
g_ptr_array_add(iter->elements, g_strdup(filename));
} else {
if (g_str_has_suffix(filename, "."G_MODULE_SUFFIX) ||
g_str_has_suffix(filename, ".js")) {
g_ptr_array_add(iter->elements,
g_strndup(filename, strlen(filename) - 3));
}
}
g_free(full_path);
}
g_dir_close(dir);
g_free(dirname);
}
if (state_p)
*state_p = PRIVATE_TO_JSVAL(iter);
if (id_p)
*id_p = INT_TO_JSID(iter->elements->len);
break;
}
case JSENUMERATE_NEXT: {
jsval element_val;
if (!state_p) {
gjs_throw(context, "Enumerate with no iterator set?");
return JS_FALSE;
}
if (JSVAL_IS_NULL(*state_p)) /* Iterating prototype */
return JS_TRUE;
iter = JSVAL_TO_PRIVATE(*state_p);
if (iter->index < iter->elements->len) {
if (!gjs_string_from_utf8(context,
g_ptr_array_index(iter->elements,
iter->index++),
-1,
&element_val))
return JS_FALSE;
if (!JS_ValueToId(context, element_val, id_p))
return JS_FALSE;
break;
}
/* else fall through to destroying the iterator */
}
case JSENUMERATE_DESTROY: {
if (state_p && !JSVAL_IS_NULL(*state_p)) {
iter = JSVAL_TO_PRIVATE(*state_p);
importer_iterator_free(iter);
*state_p = JSVAL_NULL;
}
}
}
return JS_TRUE;
}
void js_debug_argument(JSContext *cx, jsval vp) {
func(" arg mem address %p", &vp);
int tag = JSVAL_TAG(vp);
func(" type tag is %i: %s",tag,
(tag==0x0)?"object":
(tag==0x1)?"integer":
(tag==0x2)?"double":
(tag==0x4)?"string":
(tag==0x6)?"boolean":
"unknown");
switch(tag) {
case 0x0:
{
JSObject *obj = JSVAL_TO_OBJECT(vp);
jsval val;
if( JS_IsArrayObject(cx, obj) ) {
jsuint len; JS_GetArrayLength(cx, obj, &len);
func(" object is an array of %u elements", len);
for(jsuint c = 0; c<len; c++) {
func(" dumping element %u:",c);
JS_GetElement(cx, obj, c, &val);
if(val == JSVAL_VOID)
func(" content is VOID");
else
js_debug_argument(cx, val);
}
} else {
func(" object type is unknown to us (not an array?)");
}
}
break;
case 0x1:
{
jsint num = js_get_int(vp);
func(" Sint[ %i ] Uint[ %u ] Double [ %.2f ]", num, num, num);
}
break;
case 0x2:
{
jsdouble num = js_get_double(vp);
func(" Double [ %.2f ]", num);
}
break;
case 0x4:
{
char *cap;
if(JSVAL_IS_STRING(vp)) {
cap = JS_GetStringBytes( JS_ValueToString(cx, vp) );
func(" string is \"%s\"",cap);
} else {
JS_ReportError(cx,"%s: argument value is not a string",__FUNCTION__);
::error("%s: argument value is not a string",__FUNCTION__);
}
}
break;
case 0x6:
{
bool b = false;
b = JSVAL_TO_BOOLEAN(vp);
func(" boolean is %i",b);
}
break;
default:
func(" arg %u is unhandled, probably double");
jsint num = js_get_double(vp);
func(" Double [ %.4f ] - Sint[ %i ] - Uint[ %u ]",
num, num, num);
}
}
NS_IMETHODIMP
IDBDatabase::CreateObjectStore(const nsAString& aName,
const jsval& aOptions,
JSContext* aCx,
nsIIDBObjectStore** _retval)
{
NS_ASSERTION(NS_IsMainThread(), "Wrong thread!");
IDBTransaction* transaction = AsyncConnectionHelper::GetCurrentTransaction();
if (!transaction ||
transaction->Mode() != nsIIDBTransaction::VERSION_CHANGE) {
return NS_ERROR_DOM_INDEXEDDB_NOT_ALLOWED_ERR;
}
DatabaseInfo* databaseInfo = transaction->DBInfo();
nsString keyPath;
keyPath.SetIsVoid(true);
nsTArray<nsString> keyPathArray;
bool autoIncrement = false;
if (!JSVAL_IS_VOID(aOptions) && !JSVAL_IS_NULL(aOptions)) {
if (JSVAL_IS_PRIMITIVE(aOptions)) {
// XXX This isn't the right error
return NS_ERROR_DOM_TYPE_ERR;
}
NS_ASSERTION(JSVAL_IS_OBJECT(aOptions), "Huh?!");
JSObject* options = JSVAL_TO_OBJECT(aOptions);
// Get keyPath
jsval val;
if (!JS_GetPropertyById(aCx, options, nsDOMClassInfo::sKeyPath_id, &val)) {
NS_WARNING("JS_GetPropertyById failed!");
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (!JSVAL_IS_VOID(val) && !JSVAL_IS_NULL(val)) {
if (!JSVAL_IS_PRIMITIVE(val) &&
JS_IsArrayObject(aCx, JSVAL_TO_OBJECT(val))) {
JSObject* obj = JSVAL_TO_OBJECT(val);
jsuint length;
if (!JS_GetArrayLength(aCx, obj, &length)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (!length) {
return NS_ERROR_DOM_SYNTAX_ERR;
}
keyPathArray.SetCapacity(length);
for (jsuint index = 0; index < length; index++) {
jsval val;
JSString* jsstr;
nsDependentJSString str;
if (!JS_GetElement(aCx, obj, index, &val) ||
!(jsstr = JS_ValueToString(aCx, val)) ||
!str.init(aCx, jsstr)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (!IDBObjectStore::IsValidKeyPath(aCx, str)) {
return NS_ERROR_DOM_SYNTAX_ERR;
}
keyPathArray.AppendElement(str);
}
NS_ASSERTION(!keyPathArray.IsEmpty(), "This shouldn't have happened!");
}
else {
JSString* jsstr;
nsDependentJSString str;
if (!(jsstr = JS_ValueToString(aCx, val)) ||
!str.init(aCx, jsstr)) {
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
if (!IDBObjectStore::IsValidKeyPath(aCx, str)) {
return NS_ERROR_DOM_SYNTAX_ERR;
}
keyPath = str;
}
}
if (!JS_GetPropertyById(aCx, options, nsDOMClassInfo::sAutoIncrement_id,
&val)) {
NS_WARNING("JS_GetPropertyById failed!");
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
JSBool boolVal;
if (!JS_ValueToBoolean(aCx, val, &boolVal)) {
NS_WARNING("JS_ValueToBoolean failed!");
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
autoIncrement = !!boolVal;
}
if (databaseInfo->ContainsStoreName(aName)) {
return NS_ERROR_DOM_INDEXEDDB_CONSTRAINT_ERR;
}
if (autoIncrement &&
((!keyPath.IsVoid() && keyPath.IsEmpty()) || !keyPathArray.IsEmpty())) {
return NS_ERROR_DOM_INVALID_ACCESS_ERR;
}
nsRefPtr<ObjectStoreInfo> newInfo(new ObjectStoreInfo());
newInfo->name = aName;
newInfo->id = databaseInfo->nextObjectStoreId++;
newInfo->keyPath = keyPath;
newInfo->keyPathArray = keyPathArray;
newInfo->nextAutoIncrementId = autoIncrement ? 1 : 0;
newInfo->comittedAutoIncrementId = newInfo->nextAutoIncrementId;
if (!databaseInfo->PutObjectStore(newInfo)) {
NS_WARNING("Put failed!");
return NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR;
}
// Don't leave this in the hash if we fail below!
AutoRemoveObjectStore autoRemove(databaseInfo, aName);
nsRefPtr<IDBObjectStore> objectStore =
transaction->GetOrCreateObjectStore(aName, newInfo);
NS_ENSURE_TRUE(objectStore, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
nsRefPtr<CreateObjectStoreHelper> helper =
new CreateObjectStoreHelper(transaction, objectStore);
nsresult rv = helper->DispatchToTransactionPool();
NS_ENSURE_SUCCESS(rv, NS_ERROR_DOM_INDEXEDDB_UNKNOWN_ERR);
autoRemove.forget();
objectStore.forget(_retval);
return NS_OK;
}
