Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 790 insertions, 0 deletions

diff --git a/dcop/dcopc.c b/dcop/dcopc.c
new file mode 100644
index 000000000..c62caf2ba
--- /dev/null
+++ b/dcop/dcopc.c
@@ -0,0 +1,790 @@
+/* vi: set ts=2 sw=2 tw=78:
+ *
+ * C interface to DCOP
+ *
+ * (C) 2000 Rik Hemsley <rik@kde.org>
+ * (C) 2000 Simon Hausmann <hausmann@kde.org>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+/* sometimes __STDC__ is defined, but to 0. The hateful X headers
+   ask for '#if __STDC__', so they become confused. */
+#if defined(__STDC__)
+#if !__STDC__
+#undef __STDC__
+#define __STDC__ 1
+#endif
+#endif
+
+/* We really don't want to require X11 headers...  */
+
+#include "config.h"
+#include <qglobal.h>
+#if defined Q_WS_X11 && ! defined K_WS_QTONLY
+#include <X11/Xlib.h>
+#include <X11/X.h>
+#include <X11/Xproto.h>
+#include <X11/Xmd.h>
+
+#include <X11/ICE/ICE.h>
+#include <X11/ICE/ICElib.h>
+#include <X11/ICE/ICEutil.h>
+#include <X11/ICE/ICEconn.h>
+#include <X11/ICE/ICEmsg.h>
+#include <X11/ICE/ICEproto.h>
+#endif
+
+#include "dcopglobal.h"
+#include "dcopc.h"
+
+
+#define BUFFER_SIZE 1024
+
+enum {
+  DCOP_REPLY_PENDING,
+  DCOP_REPLY_OK,
+  DCOP_REPLY_FAILED
+};
+
+struct dcop_reply_struct
+{
+  unsigned long status;
+  char       ** replyType;
+  char       ** replyData;
+  int         * replyDataLength;
+  int           replyId;
+};
+
+  void
+dcop_process_message(
+  IceConn             iceConn,
+  IcePointer          clientObject,
+  int                 opcode,
+  unsigned long       length,
+  Bool                swap,
+  IceReplyWaitInfo  * replyWait,
+  Bool              * replyWaitRet
+);
+
+Bool dcop_attach_internal(Bool register_as_anonymous);
+Bool dcop_ice_register(void);
+Bool dcop_connect(void);
+Bool dcop_protocol_setup(void);
+
+char * dcop_write_int     (char * buf, int i);
+char * dcop_read_int      (char * buf, int * i);
+char * dcop_write_string  (char * buf, const char * text);
+char * dcop_read_string   (char * buf, char ** output);
+
+static char           * dcop_requested_name = 0;
+static char           * dcop_app_name       = 0;
+static int              dcop_major_opcode   = 0;
+static IceConn          dcop_ice_conn       = 0L;
+static CARD32           dcop_key           = 0;
+static int              dcop_reply_id       = 0;
+
+static IcePoVersionRec DCOPVersions[] = {
+  { DCOPVersionMajor, DCOPVersionMinor, dcop_process_message }
+};
+
+/***************************************************************************/
+
+  char *
+dcop_write_int(char * buf, int i)
+{
+  char * p = (char *)(&i);
+
+  buf[3] = *p++;
+  buf[2] = *p++;
+  buf[1] = *p++;
+  buf[0] = *p;
+
+  return buf + 4;
+}
+
+/***************************************************************************/
+
+  char *
+dcop_read_int(char * buf, int * i)
+{
+  char *p = (char *)i;
+
+  *p++ = buf[3];
+  *p++ = buf[2];
+  *p++ = buf[1];
+  *p   = buf[0];
+
+  return buf + 4;
+}
+
+/***************************************************************************/
+
+  char *
+dcop_write_string(char * buf, const char * text)
+{
+  char * pos = buf;
+  int l = strlen( text ) + 1; /* we need the \0! (Simon) */
+  pos = dcop_write_int(buf, l);
+  memcpy(pos, text, l);
+  return pos + l;
+}
+
+/***************************************************************************/
+
+  char *
+dcop_read_string(char * buf, char ** output)
+{
+  int length;
+  char * pos = dcop_read_int(buf, &length);
+  fprintf(stderr, "dcop_read_string: length == %d\n", length);
+
+  *output = (char *)malloc(length);
+  memcpy(*output, pos, length);
+  return pos + length;
+}
+
+/***************************************************************************/
+
+  Bool
+dcop_register_callback(const char * object_id, dcop_callback_t callback)
+{
+  /* STUB */
+
+  /* Avoid unused param warnings */
+  object_id = object_id;
+  callback = callback;
+  return False;
+
+  /*
+   * TODO:
+   * Map the given object id to the given callback internally, so that when we
+   * receive a message, we know where to send it. Or... should we just allow
+   * one callback only, and pass that all calls ? Depends whether I can be
+   * bothered to figure out how to do a 'map' in C.
+   */
+}
+
+/***************************************************************************/
+
+  void
+dcop_process_message(
+  IceConn             iceConn,
+  IcePointer          clientObject,
+  int                 opcode,
+  unsigned long       length,
+  Bool                swap,
+  IceReplyWaitInfo  * replyWait,
+  Bool              * replyWaitRet
+)
+{
+  struct DCOPMsg * pMsg = 0L;
+  Status status = False;
+
+  char  * buf         = 0L;
+  char  * senderId    = 0L;
+  char  * app         = 0L;
+  char  * objId       = 0L;
+  char  * fun         = 0L;
+  char  * pos         = 0L;
+  char  * replyType   = 0L;
+
+  int     dataLength  = 0;
+
+  unsigned long replyVal  = 0L;
+
+  /* Avoid unused param warnings */
+  clientObject = clientObject;
+  swap = swap;
+
+  if (0 == replyWait) {
+    fprintf(stderr, "dcop_process_message(): replyWait is 0\n");
+  }
+
+  if (iceConn != dcop_ice_conn) {
+    fprintf(stderr, "dcop_process_message(): ICE connection does not match\n");
+    return;
+  }
+
+  IceReadMessageHeader(
+    dcop_ice_conn,
+    sizeof(struct DCOPMsg),
+    struct DCOPMsg,
+    pMsg
+  );
+
+
+  switch (opcode) {
+
+    case DCOPReply:
+      fprintf(stderr, "dcop_process_message(): DCOPReply received\n");
+
+      fprintf(stderr, "dcop_process_message(): length == %ld\n", length);
+      buf = (char *)malloc(length);
+      status = IceReadData(dcop_ice_conn, length, buf);
+      if (False == status) {
+        fprintf(stderr, "dcop_process_message(): IceReadData failed\n");
+      }
+
+      fprintf(stderr, "dcop_process_message(): Reading data\n");
+      pos = buf;
+      pos = dcop_read_string(pos, &replyType);
+      fprintf(stderr, "dcop_process_message(): replyType : `%s'\n", replyType);
+
+      /* TODO: Run user-provided callback. */
+
+      free(replyType);
+
+      replyVal = DCOP_REPLY_OK;
+      break;
+
+    case DCOPReplyFailed:
+      fprintf(stderr, "dcop_process_message(): DCOPReplyFailed received\n");
+      break;
+
+    case DCOPReplyWait:
+      fprintf(stderr, "dcop_process_message(): DCOPReplyWait received\n");
+      break;
+
+    case DCOPReplyDelayed:
+      fprintf(stderr, "dcop_process_message(): DCOPReplyDelayed received\n");
+      break;
+
+    case DCOPFind:
+      fprintf(stderr, "dcop_process_message(): DCOPFind received\n");
+      break;
+
+    case DCOPSend:
+
+      fprintf(stderr, "dcop_process_message(): DCOPSend received\n");
+
+      buf = (char *)malloc(length);
+      IceReadData(dcop_ice_conn, length, buf);
+
+      pos = buf;
+      pos = dcop_read_string(pos, &senderId);
+      pos = dcop_read_string(pos, &app);
+      pos = dcop_read_string(pos, &objId);
+      pos = dcop_read_string(pos, &fun);
+      pos = dcop_read_int(pos, &dataLength);
+
+      /* TODO: Run user-provided callback. */
+
+      free(senderId);
+      free(app);
+      free(objId);
+      free(fun);
+      free(buf);
+
+      replyVal = DCOP_REPLY_OK;
+      break;
+
+    case DCOPCall:
+      fprintf(stderr, "dcop_process_message(): DCOPCall not yet implemented\n");
+      break;
+
+    default:
+      fprintf(stderr, "dcop_process_message(): Invalid opcode %d\n", opcode);
+      break;
+  }
+
+  if (0 != replyWait)
+    ((struct dcop_reply_struct *)replyWait->reply)->status = replyVal;
+
+  fprintf(stderr, "dcop_process_message(): Setting replyWaitRet = True\n");
+  *replyWaitRet = True;
+  fprintf(stderr, "dcop_process_message(): Returning\n");
+}
+
+/***************************************************************************/
+
+  Bool
+dcop_send_signal(
+  const char  * receiving_app,
+  const char  * object,
+  const char  * function,
+  char        * data,
+  int           dataLength
+)
+{
+  char        * pos           = 0L;
+  char        * header        = 0L;
+  unsigned int  headerLength  = 0;
+
+  struct DCOPMsg * pMsgPtr = 0;
+
+  static const char* sAnonymous = "anonymous";
+
+  if (0 == dcop_ice_conn) {
+    fprintf(stderr, "Try running dcop_attach(), moron\n");
+    return False;
+  }
+
+  /*
+   * First let ICE initialize the ICE Message Header and give us a pointer to
+   * it (ICE manages that buffer internally)
+   */
+  IceGetHeader(
+    dcop_ice_conn,
+    dcop_major_opcode,
+    DCOPSend,
+    sizeof(struct DCOPMsg),
+    struct DCOPMsg,
+    pMsgPtr
+  );
+
+  /*
+   * Marshall the arguments for the DCOP message header (callerApp, destApp,
+   * destObj, destFunc. The last argument is actually part of the data part of
+   * the call, but we add it to the header. It's the size of the marshalled
+   * argument data. In Qt it would look like QDataStream str( ... ) str <<
+   * callerApp << destApp << destObj << destFun <<
+   * argumentQByteArrayDataStuff; (where as str is the complete data stream
+   * sent do the dcopserver, excluding the ICE header) As the QByteArray is
+   * marshalled as [size][data] and as we (below) send the data in two chunks,
+   * first the dcop msg header and the the data, we just put the [size] field
+   * as last field into the dcop msg header ;-)
+   */
+
+  headerLength = strlen(sAnonymous) + 1 +
+                 strlen(receiving_app) + 1 +
+                 strlen(object) + 1 +
+                 strlen(function) + 1 +
+                 4*5;  /* 4 string lengths + 1 int */
+
+  header = (char *)malloc(headerLength);
+
+  pos = header;
+
+  pos = dcop_write_string(pos, sAnonymous);
+  pos = dcop_write_string(pos, receiving_app);
+  pos = dcop_write_string(pos, object);
+  pos = dcop_write_string(pos, function);
+  pos = dcop_write_int(pos, dataLength);
+
+  headerLength = pos - header;
+
+  pMsgPtr->key = dcop_key;
+  /*
+   * The length field tells the dcopserver how much bytes the dcop message
+   * takes up. We add that size to the already by IceGetHeader initialized
+   * length value, as it seems that under some circumstances (depending on the
+   * DCOPMsg structure size) the length field is aligned/padded.
+   */
+  pMsgPtr->length += headerLength + dataLength;
+
+  /* First let's send the dcop message header.
+   * IceSendData automatically takes care of first sending the Ice Message
+   * Header (outbufptr > outbuf -> flush the connection buffer)
+   */
+  IceSendData(dcop_ice_conn, headerLength, header);
+
+  /* Now the function argument data */
+  IceSendData(dcop_ice_conn, dataLength, data);
+
+  /* Send it all ;-) */
+  IceFlush(dcop_ice_conn);
+
+  free(header);
+
+  if (IceConnectionStatus(dcop_ice_conn) != IceConnectAccepted)
+    return False;
+	
+  return True;
+}
+
+/***************************************************************************/
+
+  Bool
+dcop_call(
+  const char  * appId,
+  const char  * remApp,
+  const char  * remObjId,
+  const char  * remFun,
+  const char  * data,
+  int           dataLength,
+  char       ** replyType,
+  char       ** replyData,
+  int         * replyDataLength
+)
+{
+  IceReplyWaitInfo          waitInfo;
+  IceProcessMessagesStatus  status;
+  struct dcop_reply_struct  replyStruct;
+
+  char  * pos               = 0L;
+  char  * outputData        = 0L;
+  int     outputDataLength  = 0;
+  int     temp              = 0;
+  Bool    success           = False;
+  Bool    readyRet          = False;
+
+  struct DCOPMsg * pMsg;
+
+
+  fprintf(stderr, "dcop_call() ...\n");
+
+  if (0 == dcop_ice_conn) {
+    fprintf(stderr, "Try running dcop_register(), moron\n");
+    return False;
+  }
+
+
+  temp += strlen(appId);
+  temp += strlen(remApp);
+  temp += strlen(remObjId);
+  temp += strlen(remFun);
+  temp += dataLength;
+  temp += 1024; /* Extra space for marshalling overhead */
+
+  outputData = (char *)malloc(temp);
+
+  temp = 0;
+
+  pos = outputData;
+  pos = dcop_write_string(pos, appId);
+  pos = dcop_write_string(pos, remApp);
+  pos = dcop_write_string(pos, remObjId);
+  pos = dcop_write_string(pos, remFun);
+  pos = dcop_write_int(pos, dataLength);
+
+  outputDataLength = pos - outputData;
+
+  IceGetHeader(
+	       dcop_ice_conn,
+	       dcop_major_opcode,
+	       DCOPCall,
+	       sizeof(struct DCOPMsg),
+	       struct DCOPMsg,
+	       pMsg
+	       );
+
+  pMsg->length += outputDataLength + dataLength;
+
+  IceSendData(dcop_ice_conn, outputDataLength, outputData);
+  IceSendData(dcop_ice_conn, dataLength, (char *)data);
+
+  IceFlush(dcop_ice_conn);
+
+  free(outputData);
+  outputData = NULL;
+
+  if (IceConnectionStatus(dcop_ice_conn) != IceConnectAccepted) {
+      fprintf(stderr, "dcop_call(): Connection not accepted\n");
+      return False;
+  }
+
+  waitInfo.sequence_of_request = IceLastSentSequenceNumber(dcop_ice_conn);
+  waitInfo.major_opcode_of_request = dcop_major_opcode;
+  waitInfo.minor_opcode_of_request = DCOPCall;
+
+  replyStruct.status = DCOP_REPLY_PENDING;
+  replyStruct.replyId = dcop_reply_id++;
+  replyStruct.replyType = replyType;
+  replyStruct.replyData = replyData;
+  replyStruct.replyDataLength = replyDataLength;
+
+  waitInfo.reply = (IcePointer)(&replyStruct);
+
+  readyRet = False;
+
+  do {
+      fprintf(stderr, "dcop_call(): Doing IceProcessMessages\n");
+      status = IceProcessMessages(dcop_ice_conn, &waitInfo, &readyRet);
+
+      if (status == IceProcessMessagesIOError) {
+        fprintf(stderr, "dcop_call(): IceProcessMessagesIOError\n");
+        IceCloseConnection(dcop_ice_conn);
+        return False;
+      }
+
+      fprintf(stderr, "dcop_call(): readyRet == %s\n", readyRet ? "True" : "False");
+  } while (!readyRet);
+
+  fprintf(stderr, "dcop_call(): Finished\n");
+  return (replyStruct.status == DCOP_REPLY_OK) ? True : False;
+}
+
+/***************************************************************************/
+
+  Bool
+dcop_attach()
+{
+  fprintf(stderr, "dcop_attach()\n");
+  return dcop_attach_internal(True);
+}
+
+  Bool
+dcop_attach_internal(Bool register_as_anonymous)
+{
+  fprintf(stderr,
+    "dcop_attach_internal(%s)\n", register_as_anonymous ? "True" : "False");
+
+  if (False == dcop_ice_register())   return False;
+  if (False == dcop_connect())        return False;
+  if (False == dcop_protocol_setup()) return False;
+
+  if (register_as_anonymous)
+    return (0L != dcop_register("anonymous", True)) ? True : False;
+
+  return True;
+}
+
+/***************************************************************************/
+
+  char *
+dcop_register(const char * app_name, Bool add_pid)
+{
+  char * replyType  = 0L;
+  char * replyData  = 0L;
+  int    replyLen   = 0;
+  char * data       = 0L;
+  char * pos        = 0L;
+  int    dataLength = 0;
+  Bool   callStatus = False;
+
+  fprintf(stderr, "dcop_register(`%s')\n", app_name);
+
+  if (0 == dcop_app_name) {
+
+    if (0 == dcop_ice_conn)
+      if (False == dcop_attach_internal(False))
+        return 0L;
+
+  } else {
+
+    fprintf(stderr, "dcop_init(): Reregistering as `%s'\n", app_name);
+
+    callStatus = dcop_detach();
+
+    if (False == callStatus) {
+      fprintf(stderr, "dcop_init(): Could not detach before reregistering\n");
+      return 0L;
+    }
+  }
+
+  if (False == add_pid)
+    dcop_requested_name = strdup(app_name);
+
+  else {
+
+    /* Leave room for "-pid" */
+    int len = strlen(app_name) + 64;
+    dcop_requested_name = (char *)malloc(len);
+
+    snprintf(dcop_requested_name, len, "%s-%ld", app_name, (long)getpid());
+  }
+
+  data = (char *)malloc(strlen(dcop_requested_name) + 42);
+
+  pos = data;
+  pos = dcop_write_string(pos, dcop_requested_name);
+  dataLength = pos - data;
+
+  callStatus =
+    dcop_call(
+      dcop_requested_name,
+      "DCOPServer",
+      "", /* Object irrelevant */
+      "registerAs(QCString)",
+      data,
+      dataLength,
+      &replyType,
+      &replyData,
+      &replyLen
+    );
+
+  free(dcop_requested_name);
+  free(data);
+
+  if (False == callStatus) {
+    fprintf(stderr, "dcop_register(): dcop_call() failed\n");
+    return 0L;
+  }
+
+  fprintf(stderr, "dcop_register(): Reply length is %d\n", replyLen);
+
+  if (replyLen == 0)
+    return 0L;
+
+  dcop_read_string(replyData, &dcop_app_name);
+
+  return dcop_app_name;
+}
+
+/***************************************************************************/
+
+  Bool
+dcop_ice_register()
+{
+  dcop_major_opcode =
+    IceRegisterForProtocolSetup(
+      (char *)("DCOP"),
+      (char *)DCOPVendorString,
+      (char *)DCOPReleaseString,
+      1, /* What's this ? */
+      DCOPVersions,
+      DCOPAuthCount,
+      (char **)DCOPAuthNames,
+      DCOPClientAuthProcs,
+      0L /* What's this ? */
+    );
+
+  return (dcop_major_opcode >= 0) ? True : False;
+}
+
+
+/***************************************************************************/
+
+  Bool
+dcop_connect()
+{
+  size_t      bytesRead     = 0;
+  IcePointer  context       = 0;
+  FILE *      f             = 0L;
+  char      * newline       = 0L;
+  char      * homeDir       = 0L;
+  char      * display       = 0L;
+  char      * dcopServer    = 0L;
+  char        errBuf[BUFFER_SIZE];
+  char        fileName[BUFFER_SIZE];
+  char        hostName[BUFFER_SIZE];
+  char        displayName[BUFFER_SIZE];
+  char      * i;
+
+  homeDir = getenv("HOME");
+
+  if (NULL == homeDir)
+    return False;
+
+  display = getenv("DISPLAY");
+  
+  if (NULL == display)
+    display = "NODISPLAY";
+
+  strncpy(displayName, display, sizeof(displayName));
+  displayName[sizeof(displayName) - 1] = 0;
+
+  if((i = strrchr(displayName, '.')) > strrchr(displayName, ':') && i)
+      *i = '\0';
+
+  while((i = strchr(displayName, ':')) != NULL)
+     *i = '_';
+
+  dcopServer = getenv("DCOPSERVER");
+
+  if (NULL == dcopServer) {
+
+    if (-1 == chdir(homeDir)) {
+      fprintf(stderr, "Cannot cd ~\n");
+      return False;
+    }
+
+    hostName[0] = '\0';
+    if (gethostname(hostName, sizeof(hostName)))
+	    strcpy(hostName, "localhost");
+    else
+	    hostName[sizeof(hostName)-1] = '\0';
+
+    snprintf(fileName, sizeof(fileName), ".DCOPserver_%s_%s", hostName, displayName);
+    f = fopen(fileName, "r");
+
+    if (NULL == f) {
+      fprintf(stderr, "Cannot open ~/%s\n", fileName);
+      return False;
+    }
+
+    dcopServer = (char *)malloc(BUFFER_SIZE);
+
+    bytesRead = fread((void *)dcopServer, sizeof(char), BUFFER_SIZE, f);
+    dcopServer[BUFFER_SIZE - 1] = 0;
+
+    if (0 == bytesRead)
+      return False;
+
+    newline = strchr(dcopServer, '\n');
+
+    if (NULL == newline) {
+      fprintf(stderr, "dcop server file format invalid\n");
+      return False;
+    }
+
+    *newline = '\0';
+  }
+
+  dcop_ice_conn =
+    IceOpenConnection(
+      dcopServer,
+      context,
+      False,
+      dcop_major_opcode,
+      sizeof(errBuf),
+      errBuf
+    );
+
+  if (NULL != dcopServer)
+    free(dcopServer);
+
+  if (0 == dcop_ice_conn) {
+    fprintf(stderr, "dcop_ice_conn is 0 :(\n");
+    return False;
+  }
+
+  IceSetShutdownNegotiation(dcop_ice_conn, False);
+
+  return True;
+}
+
+/***************************************************************************/
+
+  Bool
+dcop_protocol_setup()
+{
+  char        * vendor        = 0L;
+  char        * release       = 0L;
+  IcePointer    clientData    = 0;
+  int           majorVersion  = 0;
+  int           minorVersion  = 0;
+  int           status        = 0;
+  char          errBuf[BUFFER_SIZE];
+
+  status =
+    IceProtocolSetup(
+      dcop_ice_conn,
+      dcop_major_opcode,
+      clientData,
+      True,
+      &(majorVersion),
+      &(minorVersion),
+      &(vendor),
+      &(release),
+      BUFFER_SIZE,
+      errBuf
+    );
+
+  return (
+    (status == IceProtocolSetupSuccess) &&
+    (IceConnectionStatus(dcop_ice_conn) == IceConnectAccepted)
+  );
+}
+
+/***************************************************************************/
+
+  Bool
+dcop_detach()
+{
+  int status;
+  IceProtocolShutdown(dcop_ice_conn, dcop_major_opcode);
+  status = IceCloseConnection(dcop_ice_conn);
+
+  if (status == IceClosedNow)
+    dcop_ice_conn = 0L;
+  else
+    fprintf(stderr, "dcop_detach(): Could not detach\n");
+
+  return status == IceClosedNow;
+}
+