wined3d: Get rid of the invymat.
[wine] / 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  * Copyright 2006 CodeWeavers
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include <stdarg.h>
24 #include <stdio.h>
25 #include <string.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winerror.h"
30
31 #include "rpc.h"
32 #include "rpcndr.h"
33 #include "rpcdcep.h"
34
35 #include "wine/debug.h"
36
37 #include "rpc_binding.h"
38 #include "rpc_defs.h"
39 #include "rpc_message.h"
40 #include "ncastatus.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
43
44 /* note: the DCE/RPC spec says the alignment amount should be 4, but
45  * MS/RPC servers seem to always use 16 */
46 #define AUTH_ALIGNMENT 16
47
48 /* gets the amount needed to round a value up to the specified alignment */
49 #define ROUND_UP_AMOUNT(value, alignment) \
50     (((alignment) - (((value) % (alignment)))) % (alignment))
51 #define ROUND_UP(value, alignment) (((value) + ((alignment) - 1)) & ~((alignment)-1))
52
53 enum secure_packet_direction
54 {
55   SECURE_PACKET_SEND,
56   SECURE_PACKET_RECEIVE
57 };
58
59 static RPC_STATUS I_RpcReAllocateBuffer(PRPC_MESSAGE pMsg);
60
61 static DWORD RPCRT4_GetHeaderSize(const RpcPktHdr *Header)
62 {
63   static const DWORD header_sizes[] = {
64     sizeof(Header->request), 0, sizeof(Header->response),
65     sizeof(Header->fault), 0, 0, 0, 0, 0, 0, 0, sizeof(Header->bind),
66     sizeof(Header->bind_ack), sizeof(Header->bind_nack),
67     0, 0, 0, 0, 0
68   };
69   ULONG ret = 0;
70   
71   if (Header->common.ptype < sizeof(header_sizes) / sizeof(header_sizes[0])) {
72     ret = header_sizes[Header->common.ptype];
73     if (ret == 0)
74       FIXME("unhandled packet type\n");
75     if (Header->common.flags & RPC_FLG_OBJECT_UUID)
76       ret += sizeof(UUID);
77   } else {
78     TRACE("invalid packet type\n");
79   }
80
81   return ret;
82 }
83
84 static int packet_has_body(const RpcPktHdr *Header)
85 {
86     return (Header->common.ptype == PKT_FAULT) ||
87            (Header->common.ptype == PKT_REQUEST) ||
88            (Header->common.ptype == PKT_RESPONSE);
89 }
90
91 static int packet_has_auth_verifier(const RpcPktHdr *Header)
92 {
93     return !(Header->common.ptype == PKT_BIND_NACK) &&
94            !(Header->common.ptype == PKT_SHUTDOWN);
95 }
96
97 static VOID RPCRT4_BuildCommonHeader(RpcPktHdr *Header, unsigned char PacketType,
98                               unsigned long DataRepresentation)
99 {
100   Header->common.rpc_ver = RPC_VER_MAJOR;
101   Header->common.rpc_ver_minor = RPC_VER_MINOR;
102   Header->common.ptype = PacketType;
103   Header->common.drep[0] = LOBYTE(LOWORD(DataRepresentation));
104   Header->common.drep[1] = HIBYTE(LOWORD(DataRepresentation));
105   Header->common.drep[2] = LOBYTE(HIWORD(DataRepresentation));
106   Header->common.drep[3] = HIBYTE(HIWORD(DataRepresentation));
107   Header->common.auth_len = 0;
108   Header->common.call_id = 1;
109   Header->common.flags = 0;
110   /* Flags and fragment length are computed in RPCRT4_Send. */
111 }                              
112
113 static RpcPktHdr *RPCRT4_BuildRequestHeader(unsigned long DataRepresentation,
114                                      unsigned long BufferLength,
115                                      unsigned short ProcNum,
116                                      UUID *ObjectUuid)
117 {
118   RpcPktHdr *header;
119   BOOL has_object;
120   RPC_STATUS status;
121
122   has_object = (ObjectUuid != NULL && !UuidIsNil(ObjectUuid, &status));
123   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
124                      sizeof(header->request) + (has_object ? sizeof(UUID) : 0));
125   if (header == NULL) {
126     return NULL;
127   }
128
129   RPCRT4_BuildCommonHeader(header, PKT_REQUEST, DataRepresentation);
130   header->common.frag_len = sizeof(header->request);
131   header->request.alloc_hint = BufferLength;
132   header->request.context_id = 0;
133   header->request.opnum = ProcNum;
134   if (has_object) {
135     header->common.flags |= RPC_FLG_OBJECT_UUID;
136     header->common.frag_len += sizeof(UUID);
137     memcpy(&header->request + 1, ObjectUuid, sizeof(UUID));
138   }
139
140   return header;
141 }
142
143 RpcPktHdr *RPCRT4_BuildResponseHeader(unsigned long DataRepresentation,
144                                       unsigned long BufferLength)
145 {
146   RpcPktHdr *header;
147
148   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->response));
149   if (header == NULL) {
150     return NULL;
151   }
152
153   RPCRT4_BuildCommonHeader(header, PKT_RESPONSE, DataRepresentation);
154   header->common.frag_len = sizeof(header->response);
155   header->response.alloc_hint = BufferLength;
156
157   return header;
158 }
159
160 RpcPktHdr *RPCRT4_BuildFaultHeader(unsigned long DataRepresentation,
161                                    RPC_STATUS Status)
162 {
163   RpcPktHdr *header;
164
165   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->fault));
166   if (header == NULL) {
167     return NULL;
168   }
169
170   RPCRT4_BuildCommonHeader(header, PKT_FAULT, DataRepresentation);
171   header->common.frag_len = sizeof(header->fault);
172   header->fault.status = Status;
173
174   return header;
175 }
176
177 RpcPktHdr *RPCRT4_BuildBindHeader(unsigned long DataRepresentation,
178                                   unsigned short MaxTransmissionSize,
179                                   unsigned short MaxReceiveSize,
180                                   unsigned long  AssocGroupId,
181                                   const RPC_SYNTAX_IDENTIFIER *AbstractId,
182                                   const RPC_SYNTAX_IDENTIFIER *TransferId)
183 {
184   RpcPktHdr *header;
185
186   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->bind));
187   if (header == NULL) {
188     return NULL;
189   }
190
191   RPCRT4_BuildCommonHeader(header, PKT_BIND, DataRepresentation);
192   header->common.frag_len = sizeof(header->bind);
193   header->bind.max_tsize = MaxTransmissionSize;
194   header->bind.max_rsize = MaxReceiveSize;
195   header->bind.assoc_gid = AssocGroupId;
196   header->bind.num_elements = 1;
197   header->bind.num_syntaxes = 1;
198   memcpy(&header->bind.abstract, AbstractId, sizeof(RPC_SYNTAX_IDENTIFIER));
199   memcpy(&header->bind.transfer, TransferId, sizeof(RPC_SYNTAX_IDENTIFIER));
200
201   return header;
202 }
203
204 static RpcPktHdr *RPCRT4_BuildAuthHeader(unsigned long DataRepresentation)
205 {
206   RpcPktHdr *header;
207
208   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
209                      sizeof(header->common) + 12);
210   if (header == NULL)
211     return NULL;
212
213   RPCRT4_BuildCommonHeader(header, PKT_AUTH3, DataRepresentation);
214   header->common.frag_len = 0x14;
215   header->common.auth_len = 0;
216
217   return header;
218 }
219
220 RpcPktHdr *RPCRT4_BuildBindNackHeader(unsigned long DataRepresentation,
221                                       unsigned char RpcVersion,
222                                       unsigned char RpcVersionMinor)
223 {
224   RpcPktHdr *header;
225
226   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->bind_nack));
227   if (header == NULL) {
228     return NULL;
229   }
230
231   RPCRT4_BuildCommonHeader(header, PKT_BIND_NACK, DataRepresentation);
232   header->common.frag_len = sizeof(header->bind_nack);
233   header->bind_nack.reject_reason = REJECT_REASON_NOT_SPECIFIED;
234   header->bind_nack.protocols_count = 1;
235   header->bind_nack.protocols[0].rpc_ver = RpcVersion;
236   header->bind_nack.protocols[0].rpc_ver_minor = RpcVersionMinor;
237
238   return header;
239 }
240
241 RpcPktHdr *RPCRT4_BuildBindAckHeader(unsigned long DataRepresentation,
242                                      unsigned short MaxTransmissionSize,
243                                      unsigned short MaxReceiveSize,
244                                      unsigned long AssocGroupId,
245                                      LPCSTR ServerAddress,
246                                      unsigned long Result,
247                                      unsigned long Reason,
248                                      const RPC_SYNTAX_IDENTIFIER *TransferId)
249 {
250   RpcPktHdr *header;
251   unsigned long header_size;
252   RpcAddressString *server_address;
253   RpcResults *results;
254   RPC_SYNTAX_IDENTIFIER *transfer_id;
255
256   header_size = sizeof(header->bind_ack) +
257                 ROUND_UP(FIELD_OFFSET(RpcAddressString, string[strlen(ServerAddress) + 1]), 4) +
258                 sizeof(RpcResults) +
259                 sizeof(RPC_SYNTAX_IDENTIFIER);
260
261   header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, header_size);
262   if (header == NULL) {
263     return NULL;
264   }
265
266   RPCRT4_BuildCommonHeader(header, PKT_BIND_ACK, DataRepresentation);
267   header->common.frag_len = header_size;
268   header->bind_ack.max_tsize = MaxTransmissionSize;
269   header->bind_ack.max_rsize = MaxReceiveSize;
270   header->bind_ack.assoc_gid = AssocGroupId;
271   server_address = (RpcAddressString*)(&header->bind_ack + 1);
272   server_address->length = strlen(ServerAddress) + 1;
273   strcpy(server_address->string, ServerAddress);
274   /* results is 4-byte aligned */
275   results = (RpcResults*)((ULONG_PTR)server_address + ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4));
276   results->num_results = 1;
277   results->results[0].result = Result;
278   results->results[0].reason = Reason;
279   transfer_id = (RPC_SYNTAX_IDENTIFIER*)(results + 1);
280   memcpy(transfer_id, TransferId, sizeof(RPC_SYNTAX_IDENTIFIER));
281
282   return header;
283 }
284
285 VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
286 {
287   HeapFree(GetProcessHeap(), 0, Header);
288 }
289
290 NCA_STATUS RPC2NCA_STATUS(RPC_STATUS status)
291 {
292     switch (status)
293     {
294     case ERROR_INVALID_HANDLE:              return NCA_S_FAULT_CONTEXT_MISMATCH;
295     case ERROR_OUTOFMEMORY:                 return NCA_S_FAULT_REMOTE_NO_MEMORY;
296     case RPC_S_NOT_LISTENING:               return NCA_S_SERVER_TOO_BUSY;
297     case RPC_S_UNKNOWN_IF:                  return NCA_S_UNK_IF;
298     case RPC_S_SERVER_TOO_BUSY:             return NCA_S_SERVER_TOO_BUSY;
299     case RPC_S_CALL_FAILED:                 return NCA_S_FAULT_UNSPEC;
300     case RPC_S_CALL_FAILED_DNE:             return NCA_S_MANAGER_NOT_ENTERED;
301     case RPC_S_PROTOCOL_ERROR:              return NCA_S_PROTO_ERROR;
302     case RPC_S_UNSUPPORTED_TYPE:            return NCA_S_UNSUPPORTED_TYPE;
303     case RPC_S_INVALID_TAG:                 return NCA_S_FAULT_INVALID_TAG;
304     case RPC_S_INVALID_BOUND:               return NCA_S_FAULT_INVALID_BOUND;
305     case RPC_S_PROCNUM_OUT_OF_RANGE:        return NCA_S_OP_RNG_ERROR;
306     case RPC_X_SS_HANDLES_MISMATCH:         return NCA_S_FAULT_CONTEXT_MISMATCH;
307     case RPC_S_CALL_CANCELLED:              return NCA_S_FAULT_CANCEL;
308     case RPC_S_COMM_FAILURE:                return NCA_S_COMM_FAILURE;
309     case RPC_X_WRONG_PIPE_ORDER:            return NCA_S_FAULT_PIPE_ORDER;
310     case RPC_X_PIPE_CLOSED:                 return NCA_S_FAULT_PIPE_CLOSED;
311     case RPC_X_PIPE_DISCIPLINE_ERROR:       return NCA_S_FAULT_PIPE_DISCIPLINE;
312     case RPC_X_PIPE_EMPTY:                  return NCA_S_FAULT_PIPE_EMPTY;
313     case STATUS_FLOAT_DIVIDE_BY_ZERO:       return NCA_S_FAULT_FP_DIV_ZERO;
314     case STATUS_FLOAT_INVALID_OPERATION:    return NCA_S_FAULT_FP_ERROR;
315     case STATUS_FLOAT_OVERFLOW:             return NCA_S_FAULT_FP_OVERFLOW;
316     case STATUS_FLOAT_UNDERFLOW:            return NCA_S_FAULT_FP_UNDERFLOW;
317     case STATUS_INTEGER_DIVIDE_BY_ZERO:     return NCA_S_FAULT_INT_DIV_BY_ZERO;
318     case STATUS_INTEGER_OVERFLOW:           return NCA_S_FAULT_INT_OVERFLOW;
319     default:                                return status;
320     }
321 }
322
323 RPC_STATUS NCA2RPC_STATUS(NCA_STATUS status)
324 {
325     switch (status)
326     {
327     case NCA_S_COMM_FAILURE:            return RPC_S_COMM_FAILURE;
328     case NCA_S_OP_RNG_ERROR:            return RPC_S_PROCNUM_OUT_OF_RANGE;
329     case NCA_S_UNK_IF:                  return RPC_S_UNKNOWN_IF;
330     case NCA_S_YOU_CRASHED:             return RPC_S_CALL_FAILED;
331     case NCA_S_PROTO_ERROR:             return RPC_S_PROTOCOL_ERROR;
332     case NCA_S_OUT_ARGS_TOO_BIG:        return ERROR_NOT_ENOUGH_SERVER_MEMORY;
333     case NCA_S_SERVER_TOO_BUSY:         return RPC_S_SERVER_TOO_BUSY;
334     case NCA_S_UNSUPPORTED_TYPE:        return RPC_S_UNSUPPORTED_TYPE;
335     case NCA_S_FAULT_INT_DIV_BY_ZERO:   return RPC_S_ZERO_DIVIDE;
336     case NCA_S_FAULT_ADDR_ERROR:        return RPC_S_ADDRESS_ERROR;
337     case NCA_S_FAULT_FP_DIV_ZERO:       return RPC_S_FP_DIV_ZERO;
338     case NCA_S_FAULT_FP_UNDERFLOW:      return RPC_S_FP_UNDERFLOW;
339     case NCA_S_FAULT_FP_OVERFLOW:       return RPC_S_FP_OVERFLOW;
340     case NCA_S_FAULT_INVALID_TAG:       return RPC_S_INVALID_TAG;
341     case NCA_S_FAULT_INVALID_BOUND:     return RPC_S_INVALID_BOUND;
342     case NCA_S_RPC_VERSION_MISMATCH:    return RPC_S_PROTOCOL_ERROR;
343     case NCA_S_UNSPEC_REJECT:           return RPC_S_CALL_FAILED_DNE;
344     case NCA_S_BAD_ACTID:               return RPC_S_CALL_FAILED_DNE;
345     case NCA_S_WHO_ARE_YOU_FAILED:      return RPC_S_CALL_FAILED;
346     case NCA_S_MANAGER_NOT_ENTERED:     return RPC_S_CALL_FAILED_DNE;
347     case NCA_S_FAULT_CANCEL:            return RPC_S_CALL_CANCELLED;
348     case NCA_S_FAULT_ILL_INST:          return RPC_S_ADDRESS_ERROR;
349     case NCA_S_FAULT_FP_ERROR:          return RPC_S_FP_OVERFLOW;
350     case NCA_S_FAULT_INT_OVERFLOW:      return RPC_S_ADDRESS_ERROR;
351     case NCA_S_FAULT_UNSPEC:            return RPC_S_CALL_FAILED;
352     case NCA_S_FAULT_PIPE_EMPTY:        return RPC_X_PIPE_EMPTY;
353     case NCA_S_FAULT_PIPE_CLOSED:       return RPC_X_PIPE_CLOSED;
354     case NCA_S_FAULT_PIPE_ORDER:        return RPC_X_WRONG_PIPE_ORDER;
355     case NCA_S_FAULT_PIPE_DISCIPLINE:   return RPC_X_PIPE_DISCIPLINE_ERROR;
356     case NCA_S_FAULT_PIPE_COMM_ERROR:   return RPC_S_COMM_FAILURE;
357     case NCA_S_FAULT_PIPE_MEMORY:       return ERROR_OUTOFMEMORY;
358     case NCA_S_FAULT_CONTEXT_MISMATCH:  return ERROR_INVALID_HANDLE;
359     case NCA_S_FAULT_REMOTE_NO_MEMORY:  return ERROR_NOT_ENOUGH_SERVER_MEMORY;
360     default:                            return status;
361     }
362 }
363
364 static RPC_STATUS RPCRT4_SecurePacket(RpcConnection *Connection,
365     enum secure_packet_direction dir,
366     RpcPktHdr *hdr, unsigned int hdr_size,
367     unsigned char *stub_data, unsigned int stub_data_size,
368     RpcAuthVerifier *auth_hdr,
369     unsigned char *auth_value, unsigned int auth_value_size)
370 {
371     SecBufferDesc message;
372     SecBuffer buffers[4];
373     SECURITY_STATUS sec_status;
374
375     message.ulVersion = SECBUFFER_VERSION;
376     message.cBuffers = sizeof(buffers)/sizeof(buffers[0]);
377     message.pBuffers = buffers;
378
379     buffers[0].cbBuffer = hdr_size;
380     buffers[0].BufferType = SECBUFFER_DATA|SECBUFFER_READONLY_WITH_CHECKSUM;
381     buffers[0].pvBuffer = hdr;
382     buffers[1].cbBuffer = stub_data_size;
383     buffers[1].BufferType = SECBUFFER_DATA;
384     buffers[1].pvBuffer = stub_data;
385     buffers[2].cbBuffer = sizeof(*auth_hdr);
386     buffers[2].BufferType = SECBUFFER_DATA|SECBUFFER_READONLY_WITH_CHECKSUM;
387     buffers[2].pvBuffer = auth_hdr;
388     buffers[3].cbBuffer = auth_value_size;
389     buffers[3].BufferType = SECBUFFER_TOKEN;
390     buffers[3].pvBuffer = auth_value;
391
392     if (dir == SECURE_PACKET_SEND)
393     {
394         if ((auth_hdr->auth_level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY) && packet_has_body(hdr))
395         {
396             sec_status = EncryptMessage(&Connection->ctx, 0, &message, 0 /* FIXME */);
397             if (sec_status != SEC_E_OK)
398             {
399                 ERR("EncryptMessage failed with 0x%08x\n", sec_status);
400                 return RPC_S_SEC_PKG_ERROR;
401             }
402         }
403         else if (auth_hdr->auth_level != RPC_C_AUTHN_LEVEL_NONE)
404         {
405             sec_status = MakeSignature(&Connection->ctx, 0, &message, 0 /* FIXME */);
406             if (sec_status != SEC_E_OK)
407             {
408                 ERR("MakeSignature failed with 0x%08x\n", sec_status);
409                 return RPC_S_SEC_PKG_ERROR;
410             }
411         }
412     }
413     else if (dir == SECURE_PACKET_RECEIVE)
414     {
415         if ((auth_hdr->auth_level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY) && packet_has_body(hdr))
416         {
417             sec_status = DecryptMessage(&Connection->ctx, &message, 0 /* FIXME */, 0);
418             if (sec_status != SEC_E_OK)
419             {
420                 ERR("DecryptMessage failed with 0x%08x\n", sec_status);
421                 return RPC_S_SEC_PKG_ERROR;
422             }
423         }
424         else if (auth_hdr->auth_level != RPC_C_AUTHN_LEVEL_NONE)
425         {
426             sec_status = VerifySignature(&Connection->ctx, &message, 0 /* FIXME */, NULL);
427             if (sec_status != SEC_E_OK)
428             {
429                 ERR("VerifySignature failed with 0x%08x\n", sec_status);
430                 return RPC_S_SEC_PKG_ERROR;
431             }
432         }
433     }
434
435     return RPC_S_OK;
436 }
437          
438 /***********************************************************************
439  *           RPCRT4_SendAuth (internal)
440  * 
441  * Transmit a packet with authorization data over connection in acceptable fragments.
442  */
443 static RPC_STATUS RPCRT4_SendAuth(RpcConnection *Connection, RpcPktHdr *Header,
444                                   void *Buffer, unsigned int BufferLength,
445                                   const void *Auth, unsigned int AuthLength)
446 {
447   PUCHAR buffer_pos;
448   DWORD hdr_size;
449   LONG count;
450   unsigned char *pkt;
451   LONG alen;
452   RPC_STATUS status;
453
454   RPCRT4_SetThreadCurrentConnection(Connection);
455
456   buffer_pos = Buffer;
457   /* The packet building functions save the packet header size, so we can use it. */
458   hdr_size = Header->common.frag_len;
459   if (AuthLength)
460     Header->common.auth_len = AuthLength;
461   else if (Connection->AuthInfo && packet_has_auth_verifier(Header))
462   {
463     if ((Connection->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY) && packet_has_body(Header))
464       Header->common.auth_len = Connection->encryption_auth_len;
465     else
466       Header->common.auth_len = Connection->signature_auth_len;
467   }
468   else
469     Header->common.auth_len = 0;
470   Header->common.flags |= RPC_FLG_FIRST;
471   Header->common.flags &= ~RPC_FLG_LAST;
472
473   alen = RPC_AUTH_VERIFIER_LEN(&Header->common);
474
475   while (!(Header->common.flags & RPC_FLG_LAST)) {
476     unsigned char auth_pad_len = Header->common.auth_len ? ROUND_UP_AMOUNT(BufferLength, AUTH_ALIGNMENT) : 0;
477     unsigned int pkt_size = BufferLength + hdr_size + alen + auth_pad_len;
478
479     /* decide if we need to split the packet into fragments */
480    if (pkt_size <= Connection->MaxTransmissionSize) {
481      Header->common.flags |= RPC_FLG_LAST;
482      Header->common.frag_len = pkt_size;
483     } else {
484       auth_pad_len = 0;
485       /* make sure packet payload will be a multiple of 16 */
486       Header->common.frag_len =
487         ((Connection->MaxTransmissionSize - hdr_size - alen) & ~(AUTH_ALIGNMENT-1)) +
488         hdr_size + alen;
489     }
490
491     pkt = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Header->common.frag_len);
492
493     memcpy(pkt, Header, hdr_size);
494
495     /* fragment consisted of header only and is the last one */
496     if (hdr_size == Header->common.frag_len)
497       goto write;
498
499     memcpy(pkt + hdr_size, buffer_pos, Header->common.frag_len - hdr_size - auth_pad_len - alen);
500
501     /* add the authorization info */
502     if (Connection->AuthInfo && packet_has_auth_verifier(Header))
503     {
504       RpcAuthVerifier *auth_hdr = (RpcAuthVerifier *)&pkt[Header->common.frag_len - alen];
505
506       auth_hdr->auth_type = Connection->AuthInfo->AuthnSvc;
507       auth_hdr->auth_level = Connection->AuthInfo->AuthnLevel;
508       auth_hdr->auth_pad_length = auth_pad_len;
509       auth_hdr->auth_reserved = 0;
510       /* a unique number... */
511       auth_hdr->auth_context_id = (unsigned long)Connection;
512
513       if (AuthLength)
514         memcpy(auth_hdr + 1, Auth, AuthLength);
515       else
516       {
517         status = RPCRT4_SecurePacket(Connection, SECURE_PACKET_SEND,
518             (RpcPktHdr *)pkt, hdr_size,
519             pkt + hdr_size, Header->common.frag_len - hdr_size - alen,
520             auth_hdr,
521             (unsigned char *)(auth_hdr + 1), Header->common.auth_len);
522         if (status != RPC_S_OK)
523         {
524           HeapFree(GetProcessHeap(), 0, pkt);
525           RPCRT4_SetThreadCurrentConnection(NULL);
526           return status;
527         }
528       }
529     }
530
531 write:
532     count = rpcrt4_conn_write(Connection, pkt, Header->common.frag_len);
533     HeapFree(GetProcessHeap(), 0, pkt);
534     if (count<0) {
535       WARN("rpcrt4_conn_write failed (auth)\n");
536       RPCRT4_SetThreadCurrentConnection(NULL);
537       return RPC_S_CALL_FAILED;
538     }
539
540     buffer_pos += Header->common.frag_len - hdr_size - alen - auth_pad_len;
541     BufferLength -= Header->common.frag_len - hdr_size - alen - auth_pad_len;
542     Header->common.flags &= ~RPC_FLG_FIRST;
543   }
544
545   RPCRT4_SetThreadCurrentConnection(NULL);
546   return RPC_S_OK;
547 }
548
549 /***********************************************************************
550  *           RPCRT4_ClientAuthorize (internal)
551  *
552  * Authorize a client connection. A NULL in param signifies a new connection.
553  */
554 static RPC_STATUS RPCRT4_ClientAuthorize(RpcConnection *conn, SecBuffer *in,
555                                          SecBuffer *out)
556 {
557   SECURITY_STATUS r;
558   SecBufferDesc out_desc;
559   SecBufferDesc inp_desc;
560   SecPkgContext_Sizes secctx_sizes;
561   BOOL continue_needed;
562   ULONG context_req = ISC_REQ_CONNECTION | ISC_REQ_USE_DCE_STYLE |
563                       ISC_REQ_MUTUAL_AUTH | ISC_REQ_DELEGATE;
564
565   if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_INTEGRITY)
566     context_req |= ISC_REQ_INTEGRITY;
567   else if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
568     context_req |= ISC_REQ_CONFIDENTIALITY | ISC_REQ_INTEGRITY;
569
570   out->BufferType = SECBUFFER_TOKEN;
571   out->cbBuffer = conn->AuthInfo->cbMaxToken;
572   out->pvBuffer = HeapAlloc(GetProcessHeap(), 0, out->cbBuffer);
573   if (!out->pvBuffer) return ERROR_OUTOFMEMORY;
574
575   out_desc.ulVersion = 0;
576   out_desc.cBuffers = 1;
577   out_desc.pBuffers = out;
578
579   inp_desc.cBuffers = 1;
580   inp_desc.pBuffers = in;
581   inp_desc.ulVersion = 0;
582
583   r = InitializeSecurityContextA(&conn->AuthInfo->cred, in ? &conn->ctx : NULL,
584         NULL, context_req, 0, SECURITY_NETWORK_DREP,
585         in ? &inp_desc : NULL, 0, &conn->ctx, &out_desc, &conn->attr,
586         &conn->exp);
587   if (FAILED(r))
588   {
589       WARN("InitializeSecurityContext failed with error 0x%08x\n", r);
590       goto failed;
591   }
592
593   TRACE("r = 0x%08x, attr = 0x%08x\n", r, conn->attr);
594   continue_needed = ((r == SEC_I_CONTINUE_NEEDED) ||
595                      (r == SEC_I_COMPLETE_AND_CONTINUE));
596
597   if ((r == SEC_I_COMPLETE_NEEDED) || (r == SEC_I_COMPLETE_AND_CONTINUE))
598   {
599       TRACE("complete needed\n");
600       r = CompleteAuthToken(&conn->ctx, &out_desc);
601       if (FAILED(r))
602       {
603           WARN("CompleteAuthToken failed with error 0x%08x\n", r);
604           goto failed;
605       }
606   }
607
608   TRACE("cbBuffer = %ld\n", out->cbBuffer);
609
610   if (!continue_needed)
611   {
612       r = QueryContextAttributesA(&conn->ctx, SECPKG_ATTR_SIZES, &secctx_sizes);
613       if (FAILED(r))
614       {
615           WARN("QueryContextAttributes failed with error 0x%08x\n", r);
616           goto failed;
617       }
618       conn->signature_auth_len = secctx_sizes.cbMaxSignature;
619       conn->encryption_auth_len = secctx_sizes.cbSecurityTrailer;
620   }
621
622   return RPC_S_OK;
623
624 failed:
625   HeapFree(GetProcessHeap(), 0, out->pvBuffer);
626   out->pvBuffer = NULL;
627   return ERROR_ACCESS_DENIED; /* FIXME: is this correct? */
628 }
629
630 /***********************************************************************
631  *           RPCRT4_AuthorizeBinding (internal)
632  */
633 static RPC_STATUS RPCRT_AuthorizeConnection(RpcConnection* conn,
634                                             BYTE *challenge, ULONG count)
635 {
636   SecBuffer inp, out;
637   RpcPktHdr *resp_hdr;
638   RPC_STATUS status;
639
640   TRACE("challenge %s, %d bytes\n", challenge, count);
641
642   inp.BufferType = SECBUFFER_TOKEN;
643   inp.pvBuffer = challenge;
644   inp.cbBuffer = count;
645
646   status = RPCRT4_ClientAuthorize(conn, &inp, &out);
647   if (status) return status;
648
649   resp_hdr = RPCRT4_BuildAuthHeader(NDR_LOCAL_DATA_REPRESENTATION);
650   if (!resp_hdr)
651     return E_OUTOFMEMORY;
652
653   status = RPCRT4_SendAuth(conn, resp_hdr, NULL, 0, out.pvBuffer, out.cbBuffer);
654
655   HeapFree(GetProcessHeap(), 0, out.pvBuffer);
656   RPCRT4_FreeHeader(resp_hdr);
657
658   return status;
659 }
660
661 /***********************************************************************
662  *           RPCRT4_Send (internal)
663  * 
664  * Transmit a packet over connection in acceptable fragments.
665  */
666 RPC_STATUS RPCRT4_Send(RpcConnection *Connection, RpcPktHdr *Header,
667                        void *Buffer, unsigned int BufferLength)
668 {
669   RPC_STATUS r;
670   SecBuffer out;
671
672   if (!Connection->AuthInfo || SecIsValidHandle(&Connection->ctx))
673   {
674     return RPCRT4_SendAuth(Connection, Header, Buffer, BufferLength, NULL, 0);
675   }
676
677   /* tack on a negotiate packet */
678   RPCRT4_ClientAuthorize(Connection, NULL, &out);
679   r = RPCRT4_SendAuth(Connection, Header, Buffer, BufferLength, out.pvBuffer, out.cbBuffer);
680   HeapFree(GetProcessHeap(), 0, out.pvBuffer);
681
682   return r;
683 }
684
685 /***********************************************************************
686  *           RPCRT4_Receive (internal)
687  * 
688  * Receive a packet from connection and merge the fragments.
689  */
690 RPC_STATUS RPCRT4_Receive(RpcConnection *Connection, RpcPktHdr **Header,
691                           PRPC_MESSAGE pMsg)
692 {
693   RPC_STATUS status;
694   DWORD hdr_length;
695   LONG dwRead;
696   unsigned short first_flag;
697   unsigned long data_length;
698   unsigned long buffer_length;
699   unsigned long auth_length;
700   unsigned char *auth_data = NULL;
701   RpcPktCommonHdr common_hdr;
702
703   *Header = NULL;
704
705   TRACE("(%p, %p, %p)\n", Connection, Header, pMsg);
706
707   RPCRT4_SetThreadCurrentConnection(Connection);
708
709   /* read packet common header */
710   dwRead = rpcrt4_conn_read(Connection, &common_hdr, sizeof(common_hdr));
711   if (dwRead != sizeof(common_hdr)) {
712     WARN("Short read of header, %d bytes\n", dwRead);
713     status = RPC_S_CALL_FAILED;
714     goto fail;
715   }
716
717   /* verify if the header really makes sense */
718   if (common_hdr.rpc_ver != RPC_VER_MAJOR ||
719       common_hdr.rpc_ver_minor != RPC_VER_MINOR) {
720     WARN("unhandled packet version\n");
721     status = RPC_S_PROTOCOL_ERROR;
722     goto fail;
723   }
724
725   hdr_length = RPCRT4_GetHeaderSize((RpcPktHdr*)&common_hdr);
726   if (hdr_length == 0) {
727     WARN("header length == 0\n");
728     status = RPC_S_PROTOCOL_ERROR;
729     goto fail;
730   }
731
732   *Header = HeapAlloc(GetProcessHeap(), 0, hdr_length);
733   memcpy(*Header, &common_hdr, sizeof(common_hdr));
734
735   /* read the rest of packet header */
736   dwRead = rpcrt4_conn_read(Connection, &(*Header)->common + 1, hdr_length - sizeof(common_hdr));
737   if (dwRead != hdr_length - sizeof(common_hdr)) {
738     WARN("bad header length, %d bytes, hdr_length %d\n", dwRead, hdr_length);
739     status = RPC_S_CALL_FAILED;
740     goto fail;
741   }
742
743   /* read packet body */
744   switch (common_hdr.ptype) {
745   case PKT_RESPONSE:
746     pMsg->BufferLength = (*Header)->response.alloc_hint;
747     break;
748   case PKT_REQUEST:
749     pMsg->BufferLength = (*Header)->request.alloc_hint;
750     break;
751   default:
752     pMsg->BufferLength = common_hdr.frag_len - hdr_length - RPC_AUTH_VERIFIER_LEN(&common_hdr);
753   }
754
755   TRACE("buffer length = %u\n", pMsg->BufferLength);
756
757   status = I_RpcGetBuffer(pMsg);
758   if (status != RPC_S_OK) goto fail;
759
760   first_flag = RPC_FLG_FIRST;
761   auth_length = common_hdr.auth_len;
762   if (auth_length) {
763     auth_data = HeapAlloc(GetProcessHeap(), 0, RPC_AUTH_VERIFIER_LEN(&common_hdr));
764     if (!auth_data) {
765       status = RPC_S_OUT_OF_RESOURCES;
766       goto fail;
767     }
768   }
769   buffer_length = 0;
770   while (TRUE)
771   {
772     unsigned int header_auth_len = RPC_AUTH_VERIFIER_LEN(&(*Header)->common);
773
774     /* verify header fields */
775
776     if (((*Header)->common.frag_len < hdr_length) ||
777         ((*Header)->common.frag_len - hdr_length < header_auth_len)) {
778       WARN("frag_len %d too small for hdr_length %d and auth_len %d\n",
779         (*Header)->common.frag_len, hdr_length, header_auth_len);
780       status = RPC_S_PROTOCOL_ERROR;
781       goto fail;
782     }
783
784     if ((*Header)->common.auth_len != auth_length) {
785       WARN("auth_len header field changed from %ld to %d\n",
786         auth_length, (*Header)->common.auth_len);
787       status = RPC_S_PROTOCOL_ERROR;
788       goto fail;
789     }
790
791     if (((*Header)->common.flags & RPC_FLG_FIRST) != first_flag) {
792       TRACE("invalid packet flags\n");
793       status = RPC_S_PROTOCOL_ERROR;
794       goto fail;
795     }
796
797     data_length = (*Header)->common.frag_len - hdr_length - header_auth_len;
798     if (data_length + buffer_length > pMsg->BufferLength) {
799       TRACE("allocation hint exceeded, new buffer length = %ld\n",
800         data_length + buffer_length);
801       pMsg->BufferLength = data_length + buffer_length;
802       status = I_RpcReAllocateBuffer(pMsg);
803       if (status != RPC_S_OK) goto fail;
804     }
805
806     if (data_length == 0) dwRead = 0; else
807     dwRead = rpcrt4_conn_read(Connection,
808         (unsigned char *)pMsg->Buffer + buffer_length, data_length);
809     if (dwRead != data_length) {
810       WARN("bad data length, %d/%ld\n", dwRead, data_length);
811       status = RPC_S_CALL_FAILED;
812       goto fail;
813     }
814
815     if (header_auth_len) {
816       if (header_auth_len < sizeof(RpcAuthVerifier)) {
817         WARN("bad auth verifier length %d\n", header_auth_len);
818         status = RPC_S_PROTOCOL_ERROR;
819         goto fail;
820       }
821
822       /* FIXME: we should accumulate authentication data for the bind,
823        * bind_ack, alter_context and alter_context_response if necessary.
824        * however, the details of how this is done is very sketchy in the
825        * DCE/RPC spec. for all other packet types that have authentication
826        * verifier data then it is just duplicated in all the fragments */
827       dwRead = rpcrt4_conn_read(Connection, auth_data, header_auth_len);
828       if (dwRead != header_auth_len) {
829         WARN("bad authentication data length, %d/%d\n", dwRead,
830           header_auth_len);
831         status = RPC_S_CALL_FAILED;
832         goto fail;
833       }
834
835       /* these packets are handled specially, not by the generic SecurePacket
836        * function */
837       if ((common_hdr.ptype != PKT_BIND) &&
838           (common_hdr.ptype != PKT_BIND_ACK) &&
839           (common_hdr.ptype != PKT_AUTH3))
840       {
841         status = RPCRT4_SecurePacket(Connection, SECURE_PACKET_RECEIVE,
842             *Header, hdr_length,
843             (unsigned char *)pMsg->Buffer + buffer_length, data_length,
844             (RpcAuthVerifier *)auth_data,
845             (unsigned char *)auth_data + sizeof(RpcAuthVerifier),
846             header_auth_len - sizeof(RpcAuthVerifier));
847         if (status != RPC_S_OK) goto fail;
848       }
849     }
850
851     buffer_length += data_length;
852     if (!((*Header)->common.flags & RPC_FLG_LAST)) {
853       TRACE("next header\n");
854
855       /* read the header of next packet */
856       dwRead = rpcrt4_conn_read(Connection, *Header, hdr_length);
857       if (dwRead != hdr_length) {
858         WARN("invalid packet header size (%d)\n", dwRead);
859         status = RPC_S_CALL_FAILED;
860         goto fail;
861       }
862
863       first_flag = 0;
864     } else {
865       break;
866     }
867   }
868   pMsg->BufferLength = buffer_length;
869
870   /* respond to authorization request */
871   if (common_hdr.ptype == PKT_BIND_ACK && auth_length > sizeof(RpcAuthVerifier))
872   {
873     status = RPCRT_AuthorizeConnection(Connection,
874                                        auth_data + sizeof(RpcAuthVerifier),
875                                        auth_length);
876     if (status)
877         goto fail;
878   }
879
880   /* success */
881   status = RPC_S_OK;
882
883 fail:
884   RPCRT4_SetThreadCurrentConnection(NULL);
885   if (status != RPC_S_OK) {
886     RPCRT4_FreeHeader(*Header);
887     *Header = NULL;
888   }
889   HeapFree(GetProcessHeap(), 0, auth_data);
890   return status;
891 }
892
893 /***********************************************************************
894  *           I_RpcGetBuffer [RPCRT4.@]
895  *
896  * Allocates a buffer for use by I_RpcSend or I_RpcSendReceive and binds to the
897  * server interface.
898  *
899  * PARAMS
900  *  pMsg [I/O] RPC message information.
901  *
902  * RETURNS
903  *  Success: RPC_S_OK.
904  *  Failure: RPC_S_INVALID_BINDING if pMsg->Handle is invalid.
905  *           RPC_S_SERVER_UNAVAILABLE if unable to connect to server.
906  *           ERROR_OUTOFMEMORY if buffer allocation failed.
907  *
908  * NOTES
909  *  The pMsg->BufferLength field determines the size of the buffer to allocate,
910  *  in bytes.
911  *
912  *  Use I_RpcFreeBuffer() to unbind from the server and free the message buffer.
913  *
914  * SEE ALSO
915  *  I_RpcFreeBuffer(), I_RpcSend(), I_RpcReceive(), I_RpcSendReceive().
916  */
917 RPC_STATUS WINAPI I_RpcGetBuffer(PRPC_MESSAGE pMsg)
918 {
919   TRACE("(%p): BufferLength=%d\n", pMsg, pMsg->BufferLength);
920   /* FIXME: pfnAllocate? */
921   pMsg->Buffer = HeapAlloc(GetProcessHeap(), 0, pMsg->BufferLength);
922
923   TRACE("Buffer=%p\n", pMsg->Buffer);
924   /* FIXME: which errors to return? */
925   return pMsg->Buffer ? S_OK : E_OUTOFMEMORY;
926 }
927
928 /***********************************************************************
929  *           I_RpcReAllocateBuffer (internal)
930  */
931 static RPC_STATUS I_RpcReAllocateBuffer(PRPC_MESSAGE pMsg)
932 {
933   TRACE("(%p): BufferLength=%d\n", pMsg, pMsg->BufferLength);
934   pMsg->Buffer = HeapReAlloc(GetProcessHeap(), 0, pMsg->Buffer, pMsg->BufferLength);
935
936   TRACE("Buffer=%p\n", pMsg->Buffer);
937   return pMsg->Buffer ? RPC_S_OK : RPC_S_OUT_OF_RESOURCES;
938 }
939
940 /***********************************************************************
941  *           I_RpcFreeBuffer [RPCRT4.@]
942  *
943  * Frees a buffer allocated by I_RpcGetBuffer or I_RpcReceive and unbinds from
944  * the server interface.
945  *
946  * PARAMS
947  *  pMsg [I/O] RPC message information.
948  *
949  * RETURNS
950  *  RPC_S_OK.
951  *
952  * SEE ALSO
953  *  I_RpcGetBuffer(), I_RpcReceive().
954  */
955 RPC_STATUS WINAPI I_RpcFreeBuffer(PRPC_MESSAGE pMsg)
956 {
957   TRACE("(%p) Buffer=%p\n", pMsg, pMsg->Buffer);
958   /* FIXME: pfnFree? */
959   HeapFree(GetProcessHeap(), 0, pMsg->Buffer);
960   pMsg->Buffer = NULL;
961   return S_OK;
962 }
963
964 /***********************************************************************
965  *           I_RpcSend [RPCRT4.@]
966  *
967  * Sends a message to the server.
968  *
969  * PARAMS
970  *  pMsg [I/O] RPC message information.
971  *
972  * RETURNS
973  *  Unknown.
974  *
975  * NOTES
976  *  The buffer must have been allocated with I_RpcGetBuffer().
977  *
978  * SEE ALSO
979  *  I_RpcGetBuffer(), I_RpcReceive(), I_RpcSendReceive().
980  */
981 RPC_STATUS WINAPI I_RpcSend(PRPC_MESSAGE pMsg)
982 {
983   RpcBinding* bind = (RpcBinding*)pMsg->Handle;
984   RpcConnection* conn;
985   RPC_CLIENT_INTERFACE* cif = NULL;
986   RPC_STATUS status;
987   RpcPktHdr *hdr;
988
989   TRACE("(%p)\n", pMsg);
990   if (!bind || bind->server) return RPC_S_INVALID_BINDING;
991
992   cif = pMsg->RpcInterfaceInformation;
993   if (!cif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
994
995   if (!bind->Endpoint || !bind->Endpoint[0])
996   {
997     TRACE("automatically resolving partially bound binding\n");
998     status = RpcEpResolveBinding(bind, cif);
999     if (status != RPC_S_OK) return status;
1000   }
1001
1002   status = RPCRT4_OpenBinding(bind, &conn, &cif->TransferSyntax,
1003                               &cif->InterfaceId);
1004   if (status != RPC_S_OK) return status;
1005
1006   hdr = RPCRT4_BuildRequestHeader(pMsg->DataRepresentation,
1007                                   pMsg->BufferLength, pMsg->ProcNum,
1008                                   &bind->ObjectUuid);
1009   if (!hdr)
1010   {
1011     RPCRT4_CloseBinding(bind, conn);
1012     return ERROR_OUTOFMEMORY;
1013   }
1014   hdr->common.call_id = conn->NextCallId++;
1015
1016   status = RPCRT4_Send(conn, hdr, pMsg->Buffer, pMsg->BufferLength);
1017
1018   RPCRT4_FreeHeader(hdr);
1019
1020   /* save the connection, so the response can be read from it */
1021   pMsg->ReservedForRuntime = conn;
1022   return status;
1023 }
1024
1025 /* is this status something that the server can't recover from? */
1026 static inline BOOL is_hard_error(RPC_STATUS status)
1027 {
1028     switch (status)
1029     {
1030     case 0: /* user-defined fault */
1031     case ERROR_ACCESS_DENIED:
1032     case ERROR_INVALID_PARAMETER:
1033     case RPC_S_PROTOCOL_ERROR:
1034     case RPC_S_CALL_FAILED:
1035     case RPC_S_CALL_FAILED_DNE:
1036     case RPC_S_SEC_PKG_ERROR:
1037         return TRUE;
1038     default:
1039         return FALSE;
1040     }
1041 }
1042
1043 /***********************************************************************
1044  *           I_RpcReceive [RPCRT4.@]
1045  */
1046 RPC_STATUS WINAPI I_RpcReceive(PRPC_MESSAGE pMsg)
1047 {
1048   RpcBinding* bind = (RpcBinding*)pMsg->Handle;
1049   RpcConnection* conn;
1050   RPC_CLIENT_INTERFACE* cif = NULL;
1051   RPC_SERVER_INTERFACE* sif = NULL;
1052   RPC_STATUS status;
1053   RpcPktHdr *hdr = NULL;
1054
1055   TRACE("(%p)\n", pMsg);
1056   if (!bind) return RPC_S_INVALID_BINDING;
1057
1058   if (pMsg->ReservedForRuntime) {
1059     conn = pMsg->ReservedForRuntime;
1060     pMsg->ReservedForRuntime = NULL;
1061   } else {
1062     if (bind->server) {
1063       sif = pMsg->RpcInterfaceInformation;
1064       if (!sif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
1065       status = RPCRT4_OpenBinding(bind, &conn, &sif->TransferSyntax,
1066                                   &sif->InterfaceId);
1067     } else {
1068       cif = pMsg->RpcInterfaceInformation;
1069       if (!cif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
1070
1071       if (!bind->Endpoint || !bind->Endpoint[0])
1072       {
1073         TRACE("automatically resolving partially bound binding\n");
1074         status = RpcEpResolveBinding(bind, cif);
1075         if (status != RPC_S_OK) return status;
1076       }
1077
1078       status = RPCRT4_OpenBinding(bind, &conn, &cif->TransferSyntax,
1079                                   &cif->InterfaceId);
1080     }
1081     if (status != RPC_S_OK) return status;
1082   }
1083
1084   status = RPCRT4_Receive(conn, &hdr, pMsg);
1085   if (status != RPC_S_OK) {
1086     WARN("receive failed with error %lx\n", status);
1087     goto fail;
1088   }
1089
1090   switch (hdr->common.ptype) {
1091   case PKT_RESPONSE:
1092     if (bind->server) {
1093         status = RPC_S_PROTOCOL_ERROR;
1094         goto fail;
1095     }
1096     break;
1097   case PKT_REQUEST:
1098     if (!bind->server) {
1099         status = RPC_S_PROTOCOL_ERROR;
1100         goto fail;
1101     }
1102     break;
1103   case PKT_FAULT:
1104     ERR ("we got fault packet with status 0x%lx\n", hdr->fault.status);
1105     status = NCA2RPC_STATUS(hdr->fault.status);
1106     if (is_hard_error(status))
1107         goto fail;
1108     break;
1109   default:
1110     WARN("bad packet type %d\n", hdr->common.ptype);
1111     status = RPC_S_PROTOCOL_ERROR;
1112     goto fail;
1113   }
1114
1115   /* success */
1116   RPCRT4_CloseBinding(bind, conn);
1117   RPCRT4_FreeHeader(hdr);
1118   return status;
1119
1120 fail:
1121   RPCRT4_FreeHeader(hdr);
1122   RPCRT4_DestroyConnection(conn);
1123   return status;
1124 }
1125
1126 /***********************************************************************
1127  *           I_RpcSendReceive [RPCRT4.@]
1128  *
1129  * Sends a message to the server and receives the response.
1130  *
1131  * PARAMS
1132  *  pMsg [I/O] RPC message information.
1133  *
1134  * RETURNS
1135  *  Success: RPC_S_OK.
1136  *  Failure: Any error code.
1137  *
1138  * NOTES
1139  *  The buffer must have been allocated with I_RpcGetBuffer().
1140  *
1141  * SEE ALSO
1142  *  I_RpcGetBuffer(), I_RpcSend(), I_RpcReceive().
1143  */
1144 RPC_STATUS WINAPI I_RpcSendReceive(PRPC_MESSAGE pMsg)
1145 {
1146   RPC_STATUS status;
1147   RPC_MESSAGE original_message;
1148
1149   TRACE("(%p)\n", pMsg);
1150
1151   original_message = *pMsg;
1152   status = I_RpcSend(pMsg);
1153   if (status == RPC_S_OK)
1154     status = I_RpcReceive(pMsg);
1155   /* free the buffer replaced by a new buffer in I_RpcReceive */
1156   if (status == RPC_S_OK)
1157     I_RpcFreeBuffer(&original_message);
1158   return status;
1159 }