/*
 * Copyright 2004-2013 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Axel Dörfler, axeld@pinc-software.de
 *              Jérôme Duval
 *              Marcus Overhagen
 *              John Scipione, jscipione@gmail.com
 */


//! Manager for input_server add-ons (devices, filters, methods)


#include "AddOnManager.h"

#include <stdio.h>
#include <string.h>
#include <syslog.h>

#include <Autolock.h>
#include <Deskbar.h>
#include <Directory.h>
#include <Entry.h>
#include <image.h>
#include <Path.h>
#include <Roster.h>
#include <String.h>

#include <PathMonitor.h>

#include "InputServer.h"
#include "InputServerTypes.h"
#include "MethodReplicant.h"


#undef TRACE
//#define TRACE_ADD_ON_MONITOR
#ifdef TRACE_ADD_ON_MONITOR
#       define TRACE(x...) debug_printf(x)
#       define ERROR(x...) debug_printf(x)
#else
#       define TRACE(x...) ;
// TODO: probably better to the syslog
#       define ERROR(x...) debug_printf(x)
#endif



class AddOnManager::MonitorHandler : public AddOnMonitorHandler {
public:
        MonitorHandler(AddOnManager* manager)
        {
                fManager = manager;
        }

        virtual void AddOnEnabled(const add_on_entry_info* entryInfo)
        {
                CALLED();
                entry_ref ref;
                make_entry_ref(entryInfo->dir_nref.device, entryInfo->dir_nref.node,
                        entryInfo->name, &ref);
                BEntry entry(&ref, false);

                fManager->_RegisterAddOn(entry);
        }

        virtual void AddOnDisabled(const add_on_entry_info* entryInfo)
        {
                CALLED();
                entry_ref ref;
                make_entry_ref(entryInfo->dir_nref.device, entryInfo->dir_nref.node,
                        entryInfo->name, &ref);
                BEntry entry(&ref, false);

                fManager->_UnregisterAddOn(entry);
        }

private:
        AddOnManager* fManager;
};


//      #pragma mark -


template<class T> T*
instantiate_add_on(image_id image, const char* path, const char* type)
{
        T* (*instantiateFunction)();

        BString functionName = "instantiate_input_";
        functionName += type;

        if (get_image_symbol(image, functionName.String(), B_SYMBOL_TYPE_TEXT,
                        (void**)&instantiateFunction) < B_OK) {
                ERROR("AddOnManager::_RegisterAddOn(): can't find %s() in \"%s\"\n",
                        functionName.String(), path);
                return NULL;
        }

        T* addOn = (*instantiateFunction)();
        if (addOn == NULL) {
                ERROR("AddOnManager::_RegisterAddOn(): %s() in \"%s\" returned "
                        "NULL\n", functionName.String(), path);
                return NULL;
        }

        status_t status = addOn->InitCheck();
        if (status != B_OK) {
                ERROR("AddOnManager::_RegisterAddOn(): InitCheck() in \"%s\" "
                        "returned %s\n", path, strerror(status));
                delete addOn;
                return NULL;
        }

        return addOn;
}


//      #pragma mark - AddOnManager


AddOnManager::AddOnManager()
        :
        AddOnMonitor(),
        fHandler(new(std::nothrow) MonitorHandler(this))
{
        openlog("input_server", LOG_PERROR, LOG_USER);
        SetHandler(fHandler);
}


AddOnManager::~AddOnManager()
{
        delete fHandler;
}


