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