headers/bsd: Add sys/queue.h.

[haiku.git] / src / servers / midi / MidiServerApp.cpp

/*
 * Copyright 2002-2015, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Matthijs Hollemans
 */

/*
 * Copyright (c) 2002-2004 Matthijs Hollemans
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */


#include "MidiServerApp.h"

#include <new>

#include <Alert.h>

#include "debug.h"
#include "protocol.h"
#include "PortDrivers.h"
#include "ServerDefs.h"


using std::nothrow;


MidiServerApp::MidiServerApp(status_t& error)
        :
        BServer(MIDI_SERVER_SIGNATURE, true, &error)
{
        TRACE(("Running Haiku MIDI server"))

        fNextID = 1;
        fDeviceWatcher = new(std::nothrow) DeviceWatcher();
        if (fDeviceWatcher != NULL)
                fDeviceWatcher->Run();
}


MidiServerApp::~MidiServerApp()
{
        if (fDeviceWatcher && fDeviceWatcher->Lock())
                fDeviceWatcher->Quit();

        for (int32 t = 0; t < _CountApps(); ++t) {
                delete _AppAt(t);
        }

        for (int32 t = 0; t < _CountEndpoints(); ++t) {
                delete _EndpointAt(t);
        }
}


void
MidiServerApp::AboutRequested()
{
        BAlert* alert = new BAlert(0,
                "Haiku midi_server 1.0.0 alpha\n\n"
                "notes disguised as bytes\n"
                "propagating to endpoints,\n"
                "an aural delight",
                "OK", 0, 0, B_WIDTH_AS_USUAL,
                B_INFO_ALERT);
        alert->SetFlags(alert->Flags() | B_CLOSE_ON_ESCAPE);
        alert->Go();
}


void
MidiServerApp::MessageReceived(BMessage* msg)
{
#ifdef DEBUG
        printf("IN "); msg->PrintToStream();
#endif

        switch (msg->what) {
                case MSG_REGISTER_APP:
                        _OnRegisterApp(msg);
                        break;
                case MSG_CREATE_ENDPOINT:
                        _OnCreateEndpoint(msg);
                        break;
                case MSG_DELETE_ENDPOINT:
                        _OnDeleteEndpoint(msg);
                        break;
                case MSG_PURGE_ENDPOINT:
                        _OnPurgeEndpoint(msg);
                        break;
                case MSG_CHANGE_ENDPOINT:
                        _OnChangeEndpoint(msg);
                        break;
                case MSG_CONNECT_ENDPOINTS:
                        _OnConnectDisconnect(msg);
                        break;
                case MSG_DISCONNECT_ENDPOINTS:
                        _OnConnectDisconnect(msg);
                        break;

                default:
                        super::MessageReceived(msg);
                        break;
        }
}


void
MidiServerApp::_OnRegisterApp(BMessage* msg)
{
        TRACE(("MidiServerApp::_OnRegisterApp"))

        // We only send the "app registered" message upon success,
        // so if anything goes wrong here, we do not let the app
        // know about it, and we consider it unregistered. (Most
        // likely, the app is dead. If not, it freezes forever
        // in anticipation of a message that will never arrive.)

        app_t* app = new app_t;

        if (msg->FindMessenger("midi:messenger", &app->messenger) == B_OK
                && _SendAllEndpoints(app)
                && _SendAllConnections(app)) {
                BMessage reply;
                reply.what = MSG_APP_REGISTERED;

                if (_SendNotification(app, &reply)) {
                        fApps.AddItem(app);
#ifdef DEBUG
                        _DumpApps();
#endif
                        return;
                }
        }

        delete app;
}


void
MidiServerApp::_OnCreateEndpoint(BMessage* msg)
{
        TRACE(("MidiServerApp::_OnCreateEndpoint"))

        status_t status;
        endpoint_t* endpoint = new endpoint_t;

        endpoint->app = _WhichApp(msg);
        if (endpoint->app == NULL) {
                status = B_ERROR;
        } else {
                status = B_BAD_VALUE;

                if (msg->FindBool("midi:consumer", &endpoint->consumer) == B_OK
                        && msg->FindBool("midi:registered", &endpoint->registered) == B_OK
                        && msg->FindString("midi:name", &endpoint->name) == B_OK
                        && msg->FindMessage("midi:properties", &endpoint->properties)
                                        == B_OK) {
                        if (endpoint->consumer) {
                                if (msg->FindInt32("midi:port", &endpoint->port) == B_OK
                                        && msg->FindInt64("midi:latency", &endpoint->latency)
                                                        == B_OK)
                                        status = B_OK;
                        } else
                                status = B_OK;
                }
        }

        BMessage reply;

        if (status == B_OK) {
                endpoint->id = fNextID++;
                reply.AddInt32("midi:id", endpoint->id);
        }

        reply.AddInt32("midi:result", status);

        if (_SendReply(endpoint->app, msg, &reply) && status == B_OK)
                _AddEndpoint(msg, endpoint);
        else
                delete endpoint;
}