void
AddOnManager::MessageReceived(BMessage* message)
{
        CALLED();

        BMessage reply;
        status_t status;

        TRACE("%s what: %.4s\n", __PRETTY_FUNCTION__, (char*)&message->what);

        switch (message->what) {
                case IS_FIND_DEVICES:
                        status = _HandleFindDevices(message, &reply);
                        break;
                case IS_WATCH_DEVICES:
                        status = _HandleWatchDevices(message, &reply);
                        break;
                case IS_NOTIFY_DEVICE:
                        status = _HandleNotifyDevice(message, &reply);
                        break;
                case IS_IS_DEVICE_RUNNING:
                        status = _HandleIsDeviceRunning(message, &reply);
                        break;
                case IS_START_DEVICE:
                        status = _HandleStartStopDevices(message, &reply);
                        break;
                case IS_STOP_DEVICE:
                        status = _HandleStartStopDevices(message, &reply);
                        break;
                case IS_CONTROL_DEVICES:
                        status = _HandleControlDevices(message, &reply);
                        break;
                case SYSTEM_SHUTTING_DOWN:
                        status = _HandleSystemShuttingDown(message, &reply);
                        break;
                case IS_METHOD_REGISTER:
                        status = _HandleMethodReplicant(message, &reply);
                        break;

                case B_PATH_MONITOR:
                        _HandleDeviceMonitor(message);
                        return;

                default:
                        AddOnMonitor::MessageReceived(message);
                        return;
        }

        reply.AddInt32("status", status);
        message->SendReply(&reply);
}


void
AddOnManager::LoadState()
{
        _RegisterAddOns();
}


void
AddOnManager::SaveState()
{
        CALLED();
        _UnregisterAddOns();
}


status_t
AddOnManager::StartMonitoringDevice(DeviceAddOn* addOn, const char* device)
{
        CALLED();

        BString path;
        if (device[0] != '/')
                path = "/dev/";
        path += device;

        TRACE("AddOnMonitor::StartMonitoringDevice(%s)\n", path.String());

        bool newPath;
        status_t status = _AddDevicePath(addOn, path.String(), newPath);
        if (status == B_OK && newPath) {
                status = BPathMonitor::StartWatching(path.String(),
                        B_WATCH_FILES_ONLY | B_WATCH_RECURSIVELY, this);
                if (status != B_OK) {
                        bool lastPath;
                        _RemoveDevicePath(addOn, path.String(), lastPath);
                }
        }

        return status;
}


status_t
AddOnManager::StopMonitoringDevice(DeviceAddOn* addOn, const char *device)
{
        CALLED();

        BString path;
        if (device[0] != '/')
                path = "/dev/";
        path += device;

        TRACE("AddOnMonitor::StopMonitoringDevice(%s)\n", path.String());

        bool lastPath;
        status_t status = _RemoveDevicePath(addOn, path.String(), lastPath);
        if (status == B_OK && lastPath)
                BPathMonitor::StopWatching(path.String(), this);

        return status;
}


// #pragma mark -


void
AddOnManager::_RegisterAddOns()
{
        CALLED();
        BAutolock locker(this);

        fHandler->AddAddOnDirectories("input_server/devices");
        fHandler->AddAddOnDirectories("input_server/filters");
        fHandler->AddAddOnDirectories("input_server/methods");
}


void
AddOnManager::_UnregisterAddOns()
{
        BAutolock locker(this);

        // We have to stop manually the add-ons because the monitor doesn't
        // disable them on exit

        while (device_info* info = fDeviceList.RemoveItemAt(0)) {
                gInputServer->StartStopDevices(*info->add_on, false);
                delete info;
        }

        // TODO: what about the filters/methods lists in the input_server?

        while (filter_info* info = fFilterList.RemoveItemAt(0)) {
                delete info;
        }

        while (method_info* info = fMethodList.RemoveItemAt(0)) {
                delete info;
        }
}


bool
AddOnManager::_IsDevice(const char* path) const
{
        return strstr(path, "input_server/devices") != 0;
}


bool
AddOnManager::_IsFilter(const char* path) const
{
        return strstr(path, "input_server/filters") != 0;
}


bool
AddOnManager::_IsMethod(const char* path) const
{
        return strstr(path, "input_server/methods") != 0;
}


