Back to index

lightning-sunbird  0.9+nobinonly
Classes | Defines | Typedefs | Functions | Variables
ipcDConnectService.cpp File Reference
#include <stdio.h>
#include "ipcDConnectService.h"
#include "ipcMessageWriter.h"
#include "ipcMessageReader.h"
#include "ipcLog.h"
#include "nsServiceManagerUtils.h"
#include "nsIInterfaceInfo.h"
#include "nsIInterfaceInfoManager.h"
#include "nsAutoPtr.h"
#include "nsString.h"
#include "nsVoidArray.h"
#include "nsCRT.h"
#include "xptcall.h"

Go to the source code of this file.

Classes

struct  DConnectOp
struct  DConnectSetup
struct  DConnectSetupClassID
struct  DConnectSetupContractID
struct  DConnectSetupQueryInterface
struct  DConnectSetupReply
struct  DConnectRelease
struct  DConnectInvoke
struct  DConnectInvokeReply
class  DConnectInstance
class  DConnectCompletion
class  DConnectInvokeCompletion
class  DConnectStub
class  DConnectSetupCompletion

Defines

#define DCONNECT_IPC_TARGETID
#define DCON_WAIT_TIMEOUT   PR_INTERVAL_NO_TIMEOUT
#define DCON_OP_SETUP   1
#define DCON_OP_RELEASE   2
#define DCON_OP_INVOKE   3
#define DCON_OP_SETUP_REPLY   4
#define DCON_OP_INVOKE_REPLY   5
#define DCON_OP_SETUP_NEW_INST_CLASSID   1
#define DCON_OP_SETUP_NEW_INST_CONTRACTID   2
#define DCON_OP_SETUP_GET_SERV_CLASSID   3
#define DCON_OP_SETUP_GET_SERV_CONTRACTID   4
#define DCON_OP_SETUP_QUERY_INTERFACE   5
#define DCONNECT_STUB_ID

Typedefs

typedef unsigned long PtrBits
typedef class DConnectInstanceDConAddr

Functions

static nsresult SetupPeerInstance (PRUint32 aPeerID, DConnectSetup *aMsg, PRUint32 aMsgLen, void **aInstancePtr)
static void DeleteWrappers (nsVoidArray &wrappers)
static nsresult SerializeParam (ipcMessageWriter &writer, const nsXPTType &t, const nsXPTCMiniVariant &v)
static nsresult DeserializeParam (ipcMessageReader &reader, const nsXPTType &t, nsXPTCVariant &v)
static nsresult SetupParam (const nsXPTParamInfo &p, nsXPTCVariant &v)
static void FinishParam (nsXPTCVariant &v)
static nsresult DeserializeResult (ipcMessageReader &reader, const nsXPTType &t, nsXPTCMiniVariant &v)
static PRUint32 NewRequestIndex ()
static NS_DEFINE_IID (kDConnectStubID, DCONNECT_STUB_ID)
static nsresult CreateStub (const nsID &iid, PRUint32 peer, DConAddr instance, DConnectStub **result)
static nsresult SerializeInterfaceParam (ipcMessageWriter &writer, PRUint32 peer, const nsID &iid, const nsXPTType &type, const nsXPTCMiniVariant &v, nsVoidArray &wrappers)
 DestroyDConnectInstance (const void *key, DConnectInstance *wrapper, void *userArg)

Variables

static const nsID kDConnectTargetID = DCONNECT_IPC_TARGETID
static ipcDConnectServicegDConnect

Define Documentation

Definition at line 95 of file ipcDConnectService.cpp.

Definition at line 98 of file ipcDConnectService.cpp.

Definition at line 94 of file ipcDConnectService.cpp.

Definition at line 93 of file ipcDConnectService.cpp.

Definition at line 103 of file ipcDConnectService.cpp.

Definition at line 104 of file ipcDConnectService.cpp.

Definition at line 101 of file ipcDConnectService.cpp.

Definition at line 102 of file ipcDConnectService.cpp.

Definition at line 105 of file ipcDConnectService.cpp.

Definition at line 97 of file ipcDConnectService.cpp.

Definition at line 72 of file ipcDConnectService.cpp.

