Changeset 25124

Timestamp:

04/24/08 04:56:03 (3 weeks ago)

Author:

axeld

Message:

* Large cleanup. Removed inconsistent usage of errno in instantiate_object();
  instead, it will now use the image_id parameter to store errors in.
* find_instantiation_func() and validate_instantiation() will no longer
  overwrite errno with B_OK.
* Made private functions static, and moved them to the top.
* If the class name starts with '_', it will now try to add a BPrivate namespace
  in case it could not find the class. This should help with the compatibility
  issues Shinta reported (also part of ticket #2086).

Files:

• haiku/trunk/src/kits/support/Archivable.cpp (modified) (5 diffs)

haiku/trunk/src/kits/support/Archivable.cpp

@@ -1 +1 @@
-/*
-7
+8
- * Distributed under the terms of the MIT License.
- *
@@ -41 +41 @@
-//      full-featured (e.g., taking NS::ClassName::Function(Param p) instead
-//      of just NS::ClassName)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-GetNumber(const char*& name)
-{
@@ -344 +55 @@
-
-
-
-Demangl
+static 
+demangle_class_nam
-{
-// TODO: add support for template classes
@@ -389 +100 @@
-
-
-
-Mangl
+static 
+mangle_class_nam
-{
-// TODO: add support for template classes
@@ -431 +142 @@
-
-
+static void
+build_function_name(const BString& className, BString& funcName)
+{
+        funcName = "";
+
+        //      This is what we're after:
+        //              Instantiate__Q28OpenBeOS11BArchivableP8BMessage
+        mangle_class_name(className.String(), funcName);
+#if __GNUC__ >= 4
+        funcName.Prepend("_ZN");
+        funcName.Append("11InstantiateE");
+#else
+        funcName.Prepend("Instantiate__");
+#endif
+        funcName.Append("P8BMessage");
+}
+
+
+static bool
+add_private_namespace(BString& name)
+{
+        if (name.Compare("_", 1) != 0)
+                return false;
+
+        name.Prepend("BPrivate::");
+        return true;
+}
+
+
+static instantiation_func
+find_function_in_image(BString& funcName, image_id id, status_t& err)
+{
+        instantiation_func instantiationFunc = NULL;
+        err = get_image_symbol(id, funcName.String(), B_SYMBOL_TYPE_TEXT,
+                (void**)&instantiationFunc);
+        if (err != B_OK)
+                return NULL;
+
+        return instantiationFunc;
+}
+
+
+static status_t
+check_signature(const char* signature, image_info& info)
+{
+        if (signature == NULL) {
+                // If it wasn't specified, anything "matches"
+                return B_OK;
+        }
+
+        // Get image signature
+        BFile file(info.name, B_READ_ONLY);
+        status_t err = file.InitCheck();
+        if (err != B_OK)
+                return err;
+
+        char imageSignature[B_MIME_TYPE_LENGTH];
+        BAppFileInfo appFileInfo(&file);
+        err = appFileInfo.GetSignature(imageSignature);
+        if (err != B_OK) {
+                syslog(LOG_ERR, "instantiate_object - couldn't get mime sig for %s",
+                        info.name);
+                return err;
+        }
+
+        if (strcmp(signature, imageSignature))
+                return B_MISMATCHED_VALUES;
+
+        return B_OK;
+}
+
+
+//      #pragma mark -
+
+
+BArchivable::BArchivable()
+{
+}
+
+
+BArchivable::BArchivable(BMessage* from)
+{
+}
+
+
+BArchivable::~BArchivable()
+{
+}
+
+
+status_t
+BArchivable::Archive(BMessage* into, bool deep) const
+{
+        if (!into) {
+                // TODO: logging/other error reporting?
+                return B_BAD_VALUE;
+        }
+
+        BString name;
+        demangle_class_name(typeid(*this).name(), name);
+
+        return into->AddString(B_CLASS_FIELD, name);
+}
+
+
+BArchivable*
+BArchivable::Instantiate(BMessage* from)
+{
+        debugger("Can't create a plain BArchivable object");
+        return NULL;
+}
+
+
+status_t
+BArchivable::Perform(perform_code d, void* arg)
+{
+        // TODO: Check against original
+        return B_ERROR;
+}
+
+
+void BArchivable::_ReservedArchivable1() {}
+void BArchivable::_ReservedArchivable2() {}
+void BArchivable::_ReservedArchivable3() {}
+
+
+// #pragma mark -
+
+
+BArchivable*
+instantiate_object(BMessage* archive, image_id* _id)
+{
+        status_t statusBuffer;
+        status_t* status = &statusBuffer;
+        if (_id != NULL)
+                status = _id;
+
+        // Check our params
+        if (archive == NULL) {
+                syslog(LOG_ERR, "instantiate_object failed: NULL BMessage argument");
+                *status = B_BAD_VALUE;
+                return NULL;
+        }
+
+        // Get class name from archive
+        const char* className = NULL;
+        status_t err = archive->FindString(B_CLASS_FIELD, &className);
+        if (err) {
+                syslog(LOG_ERR, "instantiate_object failed: Failed to find an entry "
+                        "defining the class name (%s).", strerror(err));
+                *status = B_BAD_VALUE;
+                return NULL;
+        }
+
+        // Get sig from archive
+        const char* signature = NULL;
+        bool hasSignature = archive->FindString(B_ADD_ON_FIELD, &signature) == B_OK;
+
+        instantiation_func instantiationFunc = find_instantiation_func(className,
+                signature);
+
+        // if find_instantiation_func() can't locate Class::Instantiate()
+        // and a signature was specified
+        if (!instantiationFunc && hasSignature) {
+                // use BRoster::FindApp() to locate an app or add-on with the symbol
+                BRoster Roster;
+                entry_ref ref;
+                err = Roster.FindApp(signature, &ref);
+
+                // if an entry_ref is obtained
+                BEntry entry;
+                if (err == B_OK)
+                        err = entry.SetTo(&ref);
+
+                BPath path;
+                if (err == B_OK)
+                        err = entry.GetPath(&path);
+
+                if (err != B_OK) {
+                        syslog(LOG_ERR, "instantiate_object failed: Error finding app "
+                                "with signature \"%s\" (%s)", signature, strerror(err));
+                        *status = err;
+                        return NULL;
+                }
+
+                // load the app/add-on
+                image_id addOn = load_add_on(path.Path());
+                if (addOn < B_OK) {
+                        syslog(LOG_ERR, "instantiate_object failed: Could not load "
+                                "add-on %s: %s.", path.Path(), strerror(addOn));
+                        *status = addOn;
+                        return NULL;
+                }
+
+                // Save the image_id
+                if (_id != NULL)
+                        *_id = addOn;
+
+                BString name = className;
+                for (int32 pass = 0; pass < 2; pass++) {
+                        BString funcName;
+                        build_function_name(name, funcName);
+
+                        instantiationFunc = find_function_in_image(funcName, addOn, err);
+                        if (instantiationFunc != NULL)
+                                break;
+
+                        // Check if we have a private class, and add the BPrivate namespace
+                        // (for backwards compatibility)
+                        if (!add_private_namespace(name))
+                                break;
+                }
+
+                if (instantiationFunc == NULL) {
+                        syslog(LOG_ERR, "instantiate_object failed: Failed to find exported "
+                                "Instantiate static function for class %s.", className);
+                        *status = B_NAME_NOT_FOUND;
+                        return NULL;
+                }
+        } else if (instantiationFunc == NULL) {
+                syslog(LOG_ERR, "instantiate_object failed: No signature specified "
+                        "in archive, looking for class \"%s\".", className);
+                *status = B_NAME_NOT_FOUND;
+                return NULL;
+        }
+
+        // if Class::Instantiate(BMessage*) was found
+        if (instantiationFunc != NULL) {
+                // use to create and return an object instance
+                return instantiationFunc(archive);
+        }
+
+        return NULL;
+}
+
+
+BArchivable*
+instantiate_object(BMessage* from)
+{
+        return instantiate_object(from, NULL);
+}
+
+
+bool
+validate_instantiation(BMessage* from, const char* className)
+{
+        // Make sure our params are kosher -- original skimped here =P
+        if (!from) {
+                errno = B_BAD_VALUE;
+                return false;
+        }
+
+        const char* data;
+        for (int32 index = 0; from->FindString(B_CLASS_FIELD, index, &data) == B_OK;
+                        ++index) {
+                if (!strcmp(data, className))
+                        return true;
+        }
+
+        errno = B_MISMATCHED_VALUES;
+        syslog(LOG_ERR, "validate_instantiation failed on class %s.", className);
+
+        return false;
+}
+
+
-instantiation_func
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+