status_t
AddOnManager::_RegisterAddOn(BEntry& entry)
{
        BPath path(&entry);

        entry_ref ref;
        status_t status = entry.GetRef(&ref);
        if (status < B_OK)
                return status;

        TRACE("AddOnManager::RegisterAddOn(): trying to load \"%s\"\n",
                path.Path());

        image_id image = load_add_on(path.Path());
        if (image < B_OK) {
                ERROR("load addon %s failed\n", path.Path());
                return image;
        }

        status = B_ERROR;

        if (_IsDevice(path.Path())) {
                BInputServerDevice* device = instantiate_add_on<BInputServerDevice>(
                        image, path.Path(), "device");
                if (device != NULL)
                        status = _RegisterDevice(device, ref, image);
        } else if (_IsFilter(path.Path())) {
                BInputServerFilter* filter = instantiate_add_on<BInputServerFilter>(
                        image, path.Path(), "filter");
                if (filter != NULL)
                        status = _RegisterFilter(filter, ref, image);
        } else if (_IsMethod(path.Path())) {
                BInputServerMethod* method = instantiate_add_on<BInputServerMethod>(
                        image, path.Path(), "method");
                if (method != NULL)
                        status = _RegisterMethod(method, ref, image);
        } else {
                ERROR("AddOnManager::_RegisterAddOn(): addon type not found for "
                        "\"%s\" \n", path.Path());
        }

        if (status != B_OK)
                unload_add_on(image);

        return status;
}


status_t
AddOnManager::_UnregisterAddOn(BEntry& entry)
{
        BPath path(&entry);

        entry_ref ref;
        status_t status = entry.GetRef(&ref);
        if (status < B_OK)
                return status;

        TRACE("AddOnManager::UnregisterAddOn(): trying to unload \"%s\"\n",
                path.Path());

        BAutolock _(this);

        if (_IsDevice(path.Path())) {
                for (int32 i = fDeviceList.CountItems(); i-- > 0;) {
                        device_info* info = fDeviceList.ItemAt(i);
                        if (!strcmp(info->ref.name, ref.name)) {
                                gInputServer->StartStopDevices(*info->add_on, false);
                                delete fDeviceList.RemoveItemAt(i);
                                break;
                        }
                }
        } else if (_IsFilter(path.Path())) {
                for (int32 i = fFilterList.CountItems(); i-- > 0;) {
                        filter_info* info = fFilterList.ItemAt(i);
                        if (!strcmp(info->ref.name, ref.name)) {
                                BAutolock locker(InputServer::gInputFilterListLocker);
                                InputServer::gInputFilterList.RemoveItem(info->add_on);
                                delete fFilterList.RemoveItemAt(i);
                                break;
                        }
                }
        } else if (_IsMethod(path.Path())) {
                BInputServerMethod* method = NULL;

                for (int32 i = fMethodList.CountItems(); i-- > 0;) {
                        method_info* info = fMethodList.ItemAt(i);
                        if (!strcmp(info->ref.name, ref.name)) {
                                BAutolock locker(InputServer::gInputMethodListLocker);
                                InputServer::gInputMethodList.RemoveItem(info->add_on);
                                method = info->add_on;
                                        // this will only be used as a cookie, and not referenced
                                        // anymore
                                delete fMethodList.RemoveItemAt(i);
                                break;
                        }
                }

                if (fMethodList.CountItems() <= 0) {
                        // we remove the method replicant
                        BDeskbar().RemoveItem(REPLICANT_CTL_NAME);
                        gInputServer->SetMethodReplicant(NULL);
                } else if (method != NULL) {
                        BMessage msg(IS_REMOVE_METHOD);
                        msg.AddInt32("cookie", method->fOwner->Cookie());
                        if (gInputServer->MethodReplicant())
                                gInputServer->MethodReplicant()->SendMessage(&msg);
                }
        }

        return B_OK;
}


