4 * Copyright 2001-2002 Ove Kåven, TransGaming Technologies
5 * Copyright 2004 Filip Navara
6 * Copyright 2006 CodeWeavers
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.
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.
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
36 #include "wine/debug.h"
38 #include "rpc_binding.h"
41 #include "rpc_message.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(rpc);
45 /* note: the DCE/RPC spec says the alignment amount should be 4, but
46 * MS/RPC servers seem to always use 16 */
47 #define AUTH_ALIGNMENT 16
49 /* gets the amount needed to round a value up to the specified alignment */
50 #define ROUND_UP_AMOUNT(value, alignment) \
51 (((alignment) - (((value) % (alignment)))) % (alignment))
52 #define ROUND_UP(value, alignment) (((value) + ((alignment) - 1)) & ~((alignment)-1))
54 enum secure_packet_direction
60 static RPC_STATUS I_RpcReAllocateBuffer(PRPC_MESSAGE pMsg);
62 static DWORD RPCRT4_GetHeaderSize(const RpcPktHdr *Header)
64 static const DWORD header_sizes[] = {
65 sizeof(Header->request), 0, sizeof(Header->response),
66 sizeof(Header->fault), 0, 0, 0, 0, 0, 0, 0, sizeof(Header->bind),
67 sizeof(Header->bind_ack), sizeof(Header->bind_nack),
72 if (Header->common.ptype < sizeof(header_sizes) / sizeof(header_sizes[0])) {
73 ret = header_sizes[Header->common.ptype];
75 FIXME("unhandled packet type\n");
76 if (Header->common.flags & RPC_FLG_OBJECT_UUID)
79 TRACE("invalid packet type\n");
85 static int packet_has_body(const RpcPktHdr *Header)
87 return (Header->common.ptype == PKT_FAULT) ||
88 (Header->common.ptype == PKT_REQUEST) ||
89 (Header->common.ptype == PKT_RESPONSE);
92 static int packet_has_auth_verifier(const RpcPktHdr *Header)
94 return !(Header->common.ptype == PKT_BIND_NACK) &&
95 !(Header->common.ptype == PKT_SHUTDOWN);
98 static VOID RPCRT4_BuildCommonHeader(RpcPktHdr *Header, unsigned char PacketType,
99 unsigned long DataRepresentation)
101 Header->common.rpc_ver = RPC_VER_MAJOR;
102 Header->common.rpc_ver_minor = RPC_VER_MINOR;
103 Header->common.ptype = PacketType;
104 Header->common.drep[0] = LOBYTE(LOWORD(DataRepresentation));
105 Header->common.drep[1] = HIBYTE(LOWORD(DataRepresentation));
106 Header->common.drep[2] = LOBYTE(HIWORD(DataRepresentation));
107 Header->common.drep[3] = HIBYTE(HIWORD(DataRepresentation));
108 Header->common.auth_len = 0;
109 Header->common.call_id = 1;
110 Header->common.flags = 0;
111 /* Flags and fragment length are computed in RPCRT4_Send. */
114 static RpcPktHdr *RPCRT4_BuildRequestHeader(unsigned long DataRepresentation,
115 unsigned long BufferLength,
116 unsigned short ProcNum,
123 has_object = (ObjectUuid != NULL && !UuidIsNil(ObjectUuid, &status));
124 header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
125 sizeof(header->request) + (has_object ? sizeof(UUID) : 0));
126 if (header == NULL) {
130 RPCRT4_BuildCommonHeader(header, PKT_REQUEST, DataRepresentation);
131 header->common.frag_len = sizeof(header->request);
132 header->request.alloc_hint = BufferLength;
133 header->request.context_id = 0;
134 header->request.opnum = ProcNum;
136 header->common.flags |= RPC_FLG_OBJECT_UUID;
137 header->common.frag_len += sizeof(UUID);
138 memcpy(&header->request + 1, ObjectUuid, sizeof(UUID));
144 static RpcPktHdr *RPCRT4_BuildResponseHeader(unsigned long DataRepresentation,
145 unsigned long BufferLength)
149 header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->response));
150 if (header == NULL) {
154 RPCRT4_BuildCommonHeader(header, PKT_RESPONSE, DataRepresentation);
155 header->common.frag_len = sizeof(header->response);
156 header->response.alloc_hint = BufferLength;
161 RpcPktHdr *RPCRT4_BuildFaultHeader(unsigned long DataRepresentation,
166 header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->fault));
167 if (header == NULL) {
171 RPCRT4_BuildCommonHeader(header, PKT_FAULT, DataRepresentation);
172 header->common.frag_len = sizeof(header->fault);
173 header->fault.status = Status;
178 RpcPktHdr *RPCRT4_BuildBindHeader(unsigned long DataRepresentation,
179 unsigned short MaxTransmissionSize,
180 unsigned short MaxReceiveSize,
181 RPC_SYNTAX_IDENTIFIER *AbstractId,
182 RPC_SYNTAX_IDENTIFIER *TransferId)
186 header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->bind));
187 if (header == NULL) {
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.num_elements = 1;
196 header->bind.num_syntaxes = 1;
197 memcpy(&header->bind.abstract, AbstractId, sizeof(RPC_SYNTAX_IDENTIFIER));
198 memcpy(&header->bind.transfer, TransferId, sizeof(RPC_SYNTAX_IDENTIFIER));
203 static RpcPktHdr *RPCRT4_BuildAuthHeader(unsigned long DataRepresentation)
207 header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
208 sizeof(header->common) + 12);
212 RPCRT4_BuildCommonHeader(header, PKT_AUTH3, DataRepresentation);
213 header->common.frag_len = 0x14;
214 header->common.auth_len = 0;
219 RpcPktHdr *RPCRT4_BuildBindNackHeader(unsigned long DataRepresentation,
220 unsigned char RpcVersion,
221 unsigned char RpcVersionMinor)
225 header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->bind_nack));
226 if (header == NULL) {
230 RPCRT4_BuildCommonHeader(header, PKT_BIND_NACK, DataRepresentation);
231 header->common.frag_len = sizeof(header->bind_nack);
232 header->bind_nack.protocols_count = 1;
233 header->bind_nack.protocols[0].rpc_ver = RpcVersion;
234 header->bind_nack.protocols[0].rpc_ver_minor = RpcVersionMinor;
239 RpcPktHdr *RPCRT4_BuildBindAckHeader(unsigned long DataRepresentation,
240 unsigned short MaxTransmissionSize,
241 unsigned short MaxReceiveSize,
243 unsigned long Result,
244 unsigned long Reason,
245 RPC_SYNTAX_IDENTIFIER *TransferId)
248 unsigned long header_size;
249 RpcAddressString *server_address;
251 RPC_SYNTAX_IDENTIFIER *transfer_id;
253 header_size = sizeof(header->bind_ack) +
254 ROUND_UP(FIELD_OFFSET(RpcAddressString, string[strlen(ServerAddress) + 1]), 4) +
256 sizeof(RPC_SYNTAX_IDENTIFIER);
258 header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, header_size);
259 if (header == NULL) {
263 RPCRT4_BuildCommonHeader(header, PKT_BIND_ACK, DataRepresentation);
264 header->common.frag_len = header_size;
265 header->bind_ack.max_tsize = MaxTransmissionSize;
266 header->bind_ack.max_rsize = MaxReceiveSize;
267 server_address = (RpcAddressString*)(&header->bind_ack + 1);
268 server_address->length = strlen(ServerAddress) + 1;
269 strcpy(server_address->string, ServerAddress);
270 /* results is 4-byte aligned */
271 results = (RpcResults*)((ULONG_PTR)server_address + ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4));
272 results->num_results = 1;
273 results->results[0].result = Result;
274 results->results[0].reason = Reason;
275 transfer_id = (RPC_SYNTAX_IDENTIFIER*)(results + 1);
276 memcpy(transfer_id, TransferId, sizeof(RPC_SYNTAX_IDENTIFIER));
281 VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
283 HeapFree(GetProcessHeap(), 0, Header);
286 static RPC_STATUS RPCRT4_SecurePacket(RpcConnection *Connection,
287 enum secure_packet_direction dir,
288 RpcPktHdr *hdr, unsigned int hdr_size,
289 unsigned char *stub_data, unsigned int stub_data_size,
290 RpcAuthVerifier *auth_hdr,
291 unsigned char *auth_value, unsigned int auth_value_size)
293 SecBufferDesc message;
294 SecBuffer buffers[4];
295 SECURITY_STATUS sec_status;
297 message.ulVersion = SECBUFFER_VERSION;
298 message.cBuffers = sizeof(buffers)/sizeof(buffers[0]);
299 message.pBuffers = buffers;
301 buffers[0].cbBuffer = hdr_size;
302 buffers[0].BufferType = SECBUFFER_DATA|SECBUFFER_READONLY_WITH_CHECKSUM;
303 buffers[0].pvBuffer = hdr;
304 buffers[1].cbBuffer = stub_data_size;
305 buffers[1].BufferType = SECBUFFER_DATA;
306 buffers[1].pvBuffer = stub_data;
307 buffers[2].cbBuffer = sizeof(*auth_hdr);
308 buffers[2].BufferType = SECBUFFER_DATA|SECBUFFER_READONLY_WITH_CHECKSUM;
309 buffers[2].pvBuffer = auth_hdr;
310 buffers[3].cbBuffer = auth_value_size;
311 buffers[3].BufferType = SECBUFFER_TOKEN;
312 buffers[3].pvBuffer = auth_value;
314 if (dir == SECURE_PACKET_SEND)
316 if ((auth_hdr->auth_level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY) && packet_has_body(hdr))
318 sec_status = EncryptMessage(&Connection->ctx, 0, &message, 0 /* FIXME */);
319 if (sec_status != SEC_E_OK)
321 ERR("EncryptMessage failed with 0x%08x\n", sec_status);
322 return RPC_S_SEC_PKG_ERROR;
325 else if (auth_hdr->auth_level != RPC_C_AUTHN_LEVEL_NONE)
327 sec_status = MakeSignature(&Connection->ctx, 0, &message, 0 /* FIXME */);
328 if (sec_status != SEC_E_OK)
330 ERR("MakeSignature failed with 0x%08x\n", sec_status);
331 return RPC_S_SEC_PKG_ERROR;
335 else if (dir == SECURE_PACKET_RECEIVE)
337 if ((auth_hdr->auth_level == RPC_C_AUTHN_LEVEL_PKT_PRIVACY) && packet_has_body(hdr))
339 sec_status = DecryptMessage(&Connection->ctx, &message, 0 /* FIXME */, 0);
340 if (sec_status != SEC_E_OK)
342 ERR("EncryptMessage failed with 0x%08x\n", sec_status);
343 return RPC_S_SEC_PKG_ERROR;
346 else if (auth_hdr->auth_level != RPC_C_AUTHN_LEVEL_NONE)
348 sec_status = VerifySignature(&Connection->ctx, &message, 0 /* FIXME */, NULL);
349 if (sec_status != SEC_E_OK)
351 ERR("VerifySignature failed with 0x%08x\n", sec_status);
352 return RPC_S_SEC_PKG_ERROR;
360 /***********************************************************************
361 * RPCRT4_SendAuth (internal)
363 * Transmit a packet with authorization data over connection in acceptable fragments.
365 static RPC_STATUS RPCRT4_SendAuth(RpcConnection *Connection, RpcPktHdr *Header,
366 void *Buffer, unsigned int BufferLength,
367 void *Auth, unsigned int AuthLength)
377 /* The packet building functions save the packet header size, so we can use it. */
378 hdr_size = Header->common.frag_len;
380 Header->common.auth_len = AuthLength;
381 else if (Connection->AuthInfo && packet_has_auth_verifier(Header))
383 if ((Connection->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY) && packet_has_body(Header))
384 Header->common.auth_len = Connection->encryption_auth_len;
386 Header->common.auth_len = Connection->signature_auth_len;
389 Header->common.auth_len = 0;
390 Header->common.flags |= RPC_FLG_FIRST;
391 Header->common.flags &= ~RPC_FLG_LAST;
393 alen = RPC_AUTH_VERIFIER_LEN(&Header->common);
395 while (!(Header->common.flags & RPC_FLG_LAST)) {
396 unsigned char auth_pad_len = Header->common.auth_len ? ROUND_UP_AMOUNT(BufferLength, AUTH_ALIGNMENT) : 0;
397 unsigned int pkt_size = BufferLength + hdr_size + alen + auth_pad_len;
399 /* decide if we need to split the packet into fragments */
400 if (pkt_size <= Connection->MaxTransmissionSize) {
401 Header->common.flags |= RPC_FLG_LAST;
402 Header->common.frag_len = pkt_size;
405 /* make sure packet payload will be a multiple of 16 */
406 Header->common.frag_len =
407 ((Connection->MaxTransmissionSize - hdr_size - alen) & ~(AUTH_ALIGNMENT-1)) +
411 pkt = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, Header->common.frag_len);
413 memcpy(pkt, Header, hdr_size);
415 /* fragment consisted of header only and is the last one */
416 if (hdr_size == Header->common.frag_len)
419 memcpy(pkt + hdr_size, buffer_pos, Header->common.frag_len - hdr_size - auth_pad_len - alen);
421 /* add the authorization info */
422 if (Connection->AuthInfo && packet_has_auth_verifier(Header))
424 RpcAuthVerifier *auth_hdr = (RpcAuthVerifier *)&pkt[Header->common.frag_len - alen];
426 auth_hdr->auth_type = Connection->AuthInfo->AuthnSvc;
427 auth_hdr->auth_level = Connection->AuthInfo->AuthnLevel;
428 auth_hdr->auth_pad_length = auth_pad_len;
429 auth_hdr->auth_reserved = 0;
430 /* a unique number... */
431 auth_hdr->auth_context_id = (unsigned long)Connection;
434 memcpy(auth_hdr + 1, Auth, AuthLength);
437 status = RPCRT4_SecurePacket(Connection, SECURE_PACKET_SEND,
438 (RpcPktHdr *)pkt, hdr_size,
439 pkt + hdr_size, Header->common.frag_len - hdr_size - alen,
441 (unsigned char *)(auth_hdr + 1), Header->common.auth_len);
442 if (status != RPC_S_OK)
444 HeapFree(GetProcessHeap(), 0, pkt);
451 count = rpcrt4_conn_write(Connection, pkt, Header->common.frag_len);
452 HeapFree(GetProcessHeap(), 0, pkt);
454 WARN("rpcrt4_conn_write failed (auth)\n");
455 return RPC_S_PROTOCOL_ERROR;
458 buffer_pos += Header->common.frag_len - hdr_size - alen - auth_pad_len;
459 BufferLength -= Header->common.frag_len - hdr_size - alen - auth_pad_len;
460 Header->common.flags &= ~RPC_FLG_FIRST;
466 /***********************************************************************
467 * RPCRT4_ClientAuthorize (internal)
469 * Authorize a client connection. A NULL in param signifies a new connection.
471 static RPC_STATUS RPCRT4_ClientAuthorize(RpcConnection *conn, SecBuffer *in,
475 SecBufferDesc out_desc;
476 SecBufferDesc inp_desc;
477 SecPkgContext_Sizes secctx_sizes;
478 BOOL continue_needed;
479 ULONG context_req = ISC_REQ_CONNECTION | ISC_REQ_USE_DCE_STYLE |
480 ISC_REQ_MUTUAL_AUTH | ISC_REQ_DELEGATE;
482 if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_INTEGRITY)
483 context_req |= ISC_REQ_INTEGRITY;
484 else if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
485 context_req |= ISC_REQ_CONFIDENTIALITY | ISC_REQ_INTEGRITY;
487 out->BufferType = SECBUFFER_TOKEN;
488 out->cbBuffer = conn->AuthInfo->cbMaxToken;
489 out->pvBuffer = HeapAlloc(GetProcessHeap(), 0, out->cbBuffer);
490 if (!out->pvBuffer) return ERROR_OUTOFMEMORY;
492 out_desc.ulVersion = 0;
493 out_desc.cBuffers = 1;
494 out_desc.pBuffers = out;
496 inp_desc.cBuffers = 1;
497 inp_desc.pBuffers = in;
498 inp_desc.ulVersion = 0;
500 r = InitializeSecurityContextA(&conn->AuthInfo->cred, in ? &conn->ctx : NULL,
501 NULL, context_req, 0, SECURITY_NETWORK_DREP,
502 in ? &inp_desc : NULL, 0, &conn->ctx, &out_desc, &conn->attr,
506 WARN("InitializeSecurityContext failed with error 0x%08x\n", r);
510 TRACE("r = 0x%08x, attr = 0x%08x\n", r, conn->attr);
511 continue_needed = ((r == SEC_I_CONTINUE_NEEDED) ||
512 (r == SEC_I_COMPLETE_AND_CONTINUE));
514 if ((r == SEC_I_COMPLETE_NEEDED) || (r == SEC_I_COMPLETE_AND_CONTINUE))
516 TRACE("complete needed\n");
517 r = CompleteAuthToken(&conn->ctx, &out_desc);
520 WARN("CompleteAuthToken failed with error 0x%08x\n", r);
525 TRACE("cbBuffer = %ld\n", out->cbBuffer);
527 if (!continue_needed)
529 r = QueryContextAttributesA(&conn->ctx, SECPKG_ATTR_SIZES, &secctx_sizes);
532 WARN("QueryContextAttributes failed with error 0x%08x\n", r);
535 conn->signature_auth_len = secctx_sizes.cbMaxSignature;
536 conn->encryption_auth_len = secctx_sizes.cbSecurityTrailer;
542 HeapFree(GetProcessHeap(), 0, out->pvBuffer);
543 out->pvBuffer = NULL;
544 return ERROR_ACCESS_DENIED; /* FIXME: is this correct? */
547 /***********************************************************************
548 * RPCRT4_AuthorizeBinding (internal)
550 static RPC_STATUS RPCRT_AuthorizeConnection(RpcConnection* conn,
551 BYTE *challenge, ULONG count)
557 TRACE("challenge %s, %d bytes\n", challenge, count);
559 inp.BufferType = SECBUFFER_TOKEN;
560 inp.pvBuffer = challenge;
561 inp.cbBuffer = count;
563 status = RPCRT4_ClientAuthorize(conn, &inp, &out);
564 if (status) return status;
566 resp_hdr = RPCRT4_BuildAuthHeader(NDR_LOCAL_DATA_REPRESENTATION);
568 return E_OUTOFMEMORY;
570 status = RPCRT4_SendAuth(conn, resp_hdr, NULL, 0, out.pvBuffer, out.cbBuffer);
572 HeapFree(GetProcessHeap(), 0, out.pvBuffer);
573 RPCRT4_FreeHeader(resp_hdr);
578 /***********************************************************************
579 * RPCRT4_Send (internal)
581 * Transmit a packet over connection in acceptable fragments.
583 RPC_STATUS RPCRT4_Send(RpcConnection *Connection, RpcPktHdr *Header,
584 void *Buffer, unsigned int BufferLength)
589 if (!Connection->AuthInfo || SecIsValidHandle(&Connection->ctx))
591 return RPCRT4_SendAuth(Connection, Header, Buffer, BufferLength, NULL, 0);
594 /* tack on a negotiate packet */
595 RPCRT4_ClientAuthorize(Connection, NULL, &out);
596 r = RPCRT4_SendAuth(Connection, Header, Buffer, BufferLength, out.pvBuffer, out.cbBuffer);
597 HeapFree(GetProcessHeap(), 0, out.pvBuffer);
602 /***********************************************************************
603 * RPCRT4_Receive (internal)
605 * Receive a packet from connection and merge the fragments.
607 RPC_STATUS RPCRT4_Receive(RpcConnection *Connection, RpcPktHdr **Header,
613 unsigned short first_flag;
614 unsigned long data_length;
615 unsigned long buffer_length;
616 unsigned long auth_length;
617 unsigned char *auth_data = NULL;
618 RpcPktCommonHdr common_hdr;
622 TRACE("(%p, %p, %p)\n", Connection, Header, pMsg);
624 /* read packet common header */
625 dwRead = rpcrt4_conn_read(Connection, &common_hdr, sizeof(common_hdr));
626 if (dwRead != sizeof(common_hdr)) {
627 WARN("Short read of header, %d bytes\n", dwRead);
628 status = RPC_S_PROTOCOL_ERROR;
632 /* verify if the header really makes sense */
633 if (common_hdr.rpc_ver != RPC_VER_MAJOR ||
634 common_hdr.rpc_ver_minor != RPC_VER_MINOR) {
635 WARN("unhandled packet version\n");
636 status = RPC_S_PROTOCOL_ERROR;
640 hdr_length = RPCRT4_GetHeaderSize((RpcPktHdr*)&common_hdr);
641 if (hdr_length == 0) {
642 WARN("header length == 0\n");
643 status = RPC_S_PROTOCOL_ERROR;
647 *Header = HeapAlloc(GetProcessHeap(), 0, hdr_length);
648 memcpy(*Header, &common_hdr, sizeof(common_hdr));
650 /* read the rest of packet header */
651 dwRead = rpcrt4_conn_read(Connection, &(*Header)->common + 1, hdr_length - sizeof(common_hdr));
652 if (dwRead != hdr_length - sizeof(common_hdr)) {
653 WARN("bad header length, %d bytes, hdr_length %d\n", dwRead, hdr_length);
654 status = RPC_S_PROTOCOL_ERROR;
658 /* read packet body */
659 switch (common_hdr.ptype) {
661 pMsg->BufferLength = (*Header)->response.alloc_hint;
664 pMsg->BufferLength = (*Header)->request.alloc_hint;
667 pMsg->BufferLength = common_hdr.frag_len - hdr_length - RPC_AUTH_VERIFIER_LEN(&common_hdr);
670 TRACE("buffer length = %u\n", pMsg->BufferLength);
672 status = I_RpcGetBuffer(pMsg);
673 if (status != RPC_S_OK) goto fail;
675 first_flag = RPC_FLG_FIRST;
676 auth_length = common_hdr.auth_len;
678 auth_data = HeapAlloc(GetProcessHeap(), 0, RPC_AUTH_VERIFIER_LEN(&common_hdr));
680 status = RPC_S_PROTOCOL_ERROR;
687 unsigned int header_auth_len = RPC_AUTH_VERIFIER_LEN(&(*Header)->common);
689 /* verify header fields */
691 if (((*Header)->common.frag_len < hdr_length) ||
692 ((*Header)->common.frag_len - hdr_length < header_auth_len)) {
693 WARN("frag_len %d too small for hdr_length %d and auth_len %d\n",
694 (*Header)->common.frag_len, hdr_length, header_auth_len);
695 status = RPC_S_PROTOCOL_ERROR;
699 if ((*Header)->common.auth_len != auth_length) {
700 WARN("auth_len header field changed from %ld to %d\n",
701 auth_length, (*Header)->common.auth_len);
702 status = RPC_S_PROTOCOL_ERROR;
706 if (((*Header)->common.flags & RPC_FLG_FIRST) != first_flag) {
707 TRACE("invalid packet flags\n");
708 status = RPC_S_PROTOCOL_ERROR;
712 data_length = (*Header)->common.frag_len - hdr_length - header_auth_len;
713 if (data_length + buffer_length > pMsg->BufferLength) {
714 TRACE("allocation hint exceeded, new buffer length = %ld\n",
715 data_length + buffer_length);
716 pMsg->BufferLength = data_length + buffer_length;
717 status = I_RpcReAllocateBuffer(pMsg);
718 if (status != RPC_S_OK) goto fail;
721 if (data_length == 0) dwRead = 0; else
722 dwRead = rpcrt4_conn_read(Connection,
723 (unsigned char *)pMsg->Buffer + buffer_length, data_length);
724 if (dwRead != data_length) {
725 WARN("bad data length, %d/%ld\n", dwRead, data_length);
726 status = RPC_S_PROTOCOL_ERROR;
730 if (header_auth_len) {
731 if (header_auth_len < sizeof(RpcAuthVerifier)) {
732 WARN("bad auth verifier length %d\n", header_auth_len);
733 status = RPC_S_PROTOCOL_ERROR;
737 /* FIXME: we should accumulate authentication data for the bind,
738 * bind_ack, alter_context and alter_context_response if necessary.
739 * however, the details of how this is done is very sketchy in the
740 * DCE/RPC spec. for all other packet types that have authentication
741 * verifier data then it is just duplicated in all the fragments */
742 dwRead = rpcrt4_conn_read(Connection, auth_data, header_auth_len);
743 if (dwRead != header_auth_len) {
744 WARN("bad authentication data length, %d/%d\n", dwRead,
746 status = RPC_S_PROTOCOL_ERROR;
750 /* these packets are handled specially, not by the generic SecurePacket
752 if ((common_hdr.ptype != PKT_BIND) &&
753 (common_hdr.ptype != PKT_BIND_ACK) &&
754 (common_hdr.ptype != PKT_AUTH3))
755 status = RPCRT4_SecurePacket(Connection, SECURE_PACKET_RECEIVE,
757 (unsigned char *)pMsg->Buffer + buffer_length, data_length,
758 (RpcAuthVerifier *)auth_data,
759 (unsigned char *)auth_data + sizeof(RpcAuthVerifier),
760 header_auth_len - sizeof(RpcAuthVerifier));
763 buffer_length += data_length;
764 if (!((*Header)->common.flags & RPC_FLG_LAST)) {
765 TRACE("next header\n");
767 /* read the header of next packet */
768 dwRead = rpcrt4_conn_read(Connection, *Header, hdr_length);
769 if (dwRead != hdr_length) {
770 WARN("invalid packet header size (%d)\n", dwRead);
771 status = RPC_S_PROTOCOL_ERROR;
780 pMsg->BufferLength = buffer_length;
782 /* respond to authorization request */
783 if (common_hdr.ptype == PKT_BIND_ACK && auth_length > sizeof(RpcAuthVerifier))
785 status = RPCRT_AuthorizeConnection(Connection,
786 auth_data + sizeof(RpcAuthVerifier),
796 if (status != RPC_S_OK) {
797 RPCRT4_FreeHeader(*Header);
800 HeapFree(GetProcessHeap(), 0, auth_data);
804 /***********************************************************************
805 * I_RpcGetBuffer [RPCRT4.@]
807 * Allocates a buffer for use by I_RpcSend or I_RpcSendReceive and binds to the
811 * pMsg [I/O] RPC message information.
815 * Failure: RPC_S_INVALID_BINDING if pMsg->Handle is invalid.
816 * RPC_S_SERVER_UNAVAILABLE if unable to connect to server.
817 * ERROR_OUTOFMEMORY if buffer allocation failed.
820 * The pMsg->BufferLength field determines the size of the buffer to allocate,
823 * Use I_RpcFreeBuffer() to unbind from the server and free the message buffer.
826 * I_RpcFreeBuffer(), I_RpcSend(), I_RpcReceive(), I_RpcSendReceive().
828 RPC_STATUS WINAPI I_RpcGetBuffer(PRPC_MESSAGE pMsg)
830 TRACE("(%p): BufferLength=%d\n", pMsg, pMsg->BufferLength);
831 /* FIXME: pfnAllocate? */
832 pMsg->Buffer = HeapAlloc(GetProcessHeap(), 0, pMsg->BufferLength);
834 TRACE("Buffer=%p\n", pMsg->Buffer);
835 /* FIXME: which errors to return? */
836 return pMsg->Buffer ? S_OK : E_OUTOFMEMORY;
839 /***********************************************************************
840 * I_RpcReAllocateBuffer (internal)
842 static RPC_STATUS I_RpcReAllocateBuffer(PRPC_MESSAGE pMsg)
844 TRACE("(%p): BufferLength=%d\n", pMsg, pMsg->BufferLength);
845 pMsg->Buffer = HeapReAlloc(GetProcessHeap(), 0, pMsg->Buffer, pMsg->BufferLength);
847 TRACE("Buffer=%p\n", pMsg->Buffer);
848 return pMsg->Buffer ? RPC_S_OK : RPC_S_OUT_OF_RESOURCES;
851 /***********************************************************************
852 * I_RpcFreeBuffer [RPCRT4.@]
854 * Frees a buffer allocated by I_RpcGetBuffer or I_RpcReceive and unbinds from
855 * the server interface.
858 * pMsg [I/O] RPC message information.
864 * I_RpcGetBuffer(), I_RpcReceive().
866 RPC_STATUS WINAPI I_RpcFreeBuffer(PRPC_MESSAGE pMsg)
868 TRACE("(%p) Buffer=%p\n", pMsg, pMsg->Buffer);
869 /* FIXME: pfnFree? */
870 HeapFree(GetProcessHeap(), 0, pMsg->Buffer);
875 /***********************************************************************
876 * I_RpcSend [RPCRT4.@]
878 * Sends a message to the server.
881 * pMsg [I/O] RPC message information.
887 * The buffer must have been allocated with I_RpcGetBuffer().
890 * I_RpcGetBuffer(), I_RpcReceive(), I_RpcSendReceive().
892 RPC_STATUS WINAPI I_RpcSend(PRPC_MESSAGE pMsg)
894 RpcBinding* bind = (RpcBinding*)pMsg->Handle;
896 RPC_CLIENT_INTERFACE* cif = NULL;
897 RPC_SERVER_INTERFACE* sif = NULL;
901 TRACE("(%p)\n", pMsg);
902 if (!bind) return RPC_S_INVALID_BINDING;
905 sif = pMsg->RpcInterfaceInformation;
906 if (!sif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
907 status = RPCRT4_OpenBinding(bind, &conn, &sif->TransferSyntax,
910 cif = pMsg->RpcInterfaceInformation;
911 if (!cif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
913 if (!bind->Endpoint || !bind->Endpoint[0])
915 TRACE("automatically resolving partially bound binding\n");
916 status = RpcEpResolveBinding(bind, cif);
917 if (status != RPC_S_OK) return status;
920 status = RPCRT4_OpenBinding(bind, &conn, &cif->TransferSyntax,
924 if (status != RPC_S_OK) return status;
927 if (pMsg->RpcFlags & WINE_RPCFLAG_EXCEPTION) {
928 hdr = RPCRT4_BuildFaultHeader(pMsg->DataRepresentation,
931 hdr = RPCRT4_BuildResponseHeader(pMsg->DataRepresentation,
935 hdr = RPCRT4_BuildRequestHeader(pMsg->DataRepresentation,
936 pMsg->BufferLength, pMsg->ProcNum,
938 hdr->common.call_id = conn->NextCallId++;
941 status = RPCRT4_Send(conn, hdr, pMsg->Buffer, pMsg->BufferLength);
943 RPCRT4_FreeHeader(hdr);
947 /* save the connection, so the response can be read from it */
948 pMsg->ReservedForRuntime = conn;
951 RPCRT4_CloseBinding(bind, conn);
956 /***********************************************************************
957 * I_RpcReceive [RPCRT4.@]
959 RPC_STATUS WINAPI I_RpcReceive(PRPC_MESSAGE pMsg)
961 RpcBinding* bind = (RpcBinding*)pMsg->Handle;
963 RPC_CLIENT_INTERFACE* cif = NULL;
964 RPC_SERVER_INTERFACE* sif = NULL;
966 RpcPktHdr *hdr = NULL;
968 TRACE("(%p)\n", pMsg);
969 if (!bind) return RPC_S_INVALID_BINDING;
971 if (pMsg->ReservedForRuntime) {
972 conn = pMsg->ReservedForRuntime;
973 pMsg->ReservedForRuntime = NULL;
976 sif = pMsg->RpcInterfaceInformation;
977 if (!sif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
978 status = RPCRT4_OpenBinding(bind, &conn, &sif->TransferSyntax,
981 cif = pMsg->RpcInterfaceInformation;
982 if (!cif) return RPC_S_INTERFACE_NOT_FOUND; /* ? */
984 if (!bind->Endpoint || !bind->Endpoint[0])
986 TRACE("automatically resolving partially bound binding\n");
987 status = RpcEpResolveBinding(bind, cif);
988 if (status != RPC_S_OK) return status;
991 status = RPCRT4_OpenBinding(bind, &conn, &cif->TransferSyntax,
994 if (status != RPC_S_OK) return status;
997 status = RPCRT4_Receive(conn, &hdr, pMsg);
998 if (status != RPC_S_OK) {
999 WARN("receive failed with error %lx\n", status);
1003 status = RPC_S_PROTOCOL_ERROR;
1005 switch (hdr->common.ptype) {
1007 if (bind->server) goto fail;
1010 if (!bind->server) goto fail;
1013 pMsg->RpcFlags |= WINE_RPCFLAG_EXCEPTION;
1014 ERR ("we got fault packet with status 0x%lx\n", hdr->fault.status);
1015 status = hdr->fault.status; /* FIXME: do translation from nca error codes */
1018 WARN("bad packet type %d\n", hdr->common.ptype);
1026 RPCRT4_FreeHeader(hdr);
1027 RPCRT4_CloseBinding(bind, conn);
1031 /***********************************************************************
1032 * I_RpcSendReceive [RPCRT4.@]
1034 * Sends a message to the server and receives the response.
1037 * pMsg [I/O] RPC message information.
1040 * Success: RPC_S_OK.
1041 * Failure: Any error code.
1044 * The buffer must have been allocated with I_RpcGetBuffer().
1047 * I_RpcGetBuffer(), I_RpcSend(), I_RpcReceive().
1049 RPC_STATUS WINAPI I_RpcSendReceive(PRPC_MESSAGE pMsg)
1052 RPC_MESSAGE original_message;
1054 TRACE("(%p)\n", pMsg);
1056 original_message = *pMsg;
1057 status = I_RpcSend(pMsg);
1058 if (status == RPC_S_OK)
1059 status = I_RpcReceive(pMsg);
1060 /* free the buffer replaced by a new buffer in I_RpcReceive */
1061 if (status == RPC_S_OK)
1062 I_RpcFreeBuffer(&original_message);