programs/rpcss/epmp.c

   1 /*
   2  * Endpoint Mapper
   3  *
   4  * Copyright (C) 2007 Robert Shearman for CodeWeavers
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "epm.h"
  22
  23 #include "wine/debug.h"
  24 #include "wine/list.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  27
  28 struct registered_ept_entry
  29 {
  30     struct list entry;
  31     GUID object;
  32     RPC_SYNTAX_IDENTIFIER iface;
  33     RPC_SYNTAX_IDENTIFIER syntax;
  34     char *protseq;
  35     char *endpoint;
  36     char *address;
  37     char annotation[ept_max_annotation_size];
  38 };
  39
  40 static struct list registered_ept_entry_list = LIST_INIT(registered_ept_entry_list);
  41
  42 static CRITICAL_SECTION csEpm;
  43 static CRITICAL_SECTION_DEBUG critsect_debug =
  44 {
  45     0, 0, &csEpm,
  46     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  47     0, 0, { (DWORD_PTR)(__FILE__ ": csEpm") }
  48 };
  49 static CRITICAL_SECTION csEpm = { &critsect_debug, -1, 0, 0, 0, 0 };
  50
  51 static const UUID nil_object;
  52
  53 /* must be called inside csEpm */
  54 static void delete_registered_ept_entry(struct registered_ept_entry *entry)
  55 {
  56     I_RpcFree(entry->protseq);
  57     I_RpcFree(entry->endpoint);
  58     I_RpcFree(entry->address);
  59     list_remove(&entry->entry);
  60     HeapFree(GetProcessHeap(), 0, entry);
  61 }
  62
  63 static struct registered_ept_entry *find_ept_entry(
  64     const RPC_SYNTAX_IDENTIFIER *iface, const RPC_SYNTAX_IDENTIFIER *syntax,
  65     const char *protseq, const char *endpoint, const char *address,
  66     const UUID *object)
  67 {
  68     struct registered_ept_entry *entry;
  69     LIST_FOR_EACH_ENTRY(entry, &registered_ept_entry_list, struct registered_ept_entry, entry)
  70     {
  71         if (memcmp(&entry->iface, iface, sizeof(RPC_SYNTAX_IDENTIFIER))) continue;
  72         if (memcmp(&entry->syntax, syntax, sizeof(RPC_SYNTAX_IDENTIFIER))) continue;
  73         if (strcmp(entry->protseq, protseq)) continue;
  74         if (memcmp(&entry->object, object, sizeof(UUID))) continue;
  75         WINE_TRACE("found entry with iface %d.%d %s, syntax %d.%d %s, protseq %s, object %s\n",
  76                    entry->iface.SyntaxVersion.MajorVersion, entry->iface.SyntaxVersion.MinorVersion,
  77                    wine_dbgstr_guid(&entry->iface.SyntaxGUID),
  78                    entry->syntax.SyntaxVersion.MajorVersion, entry->syntax.SyntaxVersion.MinorVersion,
  79                    wine_dbgstr_guid(&entry->syntax.SyntaxGUID), protseq,
  80                    wine_dbgstr_guid(&entry->object));
  81         return entry;
  82     }
  83     WINE_TRACE("not found\n");
  84     return NULL;
  85 }
  86
  87 void __RPC_USER ept_lookup_handle_t_rundown(ept_lookup_handle_t entry_handle)
  88 {
  89     WINE_FIXME("%p\n", entry_handle);
  90 }
  91
  92 void ept_insert(handle_t h,
  93                 unsigned32 num_ents,
  94                 ept_entry_t entries[],
  95                 boolean32 replace,
  96                 error_status_t *status)
  97 {
  98     unsigned32 i;
  99     RPC_STATUS rpc_status;
 100
 101     WINE_TRACE("(%p, %lu, %p, %lu, %p)\n", h, num_ents, entries, replace, status);
 102
 103     *status = RPC_S_OK;
 104
 105     EnterCriticalSection(&csEpm);
 106
 107     for (i = 0; i < num_ents; i++)
 108     {
 109         struct registered_ept_entry *entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry));
 110         if (!entry)
 111         {
 112             /* FIXME: cleanup code to delete added entries */
 113             *status = EPT_S_CANT_PERFORM_OP;
 114             break;
 115         }
 116         list_init(&entry->entry);
 117         memcpy(entry->annotation, entries[i].annotation, sizeof(entries[i].annotation));
 118         rpc_status = TowerExplode(entries[i].tower, &entry->iface, &entry->syntax,
 119                                   &entry->protseq, &entry->endpoint,
 120                                   &entry->address);
 121         if (rpc_status != RPC_S_OK)
 122         {
 123             *status = rpc_status;
 124             break; /* FIXME: more cleanup? */
 125         }
 126
 127         entry->object = entries[i].object;
 128
 129         if (replace)
 130         {
 131             /* FIXME: correct find algorithm */
 132             struct registered_ept_entry *old_entry = find_ept_entry(&entry->iface, &entry->syntax, entry->protseq, entry->endpoint, entry->address, &entry->object);
 133             if (old_entry) delete_registered_ept_entry(old_entry);
 134         }
 135         list_add_tail(&registered_ept_entry_list, &entry->entry);
 136     }
 137
 138     LeaveCriticalSection(&csEpm);
 139 }
 140
 141 void ept_delete(handle_t h,
 142                 unsigned32 num_ents,
 143                 ept_entry_t entries[],
 144                 error_status_t *status)
 145 {
 146     unsigned32 i;
 147     RPC_STATUS rpc_status;
 148
 149     *status = RPC_S_OK;
 150
 151     WINE_TRACE("(%p, %lu, %p, %p)\n", h, num_ents, entries, status);
 152
 153     EnterCriticalSection(&csEpm);
 154
 155     for (i = 0; i < num_ents; i++)
 156     {
 157         struct registered_ept_entry *entry;
 158         RPC_SYNTAX_IDENTIFIER iface, syntax;
 159         char *protseq;
 160         char *endpoint;
 161         char *address;
 162         rpc_status = TowerExplode(entries[i].tower, &iface, &syntax, &protseq,
 163                                   &endpoint, &address);
 164         if (rpc_status != RPC_S_OK)
 165             break;
 166         entry = find_ept_entry(&iface, &syntax, protseq, endpoint, address, &entries[i].object);
 167         if (entry)
 168             delete_registered_ept_entry(entry);
 169         else
 170         {
 171             *status = EPT_S_NOT_REGISTERED;
 172             break;
 173         }
 174         I_RpcFree(protseq);
 175         I_RpcFree(endpoint);
 176         I_RpcFree(address);
 177     }
 178
 179     LeaveCriticalSection(&csEpm);
 180 }
 181
 182 void ept_lookup(handle_t h,
 183                 unsigned32 inquiry_type,
 184                 uuid_p_t object,
 185                 rpc_if_id_p_t interface_id,
 186                 unsigned32 vers_option,
 187                 ept_lookup_handle_t *entry_handle,
 188                 unsigned32 max_ents,
 189                 unsigned32 *num_ents,
 190                 ept_entry_t entries[],
 191                 error_status_t *status)
 192 {
 193     WINE_FIXME("(%p, %p, %p): stub\n", h, entry_handle, status);
 194
 195     *status = EPT_S_CANT_PERFORM_OP;
 196 }
 197
 198 void ept_map(handle_t h,
 199              uuid_p_t object,
 200              twr_p_t map_tower,
 201              ept_lookup_handle_t *entry_handle,
 202              unsigned32 max_towers,
 203              unsigned32 *num_towers,
 204              twr_p_t *towers,
 205              error_status_t *status)
 206 {
 207     RPC_STATUS rpc_status;
 208     RPC_SYNTAX_IDENTIFIER iface, syntax;
 209     char *protseq;
 210     struct registered_ept_entry *entry;
 211
 212     *status = RPC_S_OK;
 213     *num_towers = 0;
 214
 215     WINE_TRACE("(%p, %p, %p, %p, %lu, %p, %p, %p)\n", h, object, map_tower,
 216           entry_handle, max_towers, num_towers, towers, status);
 217
 218     rpc_status = TowerExplode(map_tower, &iface, &syntax, &protseq,
 219                               NULL, NULL);
 220     if (rpc_status != RPC_S_OK)
 221     {
 222         *status = rpc_status;
 223         return;
 224     }
 225
 226     EnterCriticalSection(&csEpm);
 227
 228     LIST_FOR_EACH_ENTRY(entry, &registered_ept_entry_list, struct registered_ept_entry, entry)
 229     {
 230         if (IsEqualGUID(&entry->iface.SyntaxGUID, &iface.SyntaxGUID) &&
 231             (entry->iface.SyntaxVersion.MajorVersion == iface.SyntaxVersion.MajorVersion) &&
 232             (entry->iface.SyntaxVersion.MinorVersion >= iface.SyntaxVersion.MinorVersion) &&
 233             !memcmp(&entry->syntax, &syntax, sizeof(syntax)) &&
 234             !strcmp(entry->protseq, protseq) &&
 235             ((!object && IsEqualGUID(&entry->object, &nil_object)) || IsEqualGUID(object, &entry->object)))
 236         {
 237             if (*num_towers < max_towers)
 238             {
 239                 rpc_status = TowerConstruct(&entry->iface, &entry->syntax,
 240                                             entry->protseq, entry->endpoint,
 241                                             entry->address,
 242                                             &towers[*num_towers]);
 243                 if (rpc_status != RPC_S_OK)
 244                 {
 245                     *status = rpc_status;
 246                     break; /* FIXME: more cleanup? */
 247                 }
 248             }
 249             (*num_towers)++;
 250         }
 251     }
 252
 253     LeaveCriticalSection(&csEpm);
 254 }
 255
 256 void ept_lookup_handle_free(handle_t h,
 257                             ept_lookup_handle_t *entry_handle,
 258                             error_status_t *status)
 259 {
 260     WINE_FIXME("(%p, %p, %p): stub\n", h, entry_handle, status);
 261
 262     *status = EPT_S_CANT_PERFORM_OP;
 263 }
 264
 265 void ept_inq_object(handle_t h,
 266                     GUID *ept_object,
 267                     error_status_t *status)
 268 {
 269     WINE_FIXME("(%p, %p, %p): stub\n", h, ept_object, status);
 270
 271     *status = EPT_S_CANT_PERFORM_OP;
 272 }
 273
 274 void ept_mgmt_delete(handle_t h,
 275                      boolean32 object_speced,
 276                      uuid_p_t object,
 277                      twr_p_t tower,
 278                      error_status_t *status)
 279 {
 280     WINE_FIXME("(%p, %ld, %p, %p, %p): stub\n", h, object_speced, object, tower, status);
 281
 282     *status = EPT_S_CANT_PERFORM_OP;
 283 }