//!     Takes over ownership of the \a device, regardless of success.
status_t
AddOnManager::_RegisterDevice(BInputServerDevice* device, const entry_ref& ref,
        image_id addOnImage)
{
        BAutolock locker(this);

        for (int32 i = fDeviceList.CountItems(); i-- > 0;) {
                device_info* info = fDeviceList.ItemAt(i);
                if (!strcmp(info->ref.name, ref.name)) {
                        // we already know this device
                        delete device;
                        return B_NAME_IN_USE;
                }
        }

        TRACE("AddOnManager::RegisterDevice, name %s\n", ref.name);

        device_info* info = new(std::nothrow) device_info;
        if (info == NULL) {
                delete device;
                return B_NO_MEMORY;
        }

        info->ref = ref;
        info->add_on = device;

        if (!fDeviceList.AddItem(info)) {
                delete info;
                return B_NO_MEMORY;
        }

        info->image = addOnImage;

        return B_OK;
}


//!     Takes over ownership of the \a filter, regardless of success.
status_t
AddOnManager::_RegisterFilter(BInputServerFilter* filter, const entry_ref& ref,
        image_id addOnImage)
{
        BAutolock _(this);

        for (int32 i = fFilterList.CountItems(); i-- > 0;) {
                filter_info* info = fFilterList.ItemAt(i);
                if (strcmp(info->ref.name, ref.name) == 0) {
                        // we already know this ref
                        delete filter;
                        return B_NAME_IN_USE;
                }
        }

        TRACE("%s, name %s\n", __PRETTY_FUNCTION__, ref.name);

        filter_info* info = new(std::nothrow) filter_info;
        if (info == NULL) {
                delete filter;
                return B_NO_MEMORY;
        }

        info->ref = ref;
        info->add_on = filter;

        if (!fFilterList.AddItem(info)) {
                delete info;
                return B_NO_MEMORY;
        }

        BAutolock locker(InputServer::gInputFilterListLocker);
        if (!InputServer::gInputFilterList.AddItem(filter)) {
                fFilterList.RemoveItem(info, false);
                delete info;
                return B_NO_MEMORY;
        }

        info->image = addOnImage;

        return B_OK;
}


//!     Takes over ownership of the \a method, regardless of success.
status_t
AddOnManager::_RegisterMethod(BInputServerMethod* method, const entry_ref& ref,
        image_id addOnImage)
{
        BAutolock _(this);

        for (int32 i = fMethodList.CountItems(); i-- > 0;) {
                method_info* info = fMethodList.ItemAt(i);
                if (!strcmp(info->ref.name, ref.name)) {
                        // we already know this ref
                        delete method;
                        return B_NAME_IN_USE;
                }
        }

        TRACE("%s, name %s\n", __PRETTY_FUNCTION__, ref.name);

        method_info* info = new(std::nothrow) method_info;
        if (info == NULL) {
                delete method;
                return B_NO_MEMORY;
        }

        info->ref = ref;
        info->add_on = method;

        if (!fMethodList.AddItem(info)) {
                delete info;
                return B_NO_MEMORY;
        }

        BAutolock locker(InputServer::gInputMethodListLocker);
        if (!InputServer::gInputMethodList.AddItem(method)) {
                fMethodList.RemoveItem(info);
                delete info;
                return B_NO_MEMORY;
        }

        info->image = addOnImage;

        if (gInputServer->MethodReplicant() == NULL) {
                _LoadReplicant();

                if (gInputServer->MethodReplicant()) {
                        _BMethodAddOn_ *addon = InputServer::gKeymapMethod.fOwner;
                        addon->AddMethod();
                }
        }

        if (gInputServer->MethodReplicant() != NULL) {
                _BMethodAddOn_ *addon = method->fOwner;
                addon->AddMethod();
        }

        return B_OK;
}


// #pragma mark -


void
AddOnManager::_UnloadReplicant()
{
        BDeskbar().RemoveItem(REPLICANT_CTL_NAME);
}


