474 lines
11 KiB
C
474 lines
11 KiB
C
/*-
|
|
* Copyright (c) 2017-2021 Carsten Sonne Larsen <cs@innolan.net>
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include "global.h"
|
|
#include "message.h"
|
|
#include "text.h"
|
|
#include "mem.h"
|
|
|
|
#include <proto/rexxsyslib.h>
|
|
|
|
#include "logmod.h"
|
|
#define MODULENAME "Dispatch"
|
|
|
|
struct MsgPort *volatile BrokerPort;
|
|
struct MsgPort *volatile SyncerPort;
|
|
struct MsgPort *volatile WindowPort;
|
|
struct MsgPort *volatile MemoryPort;
|
|
struct MsgPort *volatile ControlPort;
|
|
struct MsgPort *volatile ARexxPort;
|
|
int outstanding;
|
|
|
|
static void PublishPort(long, char *);
|
|
|
|
void InitMessages(void)
|
|
{
|
|
BrokerPort = NULL;
|
|
SyncerPort = NULL;
|
|
WindowPort = NULL;
|
|
MemoryPort = NULL;
|
|
ControlPort = NULL;
|
|
ARexxPort = NULL;
|
|
outstanding = 0;
|
|
|
|
CreateMessagePort(MSGPORT_MEMORY);
|
|
}
|
|
|
|
bool SetupPorts(void)
|
|
{
|
|
CreateMessagePort(MSGPORT_BROKER);
|
|
CreateMessagePort(MSGPORT_CONTROL);
|
|
PublishPort(MSGPORT_CONTROL, CONTROL_PORT_NAME);
|
|
|
|
if (RexxSysBase != NULL)
|
|
{
|
|
CreateMessagePort(MSGPORT_AREXX);
|
|
PublishPort(MSGPORT_AREXX, AREXX_PORT_NAME);
|
|
}
|
|
|
|
if (MemoryPort == NULL || BrokerPort == NULL)
|
|
{
|
|
LogError("Message port initialization failed");
|
|
CleanupPorts();
|
|
return false;
|
|
}
|
|
|
|
LogNotice("Publishing log to message port: %s", LOGGER_PORT_NAME);
|
|
|
|
LogTrace("Message port initialization complete");
|
|
return true;
|
|
}
|
|
|
|
void CleanupPorts(void)
|
|
{
|
|
DestroyMessagePort(MSGPORT_BROKER);
|
|
|
|
if (ControlPort != NULL)
|
|
{
|
|
RemPort((struct MsgPort *)ControlPort);
|
|
DestroyMessagePort(MSGPORT_CONTROL);
|
|
}
|
|
|
|
if (ARexxPort != NULL)
|
|
{
|
|
RemPort((struct MsgPort *)ARexxPort);
|
|
DestroyMessagePort(MSGPORT_AREXX);
|
|
}
|
|
|
|
if (MemoryPort != NULL)
|
|
{
|
|
while (outstanding != 0)
|
|
{
|
|
WaitPort(MemoryPort);
|
|
HandleMemoryMessages();
|
|
}
|
|
}
|
|
DestroyMessagePort(MSGPORT_MEMORY);
|
|
}
|
|
|
|
static struct MsgPort *FindMessagePort(long port)
|
|
{
|
|
switch (port)
|
|
{
|
|
case MSGPORT_BROKER:
|
|
return (struct MsgPort *)BrokerPort;
|
|
break;
|
|
case MSGPORT_SYNCER:
|
|
return (struct MsgPort *)SyncerPort;
|
|
break;
|
|
case MSGPORT_WINDOW:
|
|
return (struct MsgPort *)WindowPort;
|
|
break;
|
|
case MSGPORT_MEMORY:
|
|
return (struct MsgPort *)MemoryPort;
|
|
break;
|
|
case MSGPORT_CONTROL:
|
|
return (struct MsgPort *)ControlPort;
|
|
break;
|
|
case MSGPORT_AREXX:
|
|
return (struct MsgPort *)ARexxPort;
|
|
break;
|
|
default:
|
|
return NULL;
|
|
break;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static struct MsgPort *volatile *FindMessagePortAddress(long port, char **name)
|
|
{
|
|
struct MsgPort *volatile *p;
|
|
char *s;
|
|
|
|
switch (port)
|
|
{
|
|
case MSGPORT_BROKER:
|
|
p = &BrokerPort;
|
|
s = "Broker";
|
|
break;
|
|
case MSGPORT_SYNCER:
|
|
p = &SyncerPort;
|
|
s = "Synchronizer";
|
|
break;
|
|
case MSGPORT_WINDOW:
|
|
p = &WindowPort;
|
|
s = "Window";
|
|
break;
|
|
case MSGPORT_MEMORY:
|
|
p = &MemoryPort;
|
|
s = "Memory";
|
|
break;
|
|
case MSGPORT_CONTROL:
|
|
p = &ControlPort;
|
|
s = "Control";
|
|
break;
|
|
case MSGPORT_AREXX:
|
|
p = &ARexxPort;
|
|
s = "ARexx";
|
|
break;
|
|
default:
|
|
p = NULL;
|
|
s = "Unknown";
|
|
break;
|
|
}
|
|
|
|
*name = s;
|
|
return p;
|
|
}
|
|
|
|
static void PublishPort(long port, char *name)
|
|
{
|
|
char *s;
|
|
struct MsgPort *volatile *dest = FindMessagePortAddress(port, &s);
|
|
if (dest == NULL || *dest == NULL)
|
|
return;
|
|
|
|
struct MsgPort *pub = *dest;
|
|
pub->mp_Node.ln_Name = name;
|
|
pub->mp_Node.ln_Pri = 0;
|
|
|
|
Forbid();
|
|
struct MsgPort *msgPort = FindPort((CONST_STRPTR)name);
|
|
if (msgPort == NULL)
|
|
{
|
|
AddPort((struct MsgPort *)pub);
|
|
}
|
|
Permit();
|
|
|
|
if (msgPort == NULL)
|
|
LogNotice("%s message port published: %s", s, name);
|
|
else
|
|
LogWarn("%s message port is already registered: %s", s, name);
|
|
}
|
|
|
|
struct MsgPort *GetMessagePort(long port)
|
|
{
|
|
return FindMessagePort(port);
|
|
}
|
|
|
|
struct Message *GetNewMessage(long port)
|
|
{
|
|
struct MsgPort *p = FindMessagePort(port);
|
|
if (p == NULL)
|
|
return NULL;
|
|
|
|
return GetMsg(p);
|
|
}
|
|
|
|
ULONG GetPortSignalMask(long port)
|
|
{
|
|
struct MsgPort *p = FindMessagePort(port);
|
|
if (p == NULL)
|
|
{
|
|
LogError("Failed to get port signal mask: %ld", port);
|
|
return 0;
|
|
}
|
|
|
|
return (1 << p->mp_SigBit);
|
|
}
|
|
|
|
bool CreateMessagePort(long port)
|
|
{
|
|
struct MsgPort *n = CreateMsgPort();
|
|
struct MsgPort *volatile *p;
|
|
bool success = true;
|
|
char *s;
|
|
|
|
p = FindMessagePortAddress(port, &s);
|
|
if (n != NULL && p != NULL && *p == NULL)
|
|
{
|
|
LogTrace(TextPortCreated, s);
|
|
*p = n;
|
|
}
|
|
else
|
|
{
|
|
LogError(TextPortInitError, s);
|
|
success = false;
|
|
}
|
|
|
|
return success;
|
|
}
|
|
|
|
void DestroyMessagePort(long port)
|
|
{
|
|
struct MsgPort *volatile *p;
|
|
struct MsgPort *msgPort;
|
|
bool exist = true;
|
|
char *s;
|
|
|
|
Forbid();
|
|
p = FindMessagePortAddress(port, &s);
|
|
if (p == NULL || *p == NULL)
|
|
{
|
|
exist = false;
|
|
}
|
|
else
|
|
{
|
|
msgPort = *p;
|
|
*p = NULL;
|
|
}
|
|
Permit();
|
|
|
|
if (exist)
|
|
{
|
|
struct Message *msg;
|
|
while ((msg = GetMsg(msgPort)))
|
|
{
|
|
ReplyMsg(msg);
|
|
}
|
|
DeleteMsgPort(msgPort);
|
|
LogTrace(TextPortCleaned, s);
|
|
}
|
|
else
|
|
{
|
|
LogError(TextPortNotFound, s);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Send an application message in a safe manner.
|
|
*/
|
|
static void SendAppMessage(long port, long type)
|
|
{
|
|
struct MsgPort *dest, *reply;
|
|
bool sent = false;
|
|
|
|
struct ApplicationMesage *msg = AllocStructSafe(struct ApplicationMesage);
|
|
if (msg == NULL)
|
|
return;
|
|
|
|
msg->Msg.mn_Node.ln_Type = NT_MESSAGE;
|
|
msg->Msg.mn_Length = sizeof(struct ApplicationMesage);
|
|
msg->MsgType = MSGTYPE_APP;
|
|
msg->MsgId = type;
|
|
|
|
Forbid();
|
|
dest = FindMessagePort(port);
|
|
reply = (struct MsgPort *)MemoryPort;
|
|
if (dest != NULL && reply != NULL)
|
|
{
|
|
msg->Msg.mn_ReplyPort = reply;
|
|
PutMsg(dest, (struct Message *)msg);
|
|
outstanding++;
|
|
sent = true;
|
|
}
|
|
Permit();
|
|
|
|
if (!sent)
|
|
FreeMemSafe(msg);
|
|
}
|
|
|
|
/*
|
|
* Send a message to the broker.
|
|
*/
|
|
void SendBrokerMessage(long type)
|
|
{
|
|
SendAppMessage(MSGPORT_BROKER, type);
|
|
}
|
|
|
|
/*
|
|
* Send a message to the settings window.
|
|
*/
|
|
void SendWindowMessage(long type)
|
|
{
|
|
SendAppMessage(MSGPORT_WINDOW, type);
|
|
}
|
|
|
|
/*
|
|
* Try to send a message to the logger message port.
|
|
*/
|
|
void SendLogMessage(struct LogMessage *msg)
|
|
{
|
|
struct MsgPort *port, *reply;
|
|
bool sent = false;
|
|
|
|
msg->AppMsg.Msg.mn_Node.ln_Type = NT_MESSAGE;
|
|
msg->AppMsg.Msg.mn_Length = sizeof(struct LogMessage);
|
|
msg->AppMsg.MsgType = MSGTYPE_LOG;
|
|
|
|
Forbid();
|
|
reply = (struct MsgPort *)MemoryPort;
|
|
port = FindPort((CONST_STRPTR)LOGGER_PORT_NAME);
|
|
if (port != NULL && reply != NULL)
|
|
{
|
|
msg->AppMsg.Msg.mn_ReplyPort = reply;
|
|
PutMsg(port, (struct Message *)msg);
|
|
outstanding++;
|
|
sent = true;
|
|
}
|
|
Permit();
|
|
|
|
if (!sent && port != NULL)
|
|
{
|
|
// Try again using own reply port
|
|
struct MsgPort *replyPort = CreateMsgPort();
|
|
if (replyPort != NULL)
|
|
{
|
|
Forbid();
|
|
port = FindPort((CONST_STRPTR)LOGGER_PORT_NAME);
|
|
if (port != NULL)
|
|
{
|
|
msg->AppMsg.Msg.mn_ReplyPort = replyPort;
|
|
PutMsg(port, (struct Message *)msg);
|
|
sent = true;
|
|
}
|
|
Permit();
|
|
|
|
WaitPort(replyPort);
|
|
GetMsg(replyPort);
|
|
DeleteMsgPort(replyPort);
|
|
}
|
|
}
|
|
|
|
if (!sent)
|
|
FreeVec(msg);
|
|
}
|
|
|
|
/*
|
|
* Free processed messages.
|
|
*/
|
|
void HandleMemoryMessages(void)
|
|
{
|
|
struct ApplicationMesage *msg;
|
|
while ((msg = (struct ApplicationMesage *)GetMsg(MemoryPort)))
|
|
{
|
|
if (msg->MsgType == MSGTYPE_LOG)
|
|
{
|
|
FreeVec(msg);
|
|
}
|
|
else
|
|
{
|
|
FreeMemSafe(msg);
|
|
}
|
|
outstanding--;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Send a message and wait for the reply.
|
|
*/
|
|
void SendMessageWait(long port, long type)
|
|
{
|
|
struct MsgPort *replyPort = CreateMsgPort();
|
|
if (replyPort != NULL)
|
|
{
|
|
struct ApplicationMesage *message = AllocStructSafe(struct ApplicationMesage);
|
|
if (message != NULL)
|
|
{
|
|
message->Msg.mn_Node.ln_Type = NT_MESSAGE;
|
|
message->Msg.mn_Length = sizeof(struct ApplicationMesage);
|
|
message->Msg.mn_ReplyPort = replyPort;
|
|
message->MsgType = MSGTYPE_APP;
|
|
message->MsgId = type;
|
|
|
|
Forbid();
|
|
struct MsgPort *dest = FindMessagePort(port);
|
|
if (dest != NULL)
|
|
{
|
|
PutMsg(dest, (struct Message *)message);
|
|
}
|
|
Permit();
|
|
|
|
if (dest != NULL)
|
|
{
|
|
WaitPort(replyPort);
|
|
GetMsg(replyPort);
|
|
}
|
|
else
|
|
{
|
|
LogTrace("Message port is closed");
|
|
}
|
|
|
|
FreeMemSafe(message);
|
|
}
|
|
DeleteMsgPort(replyPort);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Process any remaining messages and close port cleanly.
|
|
*/
|
|
void CleanupMsgPort(struct MsgPort **port)
|
|
{
|
|
struct Message *msg;
|
|
struct MsgPort *msgPort = *port;
|
|
|
|
if (*port == NULL)
|
|
{
|
|
return;
|
|
}
|
|
|
|
*port = NULL;
|
|
|
|
while ((msg = GetMsg(msgPort)))
|
|
{
|
|
ReplyMsg(msg);
|
|
}
|
|
|
|
DeleteMsgPort(msgPort);
|
|
}
|