Ensure that only parse_prs.c access internal members of the prs_struct.
[samba.git] / source3 / rpc_server / srv_pipe_hnd.c
1 /* 
2  *  Unix SMB/CIFS implementation.
3  *  RPC Pipe client / server routines
4  *  Copyright (C) Andrew Tridgell              1992-1998,
5  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
6  *  Copyright (C) Jeremy Allison                                    1999.
7  *  
8  *  This program is free software; you can redistribute it and/or modify
9  *  it under the terms of the GNU General Public License as published by
10  *  the Free Software Foundation; either version 2 of the License, or
11  *  (at your option) any later version.
12  *  
13  *  This program 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
16  *  GNU General Public License for more details.
17  *  
18  *  You should have received a copy of the GNU General Public License
19  *  along with this program; if not, write to the Free Software
20  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21  */
22
23 #include "includes.h"
24
25 #undef DBGC_CLASS
26 #define DBGC_CLASS DBGC_RPC_SRV
27
28 #define PIPE            "\\PIPE\\"
29 #define PIPELEN         strlen(PIPE)
30
31 static smb_np_struct *chain_p;
32 static int pipes_open;
33
34 /*
35  * Sometimes I can't decide if I hate Windows printer driver
36  * writers more than I hate the Windows spooler service driver
37  * writers. This gets around a combination of bugs in the spooler
38  * and the HP 8500 PCL driver that causes a spooler spin. JRA.
39  *
40  * bumped up from 20 -> 64 after viewing traffic from WordPerfect
41  * 2002 running on NT 4.- SP6
42  * bumped up from 64 -> 256 after viewing traffic from con2prt
43  * for lots of printers on a WinNT 4.x SP6 box.
44  */
45  
46 #ifndef MAX_OPEN_SPOOLSS_PIPES
47 #define MAX_OPEN_SPOOLSS_PIPES 256
48 #endif
49 static int current_spoolss_pipes_open;
50
51 static smb_np_struct *Pipes;
52 static pipes_struct *InternalPipes;
53 static struct bitmap *bmap;
54
55 /* TODO
56  * the following prototypes are declared here to avoid
57  * code being moved about too much for a patch to be
58  * disrupted / less obvious.
59  *
60  * these functions, and associated functions that they
61  * call, should be moved behind a .so module-loading
62  * system _anyway_.  so that's the next step...
63  */
64
65 static ssize_t read_from_internal_pipe(void *np_conn, char *data, size_t n,
66                 BOOL *is_data_outstanding);
67 static ssize_t write_to_internal_pipe(void *np_conn, char *data, size_t n);
68 static BOOL close_internal_rpc_pipe_hnd(void *np_conn);
69 static void *make_internal_rpc_pipe_p(char *pipe_name, 
70                               connection_struct *conn, uint16 vuid);
71
72 /****************************************************************************
73  Pipe iterator functions.
74 ****************************************************************************/
75
76 smb_np_struct *get_first_pipe(void)
77 {
78         return Pipes;
79 }
80
81 smb_np_struct *get_next_pipe(smb_np_struct *p)
82 {
83         return p->next;
84 }
85
86 /****************************************************************************
87  Internal Pipe iterator functions.
88 ****************************************************************************/
89
90 pipes_struct *get_first_internal_pipe(void)
91 {
92         return InternalPipes;
93 }
94
95 pipes_struct *get_next_internal_pipe(pipes_struct *p)
96 {
97         return p->next;
98 }
99
100 /* this must be larger than the sum of the open files and directories */
101 static int pipe_handle_offset;
102
103 /****************************************************************************
104  Set the pipe_handle_offset. Called from smbd/files.c
105 ****************************************************************************/
106
107 void set_pipe_handle_offset(int max_open_files)
108 {
109   if(max_open_files < 0x7000)
110     pipe_handle_offset = 0x7000;
111   else
112     pipe_handle_offset = max_open_files + 10; /* For safety. :-) */
113 }
114
115 /****************************************************************************
116  Reset pipe chain handle number.
117 ****************************************************************************/
118
119 void reset_chain_p(void)
120 {
121         chain_p = NULL;
122 }
123
124 /****************************************************************************
125  Initialise pipe handle states.
126 ****************************************************************************/
127
128 void init_rpc_pipe_hnd(void)
129 {
130         bmap = bitmap_allocate(MAX_OPEN_PIPES);
131         if (!bmap)
132                 exit_server("out of memory in init_rpc_pipe_hnd");
133 }
134
135 /****************************************************************************
136  Initialise an outgoing packet.
137 ****************************************************************************/
138
139 static BOOL pipe_init_outgoing_data(pipes_struct *p)
140 {
141         output_data *o_data = &p->out_data;
142
143         /* Reset the offset counters. */
144         o_data->data_sent_length = 0;
145         o_data->current_pdu_len = 0;
146         o_data->current_pdu_sent = 0;
147
148         memset(o_data->current_pdu, '\0', sizeof(o_data->current_pdu));
149
150         /* Free any memory in the current return data buffer. */
151         prs_mem_free(&o_data->rdata);
152
153         /*
154          * Initialize the outgoing RPC data buffer.
155          * we will use this as the raw data area for replying to rpc requests.
156          */     
157         if(!prs_init(&o_data->rdata, MAX_PDU_FRAG_LEN, p->mem_ctx, MARSHALL)) {
158                 DEBUG(0,("pipe_init_outgoing_data: malloc fail.\n"));
159                 return False;
160         }
161
162         return True;
163 }
164
165 /****************************************************************************
166  Find first available pipe slot.
167 ****************************************************************************/
168
169 smb_np_struct *open_rpc_pipe_p(char *pipe_name, 
170                               connection_struct *conn, uint16 vuid)
171 {
172         int i;
173         smb_np_struct *p, *p_it;
174         static int next_pipe;
175         BOOL is_spoolss_pipe = False;
176
177         DEBUG(4,("Open pipe requested %s (pipes_open=%d)\n",
178                  pipe_name, pipes_open));
179
180         if (strstr(pipe_name, "spoolss"))
181                 is_spoolss_pipe = True;
182  
183         if (is_spoolss_pipe && current_spoolss_pipes_open >= MAX_OPEN_SPOOLSS_PIPES) {
184                 DEBUG(10,("open_rpc_pipe_p: spooler bug workaround. Denying open on pipe %s\n",
185                         pipe_name ));
186                 return NULL;
187         }
188
189         /* not repeating pipe numbers makes it easier to track things in 
190            log files and prevents client bugs where pipe numbers are reused
191            over connection restarts */
192         if (next_pipe == 0)
193                 next_pipe = (sys_getpid() ^ time(NULL)) % MAX_OPEN_PIPES;
194
195         i = bitmap_find(bmap, next_pipe);
196
197         if (i == -1) {
198                 DEBUG(0,("ERROR! Out of pipe structures\n"));
199                 return NULL;
200         }
201
202         next_pipe = (i+1) % MAX_OPEN_PIPES;
203
204         for (p = Pipes; p; p = p->next)
205                 DEBUG(5,("open_rpc_pipe_p: name %s pnum=%x\n", p->name, p->pnum));  
206
207         p = (smb_np_struct *)malloc(sizeof(*p));
208
209         if (!p) {
210                 DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
211                 return NULL;
212         }
213
214         ZERO_STRUCTP(p);
215
216         /* add a dso mechanism instead of this, here */
217
218         p->namedpipe_create = make_internal_rpc_pipe_p;
219         p->namedpipe_read = read_from_internal_pipe;
220         p->namedpipe_write = write_to_internal_pipe;
221         p->namedpipe_close = close_internal_rpc_pipe_hnd;
222
223         p->np_state = p->namedpipe_create(pipe_name, conn, vuid);
224
225         if (p->np_state == NULL) {
226                 DEBUG(0,("open_rpc_pipe_p: make_internal_rpc_pipe_p failed.\n"));
227                 SAFE_FREE(p);
228                 return NULL;
229         }
230
231         DLIST_ADD(Pipes, p);
232
233         /*
234          * Initialize the incoming RPC data buffer with one PDU worth of memory.
235          * We cheat here and say we're marshalling, as we intend to add incoming
236          * data directly into the prs_struct and we want it to auto grow. We will
237          * change the type to UNMARSALLING before processing the stream.
238          */
239
240         bitmap_set(bmap, i);
241         i += pipe_handle_offset;
242
243         pipes_open++;
244
245         p->pnum = i;
246
247         p->open = True;
248         p->device_state = 0;
249         p->priority = 0;
250         p->conn = conn;
251         p->vuid  = vuid;
252
253         p->max_trans_reply = 0;
254         
255         fstrcpy(p->name, pipe_name);
256         
257         DEBUG(4,("Opened pipe %s with handle %x (pipes_open=%d)\n",
258                  pipe_name, i, pipes_open));
259         
260         chain_p = p;
261         
262         /* Iterate over p_it as a temp variable, to display all open pipes */ 
263         for (p_it = Pipes; p_it; p_it = p_it->next)
264                 DEBUG(5,("open pipes: name %s pnum=%x\n", p_it->name, p_it->pnum));  
265
266         return chain_p;
267 }
268
269 /****************************************************************************
270  Make an internal namedpipes structure
271 ****************************************************************************/
272
273 static void *make_internal_rpc_pipe_p(char *pipe_name, 
274                               connection_struct *conn, uint16 vuid)
275 {
276         pipes_struct *p;
277         user_struct *vuser = get_valid_user_struct(vuid);
278
279         DEBUG(4,("Create pipe requested %s\n", pipe_name));
280
281         if (!vuser && vuid != UID_FIELD_INVALID) {
282                 DEBUG(0,("ERROR! vuid %d did not map to a valid vuser struct!\n", vuid));
283                 return NULL;
284         }
285
286         p = (pipes_struct *)malloc(sizeof(*p));
287
288         if (!p)
289         {
290                 DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
291                 return NULL;
292         }
293
294         ZERO_STRUCTP(p);
295
296         if ((p->mem_ctx = talloc_init("pipe %s %p", pipe_name, p)) == NULL) {
297                 DEBUG(0,("open_rpc_pipe_p: talloc_init failed.\n"));
298                 SAFE_FREE(p);
299                 return NULL;
300         }
301
302         if (!init_pipe_handle_list(p, pipe_name)) {
303                 DEBUG(0,("open_rpc_pipe_p: init_pipe_handles failed.\n"));
304                 talloc_destroy(p->mem_ctx);
305                 SAFE_FREE(p);
306                 return NULL;
307         }
308
309         /*
310          * Initialize the incoming RPC data buffer with one PDU worth of memory.
311          * We cheat here and say we're marshalling, as we intend to add incoming
312          * data directly into the prs_struct and we want it to auto grow. We will
313          * change the type to UNMARSALLING before processing the stream.
314          */
315
316         if(!prs_init(&p->in_data.data, MAX_PDU_FRAG_LEN, p->mem_ctx, MARSHALL)) {
317                 DEBUG(0,("open_rpc_pipe_p: malloc fail for in_data struct.\n"));
318                 return NULL;
319         }
320
321         DLIST_ADD(InternalPipes, p);
322
323         p->conn = conn;
324
325         /* Ensure the connection isn't idled whilst this pipe is open. */
326         p->conn->num_files_open++;
327
328         p->vuid  = vuid;
329
330         p->ntlmssp_chal_flags = 0;
331         p->ntlmssp_auth_validated = False;
332         p->ntlmssp_auth_requested = False;
333
334         p->pipe_bound = False;
335         p->fault_state = False;
336         p->endian = RPC_LITTLE_ENDIAN;
337
338         ZERO_STRUCT(p->pipe_user);
339
340         p->pipe_user.uid = (uid_t)-1;
341         p->pipe_user.gid = (gid_t)-1;
342         
343         /* Store the session key and NT_TOKEN */
344         if (vuser) {
345                 memcpy(p->session_key, vuser->session_key, sizeof(p->session_key));
346                 p->pipe_user.nt_user_token = dup_nt_token(vuser->nt_user_token);
347         }
348
349         /*
350          * Initialize the incoming RPC struct.
351          */
352
353         p->in_data.pdu_needed_len = 0;
354         p->in_data.pdu_received_len = 0;
355
356         /*
357          * Initialize the outgoing RPC struct.
358          */
359
360         p->out_data.current_pdu_len = 0;
361         p->out_data.current_pdu_sent = 0;
362         p->out_data.data_sent_length = 0;
363
364         /*
365          * Initialize the outgoing RPC data buffer with no memory.
366          */     
367         prs_init(&p->out_data.rdata, 0, p->mem_ctx, MARSHALL);
368         
369         fstrcpy(p->name, pipe_name);
370         
371         DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
372                  pipe_name, pipes_open));
373
374         return (void*)p;
375 }
376
377 /****************************************************************************
378  Sets the fault state on incoming packets.
379 ****************************************************************************/
380
381 static void set_incoming_fault(pipes_struct *p)
382 {
383         prs_mem_free(&p->in_data.data);
384         p->in_data.pdu_needed_len = 0;
385         p->in_data.pdu_received_len = 0;
386         p->fault_state = True;
387         DEBUG(10,("set_incoming_fault: Setting fault state on pipe %s : vuid = 0x%x\n",
388                 p->name, p->vuid ));
389 }
390
391 /****************************************************************************
392  Ensures we have at least RPC_HEADER_LEN amount of data in the incoming buffer.
393 ****************************************************************************/
394
395 static ssize_t fill_rpc_header(pipes_struct *p, char *data, size_t data_to_copy)
396 {
397         size_t len_needed_to_complete_hdr = MIN(data_to_copy, RPC_HEADER_LEN - p->in_data.pdu_received_len);
398
399         DEBUG(10,("fill_rpc_header: data_to_copy = %u, len_needed_to_complete_hdr = %u, receive_len = %u\n",
400                         (unsigned int)data_to_copy, (unsigned int)len_needed_to_complete_hdr,
401                         (unsigned int)p->in_data.pdu_received_len ));
402
403         memcpy((char *)&p->in_data.current_in_pdu[p->in_data.pdu_received_len], data, len_needed_to_complete_hdr);
404         p->in_data.pdu_received_len += len_needed_to_complete_hdr;
405
406         return (ssize_t)len_needed_to_complete_hdr;
407 }
408
409 /****************************************************************************
410  Unmarshalls a new PDU header. Assumes the raw header data is in current_in_pdu.
411 ****************************************************************************/
412
413 static ssize_t unmarshall_rpc_header(pipes_struct *p)
414 {
415         /*
416          * Unmarshall the header to determine the needed length.
417          */
418
419         prs_struct rpc_in;
420
421         if(p->in_data.pdu_received_len != RPC_HEADER_LEN) {
422                 DEBUG(0,("unmarshall_rpc_header: assert on rpc header length failed.\n"));
423                 set_incoming_fault(p);
424                 return -1;
425         }
426
427         prs_init( &rpc_in, 0, p->mem_ctx, UNMARSHALL);
428         prs_set_endian_data( &rpc_in, p->endian);
429
430         prs_give_memory( &rpc_in, (char *)&p->in_data.current_in_pdu[0],
431                                         p->in_data.pdu_received_len, False);
432
433         /*
434          * Unmarshall the header as this will tell us how much
435          * data we need to read to get the complete pdu.
436          * This also sets the endian flag in rpc_in.
437          */
438
439         if(!smb_io_rpc_hdr("", &p->hdr, &rpc_in, 0)) {
440                 DEBUG(0,("unmarshall_rpc_header: failed to unmarshall RPC_HDR.\n"));
441                 set_incoming_fault(p);
442                 prs_mem_free(&rpc_in);
443                 return -1;
444         }
445
446         /*
447          * Validate the RPC header.
448          */
449
450         if(p->hdr.major != 5 && p->hdr.minor != 0) {
451                 DEBUG(0,("unmarshall_rpc_header: invalid major/minor numbers in RPC_HDR.\n"));
452                 set_incoming_fault(p);
453                 prs_mem_free(&rpc_in);
454                 return -1;
455         }
456
457         /*
458          * If there's not data in the incoming buffer this should be the start of a new RPC.
459          */
460
461         if(prs_offset(&p->in_data.data) == 0) {
462
463                 /*
464                  * AS/U doesn't set FIRST flag in a BIND packet it seems.
465                  */
466
467                 if ((p->hdr.pkt_type == RPC_REQUEST) && !(p->hdr.flags & RPC_FLG_FIRST)) {
468                         /*
469                          * Ensure that the FIRST flag is set. If not then we have
470                          * a stream missmatch.
471                          */
472
473                         DEBUG(0,("unmarshall_rpc_header: FIRST flag not set in first PDU !\n"));
474                         set_incoming_fault(p);
475                         prs_mem_free(&rpc_in);
476                         return -1;
477                 }
478
479                 /*
480                  * If this is the first PDU then set the endianness
481                  * flag in the pipe. We will need this when parsing all
482                  * data in this RPC.
483                  */
484
485                 p->endian = rpc_in.bigendian_data;
486
487                 DEBUG(5,("unmarshall_rpc_header: using %sendian RPC\n",
488                                 p->endian == RPC_LITTLE_ENDIAN ? "little-" : "big-" ));
489
490         } else {
491
492                 /*
493                  * If this is *NOT* the first PDU then check the endianness
494                  * flag in the pipe is the same as that in the PDU.
495                  */
496
497                 if (p->endian != rpc_in.bigendian_data) {
498                         DEBUG(0,("unmarshall_rpc_header: FIRST endianness flag (%d) different in next PDU !\n", (int)p->endian));
499                         set_incoming_fault(p);
500                         prs_mem_free(&rpc_in);
501                         return -1;
502                 }
503         }
504
505         /*
506          * Ensure that the pdu length is sane.
507          */
508
509         if((p->hdr.frag_len < RPC_HEADER_LEN) || (p->hdr.frag_len > MAX_PDU_FRAG_LEN)) {
510                 DEBUG(0,("unmarshall_rpc_header: assert on frag length failed.\n"));
511                 set_incoming_fault(p);
512                 prs_mem_free(&rpc_in);
513                 return -1;
514         }
515
516         DEBUG(10,("unmarshall_rpc_header: type = %u, flags = %u\n", (unsigned int)p->hdr.pkt_type,
517                         (unsigned int)p->hdr.flags ));
518
519         /*
520          * Adjust for the header we just ate.
521          */
522         p->in_data.pdu_received_len = 0;
523         p->in_data.pdu_needed_len = (uint32)p->hdr.frag_len - RPC_HEADER_LEN;
524
525         /*
526          * Null the data we just ate.
527          */
528
529         memset((char *)&p->in_data.current_in_pdu[0], '\0', RPC_HEADER_LEN);
530
531         prs_mem_free(&rpc_in);
532
533         return 0; /* No extra data processed. */
534 }
535
536 /****************************************************************************
537  Call this to free any talloc'ed memory. Do this before and after processing
538  a complete PDU.
539 ****************************************************************************/
540
541 void free_pipe_context(pipes_struct *p)
542 {
543         if (p->mem_ctx) {
544                 DEBUG(3,("free_pipe_context: destroying talloc pool of size %u\n", talloc_pool_size(p->mem_ctx) ));
545                 talloc_destroy_pool(p->mem_ctx);
546         } else {
547                 p->mem_ctx = talloc_init("pipe %s %p", p->name, p);
548                 if (p->mem_ctx == NULL)
549                         p->fault_state = True;
550         }
551 }
552
553 /****************************************************************************
554  Processes a request pdu. This will do auth processing if needed, and
555  appends the data into the complete stream if the LAST flag is not set.
556 ****************************************************************************/
557
558 static BOOL process_request_pdu(pipes_struct *p, prs_struct *rpc_in_p)
559 {
560         BOOL auth_verify = ((p->ntlmssp_chal_flags & NTLMSSP_NEGOTIATE_SIGN) != 0);
561         size_t data_len = p->hdr.frag_len - RPC_HEADER_LEN - RPC_HDR_REQ_LEN -
562                                 (auth_verify ? RPC_HDR_AUTH_LEN : 0) - p->hdr.auth_len;
563
564         if(!p->pipe_bound) {
565                 DEBUG(0,("process_request_pdu: rpc request with no bind.\n"));
566                 set_incoming_fault(p);
567                 return False;
568         }
569
570         /*
571          * Check if we need to do authentication processing.
572          * This is only done on requests, not binds.
573          */
574
575         /*
576          * Read the RPC request header.
577          */
578
579         if(!smb_io_rpc_hdr_req("req", &p->hdr_req, rpc_in_p, 0)) {
580                 DEBUG(0,("process_request_pdu: failed to unmarshall RPC_HDR_REQ.\n"));
581                 set_incoming_fault(p);
582                 return False;
583         }
584
585         if(p->ntlmssp_auth_validated && !api_pipe_auth_process(p, rpc_in_p)) {
586                 DEBUG(0,("process_request_pdu: failed to do auth processing.\n"));
587                 set_incoming_fault(p);
588                 return False;
589         }
590
591         if (p->ntlmssp_auth_requested && !p->ntlmssp_auth_validated) {
592
593                 /*
594                  * Authentication _was_ requested and it already failed.
595                  */
596
597                 DEBUG(0,("process_request_pdu: RPC request received on pipe %s where \
598 authentication failed. Denying the request.\n", p->name));
599                 set_incoming_fault(p);
600         return False;
601     }
602
603         /*
604          * Check the data length doesn't go over the 15Mb limit.
605          * increased after observing a bug in the Windows NT 4.0 SP6a
606          * spoolsv.exe when the response to a GETPRINTERDRIVER2 RPC
607          * will not fit in the initial buffer of size 0x1068   --jerry 22/01/2002
608          */
609         
610         if(prs_offset(&p->in_data.data) + data_len > 15*1024*1024) {
611                 DEBUG(0,("process_request_pdu: rpc data buffer too large (%u) + (%u)\n",
612                                 (unsigned int)prs_data_size(&p->in_data.data), (unsigned int)data_len ));
613                 set_incoming_fault(p);
614                 return False;
615         }
616
617         /*
618          * Append the data portion into the buffer and return.
619          */
620
621         if(!prs_append_some_prs_data(&p->in_data.data, rpc_in_p, prs_offset(rpc_in_p), data_len)) {
622                 DEBUG(0,("process_request_pdu: Unable to append data size %u to parse buffer of size %u.\n",
623                                 (unsigned int)data_len, (unsigned int)prs_data_size(&p->in_data.data) ));
624                 set_incoming_fault(p);
625                 return False;
626         }
627
628         if(p->hdr.flags & RPC_FLG_LAST) {
629                 BOOL ret = False;
630                 /*
631                  * Ok - we finally have a complete RPC stream.
632                  * Call the rpc command to process it.
633                  */
634
635                 /*
636                  * Ensure the internal prs buffer size is *exactly* the same
637                  * size as the current offset.
638                  */
639
640                 if(!prs_set_buffer_size(&p->in_data.data, prs_offset(&p->in_data.data)))
641                 {
642                         DEBUG(0,("process_request_pdu: Call to prs_set_buffer_size failed!\n"));
643                         set_incoming_fault(p);
644                         return False;
645                 }
646
647                 /*
648                  * Set the parse offset to the start of the data and set the
649                  * prs_struct to UNMARSHALL.
650                  */
651
652                 prs_set_offset(&p->in_data.data, 0);
653                 prs_switch_type(&p->in_data.data, UNMARSHALL);
654
655                 /*
656                  * Process the complete data stream here.
657                  */
658
659                 free_pipe_context(p);
660
661                 if(pipe_init_outgoing_data(p))
662                         ret = api_pipe_request(p);
663
664                 free_pipe_context(p);
665
666                 /*
667                  * We have consumed the whole data stream. Set back to
668                  * marshalling and set the offset back to the start of
669                  * the buffer to re-use it (we could also do a prs_mem_free()
670                  * and then re_init on the next start of PDU. Not sure which
671                  * is best here.... JRA.
672                  */
673
674                 prs_switch_type(&p->in_data.data, MARSHALL);
675                 prs_set_offset(&p->in_data.data, 0);
676                 return ret;
677         }
678
679         return True;
680 }
681
682 /****************************************************************************
683  Processes a finished PDU stored in current_in_pdu. The RPC_HEADER has
684  already been parsed and stored in p->hdr.
685 ****************************************************************************/
686
687 static ssize_t process_complete_pdu(pipes_struct *p)
688 {
689         prs_struct rpc_in;
690         size_t data_len = p->in_data.pdu_received_len;
691         char *data_p = (char *)&p->in_data.current_in_pdu[0];
692         BOOL reply = False;
693
694         if(p->fault_state) {
695                 DEBUG(10,("process_complete_pdu: pipe %s in fault state.\n",
696                         p->name ));
697                 set_incoming_fault(p);
698                 setup_fault_pdu(p, NT_STATUS(0x1c010002));
699                 return (ssize_t)data_len;
700         }
701
702         prs_init( &rpc_in, 0, p->mem_ctx, UNMARSHALL);
703
704         /*
705          * Ensure we're using the corrent endianness for both the 
706          * RPC header flags and the raw data we will be reading from.
707          */
708
709         prs_set_endian_data( &rpc_in, p->endian);
710         prs_set_endian_data( &p->in_data.data, p->endian);
711
712         prs_give_memory( &rpc_in, data_p, (uint32)data_len, False);
713
714         DEBUG(10,("process_complete_pdu: processing packet type %u\n",
715                         (unsigned int)p->hdr.pkt_type ));
716
717         switch (p->hdr.pkt_type) {
718                 case RPC_BIND:
719                 case RPC_ALTCONT:
720                         /*
721                          * We assume that a pipe bind is only in one pdu.
722                          */
723                         if(pipe_init_outgoing_data(p))
724                                 reply = api_pipe_bind_req(p, &rpc_in);
725                         break;
726                 case RPC_BINDRESP:
727                         /*
728                          * We assume that a pipe bind_resp is only in one pdu.
729                          */
730                         if(pipe_init_outgoing_data(p))
731                                 reply = api_pipe_bind_auth_resp(p, &rpc_in);
732                         break;
733                 case RPC_REQUEST:
734                         reply = process_request_pdu(p, &rpc_in);
735                         break;
736                 default:
737                         DEBUG(0,("process_complete_pdu: Unknown rpc type = %u received.\n", (unsigned int)p->hdr.pkt_type ));
738                         break;
739         }
740
741         /* Reset to little endian. Probably don't need this but it won't hurt. */
742         prs_set_endian_data( &p->in_data.data, RPC_LITTLE_ENDIAN);
743
744         if (!reply) {
745                 DEBUG(3,("process_complete_pdu: DCE/RPC fault sent on pipe %s\n", p->pipe_srv_name));
746                 set_incoming_fault(p);
747                 setup_fault_pdu(p, NT_STATUS(0x1c010002));
748                 prs_mem_free(&rpc_in);
749         } else {
750                 /*
751                  * Reset the lengths. We're ready for a new pdu.
752                  */
753                 p->in_data.pdu_needed_len = 0;
754                 p->in_data.pdu_received_len = 0;
755         }
756
757         prs_mem_free(&rpc_in);
758         return (ssize_t)data_len;
759 }
760
761 /****************************************************************************
762  Accepts incoming data on an rpc pipe. Processes the data in pdu sized units.
763 ****************************************************************************/
764
765 static ssize_t process_incoming_data(pipes_struct *p, char *data, size_t n)
766 {
767         size_t data_to_copy = MIN(n, MAX_PDU_FRAG_LEN - p->in_data.pdu_received_len);
768
769         DEBUG(10,("process_incoming_data: Start: pdu_received_len = %u, pdu_needed_len = %u, incoming data = %u\n",
770                 (unsigned int)p->in_data.pdu_received_len, (unsigned int)p->in_data.pdu_needed_len,
771                 (unsigned int)n ));
772
773         if(data_to_copy == 0) {
774                 /*
775                  * This is an error - data is being received and there is no
776                  * space in the PDU. Free the received data and go into the fault state.
777                  */
778                 DEBUG(0,("process_incoming_data: No space in incoming pdu buffer. Current size = %u \
779 incoming data size = %u\n", (unsigned int)p->in_data.pdu_received_len, (unsigned int)n ));
780                 set_incoming_fault(p);
781                 return -1;
782         }
783
784         /*
785          * If we have no data already, wait until we get at least a RPC_HEADER_LEN
786          * number of bytes before we can do anything.
787          */
788
789         if((p->in_data.pdu_needed_len == 0) && (p->in_data.pdu_received_len < RPC_HEADER_LEN)) {
790                 /*
791                  * Always return here. If we have more data then the RPC_HEADER
792                  * will be processed the next time around the loop.
793                  */
794                 return fill_rpc_header(p, data, data_to_copy);
795         }
796
797         /*
798          * At this point we know we have at least an RPC_HEADER_LEN amount of data
799          * stored in current_in_pdu.
800          */
801
802         /*
803          * If pdu_needed_len is zero this is a new pdu. 
804          * Unmarshall the header so we know how much more
805          * data we need, then loop again.
806          */
807
808         if(p->in_data.pdu_needed_len == 0)
809                 return unmarshall_rpc_header(p);
810
811         /*
812          * Ok - at this point we have a valid RPC_HEADER in p->hdr.
813          * Keep reading until we have a full pdu.
814          */
815
816         data_to_copy = MIN(data_to_copy, p->in_data.pdu_needed_len);
817
818         /*
819          * Copy as much of the data as we need into the current_in_pdu buffer.
820          */
821
822         memcpy( (char *)&p->in_data.current_in_pdu[p->in_data.pdu_received_len], data, data_to_copy);
823         p->in_data.pdu_received_len += data_to_copy;
824
825         /*
826          * Do we have a complete PDU ?
827          */
828
829         if(p->in_data.pdu_received_len == p->in_data.pdu_needed_len)
830                 return process_complete_pdu(p);
831
832         DEBUG(10,("process_incoming_data: not a complete PDU yet. pdu_received_len = %u, pdu_needed_len = %u\n",
833                 (unsigned int)p->in_data.pdu_received_len, (unsigned int)p->in_data.pdu_needed_len ));
834
835         return (ssize_t)data_to_copy;
836
837 }
838
839 /****************************************************************************
840  Accepts incoming data on an rpc pipe.
841 ****************************************************************************/
842
843 ssize_t write_to_pipe(smb_np_struct *p, char *data, size_t n)
844 {
845         DEBUG(6,("write_to_pipe: %x", p->pnum));
846
847         DEBUG(6,(" name: %s open: %s len: %d\n",
848                  p->name, BOOLSTR(p->open), (int)n));
849
850         dump_data(50, data, n);
851
852         return p->namedpipe_write(p->np_state, data, n);
853 }
854
855 /****************************************************************************
856  Accepts incoming data on an internal rpc pipe.
857 ****************************************************************************/
858
859 static ssize_t write_to_internal_pipe(void *np_conn, char *data, size_t n)
860 {
861         pipes_struct *p = (pipes_struct*)np_conn;
862         size_t data_left = n;
863
864         while(data_left) {
865                 ssize_t data_used;
866
867                 DEBUG(10,("write_to_pipe: data_left = %u\n", (unsigned int)data_left ));
868
869                 data_used = process_incoming_data(p, data, data_left);
870
871                 DEBUG(10,("write_to_pipe: data_used = %d\n", (int)data_used ));
872
873                 if(data_used < 0)
874                         return -1;
875
876                 data_left -= data_used;
877                 data += data_used;
878         }       
879
880         return n;
881 }
882
883 /****************************************************************************
884  Replies to a request to read data from a pipe.
885
886  Headers are interspersed with the data at PDU intervals. By the time
887  this function is called, the start of the data could possibly have been
888  read by an SMBtrans (file_offset != 0).
889
890  Calling create_rpc_reply() here is a hack. The data should already
891  have been prepared into arrays of headers + data stream sections.
892 ****************************************************************************/
893
894 ssize_t read_from_pipe(smb_np_struct *p, char *data, size_t n,
895                 BOOL *is_data_outstanding)
896 {
897         if (!p || !p->open) {
898                 DEBUG(0,("read_from_pipe: pipe not open\n"));
899                 return -1;              
900         }
901
902         DEBUG(6,("read_from_pipe: %x", p->pnum));
903
904         return p->namedpipe_read(p->np_state, data, n, is_data_outstanding);
905 }
906
907 /****************************************************************************
908  Replies to a request to read data from a pipe.
909
910  Headers are interspersed with the data at PDU intervals. By the time
911  this function is called, the start of the data could possibly have been
912  read by an SMBtrans (file_offset != 0).
913
914  Calling create_rpc_reply() here is a hack. The data should already
915  have been prepared into arrays of headers + data stream sections.
916 ****************************************************************************/
917
918 static ssize_t read_from_internal_pipe(void *np_conn, char *data, size_t n,
919                 BOOL *is_data_outstanding)
920 {
921         pipes_struct *p = (pipes_struct*)np_conn;
922         uint32 pdu_remaining = 0;
923         ssize_t data_returned = 0;
924
925         if (!p) {
926                 DEBUG(0,("read_from_pipe: pipe not open\n"));
927                 return -1;              
928         }
929
930         DEBUG(6,(" name: %s len: %u\n", p->name, (unsigned int)n));
931
932         /*
933          * We cannot return more than one PDU length per
934          * read request.
935          */
936
937         /*
938          * This condition should result in the connection being closed.  
939          * Netapp filers seem to set it to 0xffff which results in domain
940          * authentications failing.  Just ignore it so things work.
941          */
942
943         if(n > MAX_PDU_FRAG_LEN) {
944                 DEBUG(5,("read_from_pipe: too large read (%u) requested on \
945 pipe %s. We can only service %d sized reads.\n", (unsigned int)n, p->name, MAX_PDU_FRAG_LEN ));
946         }
947
948         /*
949          * Determine if there is still data to send in the
950          * pipe PDU buffer. Always send this first. Never
951          * send more than is left in the current PDU. The
952          * client should send a new read request for a new
953          * PDU.
954          */
955
956         if((pdu_remaining = p->out_data.current_pdu_len - p->out_data.current_pdu_sent) > 0) {
957                 data_returned = (ssize_t)MIN(n, pdu_remaining);
958
959                 DEBUG(10,("read_from_pipe: %s: current_pdu_len = %u, current_pdu_sent = %u \
960 returning %d bytes.\n", p->name, (unsigned int)p->out_data.current_pdu_len, 
961                         (unsigned int)p->out_data.current_pdu_sent, (int)data_returned));
962
963                 memcpy( data, &p->out_data.current_pdu[p->out_data.current_pdu_sent], (size_t)data_returned);
964                 p->out_data.current_pdu_sent += (uint32)data_returned;
965                 goto out;
966         }
967
968         /*
969          * At this point p->current_pdu_len == p->current_pdu_sent (which
970          * may of course be zero if this is the first return fragment.
971          */
972
973         DEBUG(10,("read_from_pipe: %s: fault_state = %d : data_sent_length \
974 = %u, prs_offset(&p->out_data.rdata) = %u.\n",
975                 p->name, (int)p->fault_state, (unsigned int)p->out_data.data_sent_length, (unsigned int)prs_offset(&p->out_data.rdata) ));
976
977         if(p->out_data.data_sent_length >= prs_offset(&p->out_data.rdata)) {
978                 /*
979                  * We have sent all possible data, return 0.
980                  */
981                 data_returned = 0;
982                 goto out;
983         }
984
985         /*
986          * We need to create a new PDU from the data left in p->rdata.
987          * Create the header/data/footers. This also sets up the fields
988          * p->current_pdu_len, p->current_pdu_sent, p->data_sent_length
989          * and stores the outgoing PDU in p->current_pdu.
990          */
991
992         if(!create_next_pdu(p)) {
993                 DEBUG(0,("read_from_pipe: %s: create_next_pdu failed.\n", p->name));
994                 return -1;
995         }
996
997         data_returned = MIN(n, p->out_data.current_pdu_len);
998
999         memcpy( data, p->out_data.current_pdu, (size_t)data_returned);
1000         p->out_data.current_pdu_sent += (uint32)data_returned;
1001
1002   out:
1003
1004         (*is_data_outstanding) = p->out_data.current_pdu_len > n;
1005         return data_returned;
1006 }
1007
1008 /****************************************************************************
1009  Wait device state on a pipe. Exactly what this is for is unknown...
1010 ****************************************************************************/
1011
1012 BOOL wait_rpc_pipe_hnd_state(smb_np_struct *p, uint16 priority)
1013 {
1014         if (p == NULL)
1015                 return False;
1016
1017         if (p->open) {
1018                 DEBUG(3,("wait_rpc_pipe_hnd_state: Setting pipe wait state priority=%x on pipe (name=%s)\n",
1019                          priority, p->name));
1020
1021                 p->priority = priority;
1022                 
1023                 return True;
1024         } 
1025
1026         DEBUG(3,("wait_rpc_pipe_hnd_state: Error setting pipe wait state priority=%x (name=%s)\n",
1027                  priority, p->name));
1028         return False;
1029 }
1030
1031
1032 /****************************************************************************
1033  Set device state on a pipe. Exactly what this is for is unknown...
1034 ****************************************************************************/
1035
1036 BOOL set_rpc_pipe_hnd_state(smb_np_struct *p, uint16 device_state)
1037 {
1038         if (p == NULL)
1039                 return False;
1040
1041         if (p->open) {
1042                 DEBUG(3,("set_rpc_pipe_hnd_state: Setting pipe device state=%x on pipe (name=%s)\n",
1043                          device_state, p->name));
1044
1045                 p->device_state = device_state;
1046                 
1047                 return True;
1048         } 
1049
1050         DEBUG(3,("set_rpc_pipe_hnd_state: Error setting pipe device state=%x (name=%s)\n",
1051                  device_state, p->name));
1052         return False;
1053 }
1054
1055
1056 /****************************************************************************
1057  Close an rpc pipe.
1058 ****************************************************************************/
1059
1060 BOOL close_rpc_pipe_hnd(smb_np_struct *p)
1061 {
1062         if (!p) {
1063                 DEBUG(0,("Invalid pipe in close_rpc_pipe_hnd\n"));
1064                 return False;
1065         }
1066
1067         p->namedpipe_close(p->np_state);
1068
1069         bitmap_clear(bmap, p->pnum - pipe_handle_offset);
1070
1071         pipes_open--;
1072
1073         DEBUG(4,("closed pipe name %s pnum=%x (pipes_open=%d)\n", 
1074                  p->name, p->pnum, pipes_open));  
1075
1076         DLIST_REMOVE(Pipes, p);
1077
1078         ZERO_STRUCTP(p);
1079
1080         SAFE_FREE(p);
1081
1082         return True;
1083 }
1084
1085 /****************************************************************************
1086  Close an rpc pipe.
1087 ****************************************************************************/
1088
1089 static BOOL close_internal_rpc_pipe_hnd(void *np_conn)
1090 {
1091         pipes_struct *p = (pipes_struct *)np_conn;
1092         if (!p) {
1093                 DEBUG(0,("Invalid pipe in close_internal_rpc_pipe_hnd\n"));
1094                 return False;
1095         }
1096
1097         prs_mem_free(&p->out_data.rdata);
1098         prs_mem_free(&p->in_data.data);
1099
1100         if (p->mem_ctx)
1101                 talloc_destroy(p->mem_ctx);
1102
1103         /* Free the handles database. */
1104         close_policy_by_pipe(p);
1105
1106         delete_nt_token(&p->pipe_user.nt_user_token);
1107         SAFE_FREE(p->pipe_user.groups);
1108
1109         DLIST_REMOVE(InternalPipes, p);
1110
1111         p->conn->num_files_open--;
1112
1113         ZERO_STRUCTP(p);
1114
1115         SAFE_FREE(p);
1116         
1117         return True;
1118 }
1119
1120 /****************************************************************************
1121  Find an rpc pipe given a pipe handle in a buffer and an offset.
1122 ****************************************************************************/
1123
1124 smb_np_struct *get_rpc_pipe_p(char *buf, int where)
1125 {
1126         int pnum = SVAL(buf,where);
1127
1128         if (chain_p)
1129                 return chain_p;
1130
1131         return get_rpc_pipe(pnum);
1132 }
1133
1134 /****************************************************************************
1135  Find an rpc pipe given a pipe handle.
1136 ****************************************************************************/
1137
1138 smb_np_struct *get_rpc_pipe(int pnum)
1139 {
1140         smb_np_struct *p;
1141
1142         DEBUG(4,("search for pipe pnum=%x\n", pnum));
1143
1144         for (p=Pipes;p;p=p->next)
1145                 DEBUG(5,("pipe name %s pnum=%x (pipes_open=%d)\n", 
1146                           p->name, p->pnum, pipes_open));  
1147
1148         for (p=Pipes;p;p=p->next) {
1149                 if (p->pnum == pnum) {
1150                         chain_p = p;
1151                         return p;
1152                 }
1153         }
1154
1155         return NULL;
1156 }