void
AddOnManager::_LoadReplicant()
{
        CALLED();
        app_info info;
        be_app->GetAppInfo(&info);

        status_t err = BDeskbar().AddItem(&info.ref);
        if (err != B_OK)
                ERROR("Deskbar refuses to add method replicant: %s\n", strerror(err));

        BMessage request(B_GET_PROPERTY);
        BMessenger to;
        BMessenger status;

        request.AddSpecifier("Messenger");
        request.AddSpecifier("Shelf");

        // In the Deskbar the Shelf is in the View "Status" in Window "Deskbar"
        request.AddSpecifier("View", "Status");
        request.AddSpecifier("Window", "Deskbar");
        to = BMessenger("application/x-vnd.Be-TSKB", -1);

        BMessage reply;

        if (to.SendMessage(&request, &reply) == B_OK
                && reply.FindMessenger("result", &status) == B_OK) {
                // enum replicant in Status view
                int32 index = 0;
                int32 uid;
                while ((uid = _GetReplicantAt(status, index++)) >= B_OK) {
                        BMessage replicantInfo;
                        if (_GetReplicantName(status, uid, &replicantInfo) != B_OK)
                                continue;

                        const char *name;
                        if (replicantInfo.FindString("result", &name) == B_OK
                                && !strcmp(name, REPLICANT_CTL_NAME)) {
                                BMessage replicant;
                                if (_GetReplicantView(status, uid, &replicant) == B_OK) {
                                        BMessenger result;
                                        if (replicant.FindMessenger("result", &result) == B_OK) {
                                                gInputServer->SetMethodReplicant(new BMessenger(result));
                                        }
                                }
                        }
                }
        }

        if (!gInputServer->MethodReplicant()) {
                ERROR("LoadReplicant(): Method replicant not found!\n");
        }
}


int32
AddOnManager::_GetReplicantAt(BMessenger target, int32 index) const
{
        // So here we want to get the Unique ID of the replicant at the given index
        // in the target Shelf.

        BMessage request(B_GET_PROPERTY);// We're getting the ID property
        BMessage reply;
        status_t err;

        request.AddSpecifier("ID");// want the ID
        request.AddSpecifier("Replicant", index);// of the index'th replicant

        if ((err = target.SendMessage(&request, &reply)) != B_OK)
                return err;

        int32 uid;
        if ((err = reply.FindInt32("result", &uid)) != B_OK)
                return err;

        return uid;
}


status_t
AddOnManager::_GetReplicantName(BMessenger target, int32 uid,
        BMessage* reply) const
{
        // We send a message to the target shelf, asking it for the Name of the
        // replicant with the given unique id.

        BMessage request(B_GET_PROPERTY);
        BMessage uid_specifier(B_ID_SPECIFIER);// specifying via ID
        status_t err;
        status_t e;

        request.AddSpecifier("Name");// ask for the Name of the replicant

        // IDs are specified using code like the following 3 lines:
        uid_specifier.AddInt32("id", uid);
        uid_specifier.AddString("property", "Replicant");
        request.AddSpecifier(&uid_specifier);

        if ((err = target.SendMessage(&request, reply)) != B_OK)
                return err;

        if (((err = reply->FindInt32("error", &e)) != B_OK) || (e != B_OK))
                return err ? err : e;

        return B_OK;
}


status_t
AddOnManager::_GetReplicantView(BMessenger target, int32 uid,
        BMessage* reply) const
{
        // We send a message to the target shelf, asking it for the Name of the
        // replicant with the given unique id.

        BMessage request(B_GET_PROPERTY);
        BMessage uid_specifier(B_ID_SPECIFIER);
                // specifying via ID
        status_t err;
        status_t e;

        request.AddSpecifier("View");
                // ask for the Name of the replicant

        // IDs are specified using code like the following 3 lines:
        uid_specifier.AddInt32("id", uid);
        uid_specifier.AddString("property", "Replicant");
        request.AddSpecifier(&uid_specifier);

        if ((err = target.SendMessage(&request, reply)) != B_OK)
                return err;

        if (((err = reply->FindInt32("error", &e)) != B_OK) || (e != B_OK))
                return err ? err : e;

        return B_OK;
}


