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