void
MidiServerApp::_OnDeleteEndpoint(BMessage* msg)
{
        TRACE(("MidiServerApp::_OnDeleteEndpoint"))

        // Clients send the "delete endpoint" message from
        // the BMidiEndpoint destructor, so there is no point
        // sending a reply, because the endpoint object will
        // be destroyed no matter what.

        app_t* app = _WhichApp(msg);
        if (app != NULL) {
                endpoint_t* endpoint = _WhichEndpoint(msg, app);
                if (endpoint != NULL)
                        _RemoveEndpoint(app, endpoint);
        }
}


void
MidiServerApp::_OnPurgeEndpoint(BMessage* msg)
{
        TRACE(("MidiServerApp::_OnPurgeEndpoint"))

        // This performs the same task as OnDeleteEndpoint(),
        // except that this message was send by the midi_server
        // itself, so we don't check that the app that made the
        // request really is the owner of the endpoint. (But we
        // _do_ check that the message came from the server.)

        if (!msg->IsSourceRemote()) {
                int32 id;
                if (msg->FindInt32("midi:id", &id) == B_OK) {
                        endpoint_t* endpoint = _FindEndpoint(id);
                        if (endpoint != NULL)
                                _RemoveEndpoint(NULL, endpoint);
                }
        }
}


void
MidiServerApp::_OnChangeEndpoint(BMessage* msg)
{
        TRACE(("MidiServerApp::_OnChangeEndpoint"))

        endpoint_t* endpoint = NULL;
        status_t status;

        app_t* app = _WhichApp(msg);
        if (app == NULL)
                status = B_ERROR;
        else {
                endpoint = _WhichEndpoint(msg, app);
                if (endpoint == NULL)
                        status = B_BAD_VALUE;
                else
                        status = B_OK;
        }

        BMessage reply;
        reply.AddInt32("midi:result", status);

        if (_SendReply(app, msg, &reply) && status == B_OK) {
                TRACE(("Endpoint %" B_PRId32 " (%p) changed", endpoint->id, endpoint))

                BMessage notify;
                notify.what = MSG_ENDPOINT_CHANGED;
                notify.AddInt32("midi:id", endpoint->id);

                bool registered;
                if (msg->FindBool("midi:registered", &registered) == B_OK) {
                        notify.AddBool("midi:registered", registered);
                        endpoint->registered = registered;
                }

                BString name;
                if (msg->FindString("midi:name", &name) == B_OK) {
                        notify.AddString("midi:name", name);
                        endpoint->name = name;
                }

                BMessage properties;
                if (msg->FindMessage("midi:properties", &properties) == B_OK) {
                        notify.AddMessage("midi:properties", &properties);
                        endpoint->properties = properties;
                }

                bigtime_t latency;
                if (msg->FindInt64("midi:latency", &latency) == B_OK) {
                        notify.AddInt64("midi:latency", latency);
                        endpoint->latency = latency;
                }

                _NotifyAll(&notify, app);

#ifdef DEBUG
                _DumpEndpoints();
#endif
        }
}


void
MidiServerApp::_OnConnectDisconnect(BMessage* msg)
{
        TRACE(("MidiServerApp::_OnConnectDisconnect"))

        bool mustConnect = msg->what == MSG_CONNECT_ENDPOINTS;

        status_t status;
        endpoint_t* producer = NULL;
        endpoint_t* consumer = NULL;

        app_t* app = _WhichApp(msg);
        if (app == NULL)
                status = B_ERROR;
        else {
                status = B_BAD_VALUE;

                int32 producerID;
                int32 consumerID;
                if (msg->FindInt32("midi:producer", &producerID) == B_OK
                        && msg->FindInt32("midi:consumer", &consumerID) == B_OK) {
                        producer = _FindEndpoint(producerID);
                        consumer = _FindEndpoint(consumerID);

                        if (producer != NULL && !producer->consumer) {
                                if (consumer != NULL && consumer->consumer) {
                                        // It is an error to connect two endpoints that
                                        // are already connected, or to disconnect two
                                        // endpoints that are not connected at all.

                                        if (mustConnect == producer->connections.HasItem(consumer))
                                                status = B_ERROR;
                                        else
                                                status = B_OK;
                                }
                        }
                }
        }

        BMessage reply;
        reply.AddInt32("midi:result", status);

        if (_SendReply(app, msg, &reply) && status == B_OK) {
                if (mustConnect) {
                        TRACE(("Connection made: %" B_PRId32 " ---> %" B_PRId32,
                                producer->id, consumer->id))

                        producer->connections.AddItem(consumer);
                } else {
                        TRACE(("Connection broken: %" B_PRId32 " -X-> %" B_PRId32,
                                producer->id, consumer->id))

                        producer->connections.RemoveItem(consumer);
                }

                BMessage notify;
                _MakeConnectedNotification(&notify, producer, consumer, mustConnect);
                _NotifyAll(&notify, app);

#ifdef DEBUG
                _DumpEndpoints();
#endif
        }
}


