dlls/rpcrt4/rpc_server.c

   1 /*
   2  * RPC server API
   3  *
   4  * Copyright 2001 Ove Kåven, TransGaming Technologies
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  *
  20  * TODO:
  21  *  - a whole lot
  22  */
  23
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <string.h>
  27 #include <assert.h>
  28
  29 #include "windef.h"
  30 #include "winbase.h"
  31 #include "winerror.h"
  32 #include "winreg.h"
  33 #include "ntstatus.h"
  34
  35 #include "rpc.h"
  36 #include "excpt.h"
  37
  38 #include "wine/debug.h"
  39 #include "wine/exception.h"
  40
  41 #include "rpc_server.h"
  42 #include "rpc_misc.h"
  43 #include "rpc_defs.h"
  44
  45 #define MAX_THREADS 128
  46
  47 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  48
  49 typedef struct _RpcPacket
  50 {
  51   struct _RpcPacket* next;
  52   struct _RpcConnection* conn;
  53   RpcPktHdr hdr;
  54   void* buf;
  55 } RpcPacket;
  56
  57 static RpcServerProtseq* protseqs;
  58 static RpcServerInterface* ifs;
  59
  60 static CRITICAL_SECTION server_cs;
  61 static CRITICAL_SECTION_DEBUG server_cs_debug =
  62 {
  63     0, 0, &server_cs,
  64     { &server_cs_debug.ProcessLocksList, &server_cs_debug.ProcessLocksList },
  65       0, 0, { 0, (DWORD)(__FILE__ ": server_cs") }
  66 };
  67 static CRITICAL_SECTION server_cs = { &server_cs_debug, -1, 0, 0, 0, 0 };
  68
  69 static CRITICAL_SECTION listen_cs;
  70 static CRITICAL_SECTION_DEBUG listen_cs_debug =
  71 {
  72     0, 0, &listen_cs,
  73     { &listen_cs_debug.ProcessLocksList, &listen_cs_debug.ProcessLocksList },
  74       0, 0, { 0, (DWORD)(__FILE__ ": listen_cs") }
  75 };
  76 static CRITICAL_SECTION listen_cs = { &listen_cs_debug, -1, 0, 0, 0, 0 };
  77
  78 static BOOL std_listen;
  79 static LONG listen_count = -1;
  80 static HANDLE mgr_event, server_thread;
  81
  82 static CRITICAL_SECTION spacket_cs;
  83 static CRITICAL_SECTION_DEBUG spacket_cs_debug =
  84 {
  85     0, 0, &spacket_cs,
  86     { &spacket_cs_debug.ProcessLocksList, &spacket_cs_debug.ProcessLocksList },
  87       0, 0, { 0, (DWORD)(__FILE__ ": spacket_cs") }
  88 };
  89 static CRITICAL_SECTION spacket_cs = { &spacket_cs_debug, -1, 0, 0, 0, 0 };
  90
  91 static RpcPacket* spacket_head;
  92 static RpcPacket* spacket_tail;
  93 static HANDLE server_sem;
  94
  95 static DWORD worker_count, worker_free, worker_tls;
  96
  97 static RpcServerInterface* RPCRT4_find_interface(UUID* object, UUID* if_id)
  98 {
  99   UUID* MgrType = NULL;
 100   RpcServerInterface* cif = NULL;
 101   RPC_STATUS status;
 102
 103   /* FIXME: object -> MgrType */
 104   EnterCriticalSection(&server_cs);
 105   cif = ifs;
 106   while (cif) {
 107     if (UuidEqual(if_id, &cif->If->InterfaceId.SyntaxGUID, &status) &&
 108        UuidEqual(MgrType, &cif->MgrTypeUuid, &status) &&
 109        (std_listen || (cif->Flags & RPC_IF_AUTOLISTEN))) break;
 110     cif = cif->Next;
 111   }
 112   LeaveCriticalSection(&server_cs);
 113   return cif;
 114 }
 115
 116 static void RPCRT4_push_packet(RpcPacket* packet)
 117 {
 118   packet->next = NULL;
 119   EnterCriticalSection(&spacket_cs);
 120   if (spacket_tail) {
 121     spacket_tail->next = packet;
 122     spacket_tail = packet;
 123   } else {
 124     spacket_head = packet;
 125     spacket_tail = packet;
 126   }
 127   LeaveCriticalSection(&spacket_cs);
 128 }
 129
 130 static RpcPacket* RPCRT4_pop_packet(void)
 131 {
 132   RpcPacket* packet;
 133   EnterCriticalSection(&spacket_cs);
 134   packet = spacket_head;
 135   if (packet) {
 136     spacket_head = packet->next;
 137     if (!spacket_head) spacket_tail = NULL;
 138   }
 139   LeaveCriticalSection(&spacket_cs);
 140   if (packet) packet->next = NULL;
 141   return packet;
 142 }
 143
 144 static WINE_EXCEPTION_FILTER(rpc_filter)
 145 {
 146   PRPC_MESSAGE msg;
 147   msg = TlsGetValue(worker_tls);
 148   I_RpcFreeBuffer(msg);
 149   msg->RpcFlags |= WINE_RPCFLAG_EXCEPTION;
 150   msg->BufferLength = sizeof(DWORD);
 151   I_RpcGetBuffer(msg);
 152   *(DWORD*)msg->Buffer = GetExceptionCode();
 153   return EXCEPTION_EXECUTE_HANDLER;
 154 }
 155
 156 static void RPCRT4_process_packet(RpcConnection* conn, RpcPktHdr* hdr, void* buf)
 157 {
 158   RpcBinding* pbind;
 159   RPC_MESSAGE msg;
 160   RpcServerInterface* sif;
 161   RPC_DISPATCH_FUNCTION func;
 162
 163   TlsSetValue(worker_tls, &msg);
 164   memset(&msg, 0, sizeof(msg));
 165   msg.BufferLength = hdr->len;
 166   msg.Buffer = buf;
 167   sif = RPCRT4_find_interface(&hdr->object, &hdr->if_id);
 168   if (sif) {
 169     TRACE("packet received for interface %s\n", debugstr_guid(&hdr->if_id));
 170     msg.RpcInterfaceInformation = sif->If;
 171     /* create temporary binding for dispatch */
 172     RPCRT4_MakeBinding(&pbind, conn);
 173     RPCRT4_SetBindingObject(pbind, &hdr->object);
 174     msg.Handle = (RPC_BINDING_HANDLE)pbind;
 175     /* process packet */
 176     switch (hdr->ptype) {
 177     case PKT_REQUEST:
 178       /* find dispatch function */
 179       msg.ProcNum = hdr->opnum;
 180       if (sif->Flags & RPC_IF_OLE) {
 181         /* native ole32 always gives us a dispatch table with a single entry
 182          * (I assume that's a wrapper for IRpcStubBuffer::Invoke) */
 183         func = *sif->If->DispatchTable->DispatchTable;
 184       } else {
 185         if (msg.ProcNum >= sif->If->DispatchTable->DispatchTableCount) {
 186           ERR("invalid procnum\n");
 187           func = NULL;
 188         }
 189         func = sif->If->DispatchTable->DispatchTable[msg.ProcNum];
 190       }
 191
 192       /* put in the drep. FIXME: is this more universally applicable?
 193          perhaps we should move this outward... */
 194       msg.DataRepresentation =
 195         MAKELONG( MAKEWORD(hdr->drep[0], hdr->drep[1]),
 196                   MAKEWORD(hdr->drep[2], 0));
 197
 198       /* dispatch */
 199       __TRY {
 200         if (func) func(&msg);
 201       } __EXCEPT(rpc_filter) {
 202         /* failure packet was created in rpc_filter */
 203         TRACE("exception caught, returning failure packet\n");
 204       } __ENDTRY
 205
 206       /* send response packet */
 207       I_RpcSend(&msg);
 208       break;
 209     default:
 210       ERR("unknown packet type\n");
 211       break;
 212     }
 213
 214     RPCRT4_DestroyBinding(pbind);
 215     msg.Handle = 0;
 216     msg.RpcInterfaceInformation = NULL;
 217   }
 218   else {
 219     ERR("got RPC packet to unregistered interface %s\n", debugstr_guid(&hdr->if_id));
 220   }
 221
 222   /* clean up */
 223   if (msg.Buffer == buf) msg.Buffer = NULL;
 224   TRACE("freeing Buffer=%p\n", buf);
 225   HeapFree(GetProcessHeap(), 0, buf);
 226   I_RpcFreeBuffer(&msg);
 227   msg.Buffer = NULL;
 228   TlsSetValue(worker_tls, NULL);
 229 }
 230
 231 static DWORD CALLBACK RPCRT4_worker_thread(LPVOID the_arg)
 232 {
 233   DWORD obj;
 234   RpcPacket* pkt;
 235
 236   for (;;) {
 237     /* idle timeout after 5s */
 238     obj = WaitForSingleObject(server_sem, 5000);
 239     if (obj == WAIT_TIMEOUT) {
 240       /* if another idle thread exist, self-destruct */
 241       if (worker_free > 1) break;
 242       continue;
 243     }
 244     pkt = RPCRT4_pop_packet();
 245     if (!pkt) continue;
 246     InterlockedDecrement(&worker_free);
 247     for (;;) {
 248       RPCRT4_process_packet(pkt->conn, &pkt->hdr, pkt->buf);
 249       HeapFree(GetProcessHeap(), 0, pkt);
 250       /* try to grab another packet here without waiting
 251        * on the semaphore, in case it hits max */
 252       pkt = RPCRT4_pop_packet();
 253       if (!pkt) break;
 254       /* decrement semaphore */
 255       WaitForSingleObject(server_sem, 0);
 256     }
 257     InterlockedIncrement(&worker_free);
 258   }
 259   InterlockedDecrement(&worker_free);
 260   InterlockedDecrement(&worker_count);
 261   return 0;
 262 }
 263
 264 static void RPCRT4_create_worker_if_needed(void)
 265 {
 266   if (!worker_free && worker_count < MAX_THREADS) {
 267     HANDLE thread;
 268     InterlockedIncrement(&worker_count);
 269     InterlockedIncrement(&worker_free);
 270     thread = CreateThread(NULL, 0, RPCRT4_worker_thread, NULL, 0, NULL);
 271     if (thread) CloseHandle(thread);
 272     else {
 273       InterlockedDecrement(&worker_free);
 274       InterlockedDecrement(&worker_count);
 275     }
 276   }
 277 }
 278
 279 static DWORD CALLBACK RPCRT4_io_thread(LPVOID the_arg)
 280 {
 281   RpcConnection* conn = (RpcConnection*)the_arg;
 282   RpcPktHdr hdr;
 283   DWORD dwRead;
 284   void* buf = NULL;
 285   RpcPacket* packet;
 286
 287   TRACE("(%p)\n", conn);
 288
 289   for (;;) {
 290     /* read packet header */
 291 #ifdef OVERLAPPED_WORKS
 292     if (!ReadFile(conn->conn, &hdr, sizeof(hdr), &dwRead, &conn->ovl)) {
 293       DWORD err = GetLastError();
 294       if (err != ERROR_IO_PENDING) {
 295         TRACE("connection lost, error=%08lx\n", err);
 296         break;
 297       }
 298       if (!GetOverlappedResult(conn->conn, &conn->ovl, &dwRead, TRUE)) break;
 299     }
 300 #else
 301     if (!ReadFile(conn->conn, &hdr, sizeof(hdr), &dwRead, NULL)) {
 302       TRACE("connection lost, error=%08lx\n", GetLastError());
 303       break;
 304     }
 305 #endif
 306     if (dwRead != sizeof(hdr)) {
 307       if (dwRead) TRACE("protocol error: <hdrsz == %d, dwRead == %lu>\n", sizeof(hdr), dwRead);
 308       break;
 309     }
 310
 311     /* read packet body */
 312     buf = HeapAlloc(GetProcessHeap(), 0, hdr.len);
 313     TRACE("receiving payload=%d\n", hdr.len);
 314     if (!hdr.len) dwRead = 0; else
 315 #ifdef OVERLAPPED_WORKS
 316     if (!ReadFile(conn->conn, buf, hdr.len, &dwRead, &conn->ovl)) {
 317       DWORD err = GetLastError();
 318       if (err != ERROR_IO_PENDING) {
 319         TRACE("connection lost, error=%08lx\n", err);
 320         break;
 321       }
 322       if (!GetOverlappedResult(conn->conn, &conn->ovl, &dwRead, TRUE)) break;
 323     }
 324 #else
 325     if (!ReadFile(conn->conn, buf, hdr.len, &dwRead, NULL)) {
 326       TRACE("connection lost, error=%08lx\n", GetLastError());
 327       break;
 328     }
 329 #endif
 330     if (dwRead != hdr.len) {
 331       TRACE("protocol error: <bodylen == %d, dwRead == %lu>\n", hdr.len, dwRead);
 332       break;
 333     }
 334
 335 #if 0
 336     RPCRT4_process_packet(conn, &hdr, buf);
 337 #else
 338     packet = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcPacket));
 339     packet->conn = conn;
 340     packet->hdr = hdr;
 341     packet->buf = buf;
 342     RPCRT4_create_worker_if_needed();
 343     RPCRT4_push_packet(packet);
 344     ReleaseSemaphore(server_sem, 1, NULL);
 345 #endif
 346     buf = NULL;
 347   }
 348   if (buf) HeapFree(GetProcessHeap(), 0, buf);
 349   RPCRT4_DestroyConnection(conn);
 350   return 0;
 351 }
 352
 353 static void RPCRT4_new_client(RpcConnection* conn)
 354 {
 355   HANDLE thread = CreateThread(NULL, 0, RPCRT4_io_thread, conn, 0, NULL);
 356   if (!thread) {
 357     DWORD err = GetLastError();
 358     ERR("failed to create thread, error=%08lx\n", err);
 359     RPCRT4_DestroyConnection(conn);
 360   }
 361   /* we could set conn->thread, but then we'd have to make the io_thread wait
 362    * for that, otherwise the thread might finish, destroy the connection, and
 363    * free the memory we'd write to before we did, causing crashes and stuff -
 364    * so let's implement that later, when we really need conn->thread */
 365
 366   CloseHandle( thread );
 367 }
 368
 369 static DWORD CALLBACK RPCRT4_server_thread(LPVOID the_arg)
 370 {
 371   HANDLE m_event = mgr_event, b_handle;
 372   HANDLE *objs = NULL;
 373   DWORD count, res;
 374   RpcServerProtseq* cps;
 375   RpcConnection* conn;
 376   RpcConnection* cconn;
 377
 378   for (;;) {
 379     EnterCriticalSection(&server_cs);
 380     /* open and count connections */
 381     count = 1;
 382     cps = protseqs;
 383     while (cps) {
 384       conn = cps->conn;
 385       while (conn) {
 386         RPCRT4_OpenConnection(conn);
 387         if (conn->ovl.hEvent) count++;
 388         conn = conn->Next;
 389       }
 390       cps = cps->Next;
 391     }
 392     /* make array of connections */
 393     objs = HeapReAlloc(GetProcessHeap(), 0, objs, count*sizeof(HANDLE));
 394     objs[0] = m_event;
 395     count = 1;
 396     cps = protseqs;
 397     while (cps) {
 398       conn = cps->conn;
 399       while (conn) {
 400         if (conn->ovl.hEvent) objs[count++] = conn->ovl.hEvent;
 401         conn = conn->Next;
 402       }
 403       cps = cps->Next;
 404     }
 405     LeaveCriticalSection(&server_cs);
 406
 407     /* start waiting */
 408     res = WaitForMultipleObjects(count, objs, FALSE, INFINITE);
 409     if (res == WAIT_OBJECT_0) {
 410       ResetEvent(m_event);
 411       if (!std_listen) break;
 412     }
 413     else if (res == WAIT_FAILED) {
 414       ERR("wait failed\n");
 415     }
 416     else {
 417       b_handle = objs[res - WAIT_OBJECT_0];
 418       /* find which connection got a RPC */
 419       EnterCriticalSection(&server_cs);
 420       conn = NULL;
 421       cps = protseqs;
 422       while (cps) {
 423         conn = cps->conn;
 424         while (conn) {
 425           if (conn->ovl.hEvent == b_handle) break;
 426           conn = conn->Next;
 427         }
 428         if (conn) break;
 429         cps = cps->Next;
 430       }
 431       cconn = NULL;
 432       if (conn) RPCRT4_SpawnConnection(&cconn, conn);
 433       LeaveCriticalSection(&server_cs);
 434       if (!conn) {
 435         ERR("failed to locate connection for handle %p\n", b_handle);
 436       }
 437       if (cconn) RPCRT4_new_client(cconn);
 438     }
 439   }
 440   HeapFree(GetProcessHeap(), 0, objs);
 441   EnterCriticalSection(&server_cs);
 442   /* close connections */
 443   cps = protseqs;
 444   while (cps) {
 445     conn = cps->conn;
 446     while (conn) {
 447       RPCRT4_CloseConnection(conn);
 448       conn = conn->Next;
 449     }
 450     cps = cps->Next;
 451   }
 452   LeaveCriticalSection(&server_cs);
 453   return 0;
 454 }
 455
 456 static void RPCRT4_start_listen(void)
 457 {
 458   TRACE("\n");
 459
 460   EnterCriticalSection(&listen_cs);
 461   if (! ++listen_count) {
 462     if (!mgr_event) mgr_event = CreateEventA(NULL, TRUE, FALSE, NULL);
 463     if (!server_sem) server_sem = CreateSemaphoreA(NULL, 0, MAX_THREADS, NULL);
 464     if (!worker_tls) worker_tls = TlsAlloc();
 465     std_listen = TRUE;
 466     server_thread = CreateThread(NULL, 0, RPCRT4_server_thread, NULL, 0, NULL);
 467     LeaveCriticalSection(&listen_cs);
 468   } else {
 469     LeaveCriticalSection(&listen_cs);
 470     SetEvent(mgr_event);
 471   }
 472 }
 473
 474 static void RPCRT4_stop_listen(void)
 475 {
 476   EnterCriticalSection(&listen_cs);
 477   if (listen_count == -1)
 478     LeaveCriticalSection(&listen_cs);
 479   else if (--listen_count == -1) {
 480     std_listen = FALSE;
 481     LeaveCriticalSection(&listen_cs);
 482     SetEvent(mgr_event);
 483   } else
 484     LeaveCriticalSection(&listen_cs);
 485   assert(listen_count > -2);
 486 }
 487
 488 static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq* ps)
 489 {
 490   RPCRT4_CreateConnection(&ps->conn, TRUE, ps->Protseq, NULL, ps->Endpoint, NULL, NULL);
 491
 492   EnterCriticalSection(&server_cs);
 493   ps->Next = protseqs;
 494   protseqs = ps;
 495   LeaveCriticalSection(&server_cs);
 496
 497   if (std_listen) SetEvent(mgr_event);
 498
 499   return RPC_S_OK;
 500 }
 501
 502 /***********************************************************************
 503  *             RpcServerInqBindings (RPCRT4.@)
 504  */
 505 RPC_STATUS WINAPI RpcServerInqBindings( RPC_BINDING_VECTOR** BindingVector )
 506 {
 507   RPC_STATUS status;
 508   DWORD count;
 509   RpcServerProtseq* ps;
 510   RpcConnection* conn;
 511
 512   if (BindingVector)
 513     TRACE("(*BindingVector == ^%p)\n", *BindingVector);
 514   else
 515     ERR("(BindingVector == ^null!!?)\n");
 516
 517   EnterCriticalSection(&server_cs);
 518   /* count connections */
 519   count = 0;
 520   ps = protseqs;
 521   while (ps) {
 522     conn = ps->conn;
 523     while (conn) {
 524       count++;
 525       conn = conn->Next;
 526     }
 527     ps = ps->Next;
 528   }
 529   if (count) {
 530     /* export bindings */
 531     *BindingVector = HeapAlloc(GetProcessHeap(), 0,
 532                               sizeof(RPC_BINDING_VECTOR) +
 533                               sizeof(RPC_BINDING_HANDLE)*(count-1));
 534     (*BindingVector)->Count = count;
 535     count = 0;
 536     ps = protseqs;
 537     while (ps) {
 538       conn = ps->conn;
 539       while (conn) {
 540        RPCRT4_MakeBinding((RpcBinding**)&(*BindingVector)->BindingH[count],
 541                           conn);
 542        count++;
 543        conn = conn->Next;
 544       }
 545       ps = ps->Next;
 546     }
 547     status = RPC_S_OK;
 548   } else {
 549     *BindingVector = NULL;
 550     status = RPC_S_NO_BINDINGS;
 551   }
 552   LeaveCriticalSection(&server_cs);
 553   return status;
 554 }
 555
 556 /***********************************************************************
 557  *             RpcServerUseProtseqEpA (RPCRT4.@)
 558  */
 559 RPC_STATUS WINAPI RpcServerUseProtseqEpA( LPSTR Protseq, UINT MaxCalls, LPSTR Endpoint, LPVOID SecurityDescriptor )
 560 {
 561   RPC_POLICY policy;
 562
 563   TRACE( "(%s,%u,%s,%p)\n", Protseq, MaxCalls, Endpoint, SecurityDescriptor );
 564
 565   /* This should provide the default behaviour */
 566   policy.Length        = sizeof( policy );
 567   policy.EndpointFlags = 0;
 568   policy.NICFlags      = 0;
 569
 570   return RpcServerUseProtseqEpExA( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
 571 }
 572
 573 /***********************************************************************
 574  *             RpcServerUseProtseqEpW (RPCRT4.@)
 575  */
 576 RPC_STATUS WINAPI RpcServerUseProtseqEpW( LPWSTR Protseq, UINT MaxCalls, LPWSTR Endpoint, LPVOID SecurityDescriptor )
 577 {
 578   RPC_POLICY policy;
 579
 580   TRACE( "(%s,%u,%s,%p)\n", debugstr_w( Protseq ), MaxCalls, debugstr_w( Endpoint ), SecurityDescriptor );
 581
 582   /* This should provide the default behaviour */
 583   policy.Length        = sizeof( policy );
 584   policy.EndpointFlags = 0;
 585   policy.NICFlags      = 0;
 586
 587   return RpcServerUseProtseqEpExW( Protseq, MaxCalls, Endpoint, SecurityDescriptor, &policy );
 588 }
 589
 590 /***********************************************************************
 591  *             RpcServerUseProtseqEpExA (RPCRT4.@)
 592  */
 593 RPC_STATUS WINAPI RpcServerUseProtseqEpExA( LPSTR Protseq, UINT MaxCalls, LPSTR Endpoint, LPVOID SecurityDescriptor,
 594                                             PRPC_POLICY lpPolicy )
 595 {
 596   RpcServerProtseq* ps;
 597
 598   TRACE("(%s,%u,%s,%p,{%u,%lu,%lu})\n", debugstr_a( Protseq ), MaxCalls,
 599        debugstr_a( Endpoint ), SecurityDescriptor,
 600        lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
 601
 602   ps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcServerProtseq));
 603   ps->MaxCalls = MaxCalls;
 604   ps->Protseq = RPCRT4_strdupA(Protseq);
 605   ps->Endpoint = RPCRT4_strdupA(Endpoint);
 606
 607   return RPCRT4_use_protseq(ps);
 608 }
 609
 610 /***********************************************************************
 611  *             RpcServerUseProtseqEpExW (RPCRT4.@)
 612  */
 613 RPC_STATUS WINAPI RpcServerUseProtseqEpExW( LPWSTR Protseq, UINT MaxCalls, LPWSTR Endpoint, LPVOID SecurityDescriptor,
 614                                             PRPC_POLICY lpPolicy )
 615 {
 616   RpcServerProtseq* ps;
 617
 618   TRACE("(%s,%u,%s,%p,{%u,%lu,%lu})\n", debugstr_w( Protseq ), MaxCalls,
 619        debugstr_w( Endpoint ), SecurityDescriptor,
 620        lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
 621
 622   ps = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcServerProtseq));
 623   ps->MaxCalls = MaxCalls;
 624   /* FIXME: Did Ove have these next two as RPCRT4_strdupW for a reason? */
 625   ps->Protseq = RPCRT4_strdupWtoA(Protseq);
 626   ps->Endpoint = RPCRT4_strdupWtoA(Endpoint);
 627
 628   return RPCRT4_use_protseq(ps);
 629 }
 630
 631 /***********************************************************************
 632  *             RpcServerUseProtseqA (RPCRT4.@)
 633  */
 634 RPC_STATUS WINAPI RpcServerUseProtseqA(LPSTR Protseq, unsigned int MaxCalls, void *SecurityDescriptor)
 635 {
 636   TRACE("(Protseq == %s, MaxCalls == %d, SecurityDescriptor == ^%p)", debugstr_a(Protseq), MaxCalls, SecurityDescriptor);
 637   return RpcServerUseProtseqEpA(Protseq, MaxCalls, NULL, SecurityDescriptor);
 638 }
 639
 640 /***********************************************************************
 641  *             RpcServerUseProtseqW (RPCRT4.@)
 642  */
 643 RPC_STATUS WINAPI RpcServerUseProtseqW(LPWSTR Protseq, unsigned int MaxCalls, void *SecurityDescriptor)
 644 {
 645   TRACE("Protseq == %s, MaxCalls == %d, SecurityDescriptor == ^%p)", debugstr_w(Protseq), MaxCalls, SecurityDescriptor);
 646   return RpcServerUseProtseqEpW(Protseq, MaxCalls, NULL, SecurityDescriptor);
 647 }
 648
 649 /***********************************************************************
 650  *             RpcServerRegisterIf (RPCRT4.@)
 651  */
 652 RPC_STATUS WINAPI RpcServerRegisterIf( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv )
 653 {
 654   TRACE("(%p,%s,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv);
 655   return RpcServerRegisterIf2( IfSpec, MgrTypeUuid, MgrEpv, 0, RPC_C_LISTEN_MAX_CALLS_DEFAULT, (UINT)-1, NULL );
 656 }
 657
 658 /***********************************************************************
 659  *             RpcServerRegisterIfEx (RPCRT4.@)
 660  */
 661 RPC_STATUS WINAPI RpcServerRegisterIfEx( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
 662                        UINT Flags, UINT MaxCalls, RPC_IF_CALLBACK_FN* IfCallbackFn )
 663 {
 664   TRACE("(%p,%s,%p,%u,%u,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv, Flags, MaxCalls, IfCallbackFn);
 665   return RpcServerRegisterIf2( IfSpec, MgrTypeUuid, MgrEpv, Flags, MaxCalls, (UINT)-1, IfCallbackFn );
 666 }
 667
 668 /***********************************************************************
 669  *             RpcServerRegisterIf2 (RPCRT4.@)
 670  */
 671 RPC_STATUS WINAPI RpcServerRegisterIf2( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
 672                       UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN* IfCallbackFn )
 673 {
 674   PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
 675   RpcServerInterface* sif;
 676   int i;
 677
 678   TRACE("(%p,%s,%p,%u,%u,%u,%p)\n", IfSpec, debugstr_guid(MgrTypeUuid), MgrEpv, Flags, MaxCalls,
 679          MaxRpcSize, IfCallbackFn);
 680   TRACE(" interface id: %s %d.%d\n", debugstr_guid(&If->InterfaceId.SyntaxGUID),
 681                                      If->InterfaceId.SyntaxVersion.MajorVersion,
 682                                      If->InterfaceId.SyntaxVersion.MinorVersion);
 683   TRACE(" transfer syntax: %s %d.%d\n", debugstr_guid(&If->TransferSyntax.SyntaxGUID),
 684                                         If->TransferSyntax.SyntaxVersion.MajorVersion,
 685                                         If->TransferSyntax.SyntaxVersion.MinorVersion);
 686   TRACE(" dispatch table: %p\n", If->DispatchTable);
 687   if (If->DispatchTable) {
 688     TRACE("  dispatch table count: %d\n", If->DispatchTable->DispatchTableCount);
 689     for (i=0; i<If->DispatchTable->DispatchTableCount; i++) {
 690       TRACE("   entry %d: %p\n", i, If->DispatchTable->DispatchTable[i]);
 691     }
 692     TRACE("  reserved: %ld\n", If->DispatchTable->Reserved);
 693   }
 694   TRACE(" protseq endpoint count: %d\n", If->RpcProtseqEndpointCount);
 695   TRACE(" default manager epv: %p\n", If->DefaultManagerEpv);
 696   TRACE(" interpreter info: %p\n", If->InterpreterInfo);
 697   TRACE(" flags: %08x\n", If->Flags);
 698
 699   sif = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcServerInterface));
 700   sif->If           = If;
 701   if (MgrTypeUuid)
 702     memcpy(&sif->MgrTypeUuid, MgrTypeUuid, sizeof(UUID));
 703   else
 704     memset(&sif->MgrTypeUuid, 0, sizeof(UUID));
 705   sif->MgrEpv       = MgrEpv;
 706   sif->Flags        = Flags;
 707   sif->MaxCalls     = MaxCalls;
 708   sif->MaxRpcSize   = MaxRpcSize;
 709   sif->IfCallbackFn = IfCallbackFn;
 710
 711   EnterCriticalSection(&server_cs);
 712   sif->Next = ifs;
 713   ifs = sif;
 714   LeaveCriticalSection(&server_cs);
 715
 716   if (sif->Flags & RPC_IF_AUTOLISTEN) {
 717     /* well, start listening, I think... */
 718     RPCRT4_start_listen();
 719   }
 720
 721   return RPC_S_OK;
 722 }
 723
 724 /***********************************************************************
 725  *             RpcServerUnregisterIf (RPCRT4.@)
 726  */
 727 RPC_STATUS WINAPI RpcServerUnregisterIf( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, UINT WaitForCallsToComplete )
 728 {
 729   FIXME("(IfSpec == (RPC_IF_HANDLE)^%p, MgrTypeUuid == %s, WaitForCallsToComplete == %u): stub\n",
 730     IfSpec, debugstr_guid(MgrTypeUuid), WaitForCallsToComplete);
 731
 732   return RPC_S_OK;
 733 }
 734
 735 /***********************************************************************
 736  *             RpcServerUnregisterIfEx (RPCRT4.@)
 737  */
 738 RPC_STATUS WINAPI RpcServerUnregisterIfEx( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, int RundownContextHandles )
 739 {
 740   FIXME("(IfSpec == (RPC_IF_HANDLE)^%p, MgrTypeUuid == %s, RundownContextHandles == %d): stub\n",
 741     IfSpec, debugstr_guid(MgrTypeUuid), RundownContextHandles);
 742
 743   return RPC_S_OK;
 744 }
 745
 746 /***********************************************************************
 747  *             RpcServerRegisterAuthInfoA (RPCRT4.@)
 748  */
 749 RPC_STATUS WINAPI RpcServerRegisterAuthInfoA( LPSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
 750                             LPVOID Arg )
 751 {
 752   FIXME( "(%s,%lu,%p,%p): stub\n", ServerPrincName, AuthnSvc, GetKeyFn, Arg );
 753
 754   return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
 755 }
 756
 757 /***********************************************************************
 758  *             RpcServerRegisterAuthInfoW (RPCRT4.@)
 759  */
 760 RPC_STATUS WINAPI RpcServerRegisterAuthInfoW( LPWSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
 761                             LPVOID Arg )
 762 {
 763   FIXME( "(%s,%lu,%p,%p): stub\n", debugstr_w( ServerPrincName ), AuthnSvc, GetKeyFn, Arg );
 764
 765   return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
 766 }
 767
 768 /***********************************************************************
 769  *             RpcServerListen (RPCRT4.@)
 770  */
 771 RPC_STATUS WINAPI RpcServerListen( UINT MinimumCallThreads, UINT MaxCalls, UINT DontWait )
 772 {
 773   TRACE("(%u,%u,%u)\n", MinimumCallThreads, MaxCalls, DontWait);
 774
 775   if (!protseqs)
 776     return RPC_S_NO_PROTSEQS_REGISTERED;
 777
 778   EnterCriticalSection(&listen_cs);
 779
 780   if (std_listen) {
 781     LeaveCriticalSection(&listen_cs);
 782     return RPC_S_ALREADY_LISTENING;
 783   }
 784
 785   RPCRT4_start_listen();
 786
 787   LeaveCriticalSection(&listen_cs);
 788
 789   if (DontWait) return RPC_S_OK;
 790
 791   return RpcMgmtWaitServerListen();
 792 }
 793
 794 /***********************************************************************
 795  *             RpcMgmtServerWaitListen (RPCRT4.@)
 796  */
 797 RPC_STATUS WINAPI RpcMgmtWaitServerListen( void )
 798 {
 799   RPC_STATUS rslt = RPC_S_OK;
 800
 801   TRACE("\n");
 802
 803   EnterCriticalSection(&listen_cs);
 804
 805   if (!std_listen)
 806     if ( (rslt = RpcServerListen(1, 0, TRUE)) != RPC_S_OK ) {
 807       LeaveCriticalSection(&listen_cs);
 808       return rslt;
 809     }
 810
 811   LeaveCriticalSection(&listen_cs);
 812
 813   while (std_listen) {
 814     WaitForSingleObject(mgr_event, INFINITE);
 815     if (!std_listen) {
 816       Sleep(100); /* don't spin violently */
 817       TRACE("spinning.\n");
 818     }
 819   }
 820
 821   return rslt;
 822 }
 823
 824 /***********************************************************************
 825  *             RpcMgmtStopServerListening (RPCRT4.@)
 826  */
 827 RPC_STATUS WINAPI RpcMgmtStopServerListening ( RPC_BINDING_HANDLE Binding )
 828 {
 829   TRACE("(Binding == (RPC_BINDING_HANDLE)^%p)\n", Binding);
 830
 831   if (Binding) {
 832     FIXME("client-side invocation not implemented.\n");
 833     return RPC_S_WRONG_KIND_OF_BINDING;
 834   }
 835
 836   /* hmm... */
 837   EnterCriticalSection(&listen_cs);
 838   while (std_listen)
 839     RPCRT4_stop_listen();
 840   LeaveCriticalSection(&listen_cs);
 841
 842   return RPC_S_OK;
 843 }
 844
 845 /***********************************************************************
 846  *             I_RpcServerStartListening (RPCRT4.@)
 847  */
 848 RPC_STATUS WINAPI I_RpcServerStartListening( void* hWnd )
 849 {
 850   FIXME( "(%p): stub\n", hWnd );
 851
 852   return RPC_S_OK;
 853 }
 854
 855 /***********************************************************************
 856  *             I_RpcServerStopListening (RPCRT4.@)
 857  */
 858 RPC_STATUS WINAPI I_RpcServerStopListening( void )
 859 {
 860   FIXME( "(): stub\n" );
 861
 862   return RPC_S_OK;
 863 }
 864
 865 /***********************************************************************
 866  *             I_RpcWindowProc (RPCRT4.@)
 867  */
 868 UINT WINAPI I_RpcWindowProc( void *hWnd, UINT Message, UINT wParam, ULONG lParam )
 869 {
 870   FIXME( "(%p,%08x,%08x,%08lx): stub\n", hWnd, Message, wParam, lParam );
 871
 872   return 0;
 873 }