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