Пример #1
0
IPC_RETURN_TYPE IPC_queryNotify (const char *msgName,
				 unsigned int length, BYTE_ARRAY content,
				 HANDLER_TYPE handler, void *clientData)
{
  MSG_PTR msg;
  void *queryData;
  IPC_VARCONTENT_TYPE vc;

  if (!msgName || strlen(msgName) == 0) {
    RETURN_ERROR(IPC_Null_Argument);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    msg = x_ipc_msgFind(msgName);
    if (msg == NULL) {
      RETURN_ERROR(IPC_Message_Not_Defined);
    } else if (ipcDataToSend(msg->msgData->msgFormat, msgName, 
			     length, content, &queryData, &vc) != IPC_OK) {
      PASS_ON_ERROR();
    } else {
      return ipcReturnValue(x_ipc_queryNotifySend(msg, msgName, queryData,
						  (REPLY_HANDLER_FN)handler, 
						  clientData));
    }
  }
}
Пример #2
0
IPC_RETURN_TYPE IPC_publish (const char *msgName,
			     unsigned int length, BYTE_ARRAY content)
{
  MSG_PTR msg;
  CONST_FORMAT_PTR format;
  void *dataToSend;
  IPC_VARCONTENT_TYPE vc;

  if (!msgName || strlen(msgName) == 0) {
    RETURN_ERROR(IPC_Null_Argument);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    msg = x_ipc_msgFind(msgName);
    if (!msg) {
      RETURN_ERROR(IPC_Message_Not_Defined);
    } else {
      format = msg->msgData->msgFormat;
      if (ipcDataToSend(format, msgName, length, content, &dataToSend, &vc)
	  != IPC_OK) {
	PASS_ON_ERROR();
      } else {
	return ipcReturnValue(x_ipcBroadcast(msgName, dataToSend));
      }
    }
  }
}
Пример #3
0
IPC_RETURN_TYPE _IPC_subscribe (const char *msgName, const char *hndName,
				HANDLER_TYPE handler, void *clientData,
				int autoUnmarshall)
{
  HND_KEY_TYPE hndKey;
  HND_PTR hnd;

  if (!msgName || strlen(msgName) == 0) {
    RETURN_ERROR(IPC_Null_Argument);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    x_ipcRegisterHandler(msgName, hndName, handler);

    /* Set the client data */
    hndKey.num = 0; hndKey.str = hndName;
    LOCK_CM_MUTEX;
    hnd = GET_HANDLER(&hndKey);
    UNLOCK_CM_MUTEX;
    hnd->autoUnmarshall = autoUnmarshall;
    if (hnd->isRegistered && hnd->clientData != NO_CLIENT_DATA) {
      X_IPC_MOD_WARNING1("Resetting client data for handler %s\n", hndName);
    }
    hnd->isRegistered = TRUE;
    hnd->clientData = clientData;

    return IPC_OK;
  }
}
Пример #4
0
IPC_RETURN_TYPE IPC_defineMsg (const char *msgName, unsigned int length,
			       const char *formatString)
{
  char msgFormat[20];

  if (!msgName || strlen(msgName) == 0) {
    RETURN_ERROR(IPC_Null_Argument);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } if (length != (unsigned int)IPC_VARIABLE_LENGTH && formatString != NULL &&
	length != (unsigned int)x_ipc_dataStructureSize(ParseFormatString(formatString))) {
    RETURN_ERROR(IPC_Mismatched_Formatter);
  } else {
    if (length == IPC_VARIABLE_LENGTH) {
      sprintf(msgFormat, "{int, <byte:1>}");
    } else if (length == 0) {
      msgFormat[0] = '\0';
    } else {
      sprintf(msgFormat, "[byte:%d]", length);
    }
    x_ipcRegisterMessage(msgName, BroadcastClass, msgFormat, formatString);

    return IPC_OK;
  }
}
Пример #5
0
IPC_RETURN_TYPE IPC_respond (MSG_INSTANCE msgInstance, const char *msgName,
			     unsigned int length, BYTE_ARRAY content)
{
  MSG_PTR msg;
  void *replyData;
  IPC_VARCONTENT_TYPE vc;

  if (!msgName || strlen(msgName) == 0) {
    RETURN_ERROR(IPC_Null_Argument);
  } else if (!msgInstance) {
    RETURN_ERROR(IPC_Null_Argument);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    msg = x_ipc_msgFind(msgName);
    if (!msg) {
      RETURN_ERROR(IPC_Message_Not_Defined);
    } else if (ipcDataToSend(msg->msgData->msgFormat, msgName, 
			     length, content, &replyData, &vc) != IPC_OK) {
      PASS_ON_ERROR();
    } else {
      return ipcReturnValue(x_ipc_sendResponse(msgInstance, msg,
					       (char *)replyData,
					       ReplyClass, NULL,
					       msgInstance->responseSd));
    }
  }
}
Пример #6
0
IPC_RETURN_TYPE IPC_listen (unsigned int timeoutMSecs)
{
#ifndef IPC_ALLOW_DISCONNECTED_EVENT_HANDLING
  if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  }