status_t
AddOnManager::_HandleStartStopDevices(BMessage* message, BMessage* reply)
{
        const char *name = NULL;
        int32 type = 0;
        if (!((message->FindInt32("type", &type) != B_OK)
                        ^ (message->FindString("device", &name) != B_OK)))
                return B_ERROR;

        return gInputServer->StartStopDevices(name, (input_device_type)type,
                message->what == IS_START_DEVICE);
}


status_t
AddOnManager::_HandleFindDevices(BMessage* message, BMessage* reply)
{
        CALLED();
        const char *name = NULL;
        input_device_type type;
        if (message->FindString("device", &name) == B_OK) {
                if (gInputServer->GetDeviceInfo(name, &type) != B_OK)
                        return B_NAME_NOT_FOUND;
                reply->AddString("device", name);
                reply->AddInt32("type", type);
        } else {
                gInputServer->GetDeviceInfos(reply);
        }
        return B_OK;
}


status_t
AddOnManager::_HandleWatchDevices(BMessage* message, BMessage* reply)
{
        BMessenger watcherMessenger;
        if (message->FindMessenger("target", &watcherMessenger) != B_OK)
                return B_ERROR;

        bool startWatching;
        if (message->FindBool("start", &startWatching) != B_OK)
                return B_ERROR;

        if (fWatcherMessengerList.find(watcherMessenger)
                == fWatcherMessengerList.end()) {
                if (startWatching)
                        fWatcherMessengerList.insert(watcherMessenger);
                else
                        return B_BAD_VALUE;
        } else {
                if (!startWatching)
                        fWatcherMessengerList.erase(watcherMessenger);
        }

        return B_OK;
}


status_t
AddOnManager::_HandleNotifyDevice(BMessage* message, BMessage* reply)
{
        if (!message->HasBool("added") && !message->HasBool("started"))
                return B_BAD_VALUE;

        syslog(LOG_NOTICE, "Notify of added/removed/started/stopped device");

        BMessage changeMessage(B_INPUT_DEVICES_CHANGED);

        bool deviceAdded;
        if (message->FindBool("added", &deviceAdded) == B_OK) {
                if (deviceAdded)
                        changeMessage.AddInt32("be:opcode", B_INPUT_DEVICE_ADDED);
                else
                        changeMessage.AddInt32("be:opcode", B_INPUT_DEVICE_REMOVED);
        }

        bool deviceStarted;
        if (message->FindBool("started", &deviceStarted) == B_OK) {
                if (deviceStarted)
                        changeMessage.AddInt32("be:opcode", B_INPUT_DEVICE_STARTED);
                else
                        changeMessage.AddInt32("be:opcode", B_INPUT_DEVICE_STOPPED);
        }

        BString deviceName;
        if (message->FindString("name", &deviceName) != B_OK)
                return B_BAD_VALUE;

        changeMessage.AddString("be:device_name", deviceName);

        input_device_type deviceType = B_UNDEFINED_DEVICE;
        if (message->FindInt32("type", deviceType) != B_OK)
                return B_BAD_VALUE;

        changeMessage.AddInt32("be:device_type", deviceType);

        std::set<BMessenger>::iterator it = fWatcherMessengerList.begin();
        while (it != fWatcherMessengerList.end()) {
                const BMessenger& currentMessenger = *it;

                status_t result = currentMessenger.SendMessage(&changeMessage);

                if (result != B_OK && !currentMessenger.IsValid())
                        fWatcherMessengerList.erase(it++);
                else
                        it++;
        }

        return B_OK;
}


status_t
AddOnManager::_HandleIsDeviceRunning(BMessage* message, BMessage* reply)
{
        const char* name;
        bool running;
        if (message->FindString("device", &name) != B_OK
                || gInputServer->GetDeviceInfo(name, NULL, &running) != B_OK)
                return B_NAME_NOT_FOUND;

        return running ? B_OK : B_ERROR;
}