/*!     Sends an app MSG_ENDPOINT_CREATED notifications for
        all current endpoints. Used when the app registers.
*/
bool
MidiServerApp::_SendAllEndpoints(app_t* app)
{
        ASSERT(app != NULL)

        BMessage notify;

        for (int32 t = 0; t < _CountEndpoints(); ++t) {
                endpoint_t* endpoint = _EndpointAt(t);

                _MakeCreatedNotification(&notify, endpoint);

                if (!_SendNotification(app, &notify))
                        return false;
        }

        return true;
}


/*!     Sends an app MSG_ENDPOINTS_CONNECTED notifications for
        all current connections. Used when the app registers.
*/
bool
MidiServerApp::_SendAllConnections(app_t* app)
{
        ASSERT(app != NULL)

        BMessage notify;

        for (int32 t = 0; t < _CountEndpoints(); ++t) {
                endpoint_t* producer = _EndpointAt(t);
                if (!producer->consumer) {
                        for (int32 k = 0; k < _CountConnections(producer); ++k) {
                                endpoint_t* consumer = _ConnectionAt(producer, k);

                                _MakeConnectedNotification(&notify, producer, consumer, true);

                                if (!_SendNotification(app, &notify))
                                        return false;
                        }
                }
        }

        return true;
}


/*!     Adds the specified endpoint to the roster, and notifies
        all other applications about this event.
*/
void
MidiServerApp::_AddEndpoint(BMessage* msg, endpoint_t* endpoint)
{
        ASSERT(msg != NULL)
        ASSERT(endpoint != NULL)
        ASSERT(!fEndpoints.HasItem(endpoint))

        TRACE(("Endpoint %" B_PRId32 " (%p) added", endpoint->id, endpoint))

        fEndpoints.AddItem(endpoint);

        BMessage notify;
        _MakeCreatedNotification(&notify, endpoint);
        _NotifyAll(&notify, endpoint->app);

#ifdef DEBUG
        _DumpEndpoints();
#endif
}


/*!     Removes an endpoint from the roster, and notifies all
        other apps about this event. "app" is the application
        that the endpoint belongs to; if it is NULL, the app
        no longer exists and we're purging the endpoint.
*/
void
MidiServerApp::_RemoveEndpoint(app_t* app, endpoint_t* endpoint)
{
        ASSERT(endpoint != NULL)
        ASSERT(fEndpoints.HasItem(endpoint))

        TRACE(("Endpoint %" B_PRId32 " (%p) removed", endpoint->id, endpoint))

        fEndpoints.RemoveItem(endpoint);

        if (endpoint->consumer)
                _DisconnectDeadConsumer(endpoint);

        BMessage notify;
        notify.what = MSG_ENDPOINT_DELETED;
        notify.AddInt32("midi:id", endpoint->id);
        _NotifyAll(&notify, app);

        delete endpoint;

#ifdef DEBUG
        _DumpEndpoints();
#endif
}


/*!     Removes a consumer from the list of connections of
        all the producers it is connected to, just before
        we remove it from the roster.
*/
void
MidiServerApp::_DisconnectDeadConsumer(endpoint_t* consumer)
{
        ASSERT(consumer != NULL)
        ASSERT(consumer->consumer)

        for (int32 t = 0; t < _CountEndpoints(); ++t) {
                endpoint_t* producer = _EndpointAt(t);
                if (!producer->consumer)
                        producer->connections.RemoveItem(consumer);
        }
}


//! Fills up a MSG_ENDPOINT_CREATED message.
void
MidiServerApp::_MakeCreatedNotification(BMessage* msg, endpoint_t* endpoint)
{
        ASSERT(msg != NULL)
        ASSERT(endpoint != NULL)

        msg->MakeEmpty();
        msg->what = MSG_ENDPOINT_CREATED;
        msg->AddInt32("midi:id", endpoint->id);
        msg->AddBool("midi:consumer", endpoint->consumer);
        msg->AddBool("midi:registered", endpoint->registered);
        msg->AddString("midi:name", endpoint->name);
        msg->AddMessage("midi:properties", &endpoint->properties);

        if (endpoint->consumer) {
                msg->AddInt32("midi:port", endpoint->port);
                msg->AddInt64("midi:latency", endpoint->latency);
        }
}