#endif
  return ipcReturnValue(x_ipcHandleMessage(timeoutMSecs));
}
Пример #7
0
IPC_RETURN_TYPE _IPC_unsubscribe (const char *msgName, const char *hndName)
{
  if (!msgName || strlen(msgName) == 0) {
    RETURN_ERROR(IPC_Null_Argument);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    x_ipcDeregisterHandler(msgName, hndName);
    return IPC_OK;
  }
}
Пример #8
0
int IPC_isMsgDefined (const char *msgName)
{
  if (!msgName || strlen(msgName) == 0) {
    ipcSetError(IPC_Null_Argument);
    return FALSE;
  } else if (!X_IPC_CONNECTED()) {
    ipcSetError(IPC_Not_Connected);
    return FALSE;
  } else {
    return x_ipcMessageRegistered(msgName);
  }
}
Пример #9
0
int IPC_isModuleConnected (const char *moduleName)
{
  if (!moduleName || strlen(moduleName) == 0) {
    ipcSetError(IPC_Null_Argument); return -1;
  } else if (!X_IPC_CONNECTED()) {
    ipcSetError(IPC_Not_Connected); return -1;
  } else {
    int retVal;
    x_ipcQuery(IPC_MODULE_CONNECTED_QUERY, &moduleName, &retVal);
    return retVal;
  }
}
Пример #10
0
IPC_RETURN_TYPE IPC_unsubscribeHandlerChange (const char *msgName,
					      CHANGE_HANDLE_TYPE handler)
{
  if (!msgName || strlen(msgName) == 0) {
    RETURN_ERROR(IPC_Null_Argument);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    removeChange(msgName, handler);
    return IPC_OK;
  }
}
Пример #11
0
IPC_RETURN_TYPE IPC_unsubscribeDisconnect (CONNECT_HANDLE_TYPE handler)
{
  if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    LOCK_CM_MUTEX;
    removeConnect(GET_C_GLOBAL(disconnectNotifyList), 
		  IPC_DISCONNECT_NOTIFY_MSG, handler);
    UNLOCK_CM_MUTEX;
    return IPC_OK;
  }
}
Пример #12
0
IPC_RETURN_TYPE IPC_setCapacity (int capacity)
{
  if (capacity < 1) {
    RETURN_ERROR(IPC_Argument_Out_Of_Range);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    LOCK_M_MUTEX;
    x_ipcRegisterResource(GET_M_GLOBAL(modNameGlobal), capacity);
    UNLOCK_M_MUTEX;
    return IPC_OK;
  }
}
Пример #13
0
/* TNgo, 5/22/97, added another variable to this function
   so that it can be called by IPC_connectModule */
