dlls/rpcrt4/rpc_message.c

   1 /*
   2  * RPC messages
   3  *
   4  * Copyright 2001-2002 Ove Kåven, TransGaming Technologies
   5  * Copyright 2004 Filip Navara
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  * TODO:
  22  *  - figure out whether we *really* got this right
  23  *  - check for errors and throw exceptions
  24  */
  25
  26 #include <stdarg.h>
  27 #include <stdio.h>
  28 #include <string.h>
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winerror.h"
  33 #include "winreg.h"
  34
  35 #include "rpc.h"
  36 #include "rpcndr.h"
  37 #include "rpcdcep.h"
  38
  39 #include "wine/debug.h"
  40
  41 #include "rpc_binding.h"
  42 #include "rpc_misc.h"
  43 #include "rpc_defs.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
  46
  47 DWORD RPCRT4_GetHeaderSize(RpcPktHdr *Header)
  48 {
  49   static const DWORD header_sizes[] = {
  50     sizeof(Header->request), 0, sizeof(Header->response),
  51     sizeof(Header->fault), 0, 0, 0, 0, 0, 0, 0, sizeof(Header->bind),
  52     sizeof(Header->bind_ack), sizeof(Header->bind_nack),
  53     0, 0, 0, 0, 0
  54   };
  55   ULONG ret = 0;
  56
  57   if (Header->common.ptype < sizeof(header_sizes) / sizeof(header_sizes[0])) {
  58     ret = header_sizes[Header->common.ptype];
  59     if (ret == 0)
  60       FIXME("unhandled packet type\n");
  61     if (Header->common.flags & RPC_FLG_OBJECT_UUID)
  62       ret += sizeof(UUID);
  63   } else {
  64     TRACE("invalid packet type\n");
  65   }
  66
  67   return ret;
  68 }
  69
  70 VOID RPCRT4_BuildCommonHeader(RpcPktHdr *Header, unsigned char PacketType,
  71                               unsigned long DataRepresentation)
  72 {
  73   Header->common.rpc_ver = RPC_VER_MAJOR;
  74   Header->common.rpc_ver_minor = RPC_VER_MINOR;
  75   Header->common.ptype = PacketType;
  76   Header->common.drep[0] = LOBYTE(LOWORD(DataRepresentation));
  77   Header->common.drep[1] = HIBYTE(LOWORD(DataRepresentation));
  78   Header->common.drep[2] = LOBYTE(HIWORD(DataRepresentation));
  79   Header->common.drep[3] = HIBYTE(HIWORD(DataRepresentation));
  80   Header->common.auth_len = 0;
  81   Header->common.call_id = 1;
  82   Header->common.flags = 0;
  83   /* Flags and fragment length are computed in RPCRT4_Send. */
  84 }
  85
  86 RpcPktHdr *RPCRT4_BuildRequestHeader(unsigned long DataRepresentation,
  87                                      unsigned long BufferLength,
  88                                      unsigned short ProcNum,
  89                                      UUID *ObjectUuid)
  90 {
  91   RpcPktHdr *header;
  92   BOOL has_object;
  93   RPC_STATUS status;
  94
  95   has_object = (ObjectUuid != NULL && !UuidIsNil(ObjectUuid, &status));
  96   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  97                      sizeof(header->request) + (has_object ? sizeof(UUID) : 0));
  98   if (header == NULL) {
  99     return NULL;
 100   }
 101
 102   RPCRT4_BuildCommonHeader(header, PKT_REQUEST, DataRepresentation);
 103   header->common.frag_len = sizeof(header->request);
 104   header->request.alloc_hint = BufferLength;
 105   header->request.context_id = 0;
 106   header->request.opnum = ProcNum;
 107   if (has_object) {
 108     header->common.flags |= RPC_FLG_OBJECT_UUID;
 109     header->common.frag_len += sizeof(UUID);
 110     memcpy(&header->request + 1, ObjectUuid, sizeof(UUID));
 111   }
 112
 113   return header;
 114 }
 115
 116 RpcPktHdr *RPCRT4_BuildResponseHeader(unsigned long DataRepresentation,
 117                                       unsigned long BufferLength)
 118 {
 119   RpcPktHdr *header;
 120
 121   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->response));
 122   if (header == NULL) {
 123     return NULL;
 124   }
 125
 126   RPCRT4_BuildCommonHeader(header, PKT_RESPONSE, DataRepresentation);
 127   header->common.frag_len = sizeof(header->response);
 128   header->response.alloc_hint = BufferLength;
 129
 130   return header;
 131 }
 132
 133 RpcPktHdr *RPCRT4_BuildFaultHeader(unsigned long DataRepresentation,
 134                                    RPC_STATUS Status)
 135 {
 136   RpcPktHdr *header;
 137
 138   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->fault));
 139   if (header == NULL) {
 140     return NULL;
 141   }
 142
 143   RPCRT4_BuildCommonHeader(header, PKT_FAULT, DataRepresentation);
 144   header->common.frag_len = sizeof(header->fault);
 145   header->fault.status = Status;
 146
 147   return header;
 148 }
 149
 150 RpcPktHdr *RPCRT4_BuildBindHeader(unsigned long DataRepresentation,
 151                                   unsigned short MaxTransmissionSize,
 152                                   unsigned short MaxReceiveSize,
 153                                   RPC_SYNTAX_IDENTIFIER *AbstractId,
 154                                   RPC_SYNTAX_IDENTIFIER *TransferId)
 155 {
 156   RpcPktHdr *header;
 157
 158   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->bind));
 159   if (header == NULL) {
 160     return NULL;
 161   }
 162
 163   RPCRT4_BuildCommonHeader(header, PKT_BIND, DataRepresentation);
 164   header->common.frag_len = sizeof(header->bind);
 165   header->bind.max_tsize = MaxTransmissionSize;
 166   header->bind.max_rsize = MaxReceiveSize;
 167   header->bind.num_elements = 1;
 168   header->bind.num_syntaxes = 1;
 169   memcpy(&header->bind.abstract, AbstractId, sizeof(RPC_SYNTAX_IDENTIFIER));
 170   memcpy(&header->bind.transfer, TransferId, sizeof(RPC_SYNTAX_IDENTIFIER));
 171
 172   return header;
 173 }
 174
 175 RpcPktHdr *RPCRT4_BuildBindNackHeader(unsigned long DataRepresentation,
 176                                       unsigned char RpcVersion,
 177                                       unsigned char RpcVersionMinor)
 178 {
 179   RpcPktHdr *header;
 180
 181   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->bind_nack));
 182   if (header == NULL) {
 183     return NULL;
 184   }
 185
 186   RPCRT4_BuildCommonHeader(header, PKT_BIND_NACK, DataRepresentation);
 187   header->common.frag_len = sizeof(header->bind_nack);
 188   header->bind_nack.protocols_count = 1;
 189   header->bind_nack.protocols[0].rpc_ver = RpcVersion;
 190   header->bind_nack.protocols[0].rpc_ver_minor = RpcVersionMinor;
 191
 192   return header;
 193 }
 194
 195 RpcPktHdr *RPCRT4_BuildBindAckHeader(unsigned long DataRepresentation,
 196                                      unsigned short MaxTransmissionSize,
 197                                      unsigned short MaxReceiveSize,
 198                                      LPSTR ServerAddress,
 199                                      unsigned long Result,
 200                                      unsigned long Reason,
 201                                      RPC_SYNTAX_IDENTIFIER *TransferId)
 202 {
 203   RpcPktHdr *header;
 204   unsigned long header_size;
 205   RpcAddressString *server_address;
 206   RpcResults *results;
 207   RPC_SYNTAX_IDENTIFIER *transfer_id;
 208
 209   header_size = sizeof(header->bind_ack) + sizeof(RpcResults) +
 210                 sizeof(RPC_SYNTAX_IDENTIFIER) + sizeof(RpcAddressString) +
 211                 strlen(ServerAddress);
 212
 213   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, header_size);
 214   if (header == NULL) {
 215     return NULL;
 216   }
 217
 218   RPCRT4_BuildCommonHeader(header, PKT_BIND_ACK, DataRepresentation);
 219   header->common.frag_len = header_size;
 220   header->bind_ack.max_tsize = MaxTransmissionSize;
 221   header->bind_ack.max_rsize = MaxReceiveSize;
 222   server_address = (RpcAddressString*)(&header->bind_ack + 1);
 223   server_address->length = strlen(ServerAddress) + 1;
 224   strcpy(server_address->string, ServerAddress);
 225   results = (RpcResults*)((ULONG_PTR)server_address + sizeof(RpcAddressString) + server_address->length - 1);
 226   results->num_results = 1;
 227   results->results[0].result = Result;
 228   results->results[0].reason = Reason;
 229   transfer_id = (RPC_SYNTAX_IDENTIFIER*)(results + 1);
 230   memcpy(transfer_id, TransferId, sizeof(RPC_SYNTAX_IDENTIFIER));
 231
 232   return header;
 233 }
 234
 235 VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
 236 {
 237   HeapFree(GetProcessHeap(), 0, Header);
 238 }
 239
 240 /***********************************************************************
 241  *           RPCRT4_Send (internal)
 242  *
 243  * Transmit a packet over connection in acceptable fragments.
 244  */
 245 RPC_STATUS RPCRT4_Send(RpcConnection *Connection, RpcPktHdr *Header,
 246                        void *Buffer, unsigned int BufferLength)
 247 {
 248   PUCHAR buffer_pos;
 249   DWORD hdr_size, count;
 250
 251   buffer_pos = Buffer;
 252   /* The packet building functions save the packet header size, so we can use it. */
 253   hdr_size = Header->common.frag_len;
 254   Header->common.flags |= RPC_FLG_FIRST;
 255   Header->common.flags &= ~RPC_FLG_LAST;
 256   while (!(Header->common.flags & RPC_FLG_LAST)) {
 257     /* decide if we need to split the packet into fragments */
 258     if ((BufferLength + hdr_size) <= Connection->MaxTransmissionSize) {
 259       Header->common.flags |= RPC_FLG_LAST;
 260       Header->common.frag_len = BufferLength + hdr_size;
 261     } else {
 262       Header->common.frag_len = Connection->MaxTransmissionSize;
 263       buffer_pos += Header->common.frag_len - hdr_size;
 264       BufferLength -= Header->common.frag_len - hdr_size;
 265     }
 266
 267     /* transmit packet header */
 268     if (!WriteFile(Connection->conn, Header, hdr_size, &count, NULL)) {
 269       WARN("WriteFile failed with error %ld\n", GetLastError());
 270       return GetLastError();
 271     }
 272
 273     /* fragment consisted of header only and is the last one */
 274     if (hdr_size == Header->common.frag_len &&
 275         Header->common.flags & RPC_FLG_LAST) {
 276       return RPC_S_OK;
 277     }
 278
 279     /* send the fragment data */
 280     if (!WriteFile(Connection->conn, buffer_pos, Header->common.frag_len - hdr_size, &count, NULL)) {
 281       WARN("WriteFile failed with error %ld\n", GetLastError());
 282       return GetLastError();
 283     }
 284
 285     Header->common.flags &= ~RPC_FLG_FIRST;
 286   }
 287
 288   return RPC_S_OK;
 289 }
 290
 291 /***********************************************************************
 292  *           RPCRT4_Receive (internal)
 293  *
 294  * Receive a packet from connection and merge the fragments.
 295  */
 296 RPC_STATUS RPCRT4_Receive(RpcConnection *Connection, RpcPktHdr **Header,
 297                           PRPC_MESSAGE pMsg)
 298 {
 299   RPC_STATUS status;
 300   DWORD dwRead, hdr_length;
 301   unsigned short first_flag;
 302   unsigned long data_length;
 303   unsigned long buffer_length;
 304   unsigned char *buffer_ptr;
 305   RpcPktCommonHdr common_hdr;
 306
 307   *Header = NULL;
 308
 309   TRACE("(%p, %p, %p)\n", Connection, Header, pMsg);
 310
 311   /* read packet common header */
 312   if (!ReadFile(Connection->conn, &common_hdr, sizeof(common_hdr), &dwRead, NULL)) {
 313     if (GetLastError() != ERROR_MORE_DATA) {
 314       WARN("ReadFile failed with error %ld\n", GetLastError());
 315       status = RPC_S_PROTOCOL_ERROR;
 316       goto fail;
 317     }
 318   }
 319   if (dwRead != sizeof(common_hdr)) {
 320     WARN("Short read of header, %ld/%d bytes\n", dwRead, sizeof(common_hdr));
 321     status = RPC_S_PROTOCOL_ERROR;
 322     goto fail;
 323   }
 324
 325   /* verify if the header really makes sense */
 326   if (common_hdr.rpc_ver != RPC_VER_MAJOR ||
 327       common_hdr.rpc_ver_minor != RPC_VER_MINOR) {
 328     WARN("unhandled packet version\n");
 329     status = RPC_S_PROTOCOL_ERROR;
 330     goto fail;
 331   }
 332
 333   hdr_length = RPCRT4_GetHeaderSize((RpcPktHdr*)&common_hdr);
 334   if (hdr_length == 0) {
 335     WARN("header length == 0\n");
 336     status = RPC_S_PROTOCOL_ERROR;
 337     goto fail;
 338   }
 339
 340   *Header = HeapAlloc(GetProcessHeap(), 0, hdr_length);
 341   memcpy(*Header, &common_hdr, sizeof(common_hdr));
 342
 343   /* read the rest of packet header */
 344   if (!ReadFile(Connection->conn, &(*Header)->common + 1,
 345                 hdr_length - sizeof(common_hdr), &dwRead, NULL)) {
 346     if (GetLastError() != ERROR_MORE_DATA) {
 347       WARN("ReadFile failed with error %ld\n", GetLastError());
 348       status = RPC_S_PROTOCOL_ERROR;
 349       goto fail;
 350     }
 351   }
 352   if (dwRead != hdr_length - sizeof(common_hdr)) {
 353     WARN("bad header length, %ld/%ld bytes\n", dwRead, hdr_length - sizeof(common_hdr));
 354     status = RPC_S_PROTOCOL_ERROR;
 355     goto fail;
 356   }
 357
 358   /* read packet body */
 359   switch (common_hdr.ptype) {
 360   case PKT_RESPONSE:
 361     pMsg->BufferLength = (*Header)->response.alloc_hint;
 362     break;
 363   case PKT_REQUEST:
 364     pMsg->BufferLength = (*Header)->request.alloc_hint;
 365     break;
 366   default:
 367     pMsg->BufferLength = common_hdr.frag_len - hdr_length;
 368   }
 369
 370   TRACE("buffer length = %u\n", pMsg->BufferLength);
 371
 372   status = I_RpcGetBuffer(pMsg);
 373   if (status != RPC_S_OK) goto fail;
 374
 375   first_flag = RPC_FLG_FIRST;
 376   buffer_length = 0;
 377   buffer_ptr = pMsg->Buffer;
 378   while (buffer_length < pMsg->BufferLength)
 379   {
 380     data_length = (*Header)->common.frag_len - hdr_length;
 381     if (((*Header)->common.flags & RPC_FLG_FIRST) != first_flag ||
 382         data_length + buffer_length > pMsg->BufferLength) {
 383       TRACE("invalid packet flags or buffer length\n");
 384       status = RPC_S_PROTOCOL_ERROR;
 385       goto fail;
 386     }
 387
 388     if (data_length == 0) dwRead = 0; else
 389     if (!ReadFile(Connection->conn, buffer_ptr, data_length, &dwRead, NULL)) {
 390       if (GetLastError() != ERROR_MORE_DATA) {
 391         WARN("ReadFile failed with error %ld\n", GetLastError());
 392         status = RPC_S_PROTOCOL_ERROR;
 393         goto fail;
 394       }
 395     }
 396     if (dwRead != data_length) {
 397       WARN("bad data length, %ld/%ld\n", dwRead, data_length);
 398       status = RPC_S_PROTOCOL_ERROR;
 399       goto fail;
 400     }
 401
 402     /* when there is no more data left, it should be the last packet */
 403     if (buffer_length == pMsg->BufferLength &&
 404         ((*Header)->common.flags & RPC_FLG_LAST) == 0) {
 405       WARN("no more data left, but not last packet\n");
 406       status = RPC_S_PROTOCOL_ERROR;
 407       goto fail;
 408     }
 409
 410     buffer_length += data_length;
 411     if (buffer_length < pMsg->BufferLength) {
 412       TRACE("next header\n");
 413
 414       /* read the header of next packet */
 415       if (!ReadFile(Connection->conn, *Header, hdr_length, &dwRead, NULL)) {
 416         if (GetLastError() != ERROR_MORE_DATA) {
 417           WARN("ReadFile failed with error %ld\n", GetLastError());
 418           status = GetLastError();
 419           goto fail;
 420         }
 421       }
 422       if (dwRead != hdr_length) {
 423         WARN("invalid packet header size (%ld)\n", dwRead);
 424         status = RPC_S_PROTOCOL_ERROR;
 425         goto fail;
 426       }
 427
 428       buffer_ptr += data_length;
 429       first_flag = 0;
 430     }
 431   }
 432
 433   /* success */
 434   status = RPC_S_OK;
 435
 436 fail:
 437   if (status != RPC_S_OK && *Header) {
 438     RPCRT4_FreeHeader(*Header);
 439     *Header = NULL;
 440   }
 441   return status;
 442 }
 443
 444 /***********************************************************************
 445  *           I_RpcGetBuffer [RPCRT4.@]
 446  */
 447 RPC_STATUS WINAPI I_RpcGetBuffer(PRPC_MESSAGE pMsg)
 448 {
 449   RpcBinding* bind = (RpcBinding*)pMsg->Handle;
 450
 451   TRACE("(%p): BufferLength=%d\n", pMsg, pMsg->BufferLength);
 452   /* FIXME: pfnAllocate? */
 453   if (bind->server) {
 454     /* it turns out that the original buffer data must still be available
 455      * while the RPC server is marshalling a reply, so we should not deallocate
 456      * it, we'll leave deallocating the original buffer to the RPC server */
 457     pMsg->Buffer = HeapAlloc(GetProcessHeap(), 0, pMsg->BufferLength);
 458   } else {
 459     HeapFree(GetProcessHeap(), 0, pMsg->Buffer);
 460     pMsg->Buffer = HeapAlloc(GetProcessHeap(), 0, pMsg->BufferLength);
 461   }
 462   TRACE("Buffer=%p\n", pMsg->Buffer);
 463   /* FIXME: which errors to return? */
 464   return pMsg->Buffer ? S_OK : E_OUTOFMEMORY;
 465 }
 466
 467 /***********************************************************************
 468  *           I_RpcFreeBuffer [RPCRT4.@]
 469  */
 470 RPC_STATUS WINAPI I_RpcFreeBuffer(PRPC_MESSAGE pMsg)
 471 {
 472   TRACE("(%p) Buffer=%p\n", pMsg, pMsg->Buffer);
 473   /* FIXME: pfnFree? */
 474   HeapFree(GetProcessHeap(), 0, pMsg->Buffer);
 475   pMsg->Buffer = NULL;
 476   return S_OK;
 477 }
 478
 479 /***********************************************************************
 480  *           I_RpcSend [RPCRT4.@]
 481  */
 482 RPC_STATUS WINAPI I_RpcSend(PRPC_MESSAGE pMsg)
 483 {
 484   RpcBinding* bind = (RpcBinding*)pMsg->Handle;
 485   RpcConnection* conn;
 486   RPC_CLIENT_INTERFACE* cif = NULL;
 487   RPC_SERVER_INTERFACE* sif = NULL;
 488   RPC_STATUS status;
 489   RpcPktHdr *hdr;
 490
 491   TRACE("(%p)\n", pMsg);
 492   if (!bind) return RPC_S_INVALID_BINDING;
 493
 494   if (bind->server) {
 495     sif = pMsg->RpcInterfaceInformation;
 496     if (!sif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
 497     status = RPCRT4_OpenBinding(bind, &conn, &sif->TransferSyntax,
 498                                 &sif->InterfaceId);
 499   } else {
 500     cif = pMsg->RpcInterfaceInformation;
 501     if (!cif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
 502     status = RPCRT4_OpenBinding(bind, &conn, &cif->TransferSyntax,
 503                                 &cif->InterfaceId);
 504   }
 505
 506   if (status != RPC_S_OK) return status;
 507
 508   if (bind->server) {
 509     if (pMsg->RpcFlags & WINE_RPCFLAG_EXCEPTION) {
 510       hdr = RPCRT4_BuildFaultHeader(pMsg->DataRepresentation,
 511                                     RPC_S_CALL_FAILED);
 512     } else {
 513       hdr = RPCRT4_BuildResponseHeader(pMsg->DataRepresentation,
 514                                        pMsg->BufferLength);
 515     }
 516   } else {
 517     hdr = RPCRT4_BuildRequestHeader(pMsg->DataRepresentation,
 518                                     pMsg->BufferLength, pMsg->ProcNum,
 519                                     &bind->ObjectUuid);
 520   }
 521
 522   status = RPCRT4_Send(conn, hdr, pMsg->Buffer, pMsg->BufferLength);
 523
 524   RPCRT4_FreeHeader(hdr);
 525
 526   /* success */
 527   if (!bind->server) {
 528     /* save the connection, so the response can be read from it */
 529     pMsg->ReservedForRuntime = conn;
 530     return RPC_S_OK;
 531   }
 532   RPCRT4_CloseBinding(bind, conn);
 533   status = RPC_S_OK;
 534
 535   return status;
 536 }
 537
 538 /***********************************************************************
 539  *           I_RpcReceive [RPCRT4.@]
 540  */
 541 RPC_STATUS WINAPI I_RpcReceive(PRPC_MESSAGE pMsg)
 542 {
 543   RpcBinding* bind = (RpcBinding*)pMsg->Handle;
 544   RpcConnection* conn;
 545   RPC_CLIENT_INTERFACE* cif = NULL;
 546   RPC_SERVER_INTERFACE* sif = NULL;
 547   RPC_STATUS status;
 548   RpcPktHdr *hdr = NULL;
 549
 550   TRACE("(%p)\n", pMsg);
 551   if (!bind) return RPC_S_INVALID_BINDING;
 552
 553   if (pMsg->ReservedForRuntime) {
 554     conn = pMsg->ReservedForRuntime;
 555     pMsg->ReservedForRuntime = NULL;
 556   } else {
 557     if (bind->server) {
 558       sif = pMsg->RpcInterfaceInformation;
 559       if (!sif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
 560       status = RPCRT4_OpenBinding(bind, &conn, &sif->TransferSyntax,
 561                                   &sif->InterfaceId);
 562     } else {
 563       cif = pMsg->RpcInterfaceInformation;
 564       if (!cif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
 565       status = RPCRT4_OpenBinding(bind, &conn, &cif->TransferSyntax,
 566                                   &cif->InterfaceId);
 567     }
 568     if (status != RPC_S_OK) return status;
 569   }
 570
 571   status = RPCRT4_Receive(conn, &hdr, pMsg);
 572   if (status != RPC_S_OK) {
 573     WARN("receive failed with error %lx\n", status);
 574     goto fail;
 575   }
 576
 577   status = RPC_S_PROTOCOL_ERROR;
 578
 579   switch (hdr->common.ptype) {
 580   case PKT_RESPONSE:
 581     if (bind->server) goto fail;
 582     break;
 583   case PKT_REQUEST:
 584     if (!bind->server) goto fail;
 585     break;
 586   case PKT_FAULT:
 587     pMsg->RpcFlags |= WINE_RPCFLAG_EXCEPTION;
 588     ERR ("we got fault packet with status %lx\n", hdr->fault.status);
 589     status = RPC_S_CALL_FAILED; /* ? */
 590     goto fail;
 591   default:
 592     WARN("bad packet type %d\n", hdr->common.ptype);
 593     goto fail;
 594   }
 595
 596   /* success */
 597   status = RPC_S_OK;
 598
 599 fail:
 600   if (hdr) {
 601     RPCRT4_FreeHeader(hdr);
 602   }
 603   RPCRT4_CloseBinding(bind, conn);
 604   return status;
 605 }
 606
 607 /***********************************************************************
 608  *           I_RpcSendReceive [RPCRT4.@]
 609  */
 610 RPC_STATUS WINAPI I_RpcSendReceive(PRPC_MESSAGE pMsg)
 611 {
 612   RPC_STATUS status;
 613
 614   TRACE("(%p)\n", pMsg);
 615   status = I_RpcSend(pMsg);
 616   if (status == RPC_S_OK)
 617     status = I_RpcReceive(pMsg);
 618   return status;
 619 }