//! Fills up a MSG_ENDPOINTS_(DIS)CONNECTED message.
void
MidiServerApp::_MakeConnectedNotification(BMessage* msg, endpoint_t* producer,
        endpoint_t* consumer, bool mustConnect)
{
        ASSERT(msg != NULL)
        ASSERT(producer != NULL)
        ASSERT(consumer != NULL)
        ASSERT(!producer->consumer)
        ASSERT(consumer->consumer)

        msg->MakeEmpty();

        if (mustConnect)
                msg->what = MSG_ENDPOINTS_CONNECTED;
        else
                msg->what = MSG_ENDPOINTS_DISCONNECTED;

        msg->AddInt32("midi:producer", producer->id);
        msg->AddInt32("midi:consumer", consumer->id);
}


/*!     Figures out which application a message came from.
        Returns NULL if the application is not registered.
*/
app_t*
MidiServerApp::_WhichApp(BMessage* msg)
{
        ASSERT(msg != NULL)

        BMessenger retadr = msg->ReturnAddress();

        for (int32 t = 0; t < _CountApps(); ++t) {
                app_t* app = _AppAt(t);
                if (app->messenger.Team() == retadr.Team())
                        return app;
        }

        TRACE(("Application %" B_PRId32 " is not registered", retadr.Team()))

        return NULL;
}


/*!     Looks at the "midi:id" field from a message, and returns
        the endpoint object that corresponds to that ID. It also
        checks whether the application specified by "app" really
        owns the endpoint. Returns NULL on error.
*/
endpoint_t*
MidiServerApp::_WhichEndpoint(BMessage* msg, app_t* app)
{
        ASSERT(msg != NULL)
        ASSERT(app != NULL)

        int32 id;
        if (msg->FindInt32("midi:id", &id) == B_OK) {
                endpoint_t* endpoint = _FindEndpoint(id);
                if (endpoint != NULL && endpoint->app == app)
                        return endpoint;
        }

        TRACE(("Endpoint not found or wrong app"))
        return NULL;
}


/*!     Returns the endpoint with the specified ID, or
        \c NULL if no such endpoint exists on the roster.
*/
endpoint_t*
MidiServerApp::_FindEndpoint(int32 id)
{
        if (id > 0) {
                for (int32 t = 0; t < _CountEndpoints(); ++t) {
                        endpoint_t* endpoint = _EndpointAt(t);
                        if (endpoint->id == id)
                                return endpoint;
                }
        }

        TRACE(("Endpoint %" B_PRId32 " not found", id))
        return NULL;
}


/*!     Sends notification messages to all registered apps,
        except to the application that triggered the event.
        The "except" app is allowed to be NULL.
*/
void
MidiServerApp::_NotifyAll(BMessage* msg, app_t* except)
{
        ASSERT(msg != NULL)

        for (int32 t = _CountApps() - 1; t >= 0; --t) {
                app_t* app = _AppAt(t);
                if (app != except && !_SendNotification(app, msg)) {
                        delete (app_t*)fApps.RemoveItem(t);
#ifdef DEBUG
                        _DumpApps();
#endif
                }
        }
}


/*!     Sends a notification message to an application, which is
        not necessarily registered yet. Applications never reply
        to such notification messages.
*/
bool
MidiServerApp::_SendNotification(app_t* app, BMessage* msg)
{
        ASSERT(app != NULL)
        ASSERT(msg != NULL)

        status_t status = app->messenger.SendMessage(msg, (BHandler*) NULL,
                TIMEOUT);
        if (status != B_OK)
                _DeliveryError(app);

        return status == B_OK;
}


/*!     Sends a reply to a request made by an application.
        If "app" is NULL, the application is not registered
        (and the reply should contain an error code).
*/
bool
MidiServerApp::_SendReply(app_t* app, BMessage* msg, BMessage* reply)
{
        ASSERT(msg != NULL)
        ASSERT(reply != NULL)

        status_t status = msg->SendReply(reply, (BHandler*) NULL, TIMEOUT);
        if (status != B_OK && app != NULL) {
                _DeliveryError(app);
                fApps.RemoveItem(app);
                delete app;

#ifdef DEBUG
                _DumpApps();
#endif
        }

        return status == B_OK;
}