IPC_RETURN_TYPE _IPC_connect (const char *taskName,
			      const char *serverName,
			      BOOLEAN willListen)
{
  const char *serverHost;
  char *colon = NULL;
  int i, serverPort;
  struct timeval wait;

  /* Added by Bob Goode/Tam Ngo, 5/21/97, for WINSOCK option. */
#ifdef OS2
  sock_init();
#elif defined(_WINSOCK_)
  startWinsock();
#endif /* Winsock DLL loading */

  if (ipcVerbosity > IPC_Silent) {
    printf("NMP IPC Version %d.%d.%d (%s)\n", 
	   IPC_VERSION_MAJOR, IPC_VERSION_MINOR, IPC_VERSION_MICRO,
	   IPC_VERSION_DATE);
  }

  /* Modified by TNgo, 5/22/97 */
  serverHost = ((serverName != NULL && strlen(serverName) > 0) 
		? serverName : x_ipcServerMachine());

  for (i=0; i<MAX_RECONNECT_TRIES; i++) {
    if (i > 0 && ipcVerbosity > IPC_Silent)
      printf("  Trying again %s to connect with the central server on %s\n",
		      taskName, serverHost);
    IPC_initialize();
    x_ipcWillListen(willListen);
    x_ipcConnectModule(taskName, serverHost);
    if (X_IPC_CONNECTED()) {
      x_ipcWaitUntilReady();
      if (ipcVerbosity > IPC_Silent) {
	colon = (serverHost ? (char *)index((char *)serverHost, ':') : NULL);
	serverPort = (colon == NULL ? SERVER_PORT : atoi(colon+1));
	X_IPC_MOD_WARNING1("... IPC Connected on port %d\n", serverPort);
      }
      return IPC_OK;
    } else {
      /* Need to do this, rather than sleep, because of SIGALRM's */
      wait.tv_sec = RECONNECT_WAIT; wait.tv_usec = 0;
      select(0, 0, 0, 0, &wait);
    }
  }
  /* At this point, we've been unable to connect */
  RETURN_ERROR(IPC_Not_Connected);
}
Пример #14
0
IPC_RETURN_TYPE IPC_subscribeDisconnect (CONNECT_HANDLE_TYPE handler,
					 void *clientData)
{
  if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    LOCK_CM_MUTEX;
    insertConnect(&GET_C_GLOBAL(disconnectNotifyList),
		  IPC_DISCONNECT_NOTIFY_MSG, (X_IPC_HND_FN)ipcDisconnectHandler,
		  handler, clientData);
    UNLOCK_CM_MUTEX;
    return IPC_OK;
  }
}
Пример #15
0
IPC_RETURN_TYPE IPC_setMsgQueueLength (const char *msgName, int queueLength)
{
  MSG_PTR msg;

  if (queueLength < 1) {
    RETURN_ERROR(IPC_Argument_Out_Of_Range);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    msg = x_ipc_findOrRegisterMessage(msgName);
    msg->limit = queueLength;
    LOCK_M_MUTEX;
    x_ipcLimitPendingMessages(msgName, GET_M_GLOBAL(modNameGlobal), 
			      queueLength);
    UNLOCK_M_MUTEX;
    return IPC_OK;
  }
}
Пример #16
0
IPC_RETURN_TYPE IPC_subscribeHandlerChange (const char *msgName,
					    CHANGE_HANDLE_TYPE handler,
					    void *clientData)
{
  MSG_PTR msg;

  if (!msgName || strlen(msgName) == 0) {
    RETURN_ERROR(IPC_Null_Argument);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    msg = x_ipc_msgFind2(msgName, NULL);
    if (!msg) {
      RETURN_ERROR(IPC_Message_Not_Defined);
    } else {
      insertChange(msgName, handler, clientData);
      return IPC_OK;
    }
  }
}
Пример #17
0
IPC_RETURN_TYPE IPC_setMsgPriority (const char *msgName, int priority)
{
  SET_MSG_PRIORITY_TYPE setMsgData;
  MSG_PTR msg;

  if (priority < 0) {
    RETURN_ERROR(IPC_Argument_Out_Of_Range);
  } else if (!X_IPC_CONNECTED()) {
    RETURN_ERROR(IPC_Not_Connected);
  } else {
    msg = x_ipc_findOrRegisterMessage(msgName);
    msg->priority = priority;

    setMsgData.msgName = (char*)msgName;
    setMsgData.priority = priority;

    return ipcReturnValue(x_ipcInform(IPC_SET_MSG_PRIORITY_INFORM,
				      &setMsgData));
  } 
}
Пример #18
0
int IPC_numHandlers (const char *msgName)
{
  DIRECT_MSG_TYPE directInfo;
  X_IPC_RETURN_VALUE_TYPE status;
  int num;

  if (!msgName || strlen(msgName) == 0) {
    ipcSetError(IPC_Null_Argument); return -1;
  } else if (!X_IPC_CONNECTED()) {
    ipcSetError(IPC_Not_Connected); return -1;
  } else {
    status = x_ipcQueryCentral(X_IPC_DIRECT_MSG_QUERY, (void *)&msgName,
			       (void *)&directInfo);
    if (status == Success) {
      num = directInfo.numHandlers;
      x_ipcFreeReply(X_IPC_DIRECT_MSG_QUERY, &directInfo);
    } else {
      num = 0;
    }
    return num;
  }
}
Пример #19
0
/* Returns TRUE (1) if the module is currently connected to the IPC server */
int IPC_isConnected (void)
{
  return X_IPC_CONNECTED();
}