status_t
AddOnManager::_HandleControlDevices(BMessage* message, BMessage* reply)
{
        CALLED();
        const char *name = NULL;
        int32 type = 0;
        if (!((message->FindInt32("type", &type) != B_OK)
                        ^ (message->FindString("device", &name) != B_OK)))
                return B_BAD_VALUE;

        uint32 code = 0;
        BMessage controlMessage;
        bool hasMessage = true;
        if (message->FindInt32("code", (int32*)&code) != B_OK)
                return B_BAD_VALUE;
        if (message->FindMessage("message", &controlMessage) != B_OK)
                hasMessage = false;

        return gInputServer->ControlDevices(name, (input_device_type)type,
                code, hasMessage ? &controlMessage : NULL);
}


status_t
AddOnManager::_HandleSystemShuttingDown(BMessage* message, BMessage* reply)
{
        CALLED();

        for (int32 i = 0; i < fDeviceList.CountItems(); i++) {
                device_info* info = fDeviceList.ItemAt(i);
                info->add_on->SystemShuttingDown();
        }

        return B_OK;
}


status_t
AddOnManager::_HandleMethodReplicant(BMessage* message, BMessage* reply)
{
        CALLED();

        if (InputServer::gInputMethodList.CountItems() == 0) {
                _UnloadReplicant();
                return B_OK;
        }

        _LoadReplicant();

        BAutolock lock(InputServer::gInputMethodListLocker);

        if (gInputServer->MethodReplicant()) {
                _BMethodAddOn_* addon = InputServer::gKeymapMethod.fOwner;
                addon->AddMethod();

                for (int32 i = 0; i < InputServer::gInputMethodList.CountItems(); i++) {
                        BInputServerMethod* method
                                = (BInputServerMethod*)InputServer::gInputMethodList.ItemAt(i);

                        _BMethodAddOn_* addon = method->fOwner;
                        addon->AddMethod();
                }
        }

        return B_OK;
}


void
AddOnManager::_HandleDeviceMonitor(BMessage* message)
{
        int32 opcode;
        if (message->FindInt32("opcode", &opcode) != B_OK)
                return;

        switch (opcode) {
                case B_ENTRY_CREATED:
                case B_ENTRY_REMOVED:
                {
                        const char* path;
                        const char* watchedPath;
                        if (message->FindString("watched_path", &watchedPath) != B_OK
                                || message->FindString("path", &path) != B_OK) {
#if DEBUG
                                char string[1024];
                                sprintf(string, "message does not contain all fields - "
                                        "watched_path: %d, path: %d\n",
                                        message->HasString("watched_path"),
                                        message->HasString("path"));
                                debugger(string);
#endif
                                return;
                        }

                        // Notify all watching devices

                        for (int32 i = 0; i < fDeviceAddOns.CountItems(); i++) {
                                DeviceAddOn* addOn = fDeviceAddOns.ItemAt(i);
                                if (!addOn->HasPath(watchedPath))
                                        continue;

                                addOn->Device()->Control(NULL, NULL, B_NODE_MONITOR, message);
                        }

                        break;
                }
        }
}


status_t
AddOnManager::_AddDevicePath(DeviceAddOn* addOn, const char* path,
        bool& newPath)
{
        newPath = !fDevicePaths.HasPath(path);

        status_t status = fDevicePaths.AddPath(path);
        if (status == B_OK) {
                status = addOn->AddPath(path);
                if (status == B_OK) {
                        if (!fDeviceAddOns.HasItem(addOn)
                                && !fDeviceAddOns.AddItem(addOn)) {
                                addOn->RemovePath(path);
                                status = B_NO_MEMORY;
                        }
                } else
                        fDevicePaths.RemovePath(path);
        }

        return status;
}


status_t
AddOnManager::_RemoveDevicePath(DeviceAddOn* addOn, const char* path,
        bool& lastPath)
{
        if (!fDevicePaths.HasPath(path) || !addOn->HasPath(path))
                return B_ENTRY_NOT_FOUND;

        fDevicePaths.RemovePath(path);

        lastPath = !fDevicePaths.HasPath(path);

        addOn->RemovePath(path);
        if (addOn->CountPaths() == 0)
                fDeviceAddOns.RemoveItem(addOn);

        return B_OK;
}