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