/*!     Removes an app and all of its endpoints from the roster
        if a reply or notification message cannot be delivered.
        (Waiting for communications to fail is actually our only
        way to get rid of stale endpoints.)
*/
void
MidiServerApp::_DeliveryError(app_t* app)
{
        ASSERT(app != NULL)

        // We cannot communicate with the app, so we assume it's
        // dead. We need to remove its endpoints from the roster,
        // but we cannot do that right away; removing endpoints
        // triggers a bunch of new notifications and we don't want
        // those to get in the way of the notifications we are
        // currently sending out. Instead, we consider the death
        // of an app as a separate event, and pretend that the
        // now-dead app sent us delete requests for its endpoints.

        TRACE(("Delivery error; unregistering app (%p)", app))

        BMessage msg;

        for (int32 t = 0; t < _CountEndpoints(); ++t) {
                endpoint_t* endpoint = _EndpointAt(t);
                if (endpoint->app == app) {
                        msg.MakeEmpty();
                        msg.what = MSG_PURGE_ENDPOINT;
                        msg.AddInt32("midi:id", endpoint->id);

                        // It is not safe to post a message to your own
                        // looper's message queue, because you risk a
                        // deadlock if the queue is full. The chance of
                        // that happening is fairly small, but just in
                        // case, we catch it with a timeout. Because this
                        // situation is so unlikely, I decided to simply
                        // forget about the whole "purge" message then.

                        if (be_app_messenger.SendMessage(&msg, (BHandler*)NULL,
                                        TIMEOUT) != B_OK) {
                                WARN("Could not deliver purge message")
                        }
                }
        }
}


int32
MidiServerApp::_CountApps()
{
        return fApps.CountItems();
}


app_t*
MidiServerApp::_AppAt(int32 index)
{
        ASSERT(index >= 0 && index < _CountApps())

        return (app_t*)fApps.ItemAt(index);
}


int32
MidiServerApp::_CountEndpoints()
{
        return fEndpoints.CountItems();
}


endpoint_t*
MidiServerApp::_EndpointAt(int32 index)
{
        ASSERT(index >= 0 && index < _CountEndpoints())

        return (endpoint_t*)fEndpoints.ItemAt(index);
}


int32
MidiServerApp::_CountConnections(endpoint_t* producer)
{
        ASSERT(producer != NULL)
        ASSERT(!producer->consumer)

        return producer->connections.CountItems();
}


endpoint_t*
MidiServerApp::_ConnectionAt(endpoint_t* producer, int32 index)
{
        ASSERT(producer != NULL)
        ASSERT(!producer->consumer)
        ASSERT(index >= 0 && index < _CountConnections(producer))

        return (endpoint_t*)producer->connections.ItemAt(index);
}


#ifdef DEBUG
void
MidiServerApp::_DumpApps()
{
        printf("*** START DumpApps\n");

        for (int32 t = 0; t < _CountApps(); ++t) {
                app_t* app = _AppAt(t);

                printf("\tapp %" B_PRId32 " (%p): team %" B_PRId32 "\n", t, app,
                        app->messenger.Team());
        }

        printf("*** END DumpApps\n");
}


void
MidiServerApp::_DumpEndpoints()
{
        printf("*** START DumpEndpoints\n");

        for (int32 t = 0; t < _CountEndpoints(); ++t) {
                endpoint_t* endpoint = _EndpointAt(t);

                printf("\tendpoint %" B_PRId32 " (%p):\n", t, endpoint);
                printf("\t\tid %" B_PRId32 ", name '%s', %s, %s, app %p\n",
                        endpoint->id, endpoint->name.String(),
                        endpoint->consumer ? "consumer" : "producer",
                        endpoint->registered ? "registered" : "unregistered",
                        endpoint->app);
                printf("\t\tproperties: "); endpoint->properties.PrintToStream();

                if (endpoint->consumer)
                        printf("\t\tport %" B_PRId32 ", latency %" B_PRIdBIGTIME "\n",
                                endpoint->port, endpoint->latency);
                else {
                        printf("\t\tconnections:\n");
                        for (int32 k = 0; k < _CountConnections(endpoint); ++k) {
                                endpoint_t* consumer = _ConnectionAt(endpoint, k);
                                printf("\t\t\tid %" B_PRId32 " (%p)\n", consumer->id, consumer);
                        }
                }
        }

        printf("*** END DumpEndpoints\n");
}
#endif  // DEBUG


//      #pragma mark -


int
main()
{
        status_t status;
        MidiServerApp app(status);

        if (status == B_OK)
                app.Run();

        return status == B_OK ? EXIT_SUCCESS : EXIT_FAILURE;
}