Value:
{ /* 43ca47ef-ebc8-47a2-9679-a4703218089f */       \
  0x43ca47ef,                                      \
  0xebc8,                                          \
  0x47a2,                                          \
  {0x96, 0x79, 0xa4, 0x70, 0x32, 0x18, 0x08, 0x9f} \
}

Definition at line 61 of file ipcDConnectService.cpp.

Value:
{ /* 132c1f14-5442-49cb-8fe6-e60214bbf1db */       \
  0x132c1f14,                                      \
  0x5442,                                          \
  0x49cb,                                          \
  {0x8f, 0xe6, 0xe6, 0x02, 0x14, 0xbb, 0xf1, 0xdb} \
}

Definition at line 751 of file ipcDConnectService.cpp.


Typedef Documentation

typedef class DConnectInstance* DConAddr

Definition at line 117 of file ipcDConnectService.cpp.

typedef unsigned long PtrBits

Definition at line 76 of file ipcDConnectService.cpp.


Function Documentation

static nsresult CreateStub ( const nsID iid,
PRUint32  peer,
DConAddr  instance,
DConnectStub **  result 
) [static]

Definition at line 811 of file ipcDConnectService.cpp.

{
  nsresult rv;

  nsCOMPtr<nsIInterfaceInfo> iinfo;
  rv = gDConnect->GetInterfaceInfo(iid, getter_AddRefs(iinfo));
  if (NS_FAILED(rv))
    return rv;

  DConnectStub *stub = new DConnectStub(iinfo,
                                        instance,
                                        peer);
  if (NS_UNLIKELY(!stub))
    rv = NS_ERROR_OUT_OF_MEMORY;
  else
  {
    NS_ADDREF(stub);
    *result = stub;
  }

  return rv;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void DeleteWrappers ( nsVoidArray wrappers) [static]

Definition at line 206 of file ipcDConnectService.cpp.

{
  for (PRInt32 i=0; i<wrappers.Count(); ++i)
    gDConnect->DeleteInstance((DConnectInstance *) wrappers[i]);
}

Here is the caller graph for this function:

static nsresult DeserializeParam ( ipcMessageReader reader,
const nsXPTType t,
nsXPTCVariant v 
) [static]

Definition at line 327 of file ipcDConnectService.cpp.

{
  // defaults
  v.ptr = nsnull;
  v.type = t;
  v.flags = 0;

  switch (t.TagPart())
  {
    case nsXPTType::T_I8:
    case nsXPTType::T_U8:
      v.val.u8 = reader.GetInt8();
      break;

    case nsXPTType::T_I16:
    case nsXPTType::T_U16:
      v.val.u16 = reader.GetInt16();
      break;

    case nsXPTType::T_I32:
    case nsXPTType::T_U32:
      v.val.u32 = reader.GetInt32();
      break;

    case nsXPTType::T_I64:
    case nsXPTType::T_U64:
      reader.GetBytes(&v.val.u64, sizeof(v.val.u64));
      break;

    case nsXPTType::T_FLOAT:
      reader.GetBytes(&v.val.f, sizeof(v.val.f));
      break;

    case nsXPTType::T_DOUBLE:
      reader.GetBytes(&v.val.d, sizeof(v.val.d));
      break;

    case nsXPTType::T_BOOL:
      reader.GetBytes(&v.val.b, sizeof(v.val.b));
      break;

    case nsXPTType::T_CHAR:
      reader.GetBytes(&v.val.c, sizeof(v.val.c));
      break;

    case nsXPTType::T_WCHAR:
      reader.GetBytes(&v.val.wc, sizeof(v.val.wc));
      break;

    case nsXPTType::T_IID:
      {
        nsID *buf = (nsID *) malloc(sizeof(nsID));
        NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY);
        reader.GetBytes(buf, sizeof(nsID));
        v.val.p = v.ptr = buf;
        v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_ALLOCD;
      }
      break;

    case nsXPTType::T_CHAR_STR:
      {
        PRUint32 len = reader.GetInt32();
        char *buf = (char *) malloc(len + 1);
        NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY);
        reader.GetBytes(buf, len);
        buf[len] = char(0);

        v.val.p = v.ptr = buf;
        v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_ALLOCD;
      }
      break;

    case nsXPTType::T_WCHAR_STR:
      {
        PRUint32 len = reader.GetInt32();
        PRUnichar *buf = (PRUnichar *) malloc(len + 2);
        NS_ENSURE_TRUE(buf, NS_ERROR_OUT_OF_MEMORY);
        reader.GetBytes(buf, len);
        buf[len] = PRUnichar(0);

        v.val.p = v.ptr = buf;
        v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_ALLOCD;
      }
      break;

    case nsXPTType::T_INTERFACE:
    case nsXPTType::T_INTERFACE_IS:
      {
        reader.GetBytes(&v.ptr, sizeof(void *));
        v.val.p = nsnull;
        v.flags = nsXPTCVariant::PTR_IS_DATA;
      }
      break;

    case nsXPTType::T_ASTRING:
    case nsXPTType::T_DOMSTRING:
      {
        PRUint32 len = reader.GetInt32();

        nsString *str = new nsString();
        if (!str || !(EnsureStringLength(*str, len/2)))
          return NS_ERROR_OUT_OF_MEMORY;
        PRUnichar *buf = str->BeginWriting();
        reader.GetBytes(buf, len);

        v.val.p = v.ptr = str;
        v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_DOMSTR;
      }
      break;

    case nsXPTType::T_UTF8STRING:
    case nsXPTType::T_CSTRING:
      {
        PRUint32 len = reader.GetInt32();

        nsCString *str = new nsCString();
        if (!str || !(EnsureStringLength(*str, len)))
          return NS_ERROR_OUT_OF_MEMORY;
        char *buf = str->BeginWriting();
        reader.GetBytes(buf, len);

        v.val.p = v.ptr = str;
        v.flags = nsXPTCVariant::PTR_IS_DATA;

        // this distinction here is pretty pointless
        if (t.TagPart() == nsXPTType::T_CSTRING)
          v.flags |= nsXPTCVariant::VAL_IS_CSTR;
        else
          v.flags |= nsXPTCVariant::VAL_IS_UTF8STR;
      }
      break;

    case nsXPTType::T_ARRAY:
      LOG(("array types are not yet supported\n"));
      return NS_ERROR_NOT_IMPLEMENTED;

    case nsXPTType::T_VOID:
    case nsXPTType::T_PSTRING_SIZE_IS:
    case nsXPTType::T_PWSTRING_SIZE_IS:
    default:
      LOG(("unexpected parameter type\n"));
      return NS_ERROR_UNEXPECTED;
  }
  return NS_OK;
}

