static JSBool
CommonConstructor(JSContext *cx, int name, JSObject *obj, uintN argc,
jsval *argv, jsval *rval, PRBool enforceSecurity)
{
XPCCallContext ccx(JS_CALLER, cx, JS_GetGlobalObject(cx));
// Check if IDispatch is enabled, fail if not
if(!nsXPConnect::IsIDispatchEnabled())
{
XPCThrower::Throw(NS_ERROR_XPC_IDISPATCH_NOT_ENABLED, ccx);
return JS_FALSE;
}
XPCJSRuntime *rt = ccx.GetRuntime();
if(!rt)
{
XPCThrower::Throw(NS_ERROR_UNEXPECTED, ccx);
return JS_FALSE;
}
nsIXPCSecurityManager* sm = ccx.GetXPCContext()
->GetAppropriateSecurityManager(nsIXPCSecurityManager::HOOK_CALL_METHOD);
XPCWrappedNative * wrapper = ccx.GetWrapper();
if(sm && NS_FAILED(sm->CanAccess(nsIXPCSecurityManager::ACCESS_CALL_METHOD,
&ccx, ccx, ccx.GetFlattenedJSObject(),
wrapper->GetIdentityObject(),
wrapper->GetClassInfo(),
rt->GetStringJSVal(name),
wrapper->GetSecurityInfoAddr())))
{
// Security manager will have set an exception
return JS_FALSE;
}
// Make sure we were called with one string parameter
if(argc != 1 || (argc == 1 && !JSVAL_IS_STRING(argv[0])))
{
XPCThrower::Throw(NS_ERROR_XPC_COM_INVALID_CLASS_ID, ccx);
return JS_FALSE;
}
JSString* str = JSVAL_TO_STRING(argv[0]);
PRUint32 len = JS_GetStringLength(str);
// Cap constructor argument length to keep from crashing in string
// code.
if(len > XPC_IDISPATCH_CTOR_MAX_ARG_LEN)
{
XPCThrower::Throw(NS_ERROR_XPC_COM_INVALID_CLASS_ID, ccx);
return JS_FALSE;
}
jschar * className = JS_GetStringChars(str);
CComBSTR bstrClassName(len, reinterpret_cast<const WCHAR *>(className));
if(!bstrClassName)
{
XPCThrower::Throw(NS_ERROR_XPC_COM_INVALID_CLASS_ID, ccx);
return JS_FALSE;
}
// Instantiate the desired COM object
CComPtr<IDispatch> pDispatch;
HRESULT rv = XPCDispObject::COMCreateInstance(ccx, bstrClassName,
enforceSecurity, &pDispatch);
if(FAILED(rv))
{
XPCThrower::ThrowCOMError(ccx, rv, NS_ERROR_XPC_COM_CREATE_FAILED);
return JS_FALSE;
}
// Get a wrapper for our object
nsCOMPtr<nsIXPConnectJSObjectHolder> holder;
nsresult nsrv = ccx.GetXPConnect()->WrapNative(
ccx, ccx.GetOperandJSObject(), reinterpret_cast<nsISupports*>(pDispatch.p),
NSID_IDISPATCH, getter_AddRefs(holder));
if(NS_FAILED(nsrv))
{
XPCThrower::Throw(nsrv, ccx);
return JS_FALSE;
}
// get and return the JS object wrapper
JSObject * jsobj;
nsrv = holder->GetJSObject(&jsobj);
if(NS_FAILED(nsrv))
{
XPCThrower::Throw(nsrv, ccx);
return JS_FALSE;
}
*rval = OBJECT_TO_JSVAL(jsobj);
return JS_TRUE;
}
JavaPackage_resolve(JSContext *cx, JSObject *obj, jsval id)
{
JavaPackage_Private *package;
JSBool ok = JS_TRUE;
jclass jclazz;
char *subPath, *newPath;
const char *path;
JNIEnv *jEnv;
JSJavaThreadState *jsj_env;
/* Painful hack for pre_define_java_packages() */
if (quiet_resolve_failure)
return JS_FALSE;
package = (JavaPackage_Private *)JS_GetPrivate(cx, obj);
if (!package)
return JS_TRUE;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
subPath = JS_GetStringBytes(JSVAL_TO_STRING(id));
/*
* There will be an attempt to invoke the toString() method when producing
* the string representation of a JavaPackage. When this occurs, avoid
* creating a bogus toString package. (This means that no one can ever
* create a package with the simple name "toString", but we'll live with
* that limitation.)
*/
if (!strcmp(subPath, "toString"))
return JS_FALSE;
path = package->path;
newPath = JS_smprintf("%s%s%s", path, (path[0] ? "/" : ""), subPath);
if (!newPath) {
JS_ReportOutOfMemory(cx);
return JS_FALSE;
}
jsj_env = jsj_EnterJava(cx, &jEnv);
if (!jEnv) {
ok = JS_FALSE;
goto out;
}
/*
Unfortunately, Java provides no way to find out whether a particular
name is a package or not. The only way to tell is to try to load the
name as a class file and, if that fails, assume it's a package. This
makes things work as expected for the most part, but it has three
noticeable problems that keep coming up:
- You can refer to a package like java.lang.i.buried.paul without
generating a complaint. Of course, you'll never be able to refer to
any classes through it.
- An annoying consequence of the above is that misspelling a class name
results in a cryptic error about packages.
- In a browser context, i.e. where applets are involved, figuring out
whether something is a class may require looking for it over the net
using the current classloader. This means that the first time you
refer to java.lang.System in a js context, there will be an attempt
to search for [[DOCBASE]]/java.class on the server.
A solution is to explicitly tell jsjava the names of all the (local)
packages on the CLASSPATH. (Not implemented yet.)
*/
jclazz = (*jEnv)->FindClass(jEnv, newPath);
if (jclazz) {
JSObject *newClass;
newClass = jsj_define_JavaClass(cx, jEnv, obj, subPath, jclazz);
(*jEnv)->DeleteLocalRef(jEnv, jclazz);
if (!newClass) {
ok = JS_FALSE;
goto out;
}
} else {
/* We assume that any failed attempt to load a class is because it
doesn't exist. If we wanted to do a better job, we would check
the exception type and make sure that it's NoClassDefFoundError */
(*jEnv)->ExceptionClear(jEnv);
/*
* If there's no class of the given name, then we must be referring to
* a package. However, don't allow bogus sub-packages of pre-defined
* system packages to be created.
*/
if (JS_InstanceOf(cx, obj, &JavaPackage_class, NULL)) {
JavaPackage_Private *current_package;
current_package = JS_GetPrivate(cx, obj);
if (current_package->flags & PKG_SYSTEM) {
char *msg, *cp;
msg = JS_strdup(cx, newPath);
/* Check for OOM */
if (msg) {
/* Convert package of form "java/lang" to "java.lang" */
for (cp = msg; *cp != '\0'; cp++)
if (*cp == '/')
*cp = '.';
JS_ReportErrorNumber(cx, jsj_GetErrorMessage, NULL,
JSJMSG_MISSING_PACKAGE, msg);
free((char*)msg);
}
ok = JS_FALSE;
goto out;
}
}
if (!define_JavaPackage(cx, obj, subPath, newPath, 0, JSPROP_READONLY)) {
ok = JS_FALSE;
goto out;
}
#ifdef DEBUG
/* printf("JavaPackage \'%s\' created\n", newPath); */
#endif
}
out:
free(newPath);
jsj_ExitJava(jsj_env);
return ok;
}
void
gjstest_test_func_gjs_jsapi_util_error_throw(void)
{
GjsUnitTestFixture fixture;
JSContext *context;
jsval exc, value, previous;
char *s = NULL;
int strcmp_result;
_gjs_unit_test_fixture_begin(&fixture);
context = fixture.context;
/* Test that we can throw */
gjs_throw(context, "This is an exception %d", 42);
g_assert(JS_IsExceptionPending(context));
exc = JSVAL_VOID;
JS_GetPendingException(context, &exc);
g_assert(!JSVAL_IS_VOID(exc));
value = JSVAL_VOID;
JS_GetProperty(context, JSVAL_TO_OBJECT(exc), "message",
&value);
g_assert(JSVAL_IS_STRING(value));
gjs_string_get_binary_data (context, value, &s, NULL);
g_assert(s != NULL);
strcmp_result = strcmp(s, "This is an exception 42");
free(s);
if (strcmp_result != 0)
g_error("Exception has wrong message '%s'", s);
/* keep this around before we clear it */
previous = exc;
JS_AddValueRoot(context, &previous);
JS_ClearPendingException(context);
g_assert(!JS_IsExceptionPending(context));
/* Check that we don't overwrite a pending exception */
JS_SetPendingException(context, previous);
g_assert(JS_IsExceptionPending(context));
gjs_throw(context, "Second different exception %s", "foo");
g_assert(JS_IsExceptionPending(context));
exc = JSVAL_VOID;
JS_GetPendingException(context, &exc);
g_assert(!JSVAL_IS_VOID(exc));
g_assert(exc == previous);
JS_RemoveValueRoot(context, &previous);
_gjs_unit_test_fixture_finish(&fixture);
}
/*
* Convert a JS value to a Java value of the given type signature. The cost
* variable is incremented if coercion is required, e.g. the source value is
* a string, but the target type is a boolean.
*
* Returns JS_FALSE if no conversion is possible, either because the jsval has
* a type that is wholly incompatible with the Java value, or because a scalar
* jsval can't be represented in a variable of the target type without loss of
* precision, e.g. the source value is "4.2" but the destination type is byte.
* If conversion is not possible and java_value is non-NULL, the JS error
* reporter is called with an appropriate message.
*/
JSBool
jsj_ConvertJSValueToJavaValue(JSContext *cx, JNIEnv *jEnv, jsval v_arg,
JavaSignature *signature,
int *cost, jvalue *java_value, JSBool *is_local_refp)
{
JavaSignatureChar type;
jsval v;
JSBool success = JS_FALSE;
/* Initialize to default case, in which no new Java object is
synthesized to perform the conversion and, therefore, no JNI local
references are being held. */
*is_local_refp = JS_FALSE;
type = signature->type;
v = v_arg;
switch (type) {
case JAVA_SIGNATURE_BOOLEAN:
if (!JSVAL_IS_BOOLEAN(v)) {
if (!JS_ConvertValue(cx, v, JSTYPE_BOOLEAN, &v))
goto conversion_error;
if (JSVAL_IS_VOID(v))
goto conversion_error;
(*cost)++;
}
if (java_value)
java_value->z = (jboolean)(JSVAL_TO_BOOLEAN(v) == JS_TRUE);
break;
case JAVA_SIGNATURE_SHORT:
JSVAL_TO_INTEGRAL_JVALUE(short, s, jshort, v, java_value);
break;
case JAVA_SIGNATURE_BYTE:
JSVAL_TO_INTEGRAL_JVALUE(byte, b, jbyte, v, java_value);
break;
case JAVA_SIGNATURE_CHAR:
/* A one-character string can be converted into a character */
if (JSVAL_IS_STRING(v) && (JS_GetStringLength(JSVAL_TO_STRING(v)) == 1)) {
v = INT_TO_JSVAL(*JS_GetStringChars(JSVAL_TO_STRING(v)));
}
JSVAL_TO_INTEGRAL_JVALUE(char, c, jchar, v, java_value);
break;
case JAVA_SIGNATURE_INT:
JSVAL_TO_INTEGRAL_JVALUE(int, i, jint, v, java_value);
break;
case JAVA_SIGNATURE_LONG:
#if (defined(XP_OS2) && !defined(HAVE_LONG_LONG))
JSVAL_TO_JLONG_JVALUE(j, jlong, v, java_value);
#else
JSVAL_TO_INTEGRAL_JVALUE(long, j, jlong, v, java_value);
#endif
break;
case JAVA_SIGNATURE_FLOAT:
if (!JSVAL_IS_NUMBER(v)) {
if (!JS_ConvertValue(cx, v, JSTYPE_NUMBER, &v))
goto conversion_error;
(*cost)++;
}
if (java_value) {
if (JSVAL_IS_INT(v))
java_value->f = (jfloat) JSVAL_TO_INT(v);
else
java_value->f = (jfloat) *JSVAL_TO_DOUBLE(v);
}
break;
case JAVA_SIGNATURE_DOUBLE:
if (!JSVAL_IS_NUMBER(v)) {
if (!JS_ConvertValue(cx, v, JSTYPE_NUMBER, &v))
goto conversion_error;
(*cost)++;
}
if (java_value) {
if (JSVAL_IS_INT(v))
java_value->d = (jdouble) JSVAL_TO_INT(v);
else
java_value->d = (jdouble) *JSVAL_TO_DOUBLE(v);
}
break;
/* Non-primitive (reference) type */
default:
JS_ASSERT(IS_REFERENCE_TYPE(type));
if (!jsj_ConvertJSValueToJavaObject(cx, jEnv, v, signature, cost,
&java_value->l, is_local_refp))
goto conversion_error;
break;
case JAVA_SIGNATURE_UNKNOWN:
case JAVA_SIGNATURE_VOID:
JS_ASSERT(0);
return JS_FALSE;
}
/* Success */
return JS_TRUE;
numeric_conversion_error:
success = JS_TRUE;
/* Fall through ... */
conversion_error:
if (java_value) {
const char *jsval_string;
const char *class_name;
JSString *jsstr;
jsval_string = NULL;
jsstr = JS_ValueToString(cx, v_arg);
if (jsstr)
jsval_string = JS_GetStringBytes(jsstr);
if (!jsval_string)
jsval_string = "";
class_name = jsj_ConvertJavaSignatureToHRString(cx, signature);
JS_ReportErrorNumber(cx, jsj_GetErrorMessage, NULL,
JSJMSG_CANT_CONVERT_JS, jsval_string,
class_name);
return JS_FALSE;
}
return success;
}
// static
JSBool
XPCArrayHomogenizer::GetTypeForArray(XPCCallContext& ccx, JSObject* array,
jsuint length,
nsXPTType* resultType, nsID* resultID)
{
Type state = tUnk;
Type type;
for(jsuint i = 0; i < length; i++)
{
jsval val;
if(!JS_GetElement(ccx, array, i, &val))
return JS_FALSE;
if(JSVAL_IS_INT(val))
type = tInt;
else if(JSVAL_IS_DOUBLE(val))
type = tDbl;
else if(JSVAL_IS_BOOLEAN(val))
type = tBool;
else if(JSVAL_IS_VOID(val))
{
state = tVar;
break;
}
else if(JSVAL_IS_NULL(val))
type = tNull;
else if(JSVAL_IS_STRING(val))
type = tStr;
else
{
NS_ASSERTION(JSVAL_IS_OBJECT(val), "invalid type of jsval!");
JSObject* jsobj = JSVAL_TO_OBJECT(val);
if(JS_IsArrayObject(ccx, jsobj))
type = tArr;
else if(xpc_JSObjectIsID(ccx, jsobj))
type = tID;
else
type = tISup;
}
NS_ASSERTION(state != tErr, "bad state table!");
NS_ASSERTION(type != tErr, "bad type!");
NS_ASSERTION(type != tVar, "bad type!");
NS_ASSERTION(type != tUnk, "bad type!");
state = StateTable[state][type];
NS_ASSERTION(state != tErr, "bad state table!");
NS_ASSERTION(state != tUnk, "bad state table!");
if(state == tVar)
break;
}
switch(state)
{
case tInt :
*resultType = nsXPTType((uint8)TD_INT32);
break;
case tDbl :
*resultType = nsXPTType((uint8)TD_DOUBLE);
break;
case tBool:
*resultType = nsXPTType((uint8)TD_BOOL);
break;
case tStr :
*resultType = nsXPTType((uint8)(TD_PWSTRING | XPT_TDP_POINTER));
break;
case tID :
*resultType = nsXPTType((uint8)(TD_PNSIID | XPT_TDP_POINTER));
break;
case tISup:
*resultType = nsXPTType((uint8)(TD_INTERFACE_IS_TYPE | XPT_TDP_POINTER));
*resultID = NS_GET_IID(nsISupports);
break;
case tNull:
// FALL THROUGH
case tVar :
*resultType = nsXPTType((uint8)(TD_INTERFACE_IS_TYPE | XPT_TDP_POINTER));
*resultID = NS_GET_IID(nsIVariant);
break;
case tArr :
// FALL THROUGH
case tUnk :
// FALL THROUGH
case tErr :
// FALL THROUGH
default:
NS_ERROR("bad state");
return JS_FALSE;
}
return JS_TRUE;
}
JSBool
js_Stringify(JSContext *cx, jsval *vp, JSObject *replacer,
JSONWriteCallback callback, void *data, uint32 depth)
{
if (depth > JSON_MAX_DEPTH)
return JS_FALSE; /* encoding error */
JSBool ok = JS_TRUE;
JSObject *obj = JSVAL_TO_OBJECT(*vp);
JSBool isArray = JS_IsArrayObject(cx, obj);
jschar output = jschar(isArray ? '[' : '{');
if (!callback(&output, 1, data))
return JS_FALSE;
JSObject *iterObj = NULL;
jsint i = 0;
jsuint length = 0;
if (isArray) {
if (!JS_GetArrayLength(cx, obj, &length))
return JS_FALSE;
} else {
if (!js_ValueToIterator(cx, JSITER_ENUMERATE, vp))
return JS_FALSE;
iterObj = JSVAL_TO_OBJECT(*vp);
}
jsval outputValue = JSVAL_VOID;
JSAutoTempValueRooter tvr(cx, 1, &outputValue);
jsval key;
JSBool memberWritten = JS_FALSE;
do {
outputValue = JSVAL_VOID;
if (isArray) {
if ((jsuint)i >= length)
break;
ok = JS_GetElement(cx, obj, i++, &outputValue);
} else {
ok = js_CallIteratorNext(cx, iterObj, &key);
if (!ok)
break;
if (key == JSVAL_HOLE)
break;
JSString *ks;
if (JSVAL_IS_STRING(key)) {
ks = JSVAL_TO_STRING(key);
} else {
ks = JS_ValueToString(cx, key);
if (!ks) {
ok = JS_FALSE;
break;
}
}
ok = JS_GetUCProperty(cx, obj, JS_GetStringChars(ks),
JS_GetStringLength(ks), &outputValue);
}
if (!ok)
break;
// if this is an array, holes are transmitted as null
if (isArray && outputValue == JSVAL_VOID) {
outputValue = JSVAL_NULL;
} else if (JSVAL_IS_OBJECT(outputValue)) {
ok = js_TryJSON(cx, &outputValue);
if (!ok)
break;
}
// elide undefined values
if (outputValue == JSVAL_VOID)
continue;
// output a comma unless this is the first member to write
if (memberWritten) {
output = jschar(',');
ok = callback(&output, 1, data);
if (!ok)
break;
}
memberWritten = JS_TRUE;
JSType type = JS_TypeOfValue(cx, outputValue);
// Can't encode these types, so drop them
if (type == JSTYPE_FUNCTION || type == JSTYPE_XML)
break;
// Be careful below, this string is weakly rooted.
JSString *s;
// If this isn't an array, we need to output a key
if (!isArray) {
s = JS_ValueToString(cx, key);
if (!s) {
ok = JS_FALSE;
break;
}
ok = write_string(cx, callback, data, JS_GetStringChars(s), JS_GetStringLength(s));
if (!ok)
break;
output = jschar(':');
ok = callback(&output, 1, data);
if (!ok)
break;
}
if (!JSVAL_IS_PRIMITIVE(outputValue)) {
// recurse
ok = js_Stringify(cx, &outputValue, replacer, callback, data, depth + 1);
} else {
JSString *outputString;
s = JS_ValueToString(cx, outputValue);
if (!s) {
ok = JS_FALSE;
break;
}
if (type == JSTYPE_STRING) {
ok = write_string(cx, callback, data, JS_GetStringChars(s), JS_GetStringLength(s));
if (!ok)
break;
continue;
}
if (type == JSTYPE_NUMBER) {
if (JSVAL_IS_DOUBLE(outputValue)) {
jsdouble d = *JSVAL_TO_DOUBLE(outputValue);
if (!JSDOUBLE_IS_FINITE(d))
outputString = JS_NewStringCopyN(cx, "null", 4);
else
outputString = s;
} else {
outputString = s;
}
} else if (type == JSTYPE_BOOLEAN) {
outputString = s;
} else if (JSVAL_IS_NULL(outputValue)) {
outputString = JS_NewStringCopyN(cx, "null", 4);
} else {
ok = JS_FALSE; // encoding error
break;
}
ok = callback(JS_GetStringChars(outputString), JS_GetStringLength(outputString), data);
}
} while (ok);
if (iterObj) {
// Always close the iterator, but make sure not to stomp on OK
js_CloseIteratorState(cx, iterObj);
// encoding error or propagate? FIXME: Bug 408838.
}
if (!ok) {
JS_ReportError(cx, "Error during JSON encoding.");
return JS_FALSE;
}
output = jschar(isArray ? ']' : '}');
ok = callback(&output, 1, data);
return ok;
}
JSBool
jsd_IsValueString(JSDContext* jsdc, JSDValue* jsdval)
{
return JSVAL_IS_STRING(jsdval->val);
}
JSBool ADM_JSAvidemux::JSSetProperty(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
if (JSVAL_IS_INT(id))
{
ADM_JSAvidemux *priv = (ADM_JSAvidemux *) JS_GetPrivate(cx, obj);
switch(JSVAL_TO_INT(id))
{
case markerA_prop:
if(JSVAL_IS_INT(*vp) == false)
break;
{
int f=JSVAL_TO_INT(*vp);
if (!avifileinfo)
{
return JS_FALSE;
}
if(f==-1)
f=avifileinfo->nb_frames-1;
if(f<0 || f>avifileinfo->nb_frames-1)
return JS_FALSE;
frameStart=f;
}
break;
case markerB_prop:
if(JSVAL_IS_INT(*vp) == false)
break;
{
int f=JSVAL_TO_INT(*vp);
if (!avifileinfo)
{
return JS_FALSE;
}
if(f==-1)
f=avifileinfo->nb_frames-1;
if(f<0 || f>avifileinfo->nb_frames-1)
return JS_FALSE;
frameEnd=f;
}
break;
case audio_prop:
return JS_FALSE;
break;
case video_prop:
return JS_FALSE;
break;
case container_prop:
if(JSVAL_IS_STRING(*vp) == false)
break;
{
priv->getObject()->m_pContainer = JSVAL_TO_STRING(*vp);
char *pContainer = JS_GetStringBytes(priv->getObject()->m_pContainer);
aprintf("Setting container format \"%s\"\n",pContainer);
if(A_setContainer(pContainer))
return JS_TRUE;
return JS_FALSE;
return JS_FALSE;
}
break;
case currentframe_prop:
if(JSVAL_IS_INT(*vp) == false)
break;
{
int frameno;
if (!avifileinfo)
return JS_FALSE;
frameno = JSVAL_TO_INT(*vp);
if( frameno<0)
{
aviInfo info;
video_body->getVideoInfo(&info);
frameno=-frameno;
if(frameno>info.nb_frames)
return JS_FALSE;
frameno = info.nb_frames-frameno;
}
enterLock();
if(GUI_GoToFrame( frameno ))
{
leaveLock();
return JS_TRUE;
}
leaveLock();
return JS_FALSE;
}
break;
case fps_prop:
if(JSVAL_IS_DOUBLE(*vp) == false)
break;
{
priv->getObject()->m_dFPS = *JSVAL_TO_DOUBLE(*vp);
aviInfo info;
if (avifileinfo)
{
video_body->getVideoInfo(&info);
info.fps1000 = (uint32_t)floor(priv->getObject()->m_dFPS*1000.f);
video_body->updateVideoInfo (&info);
video_body->getVideoInfo (avifileinfo);
return JS_TRUE;
} else
{
return JS_FALSE;
}
}
break;
}
}
return JS_TRUE;
}
NS_IMETHODIMP
TCPSocketParent::SendCallback(const nsAString& aType, const JS::Value& aDataVal,
const nsAString& aReadyState, uint32_t aBuffered,
JSContext* aCx)
{
if (!mIPCOpen) {
NS_WARNING("Dropping callback due to no IPC connection");
return NS_OK;
}
CallbackData data;
if (aDataVal.isString()) {
JSString* jsstr = aDataVal.toString();
nsDependentJSString str;
if (!str.init(aCx, jsstr)) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
data = str;
} else if (aDataVal.isUndefined() || aDataVal.isNull()) {
data = mozilla::void_t();
} else if (aDataVal.isObject()) {
JSObject* obj = &aDataVal.toObject();
if (JS_IsTypedArrayObject(obj)) {
NS_ENSURE_TRUE(JS_IsUint8Array(obj), NS_ERROR_FAILURE);
uint32_t nbytes = JS_GetTypedArrayByteLength(obj);
uint8_t* buffer = JS_GetUint8ArrayData(obj);
if (!buffer) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
FallibleTArray<uint8_t> fallibleArr;
if (!fallibleArr.InsertElementsAt(0, buffer, nbytes)) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> arr;
arr.SwapElements(fallibleArr);
data = SendableData(arr);
} else {
nsDependentJSString message, filename;
uint32_t lineNumber = 0;
uint32_t columnNumber = 0;
jsval val;
if (!JS_GetProperty(aCx, obj, "message", &val)) {
NS_ERROR("No message property on supposed error object");
} else if (JSVAL_IS_STRING(val)) {
if (!message.init(aCx, JSVAL_TO_STRING(val))) {
NS_WARNING("couldn't initialize string");
}
}
if (!JS_GetProperty(aCx, obj, "fileName", &val)) {
NS_ERROR("No fileName property on supposed error object");
} else if (JSVAL_IS_STRING(val)) {
if (!filename.init(aCx, JSVAL_TO_STRING(val))) {
NS_WARNING("couldn't initialize string");
}
}
if (!JS_GetProperty(aCx, obj, "lineNumber", &val)) {
NS_ERROR("No lineNumber property on supposed error object");
} else if (JSVAL_IS_INT(val)) {
lineNumber = JSVAL_TO_INT(val);
}
if (!JS_GetProperty(aCx, obj, "columnNumber", &val)) {
NS_ERROR("No columnNumber property on supposed error object");
} else if (JSVAL_IS_INT(val)) {
columnNumber = JSVAL_TO_INT(val);
}
data = JSError(message, filename, lineNumber, columnNumber);
}
} else {
NS_ERROR("Unexpected JS value encountered");
FireInteralError(this, __LINE__);
return NS_ERROR_FAILURE;
}
mozilla::unused <<
PTCPSocketParent::SendCallback(nsString(aType), data,
nsString(aReadyState), aBuffered);
return NS_OK;
}
static JSBool
JO(JSContext *cx, jsval *vp, StringifyContext *scx)
{
JSObject *obj = JSVAL_TO_OBJECT(*vp);
if (!scx->cb.append('{'))
return JS_FALSE;
jsval vec[3] = {JSVAL_NULL, JSVAL_NULL, JSVAL_NULL};
JSAutoTempValueRooter tvr(cx, 3, vec);
jsval& key = vec[0];
jsval& outputValue = vec[1];
JSObject *iterObj = NULL;
jsval *keySource = vp;
bool usingWhitelist = false;
// if the replacer is an array, we use the keys from it
if (scx->replacer && JS_IsArrayObject(cx, scx->replacer)) {
usingWhitelist = true;
vec[2] = OBJECT_TO_JSVAL(scx->replacer);
keySource = &vec[2];
}
if (!js_ValueToIterator(cx, JSITER_ENUMERATE, keySource))
return JS_FALSE;
iterObj = JSVAL_TO_OBJECT(*keySource);
JSBool memberWritten = JS_FALSE;
bool ok = false;
while (true) {
outputValue = JSVAL_VOID;
if (!js_CallIteratorNext(cx, iterObj, &key))
goto error_break;
if (key == JSVAL_HOLE)
break;
jsuint index = 0;
if (usingWhitelist) {
// skip non-index properties
if (!js_IdIsIndex(key, &index))
continue;
jsval newKey;
if (!scx->replacer->getProperty(cx, key, &newKey))
goto error_break;
key = newKey;
}
JSString *ks;
if (JSVAL_IS_STRING(key)) {
ks = JSVAL_TO_STRING(key);
} else {
ks = js_ValueToString(cx, key);
if (!ks)
goto error_break;
}
JSAutoTempValueRooter keyStringRoot(cx, ks);
// Don't include prototype properties, since this operation is
// supposed to be implemented as if by ES3.1 Object.keys()
jsid id;
jsval v = JS_FALSE;
if (!js_ValueToStringId(cx, STRING_TO_JSVAL(ks), &id) ||
!js_HasOwnProperty(cx, obj->map->ops->lookupProperty, obj, id, &v)) {
goto error_break;
}
if (v != JSVAL_TRUE)
continue;
if (!JS_GetPropertyById(cx, obj, id, &outputValue))
goto error_break;
if (JSVAL_IS_OBJECT(outputValue) && !js_TryJSON(cx, &outputValue))
goto error_break;
// call this here, so we don't write out keys if the replacer function
// wants to elide the value.
if (!CallReplacerFunction(cx, id, obj, scx, &outputValue))
goto error_break;
JSType type = JS_TypeOfValue(cx, outputValue);
// elide undefined values and functions and XML
if (outputValue == JSVAL_VOID || type == JSTYPE_FUNCTION || type == JSTYPE_XML)
continue;
// output a comma unless this is the first member to write
if (memberWritten && !scx->cb.append(','))
goto error_break;
memberWritten = JS_TRUE;
if (!WriteIndent(cx, scx, scx->depth))
goto error_break;
// Be careful below, this string is weakly rooted
JSString *s = js_ValueToString(cx, key);
if (!s)
goto error_break;
const jschar *chars;
size_t length;
s->getCharsAndLength(chars, length);
if (!write_string(cx, scx->cb, chars, length) ||
!scx->cb.append(':') ||
!Str(cx, id, obj, scx, &outputValue, false)) {
goto error_break;
}
}
ok = true;
error_break:
if (iterObj) {
// Always close the iterator, but make sure not to stomp on OK
JS_ASSERT(OBJECT_TO_JSVAL(iterObj) == *keySource);
ok &= js_CloseIterator(cx, *keySource);
}
if (!ok)
return JS_FALSE;
if (memberWritten && !WriteIndent(cx, scx, scx->depth - 1))
return JS_FALSE;
return scx->cb.append('}');
}
JSBool JSI_IGUIObject::setProperty(JSContext* cx, JSObject* obj, jsid id, JSBool UNUSED(strict), jsval* vp)
{
IGUIObject* e = (IGUIObject*)JS_GetInstancePrivate(cx, obj, &JSI_IGUIObject::JSI_class, NULL);
if (!e)
return JS_FALSE;
jsval idval;
if (!JS_IdToValue(cx, id, &idval))
return JS_FALSE;
std::string propName;
if (!ScriptInterface::FromJSVal(cx, idval, propName))
return JS_FALSE;
if (propName == "name")
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
e->SetName(value);
return JS_TRUE;
}
// Use onWhatever to set event handlers
if (propName.substr(0, 2) == "on")
{
if (!JSVAL_IS_OBJECT(*vp) || !JS_ObjectIsFunction(cx, JSVAL_TO_OBJECT(*vp)))
{
JS_ReportError(cx, "on- event-handlers must be functions");
return JS_FALSE;
}
CStr eventName (CStr(propName.substr(2)).LowerCase());
e->SetScriptHandler(eventName, JSVAL_TO_OBJECT(*vp));
return JS_TRUE;
}
// Retrieve the setting's type (and make sure it actually exists)
EGUISettingType Type;
if (e->GetSettingType(propName, Type) != PSRETURN_OK)
{
JS_ReportError(cx, "Invalid setting '%s'", propName.c_str());
return JS_TRUE;
}
switch (Type)
{
case GUIST_CStr:
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
GUI<CStr>::SetSetting(e, propName, value);
break;
}
case GUIST_CStrW:
{
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
GUI<CStrW>::SetSetting(e, propName, value);
break;
}
case GUIST_CGUISpriteInstance:
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
GUI<CGUISpriteInstance>::SetSetting(e, propName, CGUISpriteInstance(value));
break;
}
case GUIST_CGUIString:
{
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
CGUIString str;
str.SetValue(value);
GUI<CGUIString>::SetSetting(e, propName, str);
break;
}
case GUIST_EAlign:
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
EAlign a;
if (value == "left") a = EAlign_Left;
else if (value == "right") a = EAlign_Right;
else if (value == "center" || value == "centre") a = EAlign_Center;
else
{
JS_ReportError(cx, "Invalid alignment (should be 'left', 'right' or 'center')");
return JS_FALSE;
}
GUI<EAlign>::SetSetting(e, propName, a);
break;
}
case GUIST_EVAlign:
{
std::string value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
EVAlign a;
if (value == "top") a = EVAlign_Top;
else if (value == "bottom") a = EVAlign_Bottom;
else if (value == "center" || value == "centre") a = EVAlign_Center;
else
{
JS_ReportError(cx, "Invalid alignment (should be 'top', 'bottom' or 'center')");
return JS_FALSE;
}
GUI<EVAlign>::SetSetting(e, propName, a);
break;
}
case GUIST_int:
{
int32 value;
if (JS_ValueToInt32(cx, *vp, &value) == JS_TRUE)
GUI<int>::SetSetting(e, propName, value);
else
{
JS_ReportError(cx, "Cannot convert value to int");
return JS_FALSE;
}
break;
}
case GUIST_float:
{
jsdouble value;
if (JS_ValueToNumber(cx, *vp, &value) == JS_TRUE)
GUI<float>::SetSetting(e, propName, (float)value);
else
{
JS_ReportError(cx, "Cannot convert value to float");
return JS_FALSE;
}
break;
}
case GUIST_bool:
{
JSBool value;
if (JS_ValueToBoolean(cx, *vp, &value) == JS_TRUE)
GUI<bool>::SetSetting(e, propName, value||0); // ||0 to avoid int-to-bool compiler warnings
else
{
JS_ReportError(cx, "Cannot convert value to bool");
return JS_FALSE;
}
break;
}
case GUIST_CClientArea:
{
if (JSVAL_IS_STRING(*vp))
{
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
if (e->SetSetting(propName, value) != PSRETURN_OK)
{
JS_ReportError(cx, "Invalid value for setting '%s'", propName.c_str());
return JS_FALSE;
}
}
else if (JSVAL_IS_OBJECT(*vp) && JS_InstanceOf(cx, JSVAL_TO_OBJECT(*vp), &JSI_GUISize::JSI_class, NULL))
{
CClientArea area;
GUI<CClientArea>::GetSetting(e, propName, area);
JSObject* obj = JSVAL_TO_OBJECT(*vp);
#define P(x, y, z) area.x.y = (float)g_ScriptingHost.GetObjectProperty_Double(obj, #z)
P(pixel, left, left);
P(pixel, top, top);
P(pixel, right, right);
P(pixel, bottom, bottom);
P(percent, left, rleft);
P(percent, top, rtop);
P(percent, right, rright);
P(percent, bottom, rbottom);
#undef P
GUI<CClientArea>::SetSetting(e, propName, area);
}
else
{
JS_ReportError(cx, "Size only accepts strings or GUISize objects");
return JS_FALSE;
}
break;
}
case GUIST_CColor:
{
if (JSVAL_IS_STRING(*vp))
{
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, *vp, value))
return JS_FALSE;
if (e->SetSetting(propName, value) != PSRETURN_OK)
{
JS_ReportError(cx, "Invalid value for setting '%s'", propName.c_str());
return JS_FALSE;
}
}
else if (JSVAL_IS_OBJECT(*vp) && JS_InstanceOf(cx, JSVAL_TO_OBJECT(*vp), &JSI_GUIColor::JSI_class, NULL))
{
CColor colour;
JSObject* obj = JSVAL_TO_OBJECT(*vp);
jsval t; double s;
#define PROP(x) JS_GetProperty(cx, obj, #x, &t); \
JS_ValueToNumber(cx, t, &s); \
colour.x = (float)s
PROP(r); PROP(g); PROP(b); PROP(a);
#undef PROP
GUI<CColor>::SetSetting(e, propName, colour);
}
else
{
JS_ReportError(cx, "Color only accepts strings or GUIColor objects");
return JS_FALSE;
}
break;
}
case GUIST_CGUIList:
{
JSObject* obj = JSVAL_TO_OBJECT(*vp);
jsuint length;
if (JSVAL_IS_OBJECT(*vp) && JS_GetArrayLength(cx, obj, &length) == JS_TRUE)
{
CGUIList list;
for (int i=0; i<(int)length; ++i)
{
jsval element;
if (! JS_GetElement(cx, obj, i, &element))
{
JS_ReportError(cx, "Failed to get list element");
return JS_FALSE;
}
std::wstring value;
if (!ScriptInterface::FromJSVal(cx, element, value))
return JS_FALSE;
CGUIString str;
str.SetValue(value);
list.m_Items.push_back(str);
}
GUI<CGUIList>::SetSetting(e, propName, list);
}
else
{
JS_ReportError(cx, "List only accepts a GUIList object");
return JS_FALSE;
}
break;
}
// TODO Gee: (2004-09-01) EAlign and EVAlign too.
default:
JS_ReportError(cx, "Setting '%s' uses an unimplemented type", propName.c_str());
break;
}
return !JS_IsExceptionPending(cx);
}
static JSBool SMJS_FUNCTION(upnp_action_send_reply)
{
SMJS_OBJ
SMJS_ARGS
GPAC_GenericDevice *device = (GPAC_GenericDevice *)SMJS_GET_PRIVATE(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 = (char*)"";
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 SMJS_FUNCTION(upnp_service_call_action)
{
GPAC_ActionUDTA *act_udta = NULL;
char *action_name = NULL;
SMJS_OBJ
SMJS_ARGS
GPAC_ServiceItem *service = (GPAC_ServiceItem *)SMJS_GET_PRIVATE(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 = (char*)"";
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;
}
static int
json_encode_from_object(JSContext *cx, JSObject *obj, htsbuf_queue_t *out)
{
int objtype = 0;
JSIdArray *ida;
int i;
const char *n;
if((ida = JS_Enumerate(cx, obj)) == NULL)
return -1;
for(i = 0; i < ida->length; i++) {
jsval name, value;
if(!JS_IdToValue(cx, ida->vector[i], &name))
continue;
if(JSVAL_IS_STRING(name)) {
JSString *str = JSVAL_TO_STRING(name);
n = JS_GetStringBytes(str);
if(!JS_GetProperty(cx, obj, n, &value))
continue;
if(objtype == 0) {
htsbuf_append(out, "{", 1);
objtype = OBJTYPE_MAP;
} else if(objtype != OBJTYPE_MAP)
continue;
else
htsbuf_append(out, ",", 1);
htsbuf_append_and_escape_jsonstr(out, n);
htsbuf_append(out, ":", 1);
} else if(JSVAL_IS_INT(name)) {
if(!JS_GetElement(cx, obj, JSVAL_TO_INT(name), &value) ||
JSVAL_IS_VOID(value))
continue;
if(objtype == 0) {
htsbuf_append(out, "[", 1);
objtype = OBJTYPE_LIST;
} else if(objtype != OBJTYPE_LIST)
continue;
else
htsbuf_append(out, ",", 1);
} else {
continue;
}
js_json_emit_jsval(cx, value, out);
}
JS_DestroyIdArray(cx, ida);
switch(objtype) {
case OBJTYPE_LIST:
htsbuf_append(out, "]", 1);
break;
case OBJTYPE_MAP:
htsbuf_append(out, "}", 1);
break;
default:
return -1;
}
return 0;
}
static JSBool
do_import(JSContext *context,
JSObject *obj,
Importer *priv,
const char *name)
{
char *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;
jsid search_path_name;
GFile *gfile;
gboolean exists;
search_path_name = gjs_context_get_const_string(context, GJS_STRING_SEARCH_PATH);
if (!gjs_object_require_property(context, obj, "importer", search_path_name, &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);
full_path = NULL;
directories = NULL;
/* First try importing an internal module like byteArray */
if (priv->is_root &&
gjs_is_registered_native_module(context, obj, name) &&
import_native_file(context, obj, name)) {
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 (JS_GetProperty(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);
gfile = g_file_new_for_commandline_arg(full_path);
if (g_file_query_file_type(gfile, (GFileQueryInfoFlags) 0, NULL) == G_FILE_TYPE_DIRECTORY) {
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;
}
g_object_unref(gfile);
/* 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);
gfile = g_file_new_for_commandline_arg(full_path);
exists = g_file_query_exists(gfile, NULL);
if (!exists) {
gjs_debug(GJS_DEBUG_IMPORTER,
"JS import '%s' not found in %s",
name, dirname);
g_object_unref(gfile);
continue;
}
if (import_file_on_module (context, obj, name, gfile)) {
gjs_debug(GJS_DEBUG_IMPORTER,
"successfully imported module '%s'", name);
result = JS_TRUE;
}
g_object_unref(gfile);
/* 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;
}
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(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;
}
static JSBool
screen_setProperty (JSContext * cx, JSObject * obj, jsval id, jsval * vp)
{
FILE *fOut;
JSString *str;
size_t n, i;
jschar *s;
if (JSVAL_IS_INT (id))
{
switch (JSVAL_TO_INT (id))
{
case SCREEN_AVAILHEIGHT:
case SCREEN_AVAILWIDTH:
case SCREEN_COLORDEPTH:
case SCREEN_HEIGHT:
case SCREEN_WIDTH:
fOut = fopen (SETTERLOG, "a");
if (fOut == NULL)
return JS_FALSE;
if (JSVAL_IS_INT (*vp))
{
fprintf (fOut, "screen set property read-only %s = %d\n",
screen_property_str[JSVAL_TO_INT (id)],
JSVAL_TO_INT (*vp));
}
else if (JSVAL_IS_STRING (*vp))
{
str = js_ValueToString (cx, *vp);
if (!str)
return JS_FALSE;
if (JSSTRING_IS_DEPENDENT (str))
{
n = JSSTRDEP_LENGTH (str);
s = JSSTRDEP_CHARS (str);
}
else
{
n = str->length;
s = str->chars;
}
fprintf (fOut, "screen set property read-only %s = \"",
screen_property_str[JSVAL_TO_INT (id)]);
if (n != 0)
{
for (i = 0; i < n; i++)
fputc (s[i], fOut);
}
fprintf (fOut, "\"\n");
}
else
{
fprintf (fOut,
"screen set property read-only %s to value of unknown type %x\n",
screen_property_str[JSVAL_TO_INT (id)],
JSVAL_TAG (*vp));
}
fclose (fOut);
break;
}
}
return JS_TRUE;
}
/*
* 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;
jsid search_path_name;
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;
search_path_name = gjs_context_get_const_string(context, GJS_STRING_SEARCH_PATH);
if (!gjs_object_require_property(context, *object, "importer", search_path_name, &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 = (ImporterIterator*) JSVAL_TO_PRIVATE(*state_p);
if (iter->index < iter->elements->len) {
if (!gjs_string_from_utf8(context,
(const char*) 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 = (ImporterIterator*) JSVAL_TO_PRIVATE(*state_p);
importer_iterator_free(iter);
*state_p = JSVAL_NULL;
}
}
}
return JS_TRUE;
}
static JSBool
rpmts_dbkeys(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
void * ptr = JS_GetInstancePrivate(cx, obj, &rpmtsClass, NULL);
rpmts ts = ptr;
jsval tagid = JSVAL_VOID;
jsval v = JSVAL_VOID;
rpmTag tag = RPMTAG_NVRA;
rpmMireMode _mode = RPMMIRE_PCRE;
const char * _pat = "^a.*$";
ARGV_t _av = NULL;
JSBool ok = JS_FALSE;
int xx;
_METHOD_DEBUG_ENTRY(_debug);
if (!(ok = JS_ConvertArguments(cx, argc, argv, "/vvu", &v, &tagid, &v, &_mode)))
goto exit;
if (!JSVAL_IS_VOID(tagid)) {
/* XXX TODO: make sure both tag and key were specified. */
tag = JSVAL_IS_INT(tagid)
? (rpmTag) JSVAL_TO_INT(tagid)
: tagValue(JS_GetStringBytes(JS_ValueToString(cx, tagid)));
}
if (JSVAL_IS_VOID(v))
_pat = "^.*$";
else if (JSVAL_IS_NULL(v))
_pat = NULL;
else if (JSVAL_IS_STRING(v))
_pat = JS_GetStringBytes(JS_ValueToString(cx, v));
#ifdef NOTYET
else if (JSVAL_IS_NUMBER(v)) {
uint32_t _u = 0;
if (!JS_ValueToECMAUint32(cx, v, &_u)) {
*rval = JSVAL_VOID;
goto exit;
}
} else
;
#endif
switch (_mode) {
default:
*rval = JSVAL_VOID;
goto exit;
break;
case RPMMIRE_DEFAULT:
case RPMMIRE_STRCMP:
case RPMMIRE_REGEX:
case RPMMIRE_GLOB:
case RPMMIRE_PCRE:
break;
}
if (rpmtsGetRdb(ts) == NULL)
xx = rpmtsOpenDB(ts, O_RDONLY);
if (rpmdbMireApply(rpmtsGetRdb(ts), tag, _mode, _pat, &_av))
*rval = JSVAL_VOID;
else if (_av == NULL || _av[0] == NULL)
*rval = JSVAL_NULL;
else {
int _ac = argvCount(_av);
int i;
JSObject * arr = JS_NewArrayObject(cx, 0, NULL);
*rval = OBJECT_TO_JSVAL(arr);
for (i = 0; i < _ac; i++) {
v = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, _av[i]));
ok = JS_SetElement(cx, arr, i, &v);
}
}
exit:
ok = JS_TRUE;
_av = argvFree(_av);
return ok;
}
JSBool
js_ReportUncaughtException(JSContext *cx)
{
jsval exn;
JSObject *exnObject;
jsval roots[5];
JSTempValueRooter tvr;
JSErrorReport *reportp, report;
JSString *str;
const char *bytes;
JSBool ok;
if (!JS_IsExceptionPending(cx))
return JS_TRUE;
if (!JS_GetPendingException(cx, &exn))
return JS_FALSE;
memset(roots, 0, sizeof roots);
JS_PUSH_TEMP_ROOT(cx, JS_ARRAY_LENGTH(roots), roots, &tvr);
/*
* Because js_ValueToString below could error and an exception object
* could become unrooted, we must root exnObject. Later, if exnObject is
* non-null, we need to root other intermediates, so allocate an operand
* stack segment to protect all of these values.
*/
if (JSVAL_IS_PRIMITIVE(exn)) {
exnObject = NULL;
} else {
exnObject = JSVAL_TO_OBJECT(exn);
roots[0] = exn;
}
JS_ClearPendingException(cx);
reportp = js_ErrorFromException(cx, exn);
/* XXX L10N angels cry once again (see also jsemit.c, /L10N gaffes/) */
str = js_ValueToString(cx, exn);
if (!str) {
bytes = "unknown (can't convert to string)";
} else {
roots[1] = STRING_TO_JSVAL(str);
bytes = js_GetStringBytes(cx, str);
if (!bytes) {
ok = JS_FALSE;
goto out;
}
}
ok = JS_TRUE;
if (!reportp &&
exnObject &&
OBJ_GET_CLASS(cx, exnObject) == &js_ErrorClass) {
const char *filename;
uint32 lineno;
ok = JS_GetProperty(cx, exnObject, js_message_str, &roots[2]);
if (!ok)
goto out;
if (JSVAL_IS_STRING(roots[2])) {
bytes = js_GetStringBytes(cx, JSVAL_TO_STRING(roots[2]));
if (!bytes) {
ok = JS_FALSE;
goto out;
}
}
ok = JS_GetProperty(cx, exnObject, js_fileName_str, &roots[3]);
if (!ok)
goto out;
str = js_ValueToString(cx, roots[3]);
if (!str) {
ok = JS_FALSE;
goto out;
}
filename = StringToFilename(cx, str);
if (!filename) {
ok = JS_FALSE;
goto out;
}
ok = JS_GetProperty(cx, exnObject, js_lineNumber_str, &roots[4]);
if (!ok)
goto out;
lineno = js_ValueToECMAUint32 (cx, &roots[4]);
ok = !JSVAL_IS_NULL(roots[4]);
if (!ok)
goto out;
reportp = &report;
memset(&report, 0, sizeof report);
report.filename = filename;
report.lineno = (uintN) lineno;
}
if (!reportp) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
JSMSG_UNCAUGHT_EXCEPTION, bytes);
} else {
/* Flag the error as an exception. */
reportp->flags |= JSREPORT_EXCEPTION;
/* Pass the exception object. */
JS_SetPendingException(cx, exn);
js_ReportErrorAgain(cx, bytes, reportp);
JS_ClearPendingException(cx);
}
out:
JS_POP_TEMP_ROOT(cx, &tvr);
return ok;
}
static JSBool
rpmts_getprop(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
void * ptr = JS_GetInstancePrivate(cx, obj, &rpmtsClass, NULL);
rpmts ts = ptr;
jsint tiny = JSVAL_TO_INT(id);
_PROP_DEBUG_ENTRY(_debug < 0);
/* XXX the class has ptr == NULL, instances have ptr != NULL. */
if (ptr == NULL)
return JS_TRUE;
switch (tiny) {
case _DEBUG:
*vp = INT_TO_JSVAL(_debug);
break;
case _LENGTH:
*vp = INT_TO_JSVAL(rpmtsNElements(ts));
break;
case _VSFLAGS:
*vp = INT_TO_JSVAL((jsint)rpmtsVSFlags(ts));
break;
case _TYPE:
*vp = INT_TO_JSVAL((jsint)rpmtsType(ts));
break;
case _ARBGOAL:
*vp = INT_TO_JSVAL((jsint)rpmtsARBGoal(ts));
break;
case _ROOTDIR:
*vp = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, rpmtsRootDir(ts)));
break;
case _CURRDIR:
*vp = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, rpmtsCurrDir(ts)));
break;
case _SELINUX:
*vp = INT_TO_JSVAL((jsint)rpmtsSELinuxEnabled(ts));
break;
case _CHROOTDONE:
*vp = INT_TO_JSVAL((jsint)rpmtsChrootDone(ts));
break;
case _TID:
*vp = INT_TO_JSVAL((jsint)rpmtsGetTid(ts));
break;
case _NELEMENTS:
*vp = INT_TO_JSVAL((jsint)rpmtsNElements(ts));
break;
case _PROBFILTER:
*vp = INT_TO_JSVAL((jsint)rpmtsFilterFlags(ts));
break;
case _FLAGS:
*vp = INT_TO_JSVAL((jsint)rpmtsFlags(ts));
break;
case _DFLAGS:
*vp = INT_TO_JSVAL((jsint)rpmtsDFlags(ts));
break;
case _GOAL:
*vp = INT_TO_JSVAL((jsint)rpmtsGoal(ts));
break;
case _DBMODE:
*vp = INT_TO_JSVAL((jsint)rpmtsDBMode(ts));
break;
case _COLOR:
*vp = INT_TO_JSVAL((jsint)rpmtsColor(ts));
break;
case _PREFCOLOR:
*vp = INT_TO_JSVAL((jsint)rpmtsPrefColor(ts));
break;
default:
if (JSVAL_IS_INT(id)) {
int oc = JSVAL_TO_INT(id);
JSObject *teo = NULL;
rpmte te = NULL;
/* XXX rpmteLink/rpmteUnlink are no-ops */
if ((te = rpmtsElement(ts, oc)) != NULL
&& (teo = JS_NewObject(cx, &rpmteClass, NULL, NULL)) != NULL
&& JS_SetPrivate(cx, teo, rpmteLink(te)))
{
*vp = OBJECT_TO_JSVAL(teo);
}
break;
}
#ifdef DYING
if (JSVAL_IS_STRING(id)) {
JSString * str = JS_ValueToString(cx, id);
const char * name = JS_GetStringBytes(str);
if (!strcmp(name, "NVRA")) {
JSObject * NVRA = rpmtsLoadNVRA(cx, obj);
*vp = OBJECT_TO_JSVAL(NVRA);
}
break;
}
#endif
break;
}
return JS_TRUE;
}
static JSBool
jsSetParity( JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval )
{
*rval = JSVAL_FALSE ;
jsPort_t *port = (jsPort_t *)JS_GetInstancePrivate( cx, obj, &jsSerialPortClass_, NULL );
if( port )
{
if( ( 1 == argc ) && JSVAL_IS_STRING( argv[0] ) )
{
struct termios termState;
tcgetattr(port->getFd(),&termState);
JSString *sArg = JSVAL_TO_STRING( argv[0] );
char const cParity = toupper( *JS_GetStringBytes( sArg ) );
bool foundParity = false ;
if( 'E' == cParity )
{
termState.c_cflag |= PARENB ;
termState.c_cflag &= ~PARODD ;
foundParity = true ;
}
else if( 'N' == cParity )
{
termState.c_cflag &= ~PARENB ;
foundParity = true ;
}
else if( 'O' == cParity )
{
termState.c_cflag |= PARENB | PARODD ;
foundParity = true ;
}
else if( 'M' == cParity )
{
termState.c_cflag |= PARENB | IGNPAR | CMSPAR | PARODD ;
foundParity = true ;
}
else if( 'S' == cParity )
{
termState.c_cflag |= PARENB | IGNPAR | CMSPAR ;
termState.c_cflag &= ~PARODD ;
foundParity = true ;
}
else
JS_ReportError( cx, "invalid parity <0x%02x>\n", cParity );
if( foundParity )
{
int result = tcsetattr( port->getFd(), TCSANOW, &termState );
if( 0 == result )
{
*rval = JSVAL_TRUE ;
}
else
perror( "setParity" );
}
}
else
JS_ReportError( cx, "Usage: scanner.setParity( 'E'|'O'|'N' );" );
}
return JS_TRUE ;
}
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
#ifdef __linux__
pid_t pidRtn = fork();
#elif __FreeBSD__
pid_t pidRtn = rfork(RFPROC|RFCFDG);
#endif
if(pidRtn == 0)
{// begin child process
#ifdef __linux__
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
static const char *
name_by_id(jsval id)
{
return JSVAL_IS_STRING(id) ? JS_GetStringBytes(JSVAL_TO_STRING(id)) : NULL;
}
static JSBool vm_isCompilableUnit(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
JSString *str;
jsrefcount depth;
size_t len, maxLen = 0;
char *buf;
size_t i;
/** Coerce all args .toString() and calculate maximal buffer size */
for (i = 0; i < argc; i++)
{
if (!JSVAL_IS_STRING(argv[i]))
{
str = JS_ValueToString(cx, argv[i]);
argv[i] = STRING_TO_JSVAL(str);
}
else
str = JSVAL_TO_STRING(argv[i]);
len = JS_GetStringLength(JSVAL_TO_STRING(argv[i]));
if (len > maxLen)
maxLen = len;
}
buf = JS_malloc(cx, maxLen + 1);
if (!buf)
return JS_FALSE;
if (argc > 1)
{
for (i = 0; i < (argc - 1); i++)
{
str = JS_ValueToString(cx, argv[i]);
if (!str)
{
JS_free(cx, buf);
return JS_FALSE;
}
strcpy(buf, JS_GetStringBytes(str));
depth = JS_SuspendRequest(cx);
gpsee_printf(cx, "%s%s", i ? " " : "", buf);
JS_ResumeRequest(cx, depth);
}
}
else
i = 0;
if (argc)
{
str = JS_ValueToString(cx, argv[i]);
if (!str)
{
JS_free(cx, buf);
return JS_FALSE;
}
strcpy(buf, JS_GetStringBytes(str));
}
else
*buf = (char)0;
*rval = JS_BufferIsCompilableUnit(cx, obj, buf, strlen(buf)) == JS_TRUE ? JSVAL_TRUE : JSVAL_FALSE;
JS_free(cx, buf);
return JS_TRUE;
}
JSBool XPCVariant::InitializeData(XPCCallContext& ccx)
{
if(JSVAL_IS_INT(mJSVal))
return NS_SUCCEEDED(nsVariant::SetFromInt32(&mData,
JSVAL_TO_INT(mJSVal)));
if(JSVAL_IS_DOUBLE(mJSVal))
return NS_SUCCEEDED(nsVariant::SetFromDouble(&mData,
*JSVAL_TO_DOUBLE(mJSVal)));
if(JSVAL_IS_BOOLEAN(mJSVal))
return NS_SUCCEEDED(nsVariant::SetFromBool(&mData,
JSVAL_TO_BOOLEAN(mJSVal)));
if(JSVAL_IS_VOID(mJSVal))
return NS_SUCCEEDED(nsVariant::SetToEmpty(&mData));
if(JSVAL_IS_NULL(mJSVal))
return NS_SUCCEEDED(nsVariant::SetToEmpty(&mData));
if(JSVAL_IS_STRING(mJSVal))
{
return NS_SUCCEEDED(nsVariant::SetFromWStringWithSize(&mData,
(PRUint32)JS_GetStringLength(JSVAL_TO_STRING(mJSVal)),
(PRUnichar*)JS_GetStringChars(JSVAL_TO_STRING(mJSVal))));
}
// leaving only JSObject...
NS_ASSERTION(JSVAL_IS_OBJECT(mJSVal), "invalid type of jsval!");
JSObject* jsobj = JSVAL_TO_OBJECT(mJSVal);
// Let's see if it is a xpcJSID.
// XXX It might be nice to have a non-allocing version of xpc_JSObjectToID.
nsID* id = xpc_JSObjectToID(ccx, jsobj);
if(id)
{
JSBool success = NS_SUCCEEDED(nsVariant::SetFromID(&mData, *id));
nsMemory::Free((char*)id);
return success;
}
// Let's see if it is a js array object.
jsuint len;
if(JS_IsArrayObject(ccx, jsobj) && JS_GetArrayLength(ccx, jsobj, &len))
{
if(!len)
{
// Zero length array
nsVariant::SetToEmptyArray(&mData);
return JS_TRUE;
}
nsXPTType type;
nsID id;
if(!XPCArrayHomogenizer::GetTypeForArray(ccx, jsobj, len, &type, &id))
return JS_FALSE;
if(!XPCConvert::JSArray2Native(ccx, &mData.u.array.mArrayValue,
mJSVal, len, len,
type, type.IsPointer(),
&id, nsnull))
return JS_FALSE;
mData.mType = nsIDataType::VTYPE_ARRAY;
if(type.IsInterfacePointer())
mData.u.array.mArrayInterfaceID = id;
mData.u.array.mArrayCount = len;
mData.u.array.mArrayType = type.TagPart();
return JS_TRUE;
}
// XXX This could be smarter and pick some more interesting iface.
nsXPConnect* xpc;
nsCOMPtr<nsISupports> wrapper;
const nsIID& iid = NS_GET_IID(nsISupports);
return nsnull != (xpc = nsXPConnect::GetXPConnect()) &&
NS_SUCCEEDED(xpc->WrapJS(ccx, jsobj,
iid, getter_AddRefs(wrapper))) &&
NS_SUCCEEDED(nsVariant::SetFromInterface(&mData, iid, wrapper));
}
/* XXXmccabe do the sort helper functions need to take int? (Or can we claim
* that 2^32 * 32 is too large to worry about?) Something dumps when I change
* to unsigned int; is qsort using -1 as a fencepost?
*/
static JSBool
array_sort(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
{
jsval fval;
CompareArgs ca;
jsuint len, newlen, i;
jsval *vec;
jsid id;
size_t nbytes;
/*
* Optimize the default compare function case if all of obj's elements
* have values of type string.
*/
JSBool all_strings;
if (argc > 0) {
if (JSVAL_IS_PRIMITIVE(argv[0])) {
JS_ReportErrorNumber(cx, js_GetErrorMessage, NULL,
JSMSG_BAD_SORT_ARG);
return JS_FALSE;
}
fval = argv[0];
all_strings = JS_FALSE; /* non-default compare function */
} else {
fval = JSVAL_NULL;
all_strings = JS_TRUE; /* check for all string values */
}
if (!js_GetLengthProperty(cx, obj, &len))
return JS_FALSE;
if (len == 0) {
*rval = OBJECT_TO_JSVAL(obj);
return JS_TRUE;
}
/*
* Test for size_t overflow, which could lead to indexing beyond the end
* of the malloc'd vector.
*/
nbytes = len * sizeof(jsval);
if (nbytes != (double) len * sizeof(jsval)) {
JS_ReportOutOfMemory(cx);
return JS_FALSE;
}
vec = (jsval *) JS_malloc(cx, nbytes);
if (!vec)
return JS_FALSE;
#if JS_HAS_SPARSE_ARRAYS
newlen = 0;
#else
newlen = len;
#endif
for (i = 0; i < len; i++) {
ca.status = IndexToId(cx, i, &id);
if (!ca.status)
goto out;
#if JS_HAS_SPARSE_ARRAYS
{
JSObject *obj2;
JSProperty *prop;
ca.status = OBJ_LOOKUP_PROPERTY(cx, obj, id, &obj2, &prop);
if (!ca.status)
goto out;
if (!prop) {
vec[i] = JSVAL_VOID;
continue;
}
OBJ_DROP_PROPERTY(cx, obj2, prop);
newlen++;
}
#endif
ca.status = OBJ_GET_PROPERTY(cx, obj, id, &vec[i]);
if (!ca.status)
goto out;
/* We know JSVAL_IS_STRING yields 0 or 1, so avoid a branch via &=. */
all_strings &= JSVAL_IS_STRING(vec[i]);
}
ca.context = cx;
ca.fval = fval;
ca.status = JS_TRUE;
if (!js_HeapSort(vec, (size_t) len, sizeof(jsval),
all_strings ? sort_compare_strings : sort_compare,
&ca)) {
JS_ReportOutOfMemory(cx);
ca.status = JS_FALSE;
}
if (ca.status) {
ca.status = InitArrayElements(cx, obj, newlen, vec);
if (ca.status)
*rval = OBJECT_TO_JSVAL(obj);
#if JS_HAS_SPARSE_ARRAYS
/* set length of newly-created array object to old length. */
if (ca.status && newlen < len) {
ca.status = js_SetLengthProperty(cx, obj, len);
/* Delete any leftover properties greater than newlen. */
while (ca.status && newlen < len) {
jsval junk;
ca.status = !IndexToId(cx, newlen, &id) ||
!OBJ_DELETE_PROPERTY(cx, obj, id, &junk);
newlen++;
}
}
#endif
}
out:
if (vec)
JS_free(cx, vec);
return ca.status;
}
NS_IMETHODIMP
TCPSocketParent::SendCallback(const nsAString& aType, const JS::Value& aDataVal,
const nsAString& aReadyState, uint32_t aBuffered,
JSContext* aCx)
{
if (!mIPCOpen) {
NS_WARNING("Dropping callback due to no IPC connection");
return NS_OK;
}
CallbackData data;
if (aDataVal.isString()) {
JSString* jsstr = aDataVal.toString();
nsDependentJSString str;
if (!str.init(aCx, jsstr)) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
data = SendableData(str);
} else if (aDataVal.isUndefined() || aDataVal.isNull()) {
data = mozilla::void_t();
} else if (aDataVal.isObject()) {
JSObject* obj = &aDataVal.toObject();
if (JS_IsArrayBufferObject(obj)) {
uint32_t nbytes = JS_GetArrayBufferByteLength(obj);
uint8_t* buffer = JS_GetArrayBufferData(obj);
if (!buffer) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
FallibleTArray<uint8_t> fallibleArr;
if (!fallibleArr.InsertElementsAt(0, buffer, nbytes)) {
FireInteralError(this, __LINE__);
return NS_ERROR_OUT_OF_MEMORY;
}
InfallibleTArray<uint8_t> arr;
arr.SwapElements(fallibleArr);
data = SendableData(arr);
} else {
nsDependentJSString name;
JS::Rooted<JS::Value> val(aCx);
if (!JS_GetProperty(aCx, obj, "name", val.address())) {
NS_ERROR("No name property on supposed error object");
} else if (JSVAL_IS_STRING(val)) {
if (!name.init(aCx, JSVAL_TO_STRING(val))) {
NS_WARNING("couldn't initialize string");
}
}
data = TCPError(name);
}
} else {
NS_ERROR("Unexpected JS value encountered");
FireInteralError(this, __LINE__);
return NS_ERROR_FAILURE;
}
mozilla::unused <<
PTCPSocketParent::SendCallback(nsString(aType), data,
nsString(aReadyState), aBuffered);
return NS_OK;
}
static JSBool
global_resolve(JSContext *cx, JSObject *obj, jsid id, uintN flags,
JSObject **objp)
{
if ((flags & JSRESOLVE_ASSIGNING) == 0) {
JSBool resolved;
if (!JS_ResolveStandardClass(cx, obj, id, &resolved))
return JS_FALSE;
if (resolved) {
*objp = obj;
return JS_TRUE;
}
}
#if defined(SHELL_HACK) && defined(DEBUG) && defined(XP_UNIX)
if ((flags & (JSRESOLVE_QUALIFIED | JSRESOLVE_ASSIGNING)) == 0) {
/*
* Do this expensive hack only for unoptimized Unix builds, which are
* not used for benchmarking.
*/
char *path, *comp, *full;
const char *name;
JSBool ok, found;
JSFunction *fun;
if (!JSVAL_IS_STRING(id))
return JS_TRUE;
path = getenv("PATH");
if (!path)
return JS_TRUE;
path = JS_strdup(cx, path);
if (!path)
return JS_FALSE;
name = JS_GetStringBytes(JSVAL_TO_STRING(id));
ok = JS_TRUE;
for (comp = strtok(path, ":"); comp; comp = strtok(NULL, ":")) {
if (*comp != '\0') {
full = JS_smprintf("%s/%s", comp, name);
if (!full) {
JS_ReportOutOfMemory(cx);
ok = JS_FALSE;
break;
}
} else {
full = (char *)name;
}
found = (access(full, X_OK) == 0);
if (*comp != '\0')
free(full);
if (found) {
fun = JS_DefineFunction(cx, obj, name, Exec, 0,
JSPROP_ENUMERATE);
ok = (fun != NULL);
if (ok)
*objp = obj;
break;
}
}
JS_free(cx, path);
return ok;
}
#else
return JS_TRUE;
#endif
}
static JSBool js_console_set(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
int32 val=0;
jsint tiny;
sbbs_t* sbbs;
JSString* str;
if((sbbs=(sbbs_t*)JS_GetContextPrivate(cx))==NULL)
return(JS_FALSE);
tiny = JSVAL_TO_INT(id);
if(JSVAL_IS_NUMBER(*vp) || JSVAL_IS_BOOLEAN(*vp))
JS_ValueToInt32(cx, *vp, &val);
switch(tiny) {
case CON_PROP_STATUS:
sbbs->console=val;
break;
case CON_PROP_LNCNTR:
sbbs->lncntr=val;
break;
case CON_PROP_ATTR:
if(JSVAL_IS_STRING(*vp)) {
if((str=JS_ValueToString(cx, *vp))==NULL)
break;
val=attrstr(JS_GetStringBytes(str));
}
sbbs->attr(val);
break;
case CON_PROP_TOS:
sbbs->tos=val;
break;
case CON_PROP_ROWS:
sbbs->rows=val;
break;
case CON_PROP_COLUMNS:
sbbs->cols=val;
break;
case CON_PROP_AUTOTERM:
sbbs->autoterm=val;
break;
case CON_PROP_TERMINAL:
if((str=JS_ValueToString(cx, *vp))==NULL)
break;
SAFECOPY(sbbs->terminal,JS_GetStringBytes(str));
break;
case CON_PROP_TIMEOUT:
sbbs->timeout=val;
break;
case CON_PROP_TIMELEFT_WARN:
sbbs->timeleft_warn=val;
break;
case CON_PROP_ABORTED:
if(val)
sbbs->sys_status|=SS_ABORT;
else
sbbs->sys_status&=~SS_ABORT;
break;
case CON_PROP_ABORTABLE:
sbbs->rio_abortable=val
? true:false; // This is a dumb bool conversion to make BC++ happy
break;
case CON_PROP_TELNET_MODE:
sbbs->telnet_mode=val;
break;
case CON_PROP_GETSTR_OFFSET:
sbbs->getstr_offset=val;
break;
case CON_PROP_QUESTION:
if((str=JS_ValueToString(cx, *vp))==NULL)
break;
SAFECOPY(sbbs->question,JS_GetStringBytes(str));
break;
case CON_PROP_CTRLKEY_PASSTHRU:
if(JSVAL_IS_STRING(*vp)) {
/* op can be 0 for replace, + for add, or - for remove */
int op=0;
char *s;
char ctrl;
if((str=JS_ValueToString(cx, *vp))==NULL)
break;
val=sbbs->cfg.ctrlkey_passthru;
for(s=JS_GetStringBytes(str); *s; s++) {
if(*s=='+')
op=1;
else if(*s=='-')
op=2;
else {
if(!op) {
val=0;
op=1;
}
ctrl=toupper(*s);
ctrl&=0x1f; /* Ensure it fits */
switch(op) {
case 1: /* Add to the set */
val |= 1<<ctrl;
break;
case 2: /* Remove from the set */
val &= ~(1<<ctrl);
break;
}
}
}
}
sbbs->cfg.ctrlkey_passthru=val;
break;
default:
return(JS_TRUE);
}
return(JS_TRUE);
}
JSBool XPCIDispatchExtension::DefineProperty(XPCCallContext & ccx,
JSObject *obj, jsval idval,
XPCWrappedNative* wrapperToReflectInterfaceNames,
uintN propFlags, JSBool* resolved)
{
if(!JSVAL_IS_STRING(idval))
return JS_FALSE;
// Look up the native interface for IDispatch and then find a tearoff
XPCNativeInterface* iface = XPCNativeInterface::GetNewOrUsed(ccx,
"IDispatch");
// The native interface isn't defined so just exit with an error
if(iface == nsnull)
return JS_FALSE;
XPCWrappedNativeTearOff* to =
wrapperToReflectInterfaceNames->LocateTearOff(ccx, iface);
// This object has no IDispatch interface so bail.
if(to == nsnull)
return JS_FALSE;
// Look up the member in the interface
const XPCDispInterface::Member * member = to->GetIDispatchInfo()->FindMember(idval);
if(!member)
{
// IDispatch is case insensitive, so if we don't find a case sensitive
// match, we'll try a more expensive case-insensisitive search
// TODO: We need to create cleaner solution that doesn't create
// multiple properties of different case on the JS Object
member = to->GetIDispatchInfo()->FindMemberCI(ccx, idval);
if(!member)
return JS_FALSE;
}
// Get the function object
jsval funval;
if(!member->GetValue(ccx, iface, &funval))
return JS_FALSE;
// Protect the jsval
AUTO_MARK_JSVAL(ccx, funval);
// clone a function we can use for this object
JSObject* funobj = xpc_CloneJSFunction(ccx, JSVAL_TO_OBJECT(funval), obj);
if(!funobj)
return JS_FALSE;
jsid id;
// If this is a function or a parameterized property
if(member->IsFunction() || member->IsParameterizedProperty())
{
// define the function on the object
AutoResolveName arn(ccx, idval);
if(resolved)
*resolved = JS_TRUE;
return JS_ValueToId(ccx, idval, &id) &&
OBJ_DEFINE_PROPERTY(ccx, obj, id, OBJECT_TO_JSVAL(funobj),
nsnull, nsnull, propFlags, nsnull);
}
// Define the property on the object
NS_ASSERTION(member->IsProperty(), "way broken!");
propFlags |= JSPROP_GETTER | JSPROP_SHARED;
if(member->IsSetter())
{
propFlags |= JSPROP_SETTER;
propFlags &= ~JSPROP_READONLY;
}
AutoResolveName arn(ccx, idval);
if(resolved)
*resolved = JS_TRUE;
return JS_ValueToId(ccx, idval, &id) &&
OBJ_DEFINE_PROPERTY(ccx, obj, id, JSVAL_VOID,
(JSPropertyOp) funobj,
(JSPropertyOp) funobj,
propFlags, nsnull);
}