git.oblomov.eu Git - wine/blob - dlls/rpcrt4/rpc_transport.c

   1 /*
   2  * RPC transport layer
   3  *
   4  * Copyright 2001 Ove Kåven, TransGaming Technologies
   5  * Copyright 2003 Mike Hearn
   6  * Copyright 2004 Filip Navara
   7  * Copyright 2006 Mike McCormack
   8  * Copyright 2006 Damjan Jovanovic
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  *
  24  */
  25
  26 #include "config.h"
  27
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <assert.h>
  32 #include <errno.h>
  33
  34 #ifdef HAVE_UNISTD_H
  35 # include <unistd.h>
  36 #endif
  37 #include <fcntl.h>
  38 #include <stdlib.h>
  39 #include <sys/types.h>
  40 #ifdef HAVE_SYS_SOCKET_H
  41 # include <sys/socket.h>
  42 #endif
  43 #ifdef HAVE_NETINET_IN_H
  44 # include <netinet/in.h>
  45 #endif
  46 #ifdef HAVE_NETINET_TCP_H
  47 # include <netinet/tcp.h>
  48 #endif
  49 #ifdef HAVE_ARPA_INET_H
  50 # include <arpa/inet.h>
  51 #endif
  52 #ifdef HAVE_NETDB_H
  53 #include <netdb.h>
  54 #endif
  55 #ifdef HAVE_SYS_POLL_H
  56 #include <sys/poll.h>
  57 #endif
  58
  59 #include "windef.h"
  60 #include "winbase.h"
  61 #include "winnls.h"
  62 #include "winerror.h"
  63 #include "winternl.h"
  64 #include "wine/unicode.h"
  65
  66 #include "rpc.h"
  67 #include "rpcndr.h"
  68
  69 #include "wine/debug.h"
  70
  71 #include "rpc_binding.h"
  72 #include "rpc_message.h"
  73 #include "rpc_server.h"
  74 #include "epm_towers.h"
  75
  76 #ifndef SOL_TCP
  77 # define SOL_TCP IPPROTO_TCP
  78 #endif
  79
  80 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
  81
  82 /**** ncacn_np support ****/
  83
  84 typedef struct _RpcConnection_np
  85 {
  86   RpcConnection common;
  87   HANDLE pipe;
  88   OVERLAPPED ovl;
  89   BOOL listening;
  90 } RpcConnection_np;
  91
  92 static RpcConnection *rpcrt4_conn_np_alloc(void)
  93 {
  94   RpcConnection_np *npc = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcConnection_np));
  95   if (npc)
  96   {
  97     npc->pipe = NULL;
  98     memset(&npc->ovl, 0, sizeof(npc->ovl));
  99     npc->listening = FALSE;
 100   }
 101   return &npc->common;
 102 }
 103
 104 static RPC_STATUS rpcrt4_conn_listen_pipe(RpcConnection_np *npc)
 105 {
 106   if (npc->listening)
 107     return RPC_S_OK;
 108
 109   npc->listening = TRUE;
 110   if (ConnectNamedPipe(npc->pipe, &npc->ovl))
 111     return RPC_S_OK;
 112
 113   if (GetLastError() == ERROR_PIPE_CONNECTED) {
 114     SetEvent(npc->ovl.hEvent);
 115     return RPC_S_OK;
 116   }
 117   if (GetLastError() == ERROR_IO_PENDING) {
 118     /* will be completed in rpcrt4_protseq_np_wait_for_new_connection */
 119     return RPC_S_OK;
 120   }
 121   npc->listening = FALSE;
 122   WARN("Couldn't ConnectNamedPipe (error was %d)\n", GetLastError());
 123   return RPC_S_OUT_OF_RESOURCES;
 124 }
 125
 126 static RPC_STATUS rpcrt4_conn_create_pipe(RpcConnection *Connection, LPCSTR pname)
 127 {
 128   RpcConnection_np *npc = (RpcConnection_np *) Connection;
 129   TRACE("listening on %s\n", pname);
 130
 131   npc->pipe = CreateNamedPipeA(pname, PIPE_ACCESS_DUPLEX,
 132                                PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE,
 133                                PIPE_UNLIMITED_INSTANCES,
 134                                RPC_MAX_PACKET_SIZE, RPC_MAX_PACKET_SIZE, 5000, NULL);
 135   if (npc->pipe == INVALID_HANDLE_VALUE) {
 136     WARN("CreateNamedPipe failed with error %d\n", GetLastError());
 137     if (GetLastError() == ERROR_FILE_EXISTS)
 138       return RPC_S_DUPLICATE_ENDPOINT;
 139     else
 140       return RPC_S_CANT_CREATE_ENDPOINT;
 141   }
 142
 143   memset(&npc->ovl, 0, sizeof(npc->ovl));
 144   npc->ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 145
 146   /* Note: we don't call ConnectNamedPipe here because it must be done in the
 147    * server thread as the thread must be alertable */
 148   return RPC_S_OK;
 149 }
 150
 151 static RPC_STATUS rpcrt4_conn_open_pipe(RpcConnection *Connection, LPCSTR pname, BOOL wait)
 152 {
 153   RpcConnection_np *npc = (RpcConnection_np *) Connection;
 154   HANDLE pipe;
 155   DWORD err, dwMode;
 156
 157   TRACE("connecting to %s\n", pname);
 158
 159   while (TRUE) {
 160     DWORD dwFlags = 0;
 161     if (Connection->QOS)
 162     {
 163         dwFlags = SECURITY_SQOS_PRESENT;
 164         switch (Connection->QOS->qos->ImpersonationType)
 165         {
 166             case RPC_C_IMP_LEVEL_DEFAULT:
 167                 /* FIXME: what to do here? */
 168                 break;
 169             case RPC_C_IMP_LEVEL_ANONYMOUS:
 170                 dwFlags |= SECURITY_ANONYMOUS;
 171                 break;
 172             case RPC_C_IMP_LEVEL_IDENTIFY:
 173                 dwFlags |= SECURITY_IDENTIFICATION;
 174                 break;
 175             case RPC_C_IMP_LEVEL_IMPERSONATE:
 176                 dwFlags |= SECURITY_IMPERSONATION;
 177                 break;
 178             case RPC_C_IMP_LEVEL_DELEGATE:
 179                 dwFlags |= SECURITY_DELEGATION;
 180                 break;
 181         }
 182         if (Connection->QOS->qos->IdentityTracking == RPC_C_QOS_IDENTIFY_DYNAMIC)
 183             dwFlags |= SECURITY_CONTEXT_TRACKING;
 184     }
 185     pipe = CreateFileA(pname, GENERIC_READ|GENERIC_WRITE, 0, NULL,
 186                        OPEN_EXISTING, dwFlags, 0);
 187     if (pipe != INVALID_HANDLE_VALUE) break;
 188     err = GetLastError();
 189     if (err == ERROR_PIPE_BUSY) {
 190       TRACE("connection failed, error=%x\n", err);
 191       return RPC_S_SERVER_TOO_BUSY;
 192     }
 193     if (!wait)
 194       return RPC_S_SERVER_UNAVAILABLE;
 195     if (!WaitNamedPipeA(pname, NMPWAIT_WAIT_FOREVER)) {
 196       err = GetLastError();
 197       WARN("connection failed, error=%x\n", err);
 198       return RPC_S_SERVER_UNAVAILABLE;
 199     }
 200   }
 201
 202   /* success */
 203   memset(&npc->ovl, 0, sizeof(npc->ovl));
 204   /* pipe is connected; change to message-read mode. */
 205   dwMode = PIPE_READMODE_MESSAGE;
 206   SetNamedPipeHandleState(pipe, &dwMode, NULL, NULL);
 207   npc->ovl.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
 208   npc->pipe = pipe;
 209
 210   return RPC_S_OK;
 211 }
 212
 213 static RPC_STATUS rpcrt4_ncalrpc_open(RpcConnection* Connection)
 214 {
 215   RpcConnection_np *npc = (RpcConnection_np *) Connection;
 216   static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
 217   RPC_STATUS r;
 218   LPSTR pname;
 219
 220   /* already connected? */
 221   if (npc->pipe)
 222     return RPC_S_OK;
 223
 224   /* protseq=ncalrpc: supposed to use NT LPC ports,
 225    * but we'll implement it with named pipes for now */
 226   pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
 227   strcat(strcpy(pname, prefix), Connection->Endpoint);
 228   r = rpcrt4_conn_open_pipe(Connection, pname, TRUE);
 229   I_RpcFree(pname);
 230
 231   return r;
 232 }
 233
 234 static RPC_STATUS rpcrt4_protseq_ncalrpc_open_endpoint(RpcServerProtseq* protseq, LPSTR endpoint)
 235 {
 236   static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
 237   RPC_STATUS r;
 238   LPSTR pname;
 239   RpcConnection *Connection;
 240
 241   r = RPCRT4_CreateConnection(&Connection, TRUE, protseq->Protseq, NULL,
 242                               endpoint, NULL, NULL, NULL);
 243   if (r != RPC_S_OK)
 244       return r;
 245
 246   /* protseq=ncalrpc: supposed to use NT LPC ports,
 247    * but we'll implement it with named pipes for now */
 248   pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
 249   strcat(strcpy(pname, prefix), Connection->Endpoint);
 250   r = rpcrt4_conn_create_pipe(Connection, pname);
 251   I_RpcFree(pname);
 252
 253   EnterCriticalSection(&protseq->cs);
 254   Connection->Next = protseq->conn;
 255   protseq->conn = Connection;
 256   LeaveCriticalSection(&protseq->cs);
 257
 258   return r;
 259 }
 260
 261 static RPC_STATUS rpcrt4_ncacn_np_open(RpcConnection* Connection)
 262 {
 263   RpcConnection_np *npc = (RpcConnection_np *) Connection;
 264   static const char prefix[] = "\\\\.";
 265   RPC_STATUS r;
 266   LPSTR pname;
 267
 268   /* already connected? */
 269   if (npc->pipe)
 270     return RPC_S_OK;
 271
 272   /* protseq=ncacn_np: named pipes */
 273   pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
 274   strcat(strcpy(pname, prefix), Connection->Endpoint);
 275   r = rpcrt4_conn_open_pipe(Connection, pname, FALSE);
 276   I_RpcFree(pname);
 277
 278   return r;
 279 }
 280
 281 static RPC_STATUS rpcrt4_protseq_ncacn_np_open_endpoint(RpcServerProtseq *protseq, LPSTR endpoint)
 282 {
 283   static const char prefix[] = "\\\\.";
 284   RPC_STATUS r;
 285   LPSTR pname;
 286   RpcConnection *Connection;
 287
 288   r = RPCRT4_CreateConnection(&Connection, TRUE, protseq->Protseq, NULL,
 289                               endpoint, NULL, NULL, NULL);
 290   if (r != RPC_S_OK)
 291     return r;
 292
 293   /* protseq=ncacn_np: named pipes */
 294   pname = I_RpcAllocate(strlen(prefix) + strlen(Connection->Endpoint) + 1);
 295   strcat(strcpy(pname, prefix), Connection->Endpoint);
 296   r = rpcrt4_conn_create_pipe(Connection, pname);
 297   I_RpcFree(pname);
 298
 299   EnterCriticalSection(&protseq->cs);
 300   Connection->Next = protseq->conn;
 301   protseq->conn = Connection;
 302   LeaveCriticalSection(&protseq->cs);
 303
 304   return r;
 305 }
 306
 307 static void rpcrt4_conn_np_handoff(RpcConnection_np *old_npc, RpcConnection_np *new_npc)
 308 {
 309   /* because of the way named pipes work, we'll transfer the connected pipe
 310    * to the child, then reopen the server binding to continue listening */
 311
 312   new_npc->pipe = old_npc->pipe;
 313   new_npc->ovl = old_npc->ovl;
 314   old_npc->pipe = 0;
 315   memset(&old_npc->ovl, 0, sizeof(old_npc->ovl));
 316   old_npc->listening = FALSE;
 317 }
 318
 319 static RPC_STATUS rpcrt4_ncacn_np_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
 320 {
 321   RPC_STATUS status;
 322   LPSTR pname;
 323   static const char prefix[] = "\\\\.";
 324
 325   rpcrt4_conn_np_handoff((RpcConnection_np *)old_conn, (RpcConnection_np *)new_conn);
 326
 327   pname = I_RpcAllocate(strlen(prefix) + strlen(old_conn->Endpoint) + 1);
 328   strcat(strcpy(pname, prefix), old_conn->Endpoint);
 329   status = rpcrt4_conn_create_pipe(old_conn, pname);
 330   I_RpcFree(pname);
 331
 332   return status;
 333 }
 334
 335 static RPC_STATUS rpcrt4_ncalrpc_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
 336 {
 337   RPC_STATUS status;
 338   LPSTR pname;
 339   static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
 340
 341   TRACE("%s\n", old_conn->Endpoint);
 342
 343   rpcrt4_conn_np_handoff((RpcConnection_np *)old_conn, (RpcConnection_np *)new_conn);
 344
 345   pname = I_RpcAllocate(strlen(prefix) + strlen(old_conn->Endpoint) + 1);
 346   strcat(strcpy(pname, prefix), old_conn->Endpoint);
 347   status = rpcrt4_conn_create_pipe(old_conn, pname);
 348   I_RpcFree(pname);
 349
 350   return status;
 351 }
 352
 353 static int rpcrt4_conn_np_read(RpcConnection *Connection,
 354                         void *buffer, unsigned int count)
 355 {
 356   RpcConnection_np *npc = (RpcConnection_np *) Connection;
 357   char *buf = buffer;
 358   BOOL ret = TRUE;
 359   unsigned int bytes_left = count;
 360
 361   while (bytes_left)
 362   {
 363     DWORD bytes_read;
 364     ret = ReadFile(npc->pipe, buf, bytes_left, &bytes_read, NULL);
 365     if (!ret || !bytes_read)
 366         break;
 367     bytes_left -= bytes_read;
 368     buf += bytes_read;
 369   }
 370   return ret ? count : -1;
 371 }
 372
 373 static int rpcrt4_conn_np_write(RpcConnection *Connection,
 374                              const void *buffer, unsigned int count)
 375 {
 376   RpcConnection_np *npc = (RpcConnection_np *) Connection;
 377   const char *buf = buffer;
 378   BOOL ret = TRUE;
 379   unsigned int bytes_left = count;
 380
 381   while (bytes_left)
 382   {
 383     DWORD bytes_written;
 384     ret = WriteFile(npc->pipe, buf, count, &bytes_written, NULL);
 385     if (!ret || !bytes_written)
 386         break;
 387     bytes_left -= bytes_written;
 388     buf += bytes_written;
 389   }
 390   return ret ? count : -1;
 391 }
 392
 393 static int rpcrt4_conn_np_close(RpcConnection *Connection)
 394 {
 395   RpcConnection_np *npc = (RpcConnection_np *) Connection;
 396   if (npc->pipe) {
 397     FlushFileBuffers(npc->pipe);
 398     CloseHandle(npc->pipe);
 399     npc->pipe = 0;
 400   }
 401   if (npc->ovl.hEvent) {
 402     CloseHandle(npc->ovl.hEvent);
 403     npc->ovl.hEvent = 0;
 404   }
 405   return 0;
 406 }
 407
 408 static void rpcrt4_conn_np_cancel_call(RpcConnection *Connection)
 409 {
 410     /* FIXME: implement when named pipe writes use overlapped I/O */
 411 }
 412
 413 static int rpcrt4_conn_np_wait_for_incoming_data(RpcConnection *Connection)
 414 {
 415     /* FIXME: implement when named pipe writes use overlapped I/O */
 416     return -1;
 417 }
 418
 419 static size_t rpcrt4_ncacn_np_get_top_of_tower(unsigned char *tower_data,
 420                                                const char *networkaddr,
 421                                                const char *endpoint)
 422 {
 423     twr_empty_floor_t *smb_floor;
 424     twr_empty_floor_t *nb_floor;
 425     size_t size;
 426     size_t networkaddr_size;
 427     size_t endpoint_size;
 428
 429     TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
 430
 431     networkaddr_size = networkaddr ? strlen(networkaddr) + 1 : 1;
 432     endpoint_size = endpoint ? strlen(endpoint) + 1 : 1;
 433     size = sizeof(*smb_floor) + endpoint_size + sizeof(*nb_floor) + networkaddr_size;
 434
 435     if (!tower_data)
 436         return size;
 437
 438     smb_floor = (twr_empty_floor_t *)tower_data;
 439
 440     tower_data += sizeof(*smb_floor);
 441
 442     smb_floor->count_lhs = sizeof(smb_floor->protid);
 443     smb_floor->protid = EPM_PROTOCOL_SMB;
 444     smb_floor->count_rhs = endpoint_size;
 445
 446     if (endpoint)
 447         memcpy(tower_data, endpoint, endpoint_size);
 448     else
 449         tower_data[0] = 0;
 450     tower_data += endpoint_size;
 451
 452     nb_floor = (twr_empty_floor_t *)tower_data;
 453
 454     tower_data += sizeof(*nb_floor);
 455
 456     nb_floor->count_lhs = sizeof(nb_floor->protid);
 457     nb_floor->protid = EPM_PROTOCOL_NETBIOS;
 458     nb_floor->count_rhs = networkaddr_size;
 459
 460     if (networkaddr)
 461         memcpy(tower_data, networkaddr, networkaddr_size);
 462     else
 463         tower_data[0] = 0;
 464     tower_data += networkaddr_size;
 465
 466     return size;
 467 }
 468
 469 static RPC_STATUS rpcrt4_ncacn_np_parse_top_of_tower(const unsigned char *tower_data,
 470                                                      size_t tower_size,
 471                                                      char **networkaddr,
 472                                                      char **endpoint)
 473 {
 474     const twr_empty_floor_t *smb_floor = (const twr_empty_floor_t *)tower_data;
 475     const twr_empty_floor_t *nb_floor;
 476
 477     TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
 478
 479     if (tower_size < sizeof(*smb_floor))
 480         return EPT_S_NOT_REGISTERED;
 481
 482     tower_data += sizeof(*smb_floor);
 483     tower_size -= sizeof(*smb_floor);
 484
 485     if ((smb_floor->count_lhs != sizeof(smb_floor->protid)) ||
 486         (smb_floor->protid != EPM_PROTOCOL_SMB) ||
 487         (smb_floor->count_rhs > tower_size))
 488         return EPT_S_NOT_REGISTERED;
 489
 490     if (endpoint)
 491     {
 492         *endpoint = I_RpcAllocate(smb_floor->count_rhs);
 493         if (!*endpoint)
 494             return RPC_S_OUT_OF_RESOURCES;
 495         memcpy(*endpoint, tower_data, smb_floor->count_rhs);
 496     }
 497     tower_data += smb_floor->count_rhs;
 498     tower_size -= smb_floor->count_rhs;
 499
 500     if (tower_size < sizeof(*nb_floor))
 501         return EPT_S_NOT_REGISTERED;
 502
 503     nb_floor = (const twr_empty_floor_t *)tower_data;
 504
 505     tower_data += sizeof(*nb_floor);
 506     tower_size -= sizeof(*nb_floor);
 507
 508     if ((nb_floor->count_lhs != sizeof(nb_floor->protid)) ||
 509         (nb_floor->protid != EPM_PROTOCOL_NETBIOS) ||
 510         (nb_floor->count_rhs > tower_size))
 511         return EPT_S_NOT_REGISTERED;
 512
 513     if (networkaddr)
 514     {
 515         *networkaddr = I_RpcAllocate(nb_floor->count_rhs);
 516         if (!*networkaddr)
 517         {
 518             if (endpoint)
 519             {
 520                 I_RpcFree(*endpoint);
 521                 *endpoint = NULL;
 522             }
 523             return RPC_S_OUT_OF_RESOURCES;
 524         }
 525         memcpy(*networkaddr, tower_data, nb_floor->count_rhs);
 526     }
 527
 528     return RPC_S_OK;
 529 }
 530
 531 typedef struct _RpcServerProtseq_np
 532 {
 533     RpcServerProtseq common;
 534     HANDLE mgr_event;
 535 } RpcServerProtseq_np;
 536
 537 static RpcServerProtseq *rpcrt4_protseq_np_alloc(void)
 538 {
 539     RpcServerProtseq_np *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps));
 540     if (ps)
 541         ps->mgr_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 542     return &ps->common;
 543 }
 544
 545 static void rpcrt4_protseq_np_signal_state_changed(RpcServerProtseq *protseq)
 546 {
 547     RpcServerProtseq_np *npps = CONTAINING_RECORD(protseq, RpcServerProtseq_np, common);
 548     SetEvent(npps->mgr_event);
 549 }
 550
 551 static void *rpcrt4_protseq_np_get_wait_array(RpcServerProtseq *protseq, void *prev_array, unsigned int *count)
 552 {
 553     HANDLE *objs = prev_array;
 554     RpcConnection_np *conn;
 555     RpcServerProtseq_np *npps = CONTAINING_RECORD(protseq, RpcServerProtseq_np, common);
 556
 557     EnterCriticalSection(&protseq->cs);
 558
 559     /* open and count connections */
 560     *count = 1;
 561     conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common);
 562     while (conn) {
 563         rpcrt4_conn_listen_pipe(conn);
 564         if (conn->ovl.hEvent)
 565             (*count)++;
 566         conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common);
 567     }
 568
 569     /* make array of connections */
 570     if (objs)
 571         objs = HeapReAlloc(GetProcessHeap(), 0, objs, *count*sizeof(HANDLE));
 572     else
 573         objs = HeapAlloc(GetProcessHeap(), 0, *count*sizeof(HANDLE));
 574     if (!objs)
 575     {
 576         ERR("couldn't allocate objs\n");
 577         LeaveCriticalSection(&protseq->cs);
 578         return NULL;
 579     }
 580
 581     objs[0] = npps->mgr_event;
 582     *count = 1;
 583     conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common);
 584     while (conn) {
 585         if ((objs[*count] = conn->ovl.hEvent))
 586             (*count)++;
 587         conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common);
 588     }
 589     LeaveCriticalSection(&protseq->cs);
 590     return objs;
 591 }
 592
 593 static void rpcrt4_protseq_np_free_wait_array(RpcServerProtseq *protseq, void *array)
 594 {
 595     HeapFree(GetProcessHeap(), 0, array);
 596 }
 597
 598 static int rpcrt4_protseq_np_wait_for_new_connection(RpcServerProtseq *protseq, unsigned int count, void *wait_array)
 599 {
 600     HANDLE b_handle;
 601     HANDLE *objs = wait_array;
 602     DWORD res;
 603     RpcConnection *cconn;
 604     RpcConnection_np *conn;
 605
 606     if (!objs)
 607         return -1;
 608
 609     do
 610     {
 611         /* an alertable wait isn't strictly necessary, but due to our
 612          * overlapped I/O implementation in Wine we need to free some memory
 613          * by the file user APC being called, even if no completion routine was
 614          * specified at the time of starting the async operation */
 615         res = WaitForMultipleObjectsEx(count, objs, FALSE, INFINITE, TRUE);
 616     } while (res == WAIT_IO_COMPLETION);
 617
 618     if (res == WAIT_OBJECT_0)
 619         return 0;
 620     else if (res == WAIT_FAILED)
 621     {
 622         ERR("wait failed with error %d\n", GetLastError());
 623         return -1;
 624     }
 625     else
 626     {
 627         b_handle = objs[res - WAIT_OBJECT_0];
 628         /* find which connection got a RPC */
 629         EnterCriticalSection(&protseq->cs);
 630         conn = CONTAINING_RECORD(protseq->conn, RpcConnection_np, common);
 631         while (conn) {
 632             if (b_handle == conn->ovl.hEvent) break;
 633             conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_np, common);
 634         }
 635         cconn = NULL;
 636         if (conn)
 637             RPCRT4_SpawnConnection(&cconn, &conn->common);
 638         else
 639             ERR("failed to locate connection for handle %p\n", b_handle);
 640         LeaveCriticalSection(&protseq->cs);
 641         if (cconn)
 642         {
 643             RPCRT4_new_client(cconn);
 644             return 1;
 645         }
 646         else return -1;
 647     }
 648 }
 649
 650 static size_t rpcrt4_ncalrpc_get_top_of_tower(unsigned char *tower_data,
 651                                               const char *networkaddr,
 652                                               const char *endpoint)
 653 {
 654     twr_empty_floor_t *pipe_floor;
 655     size_t size;
 656     size_t endpoint_size;
 657
 658     TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
 659
 660     endpoint_size = strlen(networkaddr) + 1;
 661     size = sizeof(*pipe_floor) + endpoint_size;
 662
 663     if (!tower_data)
 664         return size;
 665
 666     pipe_floor = (twr_empty_floor_t *)tower_data;
 667
 668     tower_data += sizeof(*pipe_floor);
 669
 670     pipe_floor->count_lhs = sizeof(pipe_floor->protid);
 671     pipe_floor->protid = EPM_PROTOCOL_SMB;
 672     pipe_floor->count_rhs = endpoint_size;
 673
 674     memcpy(tower_data, endpoint, endpoint_size);
 675     tower_data += endpoint_size;
 676
 677     return size;
 678 }
 679
 680 static RPC_STATUS rpcrt4_ncalrpc_parse_top_of_tower(const unsigned char *tower_data,
 681                                                     size_t tower_size,
 682                                                     char **networkaddr,
 683                                                     char **endpoint)
 684 {
 685     const twr_empty_floor_t *pipe_floor = (const twr_empty_floor_t *)tower_data;
 686
 687     TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
 688
 689     *networkaddr = NULL;
 690     *endpoint = NULL;
 691
 692     if (tower_size < sizeof(*pipe_floor))
 693         return EPT_S_NOT_REGISTERED;
 694
 695     tower_data += sizeof(*pipe_floor);
 696     tower_size -= sizeof(*pipe_floor);
 697
 698     if ((pipe_floor->count_lhs != sizeof(pipe_floor->protid)) ||
 699         (pipe_floor->protid != EPM_PROTOCOL_SMB) ||
 700         (pipe_floor->count_rhs > tower_size))
 701         return EPT_S_NOT_REGISTERED;
 702
 703     if (endpoint)
 704     {
 705         *endpoint = I_RpcAllocate(pipe_floor->count_rhs);
 706         if (!*endpoint)
 707             return RPC_S_OUT_OF_RESOURCES;
 708         memcpy(*endpoint, tower_data, pipe_floor->count_rhs);
 709     }
 710
 711     return RPC_S_OK;
 712 }
 713
 714 /**** ncacn_ip_tcp support ****/
 715
 716 typedef struct _RpcConnection_tcp
 717 {
 718   RpcConnection common;
 719   int sock;
 720   int cancel_fds[2];
 721 } RpcConnection_tcp;
 722
 723 static RpcConnection *rpcrt4_conn_tcp_alloc(void)
 724 {
 725   RpcConnection_tcp *tcpc;
 726   tcpc = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcConnection_tcp));
 727   if (tcpc == NULL)
 728     return NULL;
 729   tcpc->sock = -1;
 730   if (socketpair(PF_UNIX, SOCK_STREAM, 0, tcpc->cancel_fds) < 0)
 731   {
 732     ERR("socketpair() failed: %s\n", strerror(errno));
 733     HeapFree(GetProcessHeap(), 0, tcpc);
 734     return NULL;
 735   }
 736   return &tcpc->common;
 737 }
 738
 739 static RPC_STATUS rpcrt4_ncacn_ip_tcp_open(RpcConnection* Connection)
 740 {
 741   RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
 742   int sock;
 743   int ret;
 744   struct addrinfo *ai;
 745   struct addrinfo *ai_cur;
 746   struct addrinfo hints;
 747
 748   TRACE("(%s, %s)\n", Connection->NetworkAddr, Connection->Endpoint);
 749
 750   if (tcpc->sock != -1)
 751     return RPC_S_OK;
 752
 753   hints.ai_flags          = 0;
 754   hints.ai_family         = PF_UNSPEC;
 755   hints.ai_socktype       = SOCK_STREAM;
 756   hints.ai_protocol       = IPPROTO_TCP;
 757   hints.ai_addrlen        = 0;
 758   hints.ai_addr           = NULL;
 759   hints.ai_canonname      = NULL;
 760   hints.ai_next           = NULL;
 761
 762   ret = getaddrinfo(Connection->NetworkAddr, Connection->Endpoint, &hints, &ai);
 763   if (ret)
 764   {
 765     ERR("getaddrinfo for %s:%s failed: %s\n", Connection->NetworkAddr,
 766       Connection->Endpoint, gai_strerror(ret));
 767     return RPC_S_SERVER_UNAVAILABLE;
 768   }
 769
 770   for (ai_cur = ai; ai_cur; ai_cur = ai_cur->ai_next)
 771   {
 772     int val;
 773
 774     if (TRACE_ON(rpc))
 775     {
 776       char host[256];
 777       char service[256];
 778       getnameinfo(ai_cur->ai_addr, ai_cur->ai_addrlen,
 779         host, sizeof(host), service, sizeof(service),
 780         NI_NUMERICHOST | NI_NUMERICSERV);
 781       TRACE("trying %s:%s\n", host, service);
 782     }
 783
 784     sock = socket(ai_cur->ai_family, ai_cur->ai_socktype, ai_cur->ai_protocol);
 785     if (sock == -1)
 786     {
 787       WARN("socket() failed: %s\n", strerror(errno));
 788       continue;
 789     }
 790
 791     if (0>connect(sock, ai_cur->ai_addr, ai_cur->ai_addrlen))
 792     {
 793       WARN("connect() failed: %s\n", strerror(errno));
 794       close(sock);
 795       continue;
 796     }
 797
 798     /* RPC depends on having minimal latency so disable the Nagle algorithm */
 799     val = 1;
 800     setsockopt(sock, SOL_TCP, TCP_NODELAY, &val, sizeof(val));
 801     fcntl(sock, F_SETFL, O_NONBLOCK); /* make socket nonblocking */
 802
 803     tcpc->sock = sock;
 804
 805     freeaddrinfo(ai);
 806     TRACE("connected\n");
 807     return RPC_S_OK;
 808   }
 809
 810   freeaddrinfo(ai);
 811   ERR("couldn't connect to %s:%s\n", Connection->NetworkAddr, Connection->Endpoint);
 812   return RPC_S_SERVER_UNAVAILABLE;
 813 }
 814
 815 static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *protseq, LPSTR endpoint)
 816 {
 817     RPC_STATUS status = RPC_S_CANT_CREATE_ENDPOINT;
 818     int sock;
 819     int ret;
 820     struct addrinfo *ai;
 821     struct addrinfo *ai_cur;
 822     struct addrinfo hints;
 823     RpcConnection *first_connection = NULL;
 824
 825     TRACE("(%p, %s)\n", protseq, endpoint);
 826
 827     hints.ai_flags          = AI_PASSIVE /* for non-localhost addresses */;
 828     hints.ai_family         = PF_UNSPEC;
 829     hints.ai_socktype       = SOCK_STREAM;
 830     hints.ai_protocol       = IPPROTO_TCP;
 831     hints.ai_addrlen        = 0;
 832     hints.ai_addr           = NULL;
 833     hints.ai_canonname      = NULL;
 834     hints.ai_next           = NULL;
 835
 836     ret = getaddrinfo(NULL, endpoint, &hints, &ai);
 837     if (ret)
 838     {
 839         ERR("getaddrinfo for port %s failed: %s\n", endpoint,
 840             gai_strerror(ret));
 841         if ((ret == EAI_SERVICE) || (ret == EAI_NONAME))
 842             return RPC_S_INVALID_ENDPOINT_FORMAT;
 843         return RPC_S_CANT_CREATE_ENDPOINT;
 844     }
 845
 846     for (ai_cur = ai; ai_cur; ai_cur = ai_cur->ai_next)
 847     {
 848         RpcConnection_tcp *tcpc;
 849         RPC_STATUS create_status;
 850
 851         if (TRACE_ON(rpc))
 852         {
 853             char host[256];
 854             char service[256];
 855             getnameinfo(ai_cur->ai_addr, ai_cur->ai_addrlen,
 856                         host, sizeof(host), service, sizeof(service),
 857                         NI_NUMERICHOST | NI_NUMERICSERV);
 858             TRACE("trying %s:%s\n", host, service);
 859         }
 860
 861         sock = socket(ai_cur->ai_family, ai_cur->ai_socktype, ai_cur->ai_protocol);
 862         if (sock == -1)
 863         {
 864             WARN("socket() failed: %s\n", strerror(errno));
 865             status = RPC_S_CANT_CREATE_ENDPOINT;
 866             continue;
 867         }
 868
 869         ret = bind(sock, ai_cur->ai_addr, ai_cur->ai_addrlen);
 870         if (ret < 0)
 871         {
 872             WARN("bind failed: %s\n", strerror(errno));
 873             close(sock);
 874             if (errno == EADDRINUSE)
 875               status = RPC_S_DUPLICATE_ENDPOINT;
 876             else
 877               status = RPC_S_CANT_CREATE_ENDPOINT;
 878             continue;
 879         }
 880         create_status = RPCRT4_CreateConnection((RpcConnection **)&tcpc, TRUE,
 881                                                 protseq->Protseq, NULL,
 882                                                 endpoint, NULL, NULL, NULL);
 883         if (create_status != RPC_S_OK)
 884         {
 885             close(sock);
 886             status = create_status;
 887             continue;
 888         }
 889
 890         tcpc->sock = sock;
 891         ret = listen(sock, protseq->MaxCalls);
 892         if (ret < 0)
 893         {
 894             WARN("listen failed: %s\n", strerror(errno));
 895             RPCRT4_DestroyConnection(&tcpc->common);
 896             status = RPC_S_OUT_OF_RESOURCES;
 897             continue;
 898         }
 899         /* need a non-blocking socket, otherwise accept() has a potential
 900          * race-condition (poll() says it is readable, connection drops,
 901          * and accept() blocks until the next connection comes...)
 902          */
 903         ret = fcntl(sock, F_SETFL, O_NONBLOCK);
 904         if (ret < 0)
 905         {
 906             WARN("couldn't make socket non-blocking, error %d\n", ret);
 907             RPCRT4_DestroyConnection(&tcpc->common);
 908             status = RPC_S_OUT_OF_RESOURCES;
 909             continue;
 910         }
 911
 912         tcpc->common.Next = first_connection;
 913         first_connection = &tcpc->common;
 914     }
 915
 916     freeaddrinfo(ai);
 917
 918     /* if at least one connection was created for an endpoint then
 919      * return success */
 920     if (first_connection)
 921     {
 922         RpcConnection *conn;
 923
 924         /* find last element in list */
 925         for (conn = first_connection; conn->Next; conn = conn->Next)
 926             ;
 927
 928         EnterCriticalSection(&protseq->cs);
 929         conn->Next = protseq->conn;
 930         protseq->conn = first_connection;
 931         LeaveCriticalSection(&protseq->cs);
 932
 933         TRACE("listening on %s\n", endpoint);
 934         return RPC_S_OK;
 935     }
 936
 937     ERR("couldn't listen on port %s\n", endpoint);
 938     return status;
 939 }
 940
 941 static RPC_STATUS rpcrt4_conn_tcp_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
 942 {
 943   int ret;
 944   struct sockaddr_in address;
 945   socklen_t addrsize;
 946   RpcConnection_tcp *server = (RpcConnection_tcp*) old_conn;
 947   RpcConnection_tcp *client = (RpcConnection_tcp*) new_conn;
 948
 949   addrsize = sizeof(address);
 950   ret = accept(server->sock, (struct sockaddr*) &address, &addrsize);
 951   if (ret < 0)
 952   {
 953     ERR("Failed to accept a TCP connection: error %d\n", ret);
 954     return RPC_S_OUT_OF_RESOURCES;
 955   }
 956   /* reset to blocking behaviour */
 957   fcntl(ret, F_SETFL, 0);
 958   client->sock = ret;
 959   TRACE("Accepted a new TCP connection\n");
 960   return RPC_S_OK;
 961 }
 962
 963 static int rpcrt4_conn_tcp_read(RpcConnection *Connection,
 964                                 void *buffer, unsigned int count)
 965 {
 966   RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
 967   int bytes_read = 0;
 968   do
 969   {
 970     int r = recv(tcpc->sock, (char *)buffer + bytes_read, count - bytes_read, 0);
 971     if (!r)
 972       return -1;
 973     else if (r > 0)
 974       bytes_read += r;
 975     else if (errno != EAGAIN)
 976     {
 977       WARN("recv() failed: %s\n", strerror(errno));
 978       return -1;
 979     }
 980     else
 981     {
 982       struct pollfd pfds[2];
 983       pfds[0].fd = tcpc->sock;
 984       pfds[0].events = POLLIN;
 985       pfds[1].fd = tcpc->cancel_fds[0];
 986       pfds[1].events = POLLIN;
 987       if (poll(pfds, 2, -1 /* infinite */) == -1 && errno != EINTR)
 988       {
 989         ERR("poll() failed: %s\n", strerror(errno));
 990         return -1;
 991       }
 992       if (pfds[1].revents & POLLIN) /* canceled */
 993       {
 994         char dummy;
 995         read(pfds[1].fd, &dummy, sizeof(dummy));
 996         return -1;
 997       }
 998     }
 999   } while (bytes_read != count);
1000   TRACE("%d %p %u -> %d\n", tcpc->sock, buffer, count, bytes_read);
1001   return bytes_read;
1002 }
1003
1004 static int rpcrt4_conn_tcp_write(RpcConnection *Connection,
1005                                  const void *buffer, unsigned int count)
1006 {
1007   RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1008   int bytes_written = 0;
1009   do
1010   {
1011     int r = send(tcpc->sock, (const char *)buffer + bytes_written, count - bytes_written, 0);
1012     if (r >= 0)
1013       bytes_written += r;
1014     else if (errno != EAGAIN)
1015       return -1;
1016     else
1017     {
1018       struct pollfd pfd;
1019       pfd.fd = tcpc->sock;
1020       pfd.events = POLLOUT;
1021       if (poll(&pfd, 1, -1 /* infinite */) == -1 && errno != EINTR)
1022       {
1023         ERR("poll() failed: %s\n", strerror(errno));
1024         return -1;
1025       }
1026     }
1027   } while (bytes_written != count);
1028   TRACE("%d %p %u -> %d\n", tcpc->sock, buffer, count, bytes_written);
1029   return bytes_written;
1030 }
1031
1032 static int rpcrt4_conn_tcp_close(RpcConnection *Connection)
1033 {
1034   RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1035
1036   TRACE("%d\n", tcpc->sock);
1037
1038   if (tcpc->sock != -1)
1039     close(tcpc->sock);
1040   tcpc->sock = -1;
1041   close(tcpc->cancel_fds[0]);
1042   close(tcpc->cancel_fds[1]);
1043   return 0;
1044 }
1045
1046 static void rpcrt4_conn_tcp_cancel_call(RpcConnection *Connection)
1047 {
1048     RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1049     char dummy = 1;
1050
1051     TRACE("%p\n", Connection);
1052
1053     write(tcpc->cancel_fds[1], &dummy, 1);
1054 }
1055
1056 static int rpcrt4_conn_tcp_wait_for_incoming_data(RpcConnection *Connection)
1057 {
1058     RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1059     struct pollfd pfds[2];
1060
1061     TRACE("%p\n", Connection);
1062
1063     pfds[0].fd = tcpc->sock;
1064     pfds[0].events = POLLIN;
1065     pfds[1].fd = tcpc->cancel_fds[0];
1066     pfds[1].events = POLLIN;
1067     if (poll(pfds, 2, -1 /* infinite */) == -1 && errno != EINTR)
1068     {
1069       ERR("poll() failed: %s\n", strerror(errno));
1070       return -1;
1071     }
1072     if (pfds[1].revents & POLLIN) /* canceled */
1073     {
1074       char dummy;
1075       read(pfds[1].fd, &dummy, sizeof(dummy));
1076       return -1;
1077     }
1078
1079     return 0;
1080 }
1081
1082 static size_t rpcrt4_ncacn_ip_tcp_get_top_of_tower(unsigned char *tower_data,
1083                                                    const char *networkaddr,
1084                                                    const char *endpoint)
1085 {
1086     twr_tcp_floor_t *tcp_floor;
1087     twr_ipv4_floor_t *ipv4_floor;
1088     struct addrinfo *ai;
1089     struct addrinfo hints;
1090     int ret;
1091     size_t size = sizeof(*tcp_floor) + sizeof(*ipv4_floor);
1092
1093     TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
1094
1095     if (!tower_data)
1096         return size;
1097
1098     tcp_floor = (twr_tcp_floor_t *)tower_data;
1099     tower_data += sizeof(*tcp_floor);
1100
1101     ipv4_floor = (twr_ipv4_floor_t *)tower_data;
1102
1103     tcp_floor->count_lhs = sizeof(tcp_floor->protid);
1104     tcp_floor->protid = EPM_PROTOCOL_TCP;
1105     tcp_floor->count_rhs = sizeof(tcp_floor->port);
1106
1107     ipv4_floor->count_lhs = sizeof(ipv4_floor->protid);
1108     ipv4_floor->protid = EPM_PROTOCOL_IP;
1109     ipv4_floor->count_rhs = sizeof(ipv4_floor->ipv4addr);
1110
1111     hints.ai_flags          = AI_NUMERICHOST;
1112     /* FIXME: only support IPv4 at the moment. how is IPv6 represented by the EPM? */
1113     hints.ai_family         = PF_INET;
1114     hints.ai_socktype       = SOCK_STREAM;
1115     hints.ai_protocol       = IPPROTO_TCP;
1116     hints.ai_addrlen        = 0;
1117     hints.ai_addr           = NULL;
1118     hints.ai_canonname      = NULL;
1119     hints.ai_next           = NULL;
1120
1121     ret = getaddrinfo(networkaddr, endpoint, &hints, &ai);
1122     if (ret)
1123     {
1124         ret = getaddrinfo("0.0.0.0", endpoint, &hints, &ai);
1125         if (ret)
1126         {
1127             ERR("getaddrinfo failed: %s\n", gai_strerror(ret));
1128             return 0;
1129         }
1130     }
1131
1132     if (ai->ai_family == PF_INET)
1133     {
1134         const struct sockaddr_in *sin = (const struct sockaddr_in *)ai->ai_addr;
1135         tcp_floor->port = sin->sin_port;
1136         ipv4_floor->ipv4addr = sin->sin_addr.s_addr;
1137     }
1138     else
1139     {
1140         ERR("unexpected protocol family %d\n", ai->ai_family);
1141         return 0;
1142     }
1143
1144     freeaddrinfo(ai);
1145
1146     return size;
1147 }
1148
1149 static RPC_STATUS rpcrt4_ncacn_ip_tcp_parse_top_of_tower(const unsigned char *tower_data,
1150                                                          size_t tower_size,
1151                                                          char **networkaddr,
1152                                                          char **endpoint)
1153 {
1154     const twr_tcp_floor_t *tcp_floor = (const twr_tcp_floor_t *)tower_data;
1155     const twr_ipv4_floor_t *ipv4_floor;
1156     struct in_addr in_addr;
1157
1158     TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
1159
1160     if (tower_size < sizeof(*tcp_floor))
1161         return EPT_S_NOT_REGISTERED;
1162
1163     tower_data += sizeof(*tcp_floor);
1164     tower_size -= sizeof(*tcp_floor);
1165
1166     if (tower_size < sizeof(*ipv4_floor))
1167         return EPT_S_NOT_REGISTERED;
1168
1169     ipv4_floor = (const twr_ipv4_floor_t *)tower_data;
1170
1171     if ((tcp_floor->count_lhs != sizeof(tcp_floor->protid)) ||
1172         (tcp_floor->protid != EPM_PROTOCOL_TCP) ||
1173         (tcp_floor->count_rhs != sizeof(tcp_floor->port)) ||
1174         (ipv4_floor->count_lhs != sizeof(ipv4_floor->protid)) ||
1175         (ipv4_floor->protid != EPM_PROTOCOL_IP) ||
1176         (ipv4_floor->count_rhs != sizeof(ipv4_floor->ipv4addr)))
1177         return EPT_S_NOT_REGISTERED;
1178
1179     if (endpoint)
1180     {
1181         *endpoint = I_RpcAllocate(6 /* sizeof("65535") + 1 */);
1182         if (!*endpoint)
1183             return RPC_S_OUT_OF_RESOURCES;
1184         sprintf(*endpoint, "%u", ntohs(tcp_floor->port));
1185     }
1186
1187     if (networkaddr)
1188     {
1189         *networkaddr = I_RpcAllocate(INET_ADDRSTRLEN);
1190         if (!*networkaddr)
1191         {
1192             if (endpoint)
1193             {
1194                 I_RpcFree(*endpoint);
1195                 *endpoint = NULL;
1196             }
1197             return RPC_S_OUT_OF_RESOURCES;
1198         }
1199         in_addr.s_addr = ipv4_floor->ipv4addr;
1200         if (!inet_ntop(AF_INET, &in_addr, *networkaddr, INET_ADDRSTRLEN))
1201         {
1202             ERR("inet_ntop: %s\n", strerror(errno));
1203             I_RpcFree(*networkaddr);
1204             *networkaddr = NULL;
1205             if (endpoint)
1206             {
1207                 I_RpcFree(*endpoint);
1208                 *endpoint = NULL;
1209             }
1210             return EPT_S_NOT_REGISTERED;
1211         }
1212     }
1213
1214     return RPC_S_OK;
1215 }
1216
1217 typedef struct _RpcServerProtseq_sock
1218 {
1219     RpcServerProtseq common;
1220     int mgr_event_rcv;
1221     int mgr_event_snd;
1222 } RpcServerProtseq_sock;
1223
1224 static RpcServerProtseq *rpcrt4_protseq_sock_alloc(void)
1225 {
1226     RpcServerProtseq_sock *ps = HeapAlloc(GetProcessHeap(), 0, sizeof(*ps));
1227     if (ps)
1228     {
1229         int fds[2];
1230         if (!socketpair(PF_UNIX, SOCK_DGRAM, 0, fds))
1231         {
1232             fcntl(fds[0], F_SETFL, O_NONBLOCK);
1233             fcntl(fds[1], F_SETFL, O_NONBLOCK);
1234             ps->mgr_event_rcv = fds[0];
1235             ps->mgr_event_snd = fds[1];
1236         }
1237         else
1238         {
1239             ERR("socketpair failed with error %s\n", strerror(errno));
1240             HeapFree(GetProcessHeap(), 0, ps);
1241             return NULL;
1242         }
1243     }
1244     return &ps->common;
1245 }
1246
1247 static void rpcrt4_protseq_sock_signal_state_changed(RpcServerProtseq *protseq)
1248 {
1249     RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common);
1250     char dummy = 1;
1251     write(sockps->mgr_event_snd, &dummy, sizeof(dummy));
1252 }
1253
1254 static void *rpcrt4_protseq_sock_get_wait_array(RpcServerProtseq *protseq, void *prev_array, unsigned int *count)
1255 {
1256     struct pollfd *poll_info = prev_array;
1257     RpcConnection_tcp *conn;
1258     RpcServerProtseq_sock *sockps = CONTAINING_RECORD(protseq, RpcServerProtseq_sock, common);
1259
1260     EnterCriticalSection(&protseq->cs);
1261
1262     /* open and count connections */
1263     *count = 1;
1264     conn = (RpcConnection_tcp *)protseq->conn;
1265     while (conn) {
1266         if (conn->sock != -1)
1267             (*count)++;
1268         conn = (RpcConnection_tcp *)conn->common.Next;
1269     }
1270
1271     /* make array of connections */
1272     if (poll_info)
1273         poll_info = HeapReAlloc(GetProcessHeap(), 0, poll_info, *count*sizeof(*poll_info));
1274     else
1275         poll_info = HeapAlloc(GetProcessHeap(), 0, *count*sizeof(*poll_info));
1276     if (!poll_info)
1277     {
1278         ERR("couldn't allocate poll_info\n");
1279         LeaveCriticalSection(&protseq->cs);
1280         return NULL;
1281     }
1282
1283     poll_info[0].fd = sockps->mgr_event_rcv;
1284     poll_info[0].events = POLLIN;
1285     *count = 1;
1286     conn =  CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common);
1287     while (conn) {
1288         if (conn->sock != -1)
1289         {
1290             poll_info[*count].fd = conn->sock;
1291             poll_info[*count].events = POLLIN;
1292             (*count)++;
1293         }
1294         conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common);
1295     }
1296     LeaveCriticalSection(&protseq->cs);
1297     return poll_info;
1298 }
1299
1300 static void rpcrt4_protseq_sock_free_wait_array(RpcServerProtseq *protseq, void *array)
1301 {
1302     HeapFree(GetProcessHeap(), 0, array);
1303 }
1304
1305 static int rpcrt4_protseq_sock_wait_for_new_connection(RpcServerProtseq *protseq, unsigned int count, void *wait_array)
1306 {
1307     struct pollfd *poll_info = wait_array;
1308     int ret, i;
1309     RpcConnection *cconn;
1310     RpcConnection_tcp *conn;
1311
1312     if (!poll_info)
1313         return -1;
1314
1315     ret = poll(poll_info, count, -1);
1316     if (ret < 0)
1317     {
1318         ERR("poll failed with error %d\n", ret);
1319         return -1;
1320     }
1321
1322     for (i = 0; i < count; i++)
1323         if (poll_info[i].revents & POLLIN)
1324         {
1325             /* RPC server event */
1326             if (i == 0)
1327             {
1328                 char dummy;
1329                 read(poll_info[0].fd, &dummy, sizeof(dummy));
1330                 return 0;
1331             }
1332
1333             /* find which connection got a RPC */
1334             EnterCriticalSection(&protseq->cs);
1335             conn = CONTAINING_RECORD(protseq->conn, RpcConnection_tcp, common);
1336             while (conn) {
1337                 if (poll_info[i].fd == conn->sock) break;
1338                 conn = CONTAINING_RECORD(conn->common.Next, RpcConnection_tcp, common);
1339             }
1340             cconn = NULL;
1341             if (conn)
1342                 RPCRT4_SpawnConnection(&cconn, &conn->common);
1343             else
1344                 ERR("failed to locate connection for fd %d\n", poll_info[i].fd);
1345             LeaveCriticalSection(&protseq->cs);
1346             if (cconn)
1347                 RPCRT4_new_client(cconn);
1348             else
1349                 return -1;
1350         }
1351
1352     return 1;
1353 }
1354
1355 static const struct connection_ops conn_protseq_list[] = {
1356   { "ncacn_np",
1357     { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_SMB },
1358     rpcrt4_conn_np_alloc,
1359     rpcrt4_ncacn_np_open,
1360     rpcrt4_ncacn_np_handoff,
1361     rpcrt4_conn_np_read,
1362     rpcrt4_conn_np_write,
1363     rpcrt4_conn_np_close,
1364     rpcrt4_conn_np_cancel_call,
1365     rpcrt4_conn_np_wait_for_incoming_data,
1366     rpcrt4_ncacn_np_get_top_of_tower,
1367     rpcrt4_ncacn_np_parse_top_of_tower,
1368   },
1369   { "ncalrpc",
1370     { EPM_PROTOCOL_NCALRPC, EPM_PROTOCOL_PIPE },
1371     rpcrt4_conn_np_alloc,
1372     rpcrt4_ncalrpc_open,
1373     rpcrt4_ncalrpc_handoff,
1374     rpcrt4_conn_np_read,
1375     rpcrt4_conn_np_write,
1376     rpcrt4_conn_np_close,
1377     rpcrt4_conn_np_cancel_call,
1378     rpcrt4_conn_np_wait_for_incoming_data,
1379     rpcrt4_ncalrpc_get_top_of_tower,
1380     rpcrt4_ncalrpc_parse_top_of_tower,
1381   },
1382   { "ncacn_ip_tcp",
1383     { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_TCP },
1384     rpcrt4_conn_tcp_alloc,
1385     rpcrt4_ncacn_ip_tcp_open,
1386     rpcrt4_conn_tcp_handoff,
1387     rpcrt4_conn_tcp_read,
1388     rpcrt4_conn_tcp_write,
1389     rpcrt4_conn_tcp_close,
1390     rpcrt4_conn_tcp_cancel_call,
1391     rpcrt4_conn_tcp_wait_for_incoming_data,
1392     rpcrt4_ncacn_ip_tcp_get_top_of_tower,
1393     rpcrt4_ncacn_ip_tcp_parse_top_of_tower,
1394   }
1395 };
1396
1397
1398 static const struct protseq_ops protseq_list[] =
1399 {
1400     {
1401         "ncacn_np",
1402         rpcrt4_protseq_np_alloc,
1403         rpcrt4_protseq_np_signal_state_changed,
1404         rpcrt4_protseq_np_get_wait_array,
1405         rpcrt4_protseq_np_free_wait_array,
1406         rpcrt4_protseq_np_wait_for_new_connection,
1407         rpcrt4_protseq_ncacn_np_open_endpoint,
1408     },
1409     {
1410         "ncalrpc",
1411         rpcrt4_protseq_np_alloc,
1412         rpcrt4_protseq_np_signal_state_changed,
1413         rpcrt4_protseq_np_get_wait_array,
1414         rpcrt4_protseq_np_free_wait_array,
1415         rpcrt4_protseq_np_wait_for_new_connection,
1416         rpcrt4_protseq_ncalrpc_open_endpoint,
1417     },
1418     {
1419         "ncacn_ip_tcp",
1420         rpcrt4_protseq_sock_alloc,
1421         rpcrt4_protseq_sock_signal_state_changed,
1422         rpcrt4_protseq_sock_get_wait_array,
1423         rpcrt4_protseq_sock_free_wait_array,
1424         rpcrt4_protseq_sock_wait_for_new_connection,
1425         rpcrt4_protseq_ncacn_ip_tcp_open_endpoint,
1426     },
1427 };
1428
1429 #define ARRAYSIZE(a) (sizeof((a)) / sizeof((a)[0]))
1430
1431 const struct protseq_ops *rpcrt4_get_protseq_ops(const char *protseq)
1432 {
1433   int i;
1434   for(i=0; i<ARRAYSIZE(protseq_list); i++)
1435     if (!strcmp(protseq_list[i].name, protseq))
1436       return &protseq_list[i];
1437   return NULL;
1438 }
1439
1440 static const struct connection_ops *rpcrt4_get_conn_protseq_ops(const char *protseq)
1441 {
1442     int i;
1443     for(i=0; i<ARRAYSIZE(conn_protseq_list); i++)
1444         if (!strcmp(conn_protseq_list[i].name, protseq))
1445             return &conn_protseq_list[i];
1446     return NULL;
1447 }
1448
1449 /**** interface to rest of code ****/
1450
1451 RPC_STATUS RPCRT4_OpenClientConnection(RpcConnection* Connection)
1452 {
1453   TRACE("(Connection == ^%p)\n", Connection);
1454
1455   assert(!Connection->server);
1456   return Connection->ops->open_connection_client(Connection);
1457 }
1458
1459 RPC_STATUS RPCRT4_CloseConnection(RpcConnection* Connection)
1460 {
1461   TRACE("(Connection == ^%p)\n", Connection);
1462   if (SecIsValidHandle(&Connection->ctx))
1463   {
1464     DeleteSecurityContext(&Connection->ctx);
1465     SecInvalidateHandle(&Connection->ctx);
1466   }
1467   rpcrt4_conn_close(Connection);
1468   return RPC_S_OK;
1469 }
1470
1471 RPC_STATUS RPCRT4_CreateConnection(RpcConnection** Connection, BOOL server,
1472     LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint,
1473     LPCWSTR NetworkOptions, RpcAuthInfo* AuthInfo, RpcQualityOfService *QOS)
1474 {
1475   const struct connection_ops *ops;
1476   RpcConnection* NewConnection;
1477
1478   ops = rpcrt4_get_conn_protseq_ops(Protseq);
1479   if (!ops)
1480   {
1481     FIXME("not supported for protseq %s\n", Protseq);
1482     return RPC_S_PROTSEQ_NOT_SUPPORTED;
1483   }
1484
1485   NewConnection = ops->alloc();
1486   NewConnection->Next = NULL;
1487   NewConnection->server_binding = NULL;
1488   NewConnection->server = server;
1489   NewConnection->ops = ops;
1490   NewConnection->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
1491   NewConnection->Endpoint = RPCRT4_strdupA(Endpoint);
1492   NewConnection->NetworkOptions = RPCRT4_strdupW(NetworkOptions);
1493   NewConnection->MaxTransmissionSize = RPC_MAX_PACKET_SIZE;
1494   memset(&NewConnection->ActiveInterface, 0, sizeof(NewConnection->ActiveInterface));
1495   NewConnection->NextCallId = 1;
1496
1497   SecInvalidateHandle(&NewConnection->ctx);
1498   memset(&NewConnection->exp, 0, sizeof(NewConnection->exp));
1499   NewConnection->attr = 0;
1500   if (AuthInfo) RpcAuthInfo_AddRef(AuthInfo);
1501   NewConnection->AuthInfo = AuthInfo;
1502   NewConnection->encryption_auth_len = 0;
1503   NewConnection->signature_auth_len = 0;
1504   if (QOS) RpcQualityOfService_AddRef(QOS);
1505   NewConnection->QOS = QOS;
1506
1507   list_init(&NewConnection->conn_pool_entry);
1508   NewConnection->async_state = NULL;
1509
1510   TRACE("connection: %p\n", NewConnection);
1511   *Connection = NewConnection;
1512
1513   return RPC_S_OK;
1514 }
1515
1516
1517 RPC_STATUS RPCRT4_SpawnConnection(RpcConnection** Connection, RpcConnection* OldConnection)
1518 {
1519   RPC_STATUS err;
1520
1521   err = RPCRT4_CreateConnection(Connection, OldConnection->server,
1522                                 rpcrt4_conn_get_name(OldConnection),
1523                                 OldConnection->NetworkAddr,
1524                                 OldConnection->Endpoint, NULL,
1525                                 OldConnection->AuthInfo, OldConnection->QOS);
1526   if (err == RPC_S_OK)
1527     rpcrt4_conn_handoff(OldConnection, *Connection);
1528   return err;
1529 }
1530
1531 RPC_STATUS RPCRT4_DestroyConnection(RpcConnection* Connection)
1532 {
1533   TRACE("connection: %p\n", Connection);
1534
1535   RPCRT4_CloseConnection(Connection);
1536   RPCRT4_strfree(Connection->Endpoint);
1537   RPCRT4_strfree(Connection->NetworkAddr);
1538   HeapFree(GetProcessHeap(), 0, Connection->NetworkOptions);
1539   if (Connection->AuthInfo) RpcAuthInfo_Release(Connection->AuthInfo);
1540   if (Connection->QOS) RpcQualityOfService_Release(Connection->QOS);
1541
1542   /* server-only */
1543   if (Connection->server_binding) RPCRT4_DestroyBinding(Connection->server_binding);
1544
1545   HeapFree(GetProcessHeap(), 0, Connection);
1546   return RPC_S_OK;
1547 }
1548
1549 RPC_STATUS RpcTransport_GetTopOfTower(unsigned char *tower_data,
1550                                       size_t *tower_size,
1551                                       const char *protseq,
1552                                       const char *networkaddr,
1553                                       const char *endpoint)
1554 {
1555     twr_empty_floor_t *protocol_floor;
1556     const struct connection_ops *protseq_ops = rpcrt4_get_conn_protseq_ops(protseq);
1557
1558     *tower_size = 0;
1559
1560     if (!protseq_ops)
1561         return RPC_S_INVALID_RPC_PROTSEQ;
1562
1563     if (!tower_data)
1564     {
1565         *tower_size = sizeof(*protocol_floor);
1566         *tower_size += protseq_ops->get_top_of_tower(NULL, networkaddr, endpoint);
1567         return RPC_S_OK;
1568     }
1569
1570     protocol_floor = (twr_empty_floor_t *)tower_data;
1571     protocol_floor->count_lhs = sizeof(protocol_floor->protid);
1572     protocol_floor->protid = protseq_ops->epm_protocols[0];
1573     protocol_floor->count_rhs = 0;
1574
1575     tower_data += sizeof(*protocol_floor);
1576
1577     *tower_size = protseq_ops->get_top_of_tower(tower_data, networkaddr, endpoint);
1578     if (!*tower_size)
1579         return EPT_S_NOT_REGISTERED;
1580
1581     *tower_size += sizeof(*protocol_floor);
1582
1583     return RPC_S_OK;
1584 }
1585
1586 RPC_STATUS RpcTransport_ParseTopOfTower(const unsigned char *tower_data,
1587                                         size_t tower_size,
1588                                         char **protseq,
1589                                         char **networkaddr,
1590                                         char **endpoint)
1591 {
1592     const twr_empty_floor_t *protocol_floor;
1593     const twr_empty_floor_t *floor4;
1594     const struct connection_ops *protseq_ops = NULL;
1595     RPC_STATUS status;
1596     int i;
1597
1598     if (tower_size < sizeof(*protocol_floor))
1599         return EPT_S_NOT_REGISTERED;
1600
1601     protocol_floor = (const twr_empty_floor_t *)tower_data;
1602     tower_data += sizeof(*protocol_floor);
1603     tower_size -= sizeof(*protocol_floor);
1604     if ((protocol_floor->count_lhs != sizeof(protocol_floor->protid)) ||
1605         (protocol_floor->count_rhs > tower_size))
1606         return EPT_S_NOT_REGISTERED;
1607     tower_data += protocol_floor->count_rhs;
1608     tower_size -= protocol_floor->count_rhs;
1609
1610     floor4 = (const twr_empty_floor_t *)tower_data;
1611     if ((tower_size < sizeof(*floor4)) ||
1612         (floor4->count_lhs != sizeof(floor4->protid)))
1613         return EPT_S_NOT_REGISTERED;
1614
1615     for(i = 0; i < ARRAYSIZE(conn_protseq_list); i++)
1616         if ((protocol_floor->protid == conn_protseq_list[i].epm_protocols[0]) &&
1617             (floor4->protid == conn_protseq_list[i].epm_protocols[1]))
1618         {
1619             protseq_ops = &conn_protseq_list[i];
1620             break;
1621         }
1622
1623     if (!protseq_ops)
1624         return EPT_S_NOT_REGISTERED;
1625
1626     status = protseq_ops->parse_top_of_tower(tower_data, tower_size, networkaddr, endpoint);
1627
1628     if ((status == RPC_S_OK) && protseq)
1629     {
1630         *protseq = I_RpcAllocate(strlen(protseq_ops->name) + 1);
1631         strcpy(*protseq, protseq_ops->name);
1632     }
1633
1634     return status;
1635 }
1636
1637 /***********************************************************************
1638  *             RpcNetworkIsProtseqValidW (RPCRT4.@)
1639  *
1640  * Checks if the given protocol sequence is known by the RPC system.
1641  * If it is, returns RPC_S_OK, otherwise RPC_S_PROTSEQ_NOT_SUPPORTED.
1642  *
1643  */
1644 RPC_STATUS WINAPI RpcNetworkIsProtseqValidW(RPC_WSTR protseq)
1645 {
1646   char ps[0x10];
1647
1648   WideCharToMultiByte(CP_ACP, 0, protseq, -1,
1649                       ps, sizeof ps, NULL, NULL);
1650   if (rpcrt4_get_conn_protseq_ops(ps))
1651     return RPC_S_OK;
1652
1653   FIXME("Unknown protseq %s\n", debugstr_w(protseq));
1654
1655   return RPC_S_INVALID_RPC_PROTSEQ;
1656 }
1657
1658 /***********************************************************************
1659  *             RpcNetworkIsProtseqValidA (RPCRT4.@)
1660  */
1661 RPC_STATUS WINAPI RpcNetworkIsProtseqValidA(RPC_CSTR protseq)
1662 {
1663   UNICODE_STRING protseqW;
1664
1665   if (RtlCreateUnicodeStringFromAsciiz(&protseqW, (char*)protseq))
1666   {
1667     RPC_STATUS ret = RpcNetworkIsProtseqValidW(protseqW.Buffer);
1668     RtlFreeUnicodeString(&protseqW);
1669     return ret;
1670   }
1671   return RPC_S_OUT_OF_MEMORY;
1672 }