Here is the call graph for this function:

static nsresult DeserializeResult ( ipcMessageReader reader,
const nsXPTType t,
nsXPTCMiniVariant v 
) [static]

Definition at line 536 of file ipcDConnectService.cpp.

{
  if (v.val.p == nsnull)
    return NS_OK;

  switch (t.TagPart())
  {
    case nsXPTType::T_I8:
    case nsXPTType::T_U8:
      *((PRUint8 *) v.val.p) = reader.GetInt8();
      break;

    case nsXPTType::T_I16:
    case nsXPTType::T_U16:
      *((PRUint16 *) v.val.p) = reader.GetInt16();
      break;

    case nsXPTType::T_I32:
    case nsXPTType::T_U32:
      *((PRUint32 *) v.val.p) = reader.GetInt32();
      break;

    case nsXPTType::T_I64:
    case nsXPTType::T_U64:
      reader.GetBytes(v.val.p, sizeof(PRUint64));
      break;

    case nsXPTType::T_FLOAT:
      reader.GetBytes(v.val.p, sizeof(float));
      break;

    case nsXPTType::T_DOUBLE:
      reader.GetBytes(v.val.p, sizeof(double));
      break;

    case nsXPTType::T_BOOL:
      reader.GetBytes(v.val.p, sizeof(PRBool));
      break;

    case nsXPTType::T_CHAR:
      reader.GetBytes(v.val.p, sizeof(char));
      break;

    case nsXPTType::T_WCHAR:
      reader.GetBytes(v.val.p, sizeof(PRUnichar));
      break;

    case nsXPTType::T_IID:
      {
        nsID *buf = (nsID *) nsMemory::Alloc(sizeof(nsID));
        reader.GetBytes(buf, sizeof(nsID));
        *((nsID **) v.val.p) = buf;
      }
      break;

    case nsXPTType::T_CHAR_STR:
      {
        PRUint32 len = reader.GetInt32();
        char *buf = (char *) nsMemory::Alloc(len + 1);
        reader.GetBytes(buf, len);
        buf[len] = char(0);

        *((char **) v.val.p) = buf;
      }
      break;

    case nsXPTType::T_WCHAR_STR:
      {
        PRUint32 len = reader.GetInt32();
        PRUnichar *buf = (PRUnichar *) nsMemory::Alloc(len + 2);
        reader.GetBytes(buf, len);
        buf[len] = PRUnichar(0);

        *((PRUnichar **) v.val.p) = buf;
      }
      break;

    case nsXPTType::T_INTERFACE:
    case nsXPTType::T_INTERFACE_IS:
      {
        // stub creation will be handled outside this routine.  we only
        // deserialize the DConAddr into v.val.p temporarily.
        void *ptr;
        reader.GetBytes(&ptr, sizeof(void *));
        *((void **) v.val.p) = ptr;
      }
      break;

    case nsXPTType::T_ASTRING:
    case nsXPTType::T_DOMSTRING:
      {
        PRUint32 len = reader.GetInt32();

        nsAString *str = (nsAString *) v.val.p;

        if (!str || !(EnsureStringLength(*str, len/2)))
          return NS_ERROR_OUT_OF_MEMORY;
        nsAString::iterator begin;
        str->BeginWriting(begin);

        reader.GetBytes(begin.get(), len);
      }
      break;

    case nsXPTType::T_UTF8STRING:
    case nsXPTType::T_CSTRING:
      {
        PRUint32 len = reader.GetInt32();

        nsACString *str = (nsACString *) v.val.p;

        if (!str || !(EnsureStringLength(*str, len)))
          return NS_ERROR_OUT_OF_MEMORY;
        nsACString::iterator begin;
        str->BeginWriting(begin);

        reader.GetBytes(begin.get(), len);
      }
      break;

    case nsXPTType::T_ARRAY:
      LOG(("array types are not yet supported\n"));
      return NS_ERROR_NOT_IMPLEMENTED;

    case nsXPTType::T_VOID:
    case nsXPTType::T_PSTRING_SIZE_IS:
    case nsXPTType::T_PWSTRING_SIZE_IS:
    default:
      LOG(("unexpected parameter type\n"));
      return NS_ERROR_UNEXPECTED;
  }
  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DestroyDConnectInstance ( const void key,
DConnectInstance wrapper,
void userArg 
)

Definition at line 1334 of file ipcDConnectService.cpp.

{
  delete wrapper;
  return PL_DHASH_NEXT;
}

Here is the caller graph for this function:

static void FinishParam ( nsXPTCVariant v) [static]

Definition at line 520 of file ipcDConnectService.cpp.

{
  if (!v.val.p)
    return;

  if (v.IsValAllocated())
    free(v.val.p);
  else if (v.IsValInterface())
    ((nsISupports *) v.val.p)->Release();
  else if (v.IsValDOMString())
    delete (nsAString *) v.val.p;
  else if (v.IsValUTF8String() || v.IsValCString())
    delete (nsACString *) v.val.p;
}

Here is the call graph for this function:

static PRUint32 NewRequestIndex ( ) [static]

Definition at line 673 of file ipcDConnectService.cpp.

{
  static PRUint32 sRequestIndex;
  return ++sRequestIndex;
}

Here is the caller graph for this function:

static NS_DEFINE_IID ( kDConnectStubID  ,
DCONNECT_STUB_ID   
) [static]
static nsresult SerializeInterfaceParam ( ipcMessageWriter writer,
PRUint32  peer,
const nsID iid,
const nsXPTType type,
const nsXPTCMiniVariant v,
nsVoidArray wrappers 
) [static]

Definition at line 835 of file ipcDConnectService.cpp.

{
  // we create an instance wrapper, and assume that the other side will send a
  // RELEASE message when it no longer needs the instance wrapper.  that will
  // usually happen after the call returns.
  //
  // XXX a lazy scheme might be better, but for now simplicity wins.

  // if the interface pointer references a DConnectStub corresponding
  // to an object in the address space of the peer, then no need to
  // create a new wrapper.

  nsISupports *obj = (nsISupports *) v.val.p;
  if (!obj)
  {
    // write null address
    writer.PutBytes(&obj, sizeof(obj));
  }
  else
  {
    DConnectStub *stub = nsnull;
    nsresult rv = obj->QueryInterface(kDConnectStubID, (void **) &stub);
    if (NS_SUCCEEDED(rv) && (stub->PeerID() == peer))
    {
      void *p = stub->Instance();
      writer.PutBytes(&p, sizeof(p));
    }
    else
    {
      // create instance wrapper

      nsCOMPtr<nsIInterfaceInfo> iinfo;
      rv = gDConnect->GetInterfaceInfo(iid, getter_AddRefs(iinfo));
      if (NS_FAILED(rv))
        return rv;

      DConnectInstance *wrapper = nsnull;

      wrapper = new DConnectInstance(peer, iinfo, obj);
      if (!wrapper)
        return NS_ERROR_OUT_OF_MEMORY;

      if (!wrappers.AppendElement(wrapper))
      {
        delete wrapper;
        return NS_ERROR_OUT_OF_MEMORY;
      }

      rv = gDConnect->StoreInstance(wrapper);
      if (NS_FAILED(rv))
      {
        wrappers.RemoveElement(wrapper);
        delete wrapper;
        return rv;
      }

      // send address of the instance wrapper, and set the low bit
      // to indicate that this is an instance wrapper.
      PtrBits bits = ((PtrBits) wrapper) | 0x1;
      writer.PutBytes(&bits, sizeof(bits));
    }
    NS_IF_RELEASE(stub);
  }
  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static nsresult SerializeParam ( ipcMessageWriter writer,
const nsXPTType t,
const nsXPTCMiniVariant v 
) [static]

Definition at line 215 of file ipcDConnectService.cpp.

{
  switch (t.TagPart())
  {
    case nsXPTType::T_I8:
    case nsXPTType::T_U8:
      writer.PutInt8(v.val.u8);
      break;

    case nsXPTType::T_I16:
    case nsXPTType::T_U16:
      writer.PutInt16(v.val.u16);
      break;

    case nsXPTType::T_I32:
    case nsXPTType::T_U32:
      writer.PutInt32(v.val.u32);
      break;

    case nsXPTType::T_I64:
    case nsXPTType::T_U64:
      writer.PutBytes(&v.val.u64, sizeof(PRUint64));
      break;

    case nsXPTType::T_FLOAT:
      writer.PutBytes(&v.val.f, sizeof(float));
      break;

    case nsXPTType::T_DOUBLE:
      writer.PutBytes(&v.val.d, sizeof(double));
      break;

    case nsXPTType::T_BOOL:
      writer.PutBytes(&v.val.b, sizeof(PRBool));
      break;

    case nsXPTType::T_CHAR:
      writer.PutBytes(&v.val.c, sizeof(char));
      break;

    case nsXPTType::T_WCHAR:
      writer.PutBytes(&v.val.wc, sizeof(PRUnichar));
      break;

    case nsXPTType::T_IID:
      writer.PutBytes(v.val.p, sizeof(nsID));
      break;

    case nsXPTType::T_CHAR_STR:
      {
        int len = strlen((const char *) v.val.p);
        writer.PutInt32(len);
        writer.PutBytes(v.val.p, len);
      }
      break;

    case nsXPTType::T_WCHAR_STR:
      {
        int len = 2 * nsCRT::strlen((const PRUnichar *) v.val.p);
        writer.PutInt32(len);
        writer.PutBytes(v.val.p, len);
      }
      break;

    case nsXPTType::T_INTERFACE:
    case nsXPTType::T_INTERFACE_IS:
      NS_NOTREACHED("this should be handled elsewhere");
      return NS_ERROR_UNEXPECTED;

    case nsXPTType::T_ASTRING:
    case nsXPTType::T_DOMSTRING:
      {
        const nsAString *str = (const nsAString *) v.val.p;

        PRUint32 len = 2 * str->Length();
        nsAString::const_iterator begin;
        const PRUnichar *data = str->BeginReading(begin).get();

        writer.PutInt32(len);
        writer.PutBytes(data, len);
      }
      break;

    case nsXPTType::T_UTF8STRING:
    case nsXPTType::T_CSTRING:
      {
        const nsACString *str = (const nsACString *) v.val.p;

        PRUint32 len = str->Length();
        nsACString::const_iterator begin;
        const char *data = str->BeginReading(begin).get();

        writer.PutInt32(len);
        writer.PutBytes(data, len);
      }
      break;

    case nsXPTType::T_ARRAY:
      LOG(("array types are not yet supported\n"));
      return NS_ERROR_NOT_IMPLEMENTED;

    case nsXPTType::T_VOID:
    case nsXPTType::T_PSTRING_SIZE_IS:
    case nsXPTType::T_PWSTRING_SIZE_IS:
    default:
      LOG(("unexpected parameter type\n"));
      return NS_ERROR_UNEXPECTED;
  }
  return NS_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static nsresult SetupParam ( const nsXPTParamInfo p,
nsXPTCVariant v 
) [static]

Definition at line 474 of file ipcDConnectService.cpp.

{
  const nsXPTType &t = p.GetType();

  if (p.IsIn() && p.IsDipper())
  {
    v.ptr = nsnull;

    switch (t.TagPart())
    {
      case nsXPTType::T_ASTRING:
      case nsXPTType::T_DOMSTRING:
        v.ptr = new nsString();
        if (!v.ptr)
          return NS_ERROR_OUT_OF_MEMORY;
        v.val.p = v.ptr;
        v.type = t;
        v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_DOMSTR;
        break;

      case nsXPTType::T_UTF8STRING:
      case nsXPTType::T_CSTRING:
        v.ptr = new nsCString();
        if (!v.ptr)
          return NS_ERROR_OUT_OF_MEMORY;
        v.val.p = v.ptr;
        v.type = t;
        v.flags = nsXPTCVariant::PTR_IS_DATA | nsXPTCVariant::VAL_IS_CSTR;
        break;

      default:
        LOG(("unhandled dipper: type=%d\n", t.TagPart()));
        return NS_ERROR_UNEXPECTED;
    }
  }
  else if (p.IsOut())
  {
    v.ptr = &v.val;
    v.type = t;
    v.flags = nsXPTCVariant::PTR_IS_DATA;
  }

  return NS_OK;
}

Here is the call graph for this function:

nsresult SetupPeerInstance ( PRUint32  aPeerID,
DConnectSetup aMsg,
PRUint32  aMsgLen,
void **  aInstancePtr 
) [static]

Definition at line 1296 of file ipcDConnectService.cpp.

{
  *aInstancePtr = nsnull;

  aMsg->opcode_major = DCON_OP_SETUP;
  aMsg->request_index = NewRequestIndex();

  // send SETUP message, expect SETUP_REPLY

  nsresult rv = IPC_SendMessage(aPeerID, kDConnectTargetID,
                                (const PRUint8 *) aMsg, aMsgLen);
  if (NS_FAILED(rv))
    return rv;

  DConnectSetupCompletion completion(aMsg);

  // need to allow messages from other clients to be processed immediately 
  // to avoid distributed dead locks.  the completion's OnMessageAvailable
  // will call our default OnMessageAvailable if it receives any message
  // other than the one for which it is waiting.

  do
  {
    rv = IPC_WaitMessage(aPeerID, kDConnectTargetID, &completion, DCON_WAIT_TIMEOUT);
    if (NS_FAILED(rv))
      break;

    rv = completion.GetStub(aInstancePtr);
  }
  while (NS_SUCCEEDED(rv) && *aInstancePtr == nsnull);

  return rv;
} 

Here is the call graph for this function:


Variable Documentation

Definition at line 175 of file ipcDConnectService.cpp.

Definition at line 68 of file ipcDConnectService.cpp.