The Tor Browser: js/src/ctypes/Library.cpp@6474c204b198 (annotated)

js/src/ctypes/Library.cpp@6474c204b198 (annotated)

js/src/ctypes/Library.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  * vim: set ts=2 sw=2 et tw=99:
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "ctypes/Library.h"
 #include "prlink.h"
 #include "ctypes/CTypes.h"
 namespace js {
 namespace ctypes {
 /*******************************************************************************
 ** JSAPI function prototypes
 *******************************************************************************/
 namespace Library
 {
   static void Finalize(JSFreeOp *fop, JSObject* obj);
   static bool Close(JSContext* cx, unsigned argc, jsval* vp);
   static bool Declare(JSContext* cx, unsigned argc, jsval* vp);
 }
 /*******************************************************************************
 ** JSObject implementation
 *******************************************************************************/
 typedef Rooted<JSFlatString*>    RootedFlatString;
 static const JSClass sLibraryClass = {
   "Library",
   JSCLASS_HAS_RESERVED_SLOTS(LIBRARY_SLOTS),
   JS_PropertyStub, JS_DeletePropertyStub, JS_PropertyStub, JS_StrictPropertyStub,
   JS_EnumerateStub,JS_ResolveStub, JS_ConvertStub, Library::Finalize
 };
 #define CTYPESFN_FLAGS \
   (JSPROP_ENUMERATE | JSPROP_READONLY | JSPROP_PERMANENT)
 static const JSFunctionSpec sLibraryFunctions[] = {
   JS_FN("close",   Library::Close,   0, CTYPESFN_FLAGS),
   JS_FN("declare", Library::Declare, 0, CTYPESFN_FLAGS),
   JS_FS_END
 };
 bool
 Library::Name(JSContext* cx, unsigned argc, jsval *vp)
 {
   CallArgs args = CallArgsFromVp(argc, vp);
   if (args.length() != 1) {
     JS_ReportError(cx, "libraryName takes one argument");
     return false;
   }
   Value arg = args[0];
   JSString* str = nullptr;
   if (JSVAL_IS_STRING(arg)) {
     str = JSVAL_TO_STRING(arg);
   }
   else {
     JS_ReportError(cx, "name argument must be a string");
     return false;
   }
   AutoString resultString;
   AppendString(resultString, DLL_PREFIX);
   AppendString(resultString, str);
   AppendString(resultString, DLL_SUFFIX);
   JSString *result = JS_NewUCStringCopyN(cx, resultString.begin(),
                                          resultString.length());
   if (!result)
     return false;
   args.rval().setString(result);
   return true;
 }
 JSObject*
 Library::Create(JSContext* cx, jsval path_, JSCTypesCallbacks* callbacks)
 {
   RootedValue path(cx, path_);
   RootedObject libraryObj(cx,
                           JS_NewObject(cx, &sLibraryClass, NullPtr(), NullPtr()));
   if (!libraryObj)
     return nullptr;
   // initialize the library
   JS_SetReservedSlot(libraryObj, SLOT_LIBRARY, PRIVATE_TO_JSVAL(nullptr));
   // attach API functions
   if (!JS_DefineFunctions(cx, libraryObj, sLibraryFunctions))
     return nullptr;
   if (!JSVAL_IS_STRING(path)) {
     JS_ReportError(cx, "open takes a string argument");
     return nullptr;
   }
   PRLibSpec libSpec;
   RootedFlatString pathStr(cx, JS_FlattenString(cx, JSVAL_TO_STRING(path)));
   if (!pathStr)
     return nullptr;
 #ifdef XP_WIN
   // On Windows, converting to native charset may corrupt path string.
   // So, we have to use Unicode path directly.
   char16ptr_t pathChars = JS_GetFlatStringChars(pathStr);
   if (!pathChars)
     return nullptr;
   libSpec.value.pathname_u = pathChars;
   libSpec.type = PR_LibSpec_PathnameU;
 #else
   // Convert to platform native charset if the appropriate callback has been
   // provided.
   char* pathBytes;
   if (callbacks && callbacks->unicodeToNative) {
     pathBytes =
       callbacks->unicodeToNative(cx, pathStr->chars(), pathStr->length());
     if (!pathBytes)
       return nullptr;
   } else {
     // Fallback: assume the platform native charset is UTF-8. This is true
     // for Mac OS X, Android, and probably Linux.
     size_t nbytes =
       GetDeflatedUTF8StringLength(cx, pathStr->chars(), pathStr->length());
     if (nbytes == (size_t) -1)
       return nullptr;
     pathBytes = static_cast<char*>(JS_malloc(cx, nbytes + 1));
     if (!pathBytes)
       return nullptr;
     ASSERT_OK(DeflateStringToUTF8Buffer(cx, pathStr->chars(),
                 pathStr->length(), pathBytes, &nbytes));
     pathBytes[nbytes] = 0;
   }
   libSpec.value.pathname = pathBytes;
   libSpec.type = PR_LibSpec_Pathname;
 #endif
   PRLibrary* library = PR_LoadLibraryWithFlags(libSpec, 0);
   if (!library) {
 #ifdef XP_WIN
     JS_ReportError(cx, "couldn't open library %hs", pathChars);
 #else
     JS_ReportError(cx, "couldn't open library %s", pathBytes);
     JS_free(cx, pathBytes);
 #endif
     return nullptr;
   }
 #ifndef XP_WIN
   JS_free(cx, pathBytes);
 #endif
   // stash the library
   JS_SetReservedSlot(libraryObj, SLOT_LIBRARY, PRIVATE_TO_JSVAL(library));
   return libraryObj;
 }
 bool
 Library::IsLibrary(JSObject* obj)
 {
   return JS_GetClass(obj) == &sLibraryClass;
 }
 PRLibrary*
 Library::GetLibrary(JSObject* obj)
 {
   JS_ASSERT(IsLibrary(obj));
   jsval slot = JS_GetReservedSlot(obj, SLOT_LIBRARY);
   return static_cast<PRLibrary*>(JSVAL_TO_PRIVATE(slot));
 }
 static void
 UnloadLibrary(JSObject* obj)
 {
   PRLibrary* library = Library::GetLibrary(obj);
   if (library)
     PR_UnloadLibrary(library);
 }
 void
 Library::Finalize(JSFreeOp *fop, JSObject* obj)
 {
   UnloadLibrary(obj);
 }
 bool
 Library::Open(JSContext* cx, unsigned argc, jsval *vp)
 {
   CallArgs args = CallArgsFromVp(argc, vp);
   JSObject* ctypesObj = JS_THIS_OBJECT(cx, vp);
   if (!ctypesObj)
     return false;
   if (!IsCTypesGlobal(ctypesObj)) {
     JS_ReportError(cx, "not a ctypes object");
     return false;
   }
   if (args.length() != 1 || args[0].isUndefined()) {
     JS_ReportError(cx, "open requires a single argument");
     return false;
   }
   JSObject* library = Create(cx, args[0], GetCallbacks(ctypesObj));
   if (!library)
     return false;
   args.rval().setObject(*library);
   return true;
 }
 bool
 Library::Close(JSContext* cx, unsigned argc, jsval* vp)
 {
   CallArgs args = CallArgsFromVp(argc, vp);
   JSObject* obj = JS_THIS_OBJECT(cx, vp);
   if (!obj)
     return false;
   if (!IsLibrary(obj)) {
     JS_ReportError(cx, "not a library");
     return false;
   }
   if (args.length() != 0) {
     JS_ReportError(cx, "close doesn't take any arguments");
     return false;
   }
   // delete our internal objects
   UnloadLibrary(obj);
   JS_SetReservedSlot(obj, SLOT_LIBRARY, PRIVATE_TO_JSVAL(nullptr));
   args.rval().setUndefined();
   return true;
 }
 bool
 Library::Declare(JSContext* cx, unsigned argc, jsval* vp)
 {
   CallArgs args = CallArgsFromVp(argc, vp);
   RootedObject obj(cx, JS_THIS_OBJECT(cx, vp));
   if (!obj)
     return false;
   if (!IsLibrary(obj)) {
     JS_ReportError(cx, "not a library");
     return false;
   }
   PRLibrary* library = GetLibrary(obj);
   if (!library) {
     JS_ReportError(cx, "library not open");
     return false;
   }
   // We allow two API variants:
   // 1) library.declare(name, abi, returnType, argType1, ...)
   //    declares a function with the given properties, and resolves the symbol
   //    address in the library.
   // 2) library.declare(name, type)
   //    declares a symbol of 'type', and resolves it. The object that comes
   //    back will be of type 'type', and will point into the symbol data.
   //    This data will be both readable and writable via the usual CData
   //    accessors. If 'type' is a PointerType to a FunctionType, the result will
   //    be a function pointer, as with 1).
   if (args.length() < 2) {
     JS_ReportError(cx, "declare requires at least two arguments");
     return false;
   }
   if (!args[0].isString()) {
     JS_ReportError(cx, "first argument must be a string");
     return false;
   }
   RootedObject fnObj(cx, nullptr);
   RootedObject typeObj(cx);
   bool isFunction = args.length() > 2;
   if (isFunction) {
     // Case 1).
     // Create a FunctionType representing the function.
     fnObj = FunctionType::CreateInternal(cx,
               args[1], args[2], &args.array()[3], args.length() - 3);
     if (!fnObj)
       return false;
     // Make a function pointer type.
     typeObj = PointerType::CreateInternal(cx, fnObj);
     if (!typeObj)
       return false;
   } else {
     // Case 2).
     if (args[1].isPrimitive() ||
         !CType::IsCType(args[1].toObjectOrNull()) ||
         !CType::IsSizeDefined(args[1].toObjectOrNull())) {
       JS_ReportError(cx, "second argument must be a type of defined size");
       return false;
     }
     typeObj = args[1].toObjectOrNull();
     if (CType::GetTypeCode(typeObj) == TYPE_pointer) {
       fnObj = PointerType::GetBaseType(typeObj);
       isFunction = fnObj && CType::GetTypeCode(fnObj) == TYPE_function;
     }
   }
   void* data;
   PRFuncPtr fnptr;
   JSString* nameStr = args[0].toString();
   AutoCString symbol;
   if (isFunction) {
     // Build the symbol, with mangling if necessary.
     FunctionType::BuildSymbolName(nameStr, fnObj, symbol);
     AppendString(symbol, "\0");
     // Look up the function symbol.
     fnptr = PR_FindFunctionSymbol(library, symbol.begin());
     if (!fnptr) {
       JS_ReportError(cx, "couldn't find function symbol in library");
       return false;
     }
     data = &fnptr;
   } else {
     // 'typeObj' is another data type. Look up the data symbol.
     AppendString(symbol, nameStr);
     AppendString(symbol, "\0");
     data = PR_FindSymbol(library, symbol.begin());
     if (!data) {
       JS_ReportError(cx, "couldn't find symbol in library");
       return false;
     }
   }
   RootedObject result(cx, CData::Create(cx, typeObj, obj, data, isFunction));
   if (!result)
     return false;
   args.rval().setObject(*result);
   // Seal the CData object, to prevent modification of the function pointer.
   // This permanently associates this object with the library, and avoids
   // having to do things like reset SLOT_REFERENT when someone tries to
   // change the pointer value.
   // XXX This will need to change when bug 541212 is fixed -- CData::ValueSetter
   // could be called on a sealed object.
   if (isFunction && !JS_FreezeObject(cx, result))
     return false;
   return true;
 }
 }
 }

The Tor Browser / annotate

js/src/ctypes/Library.cpp@6474c204b198 (annotated)

js/src/ctypes/Library.cpp