dlls/rpcrt4/rpc_epmap.c

   1 /*
   2  * RPC endpoint mapper
   3  *
   4  * Copyright 2002 Greg Turner
   5  * Copyright 2001 Ove Kåven, TransGaming Technologies
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  * TODO:
  22  *  - actually do things right
  23  */
  24
  25 #include <stdio.h>
  26 #include <string.h>
  27
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winerror.h"
  31 #include "winreg.h"
  32
  33 #include "rpc.h"
  34
  35 #include "wine/debug.h"
  36
  37 #include "rpc_binding.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  40
  41 /* The "real" RPC portmapper endpoints that I know of are:
  42  *
  43  *  ncadg_ip_udp: 135
  44  *  ncacn_ip_tcp: 135
  45  *  ncacn_np: \\pipe\epmapper (?)
  46  *  ncalrpc: epmapper
  47  *
  48  * If the user's machine ran a DCE RPC daemon, it would
  49  * probably be possible to connect to it, but there are many
  50  * reasons not to, like:
  51  *  - the user probably does *not* run one, and probably
  52  *    shouldn't be forced to run one just for local COM
  53  *  - very few Unix systems use DCE RPC... if they run a RPC
  54  *    daemon at all, it's usually Sun RPC
  55  *  - DCE RPC registrations are persistent and saved on disk,
  56  *    while MS-RPC registrations are documented as non-persistent
  57  *    and stored only in RAM, and auto-destroyed when the process
  58  *    dies (something DCE RPC can't do)
  59  *
  60  * Of course, if the user *did* want to run a DCE RPC daemon anyway,
  61  * there would be interoperability advantages, like the possibility
  62  * of running a fully functional DCOM server using Wine...
  63  */
  64
  65 /***********************************************************************
  66  *             RpcEpRegisterA (RPCRT4.@)
  67  */
  68 RPC_STATUS WINAPI RpcEpRegisterA( RPC_IF_HANDLE IfSpec, PRPC_BINDING_VECTOR BindingVector,
  69                                   PUUID_VECTOR UuidVector, LPSTR Annotation )
  70 {
  71   RPCSS_NP_MESSAGE msg;
  72   RPCSS_NP_REPLY reply;
  73   char *vardata_payload, *vp;
  74   PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
  75   unsigned long c;
  76   RPC_STATUS rslt = RPC_S_OK;
  77
  78   TRACE("(%p,%p,%p,%s)\n", IfSpec, BindingVector, UuidVector, debugstr_a(Annotation));
  79   TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
  80   for (c=0; c<BindingVector->Count; c++) {
  81     RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[c]);
  82     TRACE(" protseq[%ld]=%s\n", c, debugstr_a(bind->Protseq));
  83     TRACE(" endpoint[%ld]=%s\n", c, debugstr_a(bind->Endpoint));
  84   }
  85   if (UuidVector) {
  86     for (c=0; c<UuidVector->Count; c++)
  87       TRACE(" obj[%ld]=%s\n", c, debugstr_guid(UuidVector->Uuid[c]));
  88   }
  89
  90   /* FIXME: Do something with annotation. */
  91
  92   /* construct the message to rpcss */
  93   msg.message_type = RPCSS_NP_MESSAGE_TYPEID_REGISTEREPMSG;
  94   msg.message.registerepmsg.iface = If->InterfaceId;
  95   msg.message.registerepmsg.no_replace = 0;
  96
  97   msg.message.registerepmsg.object_count = (UuidVector) ? UuidVector->Count : 0;
  98   msg.message.registerepmsg.binding_count = BindingVector->Count;
  99
 100   /* calculate vardata payload size */
 101   msg.vardata_payload_size = msg.message.registerepmsg.object_count * sizeof(UUID);
 102   for (c=0; c < msg.message.registerepmsg.binding_count; c++) {
 103     RpcBinding *bind = (RpcBinding *)(BindingVector->BindingH[c]);
 104     msg.vardata_payload_size += strlen(bind->Protseq) + 1;
 105     msg.vardata_payload_size += strlen(bind->Endpoint) + 1;
 106   }
 107
 108   /* allocate the payload buffer */
 109   vp = vardata_payload = LocalAlloc(LPTR, msg.vardata_payload_size);
 110   if (!vardata_payload)
 111     return RPC_S_OUT_OF_MEMORY;
 112
 113   /* populate the payload data */
 114   for (c=0; c < msg.message.registerepmsg.object_count; c++) {
 115     CopyMemory(vp, UuidVector->Uuid[c], sizeof(UUID));
 116     vp += sizeof(UUID);
 117   }
 118
 119   for (c=0; c < msg.message.registerepmsg.binding_count; c++) {
 120     RpcBinding *bind = (RpcBinding*)(BindingVector->BindingH[c]);
 121     unsigned long pslen = strlen(bind->Protseq) + 1, eplen = strlen(bind->Endpoint) + 1;
 122     CopyMemory(vp, bind->Protseq, pslen);
 123     vp += pslen;
 124     CopyMemory(vp, bind->Endpoint, eplen);
 125     vp += eplen;
 126   }
 127
 128   /* send our request */
 129   if (!RPCRT4_RPCSSOnDemandCall(&msg, vardata_payload, &reply))
 130     rslt = RPC_S_OUT_OF_MEMORY;
 131
 132   /* free the payload buffer */
 133   LocalFree(vardata_payload);
 134
 135   return rslt;
 136 }
 137
 138 /***********************************************************************
 139  *             RpcEpUnregister (RPCRT4.@)
 140  */
 141 RPC_STATUS WINAPI RpcEpUnregister( RPC_IF_HANDLE IfSpec, PRPC_BINDING_VECTOR BindingVector,
 142                                    PUUID_VECTOR UuidVector )
 143 {
 144   RPCSS_NP_MESSAGE msg;
 145   RPCSS_NP_REPLY reply;
 146   char *vardata_payload, *vp;
 147   PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
 148   unsigned long c;
 149   RPC_STATUS rslt = RPC_S_OK;
 150
 151   TRACE("(%p,%p,%p)\n", IfSpec, BindingVector, UuidVector);
 152   TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
 153   for (c=0; c<BindingVector->Count; c++) {
 154     RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[c]);
 155     TRACE(" protseq[%ld]=%s\n", c, debugstr_a(bind->Protseq));
 156     TRACE(" endpoint[%ld]=%s\n", c, debugstr_a(bind->Endpoint));
 157   }
 158   if (UuidVector) {
 159     for (c=0; c<UuidVector->Count; c++)
 160       TRACE(" obj[%ld]=%s\n", c, debugstr_guid(UuidVector->Uuid[c]));
 161   }
 162
 163   /* construct the message to rpcss */
 164   msg.message_type = RPCSS_NP_MESSAGE_TYPEID_UNREGISTEREPMSG;
 165   msg.message.unregisterepmsg.iface = If->InterfaceId;
 166
 167   msg.message.unregisterepmsg.object_count = (UuidVector) ? UuidVector->Count : 0;
 168   msg.message.unregisterepmsg.binding_count = BindingVector->Count;
 169
 170   /* calculate vardata payload size */
 171   msg.vardata_payload_size = msg.message.unregisterepmsg.object_count * sizeof(UUID);
 172   for (c=0; c < msg.message.unregisterepmsg.binding_count; c++) {
 173     RpcBinding *bind = (RpcBinding *)(BindingVector->BindingH[c]);
 174     msg.vardata_payload_size += strlen(bind->Protseq) + 1;
 175     msg.vardata_payload_size += strlen(bind->Endpoint) + 1;
 176   }
 177
 178   /* allocate the payload buffer */
 179   vp = vardata_payload = LocalAlloc(LPTR, msg.vardata_payload_size);
 180   if (!vardata_payload)
 181     return RPC_S_OUT_OF_MEMORY;
 182
 183   /* populate the payload data */
 184   for (c=0; c < msg.message.unregisterepmsg.object_count; c++) {
 185     CopyMemory(vp, UuidVector->Uuid[c], sizeof(UUID));
 186     vp += sizeof(UUID);
 187   }
 188
 189   for (c=0; c < msg.message.unregisterepmsg.binding_count; c++) {
 190     RpcBinding *bind = (RpcBinding*)(BindingVector->BindingH[c]);
 191     unsigned long pslen = strlen(bind->Protseq) + 1, eplen = strlen(bind->Endpoint) + 1;
 192     CopyMemory(vp, bind->Protseq, pslen);
 193     vp += pslen;
 194     CopyMemory(vp, bind->Endpoint, eplen);
 195     vp += eplen;
 196   }
 197
 198   /* send our request */
 199   if (!RPCRT4_RPCSSOnDemandCall(&msg, vardata_payload, &reply))
 200     rslt = RPC_S_OUT_OF_MEMORY;
 201
 202   /* free the payload buffer */
 203   LocalFree(vardata_payload);
 204
 205   return rslt;
 206 }
 207
 208 /***********************************************************************
 209  *             RpcEpResolveBinding (RPCRT4.@)
 210  */
 211 RPC_STATUS WINAPI RpcEpResolveBinding( RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec )
 212 {
 213   RPCSS_NP_MESSAGE msg;
 214   RPCSS_NP_REPLY reply;
 215   PRPC_CLIENT_INTERFACE If = (PRPC_CLIENT_INTERFACE)IfSpec;
 216   RpcBinding* bind = (RpcBinding*)Binding;
 217
 218   TRACE("(%p,%p)\n", Binding, IfSpec);
 219   TRACE(" protseq=%s\n", debugstr_a(bind->Protseq));
 220   TRACE(" obj=%s\n", debugstr_guid(&bind->ObjectUuid));
 221   TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
 222
 223   /* FIXME: totally untested */
 224
 225   /* just return for fully bound handles */
 226   if (bind->Endpoint && (bind->Endpoint[0] != '\0'))
 227     return RPC_S_OK;
 228
 229   /* construct the message to rpcss */
 230   msg.message_type = RPCSS_NP_MESSAGE_TYPEID_RESOLVEEPMSG;
 231   msg.message.resolveepmsg.iface = If->InterfaceId;
 232   msg.message.resolveepmsg.object = bind->ObjectUuid;
 233
 234   msg.vardata_payload_size = strlen(bind->Protseq) + 1;
 235
 236   /* send the message */
 237   if (!RPCRT4_RPCSSOnDemandCall(&msg, bind->Protseq, &reply))
 238     return RPC_S_OUT_OF_MEMORY;
 239
 240   /* empty-string result means not registered */
 241   if (reply.as_string[0] == '\0')
 242     return EPT_S_NOT_REGISTERED;
 243
 244   /* otherwise we fully bind the handle & return RPC_S_OK */
 245   return RPCRT4_ResolveBinding(Binding, reply.as_string);
 246 }