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 #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 and NT_TOKEN */
 348         if (vuser) {
 349                 memcpy(p->session_key, vuser->session_key, sizeof(p->session_key));
 350                 p->pipe_user.nt_user_token = dup_nt_token(vuser->nt_user_token);
 351         }
 352
 353         /*
 354          * Initialize the incoming RPC struct.
 355          */
 356
 357         p->in_data.pdu_needed_len = 0;
 358         p->in_data.pdu_received_len = 0;
 359
 360         /*
 361          * Initialize the outgoing RPC struct.
 362          */
 363
 364         p->out_data.current_pdu_len = 0;
 365         p->out_data.current_pdu_sent = 0;
 366         p->out_data.data_sent_length = 0;
 367
 368         /*
 369          * Initialize the outgoing RPC data buffer with no memory.
 370          */
 371         prs_init(&p->out_data.rdata, 0, p->mem_ctx, MARSHALL);
 372
 373         fstrcpy(p->name, pipe_name);
 374
 375         DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
 376                  pipe_name, pipes_open));
 377
 378         return (void*)p;
 379 }
 380
 381 /****************************************************************************
 382  Sets the fault state on incoming packets.
 383 ****************************************************************************/
 384
 385 static void set_incoming_fault(pipes_struct *p)
 386 {
 387         prs_mem_free(&p->in_data.data);
 388         p->in_data.pdu_needed_len = 0;
 389         p->in_data.pdu_received_len = 0;
 390         p->fault_state = True;
 391         DEBUG(10,("set_incoming_fault: Setting fault state on pipe %s : vuid = 0x%x\n",
 392                 p->name, p->vuid ));
 393 }
 394
 395 /****************************************************************************
 396  Ensures we have at least RPC_HEADER_LEN amount of data in the incoming buffer.
 397 ****************************************************************************/
 398
 399 static ssize_t fill_rpc_header(pipes_struct *p, char *data, size_t data_to_copy)
 400 {
 401         size_t len_needed_to_complete_hdr = MIN(data_to_copy, RPC_HEADER_LEN - p->in_data.pdu_received_len);
 402
 403         DEBUG(10,("fill_rpc_header: data_to_copy = %u, len_needed_to_complete_hdr = %u, receive_len = %u\n",
 404                         (unsigned int)data_to_copy, (unsigned int)len_needed_to_complete_hdr,
 405                         (unsigned int)p->in_data.pdu_received_len ));
 406
 407         memcpy((char *)&p->in_data.current_in_pdu[p->in_data.pdu_received_len], data, len_needed_to_complete_hdr);
 408         p->in_data.pdu_received_len += len_needed_to_complete_hdr;
 409
 410         return (ssize_t)len_needed_to_complete_hdr;
 411 }
 412
 413 /****************************************************************************
 414  Unmarshalls a new PDU header. Assumes the raw header data is in current_in_pdu.
 415 ****************************************************************************/
 416
 417 static ssize_t unmarshall_rpc_header(pipes_struct *p)
 418 {
 419         /*
 420          * Unmarshall the header to determine the needed length.
 421          */
 422
 423         prs_struct rpc_in;
 424
 425         if(p->in_data.pdu_received_len != RPC_HEADER_LEN) {
 426                 DEBUG(0,("unmarshall_rpc_header: assert on rpc header length failed.\n"));
 427                 set_incoming_fault(p);
 428                 return -1;
 429         }
 430
 431         prs_init( &rpc_in, 0, p->mem_ctx, UNMARSHALL);
 432         prs_set_endian_data( &rpc_in, p->endian);
 433
 434         prs_give_memory( &rpc_in, (char *)&p->in_data.current_in_pdu[0],
 435                                         p->in_data.pdu_received_len, False);
 436
 437         /*
 438          * Unmarshall the header as this will tell us how much
 439          * data we need to read to get the complete pdu.
 440          * This also sets the endian flag in rpc_in.
 441          */
 442
 443         if(!smb_io_rpc_hdr("", &p->hdr, &rpc_in, 0)) {
 444                 DEBUG(0,("unmarshall_rpc_header: failed to unmarshall RPC_HDR.\n"));
 445                 set_incoming_fault(p);
 446                 prs_mem_free(&rpc_in);
 447                 return -1;
 448         }
 449
 450         /*
 451          * Validate the RPC header.
 452          */
 453
 454         if(p->hdr.major != 5 && p->hdr.minor != 0) {
 455                 DEBUG(0,("unmarshall_rpc_header: invalid major/minor numbers in RPC_HDR.\n"));
 456                 set_incoming_fault(p);
 457                 prs_mem_free(&rpc_in);
 458                 return -1;
 459         }
 460
 461         /*
 462          * If there's not data in the incoming buffer this should be the start of a new RPC.
 463          */
 464
 465         if(prs_offset(&p->in_data.data) == 0) {
 466
 467                 /*
 468                  * AS/U doesn't set FIRST flag in a BIND packet it seems.
 469                  */
 470
 471                 if ((p->hdr.pkt_type == RPC_REQUEST) && !(p->hdr.flags & RPC_FLG_FIRST)) {
 472                         /*
 473                          * Ensure that the FIRST flag is set. If not then we have
 474                          * a stream missmatch.
 475                          */
 476
 477                         DEBUG(0,("unmarshall_rpc_header: FIRST flag not set in first PDU !\n"));
 478                         set_incoming_fault(p);
 479                         prs_mem_free(&rpc_in);
 480                         return -1;
 481                 }
 482
 483                 /*
 484                  * If this is the first PDU then set the endianness
 485                  * flag in the pipe. We will need this when parsing all
 486                  * data in this RPC.
 487                  */
 488
 489                 p->endian = rpc_in.bigendian_data;
 490
 491                 DEBUG(5,("unmarshall_rpc_header: using %sendian RPC\n",
 492                                 p->endian == RPC_LITTLE_ENDIAN ? "little-" : "big-" ));
 493
 494         } else {
 495
 496                 /*
 497                  * If this is *NOT* the first PDU then check the endianness
 498                  * flag in the pipe is the same as that in the PDU.
 499                  */
 500
 501                 if (p->endian != rpc_in.bigendian_data) {
 502                         DEBUG(0,("unmarshall_rpc_header: FIRST endianness flag (%d) different in next PDU !\n", (int)p->endian));
 503                         set_incoming_fault(p);
 504                         prs_mem_free(&rpc_in);
 505                         return -1;
 506                 }
 507         }
 508
 509         /*
 510          * Ensure that the pdu length is sane.
 511          */
 512
 513         if((p->hdr.frag_len < RPC_HEADER_LEN) || (p->hdr.frag_len > MAX_PDU_FRAG_LEN)) {
 514                 DEBUG(0,("unmarshall_rpc_header: assert on frag length failed.\n"));
 515                 set_incoming_fault(p);
 516                 prs_mem_free(&rpc_in);
 517                 return -1;
 518         }
 519
 520         DEBUG(10,("unmarshall_rpc_header: type = %u, flags = %u\n", (unsigned int)p->hdr.pkt_type,
 521                         (unsigned int)p->hdr.flags ));
 522
 523         /*
 524          * Adjust for the header we just ate.
 525          */
 526         p->in_data.pdu_received_len = 0;
 527         p->in_data.pdu_needed_len = (uint32)p->hdr.frag_len - RPC_HEADER_LEN;
 528
 529         /*
 530          * Null the data we just ate.
 531          */
 532
 533         memset((char *)&p->in_data.current_in_pdu[0], '\0', RPC_HEADER_LEN);
 534
 535         prs_mem_free(&rpc_in);
 536
 537         return 0; /* No extra data processed. */
 538 }
 539
 540 /****************************************************************************
 541  Call this to free any talloc'ed memory. Do this before and after processing
 542  a complete PDU.
 543 ****************************************************************************/
 544
 545 void free_pipe_context(pipes_struct *p)
 546 {
 547         if (p->mem_ctx) {
 548                 DEBUG(3,("free_pipe_context: destroying talloc pool of size %u\n", talloc_pool_size(p->mem_ctx) ));
 549                 talloc_destroy_pool(p->mem_ctx);
 550         } else {
 551                 p->mem_ctx = talloc_init();
 552                 if (p->mem_ctx == NULL)
 553                         p->fault_state = True;
 554         }
 555 }
 556
 557 /****************************************************************************
 558  Processes a request pdu. This will do auth processing if needed, and
 559  appends the data into the complete stream if the LAST flag is not set.
 560 ****************************************************************************/
 561
 562 static BOOL process_request_pdu(pipes_struct *p, prs_struct *rpc_in_p)
 563 {
 564         BOOL auth_verify = ((p->ntlmssp_chal_flags & NTLMSSP_NEGOTIATE_SIGN) != 0);
 565         size_t data_len = p->hdr.frag_len - RPC_HEADER_LEN - RPC_HDR_REQ_LEN -
 566                                 (auth_verify ? RPC_HDR_AUTH_LEN : 0) - p->hdr.auth_len;
 567
 568         if(!p->pipe_bound) {
 569                 DEBUG(0,("process_request_pdu: rpc request with no bind.\n"));
 570                 set_incoming_fault(p);
 571                 return False;
 572         }
 573
 574         /*
 575          * Check if we need to do authentication processing.
 576          * This is only done on requests, not binds.
 577          */
 578
 579         /*
 580          * Read the RPC request header.
 581          */
 582
 583         if(!smb_io_rpc_hdr_req("req", &p->hdr_req, rpc_in_p, 0)) {
 584                 DEBUG(0,("process_request_pdu: failed to unmarshall RPC_HDR_REQ.\n"));
 585                 set_incoming_fault(p);
 586                 return False;
 587         }
 588
 589         if(p->ntlmssp_auth_validated && !api_pipe_auth_process(p, rpc_in_p)) {
 590                 DEBUG(0,("process_request_pdu: failed to do auth processing.\n"));
 591                 set_incoming_fault(p);
 592                 return False;
 593         }
 594
 595         if (p->ntlmssp_auth_requested && !p->ntlmssp_auth_validated) {
 596
 597                 /*
 598                  * Authentication _was_ requested and it already failed.
 599                  */
 600
 601                 DEBUG(0,("process_request_pdu: RPC request received on pipe %s where \
 602 authentication failed. Denying the request.\n", p->name));
 603                 set_incoming_fault(p);
 604         return False;
 605     }
 606
 607         /*
 608          * Check the data length doesn't go over the 15Mb limit.
 609          * increased after observing a bug in the Windows NT 4.0 SP6a
 610          * spoolsv.exe when the response to a GETPRINTERDRIVER2 RPC
 611          * will not fit in the initial buffer of size 0x1068   --jerry 22/01/2002
 612          */
 613
 614         if(prs_offset(&p->in_data.data) + data_len > 15*1024*1024) {
 615                 DEBUG(0,("process_request_pdu: rpc data buffer too large (%u) + (%u)\n",
 616                                 (unsigned int)prs_data_size(&p->in_data.data), (unsigned int)data_len ));
 617                 set_incoming_fault(p);
 618                 return False;
 619         }
 620
 621         /*
 622          * Append the data portion into the buffer and return.
 623          */
 624
 625         {
 626                 char *data_from = prs_data_p(rpc_in_p) + prs_offset(rpc_in_p);
 627
 628                 if(!prs_append_data(&p->in_data.data, data_from, data_len)) {
 629                         DEBUG(0,("process_request_pdu: Unable to append data size %u to parse buffer of size %u.\n",
 630                                         (unsigned int)data_len, (unsigned int)prs_data_size(&p->in_data.data) ));
 631                         set_incoming_fault(p);
 632                         return False;
 633                 }
 634
 635         }
 636
 637         if(p->hdr.flags & RPC_FLG_LAST) {
 638                 BOOL ret = False;
 639                 /*
 640                  * Ok - we finally have a complete RPC stream.
 641                  * Call the rpc command to process it.
 642                  */
 643
 644                 /*
 645                  * Ensure the internal prs buffer size is *exactly* the same
 646                  * size as the current offset.
 647                  */
 648
 649                 if(!prs_set_buffer_size(&p->in_data.data, prs_offset(&p->in_data.data)))
 650                 {
 651                         DEBUG(0,("process_request_pdu: Call to prs_set_buffer_size failed!\n"));
 652                         set_incoming_fault(p);
 653                         return False;
 654                 }
 655
 656                 /*
 657                  * Set the parse offset to the start of the data and set the
 658                  * prs_struct to UNMARSHALL.
 659                  */
 660
 661                 prs_set_offset(&p->in_data.data, 0);
 662                 prs_switch_type(&p->in_data.data, UNMARSHALL);
 663
 664                 /*
 665                  * Process the complete data stream here.
 666                  */
 667
 668                 free_pipe_context(p);
 669
 670                 if(pipe_init_outgoing_data(p))
 671                         ret = api_pipe_request(p);
 672
 673                 free_pipe_context(p);
 674
 675                 /*
 676                  * We have consumed the whole data stream. Set back to
 677                  * marshalling and set the offset back to the start of
 678                  * the buffer to re-use it (we could also do a prs_mem_free()
 679                  * and then re_init on the next start of PDU. Not sure which
 680                  * is best here.... JRA.
 681                  */
 682
 683                 prs_switch_type(&p->in_data.data, MARSHALL);
 684                 prs_set_offset(&p->in_data.data, 0);
 685                 return ret;
 686         }
 687
 688         return True;
 689 }
 690
 691 /****************************************************************************
 692  Processes a finished PDU stored in current_in_pdu. The RPC_HEADER has
 693  already been parsed and stored in p->hdr.
 694 ****************************************************************************/
 695
 696 static ssize_t process_complete_pdu(pipes_struct *p)
 697 {
 698         prs_struct rpc_in;
 699         size_t data_len = p->in_data.pdu_received_len;
 700         char *data_p = (char *)&p->in_data.current_in_pdu[0];
 701         BOOL reply = False;
 702
 703         if(p->fault_state) {
 704                 DEBUG(10,("process_complete_pdu: pipe %s in fault state.\n",
 705                         p->name ));
 706                 set_incoming_fault(p);
 707                 setup_fault_pdu(p, NT_STATUS(0x1c010002));
 708                 return (ssize_t)data_len;
 709         }
 710
 711         prs_init( &rpc_in, 0, p->mem_ctx, UNMARSHALL);
 712
 713         /*
 714          * Ensure we're using the corrent endianness for both the
 715          * RPC header flags and the raw data we will be reading from.
 716          */
 717
 718         prs_set_endian_data( &rpc_in, p->endian);
 719         prs_set_endian_data( &p->in_data.data, p->endian);
 720
 721         prs_give_memory( &rpc_in, data_p, (uint32)data_len, False);
 722
 723         DEBUG(10,("process_complete_pdu: processing packet type %u\n",
 724                         (unsigned int)p->hdr.pkt_type ));
 725
 726         switch (p->hdr.pkt_type) {
 727                 case RPC_BIND:
 728                 case RPC_ALTCONT:
 729                         /*
 730                          * We assume that a pipe bind is only in one pdu.
 731                          */
 732                         if(pipe_init_outgoing_data(p))
 733                                 reply = api_pipe_bind_req(p, &rpc_in);
 734                         break;
 735                 case RPC_BINDRESP:
 736                         /*
 737                          * We assume that a pipe bind_resp is only in one pdu.
 738                          */
 739                         if(pipe_init_outgoing_data(p))
 740                                 reply = api_pipe_bind_auth_resp(p, &rpc_in);
 741                         break;
 742                 case RPC_REQUEST:
 743                         reply = process_request_pdu(p, &rpc_in);
 744                         break;
 745                 default:
 746                         DEBUG(0,("process_complete_pdu: Unknown rpc type = %u received.\n", (unsigned int)p->hdr.pkt_type ));
 747                         break;
 748         }
 749
 750         /* Reset to little endian. Probably don't need this but it won't hurt. */
 751         prs_set_endian_data( &p->in_data.data, RPC_LITTLE_ENDIAN);
 752
 753         if (!reply) {
 754                 DEBUG(3,("process_complete_pdu: DCE/RPC fault sent on pipe %s\n", p->pipe_srv_name));
 755                 set_incoming_fault(p);
 756                 setup_fault_pdu(p, NT_STATUS(0x1c010002));
 757                 prs_mem_free(&rpc_in);
 758         } else {
 759                 /*
 760                  * Reset the lengths. We're ready for a new pdu.
 761                  */
 762                 p->in_data.pdu_needed_len = 0;
 763                 p->in_data.pdu_received_len = 0;
 764         }
 765
 766         prs_mem_free(&rpc_in);
 767         return (ssize_t)data_len;
 768 }
 769
 770 /****************************************************************************
 771  Accepts incoming data on an rpc pipe. Processes the data in pdu sized units.
 772 ****************************************************************************/
 773
 774 static ssize_t process_incoming_data(pipes_struct *p, char *data, size_t n)
 775 {
 776         size_t data_to_copy = MIN(n, MAX_PDU_FRAG_LEN - p->in_data.pdu_received_len);
 777
 778         DEBUG(10,("process_incoming_data: Start: pdu_received_len = %u, pdu_needed_len = %u, incoming data = %u\n",
 779                 (unsigned int)p->in_data.pdu_received_len, (unsigned int)p->in_data.pdu_needed_len,
 780                 (unsigned int)n ));
 781
 782         if(data_to_copy == 0) {
 783                 /*
 784                  * This is an error - data is being received and there is no
 785                  * space in the PDU. Free the received data and go into the fault state.
 786                  */
 787                 DEBUG(0,("process_incoming_data: No space in incoming pdu buffer. Current size = %u \
 788 incoming data size = %u\n", (unsigned int)p->in_data.pdu_received_len, (unsigned int)n ));
 789                 set_incoming_fault(p);
 790                 return -1;
 791         }
 792
 793         /*
 794          * If we have no data already, wait until we get at least a RPC_HEADER_LEN
 795          * number of bytes before we can do anything.
 796          */
 797
 798         if((p->in_data.pdu_needed_len == 0) && (p->in_data.pdu_received_len < RPC_HEADER_LEN)) {
 799                 /*
 800                  * Always return here. If we have more data then the RPC_HEADER
 801                  * will be processed the next time around the loop.
 802                  */
 803                 return fill_rpc_header(p, data, data_to_copy);
 804         }
 805
 806         /*
 807          * At this point we know we have at least an RPC_HEADER_LEN amount of data
 808          * stored in current_in_pdu.
 809          */
 810
 811         /*
 812          * If pdu_needed_len is zero this is a new pdu.
 813          * Unmarshall the header so we know how much more
 814          * data we need, then loop again.
 815          */
 816
 817         if(p->in_data.pdu_needed_len == 0)
 818                 return unmarshall_rpc_header(p);
 819
 820         /*
 821          * Ok - at this point we have a valid RPC_HEADER in p->hdr.
 822          * Keep reading until we have a full pdu.
 823          */
 824
 825         data_to_copy = MIN(data_to_copy, p->in_data.pdu_needed_len);
 826
 827         /*
 828          * Copy as much of the data as we need into the current_in_pdu buffer.
 829          */
 830
 831         memcpy( (char *)&p->in_data.current_in_pdu[p->in_data.pdu_received_len], data, data_to_copy);
 832         p->in_data.pdu_received_len += data_to_copy;
 833
 834         /*
 835          * Do we have a complete PDU ?
 836          */
 837
 838         if(p->in_data.pdu_received_len == p->in_data.pdu_needed_len)
 839                 return process_complete_pdu(p);
 840
 841         DEBUG(10,("process_incoming_data: not a complete PDU yet. pdu_received_len = %u, pdu_needed_len = %u\n",
 842                 (unsigned int)p->in_data.pdu_received_len, (unsigned int)p->in_data.pdu_needed_len ));
 843
 844         return (ssize_t)data_to_copy;
 845
 846 }
 847
 848 /****************************************************************************
 849  Accepts incoming data on an rpc pipe.
 850 ****************************************************************************/
 851
 852 ssize_t write_to_pipe(smb_np_struct *p, char *data, size_t n)
 853 {
 854         DEBUG(6,("write_to_pipe: %x", p->pnum));
 855
 856         DEBUG(6,(" name: %s open: %s len: %d\n",
 857                  p->name, BOOLSTR(p->open), (int)n));
 858
 859         dump_data(50, data, n);
 860
 861         return p->namedpipe_write(p->np_state, data, n);
 862 }
 863
 864 /****************************************************************************
 865  Accepts incoming data on an internal rpc pipe.
 866 ****************************************************************************/
 867
 868 static ssize_t write_to_internal_pipe(void *np_conn, char *data, size_t n)
 869 {
 870         pipes_struct *p = (pipes_struct*)np_conn;
 871         size_t data_left = n;
 872
 873         while(data_left) {
 874                 ssize_t data_used;
 875
 876                 DEBUG(10,("write_to_pipe: data_left = %u\n", (unsigned int)data_left ));
 877
 878                 data_used = process_incoming_data(p, data, data_left);
 879
 880                 DEBUG(10,("write_to_pipe: data_used = %d\n", (int)data_used ));
 881
 882                 if(data_used < 0)
 883                         return -1;
 884
 885                 data_left -= data_used;
 886                 data += data_used;
 887         }
 888
 889         return n;
 890 }
 891
 892 /****************************************************************************
 893  Replies to a request to read data from a pipe.
 894
 895  Headers are interspersed with the data at PDU intervals. By the time
 896  this function is called, the start of the data could possibly have been
 897  read by an SMBtrans (file_offset != 0).
 898
 899  Calling create_rpc_reply() here is a hack. The data should already
 900  have been prepared into arrays of headers + data stream sections.
 901 ****************************************************************************/
 902
 903 ssize_t read_from_pipe(smb_np_struct *p, char *data, size_t n,
 904                 BOOL *is_data_outstanding)
 905 {
 906         if (!p || !p->open) {
 907                 DEBUG(0,("read_from_pipe: pipe not open\n"));
 908                 return -1;
 909         }
 910
 911         DEBUG(6,("read_from_pipe: %x", p->pnum));
 912
 913         return p->namedpipe_read(p->np_state, data, n, is_data_outstanding);
 914 }
 915
 916 /****************************************************************************
 917  Replies to a request to read data from a pipe.
 918
 919  Headers are interspersed with the data at PDU intervals. By the time
 920  this function is called, the start of the data could possibly have been
 921  read by an SMBtrans (file_offset != 0).
 922
 923  Calling create_rpc_reply() here is a hack. The data should already
 924  have been prepared into arrays of headers + data stream sections.
 925 ****************************************************************************/
 926
 927 static ssize_t read_from_internal_pipe(void *np_conn, char *data, size_t n,
 928                 BOOL *is_data_outstanding)
 929 {
 930         pipes_struct *p = (pipes_struct*)np_conn;
 931         uint32 pdu_remaining = 0;
 932         ssize_t data_returned = 0;
 933
 934         if (!p) {
 935                 DEBUG(0,("read_from_pipe: pipe not open\n"));
 936                 return -1;
 937         }
 938
 939         DEBUG(6,(" name: %s len: %u\n", p->name, (unsigned int)n));
 940
 941         /*
 942          * We cannot return more than one PDU length per
 943          * read request.
 944          */
 945
 946         /*
 947          * This condition should result in the connection being closed.
 948          * Netapp filers seem to set it to 0xffff which results in domain
 949          * authentications failing.  Just ignore it so things work.
 950          */
 951
 952         if(n > MAX_PDU_FRAG_LEN) {
 953                 DEBUG(5,("read_from_pipe: too large read (%u) requested on \
 954 pipe %s. We can only service %d sized reads.\n", (unsigned int)n, p->name, MAX_PDU_FRAG_LEN ));
 955         }
 956
 957         /*
 958          * Determine if there is still data to send in the
 959          * pipe PDU buffer. Always send this first. Never
 960          * send more than is left in the current PDU. The
 961          * client should send a new read request for a new
 962          * PDU.
 963          */
 964
 965         if((pdu_remaining = p->out_data.current_pdu_len - p->out_data.current_pdu_sent) > 0) {
 966                 data_returned = (ssize_t)MIN(n, pdu_remaining);
 967
 968                 DEBUG(10,("read_from_pipe: %s: current_pdu_len = %u, current_pdu_sent = %u \
 969 returning %d bytes.\n", p->name, (unsigned int)p->out_data.current_pdu_len,
 970                         (unsigned int)p->out_data.current_pdu_sent, (int)data_returned));
 971
 972                 memcpy( data, &p->out_data.current_pdu[p->out_data.current_pdu_sent], (size_t)data_returned);
 973                 p->out_data.current_pdu_sent += (uint32)data_returned;
 974                 goto out;
 975         }
 976
 977         /*
 978          * At this point p->current_pdu_len == p->current_pdu_sent (which
 979          * may of course be zero if this is the first return fragment.
 980          */
 981
 982         DEBUG(10,("read_from_pipe: %s: fault_state = %d : data_sent_length \
 983 = %u, prs_offset(&p->out_data.rdata) = %u.\n",
 984                 p->name, (int)p->fault_state, (unsigned int)p->out_data.data_sent_length, (unsigned int)prs_offset(&p->out_data.rdata) ));
 985
 986         if(p->out_data.data_sent_length >= prs_offset(&p->out_data.rdata)) {
 987                 /*
 988                  * We have sent all possible data, return 0.
 989                  */
 990                 data_returned = 0;
 991                 goto out;
 992         }
 993
 994         /*
 995          * We need to create a new PDU from the data left in p->rdata.
 996          * Create the header/data/footers. This also sets up the fields
 997          * p->current_pdu_len, p->current_pdu_sent, p->data_sent_length
 998          * and stores the outgoing PDU in p->current_pdu.
 999          */
1000
1001         if(!create_next_pdu(p)) {
1002                 DEBUG(0,("read_from_pipe: %s: create_next_pdu failed.\n", p->name));
1003                 return -1;
1004         }
1005
1006         data_returned = MIN(n, p->out_data.current_pdu_len);
1007
1008         memcpy( data, p->out_data.current_pdu, (size_t)data_returned);
1009         p->out_data.current_pdu_sent += (uint32)data_returned;
1010
1011   out:
1012
1013         (*is_data_outstanding) = p->out_data.current_pdu_len > n;
1014         return data_returned;
1015 }
1016
1017 /****************************************************************************
1018  Wait device state on a pipe. Exactly what this is for is unknown...
1019 ****************************************************************************/
1020
1021 BOOL wait_rpc_pipe_hnd_state(smb_np_struct *p, uint16 priority)
1022 {
1023         if (p == NULL)
1024                 return False;
1025
1026         if (p->open) {
1027                 DEBUG(3,("wait_rpc_pipe_hnd_state: Setting pipe wait state priority=%x on pipe (name=%s)\n",
1028                          priority, p->name));
1029
1030                 p->priority = priority;
1031
1032                 return True;
1033         }
1034
1035         DEBUG(3,("wait_rpc_pipe_hnd_state: Error setting pipe wait state priority=%x (name=%s)\n",
1036                  priority, p->name));
1037         return False;
1038 }
1039
1040
1041 /****************************************************************************
1042  Set device state on a pipe. Exactly what this is for is unknown...
1043 ****************************************************************************/
1044
1045 BOOL set_rpc_pipe_hnd_state(smb_np_struct *p, uint16 device_state)
1046 {
1047         if (p == NULL)
1048                 return False;
1049
1050         if (p->open) {
1051                 DEBUG(3,("set_rpc_pipe_hnd_state: Setting pipe device state=%x on pipe (name=%s)\n",
1052                          device_state, p->name));
1053
1054                 p->device_state = device_state;
1055
1056                 return True;
1057         }
1058
1059         DEBUG(3,("set_rpc_pipe_hnd_state: Error setting pipe device state=%x (name=%s)\n",
1060                  device_state, p->name));
1061         return False;
1062 }
1063
1064
1065 /****************************************************************************
1066  Close an rpc pipe.
1067 ****************************************************************************/
1068
1069 BOOL close_rpc_pipe_hnd(smb_np_struct *p)
1070 {
1071         if (!p) {
1072                 DEBUG(0,("Invalid pipe in close_rpc_pipe_hnd\n"));
1073                 return False;
1074         }
1075
1076         p->namedpipe_close(p->np_state);
1077
1078         bitmap_clear(bmap, p->pnum - pipe_handle_offset);
1079
1080         pipes_open--;
1081
1082         DEBUG(4,("closed pipe name %s pnum=%x (pipes_open=%d)\n",
1083                  p->name, p->pnum, pipes_open));
1084
1085         DLIST_REMOVE(Pipes, p);
1086
1087         ZERO_STRUCTP(p);
1088
1089         SAFE_FREE(p);
1090
1091         return True;
1092 }
1093
1094 /****************************************************************************
1095  Close an rpc pipe.
1096 ****************************************************************************/
1097
1098 static BOOL close_internal_rpc_pipe_hnd(void *np_conn)
1099 {
1100         pipes_struct *p = (pipes_struct *)np_conn;
1101         if (!p) {
1102                 DEBUG(0,("Invalid pipe in close_internal_rpc_pipe_hnd\n"));
1103                 return False;
1104         }
1105
1106         prs_mem_free(&p->out_data.rdata);
1107         prs_mem_free(&p->in_data.data);
1108
1109         if (p->mem_ctx)
1110                 talloc_destroy(p->mem_ctx);
1111
1112         /* Free the handles database. */
1113         close_policy_by_pipe(p);
1114
1115         delete_nt_token(&p->pipe_user.nt_user_token);
1116         SAFE_FREE(p->pipe_user.groups);
1117
1118         DLIST_REMOVE(InternalPipes, p);
1119
1120         p->conn->num_files_open--;
1121
1122         ZERO_STRUCTP(p);
1123
1124         SAFE_FREE(p);
1125
1126         return True;
1127 }
1128
1129 /****************************************************************************
1130  Find an rpc pipe given a pipe handle in a buffer and an offset.
1131 ****************************************************************************/
1132
1133 smb_np_struct *get_rpc_pipe_p(char *buf, int where)
1134 {
1135         int pnum = SVAL(buf,where);
1136
1137         if (chain_p)
1138                 return chain_p;
1139
1140         return get_rpc_pipe(pnum);
1141 }
1142
1143 /****************************************************************************
1144  Find an rpc pipe given a pipe handle.
1145 ****************************************************************************/
1146
1147 smb_np_struct *get_rpc_pipe(int pnum)
1148 {
1149         smb_np_struct *p;
1150
1151         DEBUG(4,("search for pipe pnum=%x\n", pnum));
1152
1153         for (p=Pipes;p;p=p->next)
1154                 DEBUG(5,("pipe name %s pnum=%x (pipes_open=%d)\n",
1155                           p->name, p->pnum, pipes_open));
1156
1157         for (p=Pipes;p;p=p->next) {
1158                 if (p->pnum == pnum) {
1159                         chain_p = p;
1160                         return p;
1161                 }
1162         }
1163
1164         return NULL;
1165 }