reactos/base/services/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_s.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             WINE_WARN("TowerExplode failed %lu\n", rpc_status);
 124             *status = rpc_status;
 125             break; /* FIXME: more cleanup? */
 126         }
 127
 128         entry->object = entries[i].object;
 129
 130         if (replace)
 131         {
 132             /* FIXME: correct find algorithm */
 133             struct registered_ept_entry *old_entry = find_ept_entry(&entry->iface, &entry->syntax, entry->protseq, entry->endpoint, entry->address, &entry->object);
 134             if (old_entry) delete_registered_ept_entry(old_entry);
 135         }
 136         list_add_tail(&registered_ept_entry_list, &entry->entry);
 137     }
 138
 139     LeaveCriticalSection(&csEpm);
 140 }
 141
 142 void ept_delete(handle_t h,
 143                 unsigned32 num_ents,
 144                 ept_entry_t entries[],
 145                 error_status_t *status)
 146 {
 147     unsigned32 i;
 148     RPC_STATUS rpc_status;
 149
 150     *status = RPC_S_OK;
 151
 152     WINE_TRACE("(%p, %lu, %p, %p)\n", h, num_ents, entries, status);
 153
 154     EnterCriticalSection(&csEpm);
 155
 156     for (i = 0; i < num_ents; i++)
 157     {
 158         struct registered_ept_entry *entry;
 159         RPC_SYNTAX_IDENTIFIER iface, syntax;
 160         char *protseq;
 161         char *endpoint;
 162         char *address;
 163         rpc_status = TowerExplode(entries[i].tower, &iface, &syntax, &protseq,
 164                                   &endpoint, &address);
 165         if (rpc_status != RPC_S_OK)
 166             break;
 167         entry = find_ept_entry(&iface, &syntax, protseq, endpoint, address, &entries[i].object);
 168         if (entry)
 169             delete_registered_ept_entry(entry);
 170         else
 171         {
 172             *status = EPT_S_NOT_REGISTERED;
 173             break;
 174         }
 175         I_RpcFree(protseq);
 176         I_RpcFree(endpoint);
 177         I_RpcFree(address);
 178     }
 179
 180     LeaveCriticalSection(&csEpm);
 181 }
 182
 183 void ept_lookup(handle_t h,
 184                 unsigned32 inquiry_type,
 185                 uuid_p_t object,
 186                 rpc_if_id_p_t interface_id,
 187                 unsigned32 vers_option,
 188                 ept_lookup_handle_t *entry_handle,
 189                 unsigned32 max_ents,
 190                 unsigned32 *num_ents,
 191                 ept_entry_t entries[],
 192                 error_status_t *status)
 193 {
 194     WINE_FIXME("(%p, %p, %p): stub\n", h, entry_handle, status);
 195
 196     *status = EPT_S_CANT_PERFORM_OP;
 197 }
 198
 199 void ept_map(handle_t h,
 200              uuid_p_t object,
 201              twr_p_t map_tower,
 202              ept_lookup_handle_t *entry_handle,
 203              unsigned32 max_towers,
 204              unsigned32 *num_towers,
 205              twr_p_t *towers,
 206              error_status_t *status)
 207 {
 208     RPC_STATUS rpc_status;
 209     RPC_SYNTAX_IDENTIFIER iface, syntax;
 210     char *protseq;
 211     struct registered_ept_entry *entry;
 212
 213     *status = RPC_S_OK;
 214     *num_towers = 0;
 215
 216     WINE_TRACE("(%p, %p, %p, %p, %lu, %p, %p, %p)\n", h, object, map_tower,
 217           entry_handle, max_towers, num_towers, towers, status);
 218
 219     rpc_status = TowerExplode(map_tower, &iface, &syntax, &protseq,
 220                               NULL, NULL);
 221     if (rpc_status != RPC_S_OK)
 222     {
 223         *status = rpc_status;
 224         return;
 225     }
 226
 227     EnterCriticalSection(&csEpm);
 228
 229     LIST_FOR_EACH_ENTRY(entry, &registered_ept_entry_list, struct registered_ept_entry, entry)
 230     {
 231         if (IsEqualGUID(&entry->iface.SyntaxGUID, &iface.SyntaxGUID) &&
 232             (entry->iface.SyntaxVersion.MajorVersion == iface.SyntaxVersion.MajorVersion) &&
 233             (entry->iface.SyntaxVersion.MinorVersion >= iface.SyntaxVersion.MinorVersion) &&
 234             !memcmp(&entry->syntax, &syntax, sizeof(syntax)) &&
 235             !strcmp(entry->protseq, protseq) &&
 236             ((!object && IsEqualGUID(&entry->object, &nil_object)) || IsEqualGUID(object, &entry->object)))
 237         {
 238             if (*num_towers < max_towers)
 239             {
 240                 rpc_status = TowerConstruct(&entry->iface, &entry->syntax,
 241                                             entry->protseq, entry->endpoint,
 242                                             entry->address,
 243                                             &towers[*num_towers]);
 244                 if (rpc_status != RPC_S_OK)
 245                 {
 246                     *status = rpc_status;
 247                     break; /* FIXME: more cleanup? */
 248                 }
 249             }
 250             (*num_towers)++;
 251         }
 252     }
 253
 254     LeaveCriticalSection(&csEpm);
 255 }
 256
 257 void ept_lookup_handle_free(handle_t h,
 258                             ept_lookup_handle_t *entry_handle,
 259                             error_status_t *status)
 260 {
 261     WINE_FIXME("(%p, %p, %p): stub\n", h, entry_handle, status);
 262
 263     *status = EPT_S_CANT_PERFORM_OP;
 264 }
 265
 266 void ept_inq_object(handle_t h,
 267                     GUID *ept_object,
 268                     error_status_t *status)
 269 {
 270     WINE_FIXME("(%p, %p, %p): stub\n", h, ept_object, status);
 271
 272     *status = EPT_S_CANT_PERFORM_OP;
 273 }
 274
 275 void ept_mgmt_delete(handle_t h,
 276                      boolean32 object_speced,
 277                      uuid_p_t object,
 278                      twr_p_t tower,
 279                      error_status_t *status)
 280 {
 281     WINE_FIXME("(%p, %ld, %p, %p, %p): stub\n", h, object_speced, object, tower, status);
 282
 283     *status = EPT_S_CANT_PERFORM_OP;
 284 }