* Unix SMB/Netbios implementation.
* Version 1.9.
* RPC Pipe client / server routines
- * Copyright (C) Andrew Tridgell 1992-1997,
- * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
+ * Copyright (C) Andrew Tridgell 1992-1998,
+ * Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
#define PIPELEN strlen(PIPE)
extern int DEBUGLEVEL;
-static int chain_pnum = -1;
+static pipes_struct *chain_p;
+static int pipes_open;
#ifndef MAX_OPEN_PIPES
-#define MAX_OPEN_PIPES 50
+#define MAX_OPEN_PIPES 64
#endif
-#define PIPE_HANDLE_OFFSET 0x800
-
-pipes_struct Pipes[MAX_OPEN_PIPES];
-
-#define P_OPEN(p) ((p)->open)
-#define P_OK(p,c) (P_OPEN(p) && (c)==((p)->cnum))
-#define VALID_PNUM(pnum) (((pnum) >= 0) && ((pnum) < MAX_OPEN_PIPES))
-#define OPEN_PNUM(pnum) (VALID_PNUM(pnum) && P_OPEN(&(Pipes[pnum])))
-#define PNUM_OK(pnum,c) (OPEN_PNUM(pnum) && (c)==Pipes[pnum].cnum)
+static pipes_struct *Pipes;
+static struct bitmap *bmap;
+/* this must be larger than the sum of the open files and directories */
+static int pipe_handle_offset;
/****************************************************************************
- reset pipe chain handle number
+ Set the pipe_handle_offset. Called from smbd/files.c
****************************************************************************/
-void reset_chain_pnum(void)
+
+void set_pipe_handle_offset(int max_open_files)
{
- chain_pnum = -1;
+ if(max_open_files < 0x7000)
+ pipe_handle_offset = 0x7000;
+ else
+ pipe_handle_offset = max_open_files + 10; /* For safety. :-) */
}
/****************************************************************************
- sets chain pipe-file handle
+ reset pipe chain handle number
****************************************************************************/
-void set_chain_pnum(int new_pnum)
+void reset_chain_p(void)
{
- chain_pnum = new_pnum;
+ chain_p = NULL;
}
/****************************************************************************
****************************************************************************/
void init_rpc_pipe_hnd(void)
{
- int i;
- /* we start at 1 here for an obscure reason I can't now remember,
- but I think is important :-) */
- for (i = 1; i < MAX_OPEN_PIPES; i++)
- {
- Pipes[i].open = False;
- Pipes[i].name[0] = 0;
- Pipes[i].pipe_srv_name[0] = 0;
-
- Pipes[i].rhdr.data = NULL;
- Pipes[i].rdata.data = NULL;
- Pipes[i].rhdr.offset = 0;
- Pipes[i].rdata.offset = 0;
-
- Pipes[i].max_rdata_len = 0;
- Pipes[i].hdr_offsets = 0;
+ bmap = bitmap_allocate(MAX_OPEN_PIPES);
+ if (!bmap) {
+ exit_server("out of memory in init_rpc_pipe_hnd\n");
}
-
- return;
}
+
/****************************************************************************
find first available file slot
****************************************************************************/
-int open_rpc_pipe_hnd(char *pipe_name, int cnum, uint16 vuid)
+pipes_struct *open_rpc_pipe_p(char *pipe_name,
+ connection_struct *conn, uint16 vuid)
{
int i;
- /* we start at 1 here for an obscure reason I can't now remember,
- but I think is important :-) */
- for (i = 1; i < MAX_OPEN_PIPES; i++)
+ pipes_struct *p;
+ static int next_pipe;
+
+ DEBUG(4,("Open pipe requested %s (pipes_open=%d)\n",
+ pipe_name, pipes_open));
+
+ /* not repeating pipe numbers makes it easier to track things in
+ log files and prevents client bugs where pipe numbers are reused
+ over connection restarts */
+ if (next_pipe == 0) {
+ next_pipe = (getpid() ^ time(NULL)) % MAX_OPEN_PIPES;
+ }
+
+ i = bitmap_find(bmap, next_pipe);
+
+ if (i == -1) {
+ DEBUG(0,("ERROR! Out of pipe structures\n"));
+ return NULL;
+ }
+
+ next_pipe = (i+1) % MAX_OPEN_PIPES;
+
+ for (p = Pipes; p; p = p->next)
{
- if (!Pipes[i].open)
- {
- Pipes[i].open = True;
- Pipes[i].device_state = 0;
- Pipes[i].cnum = cnum;
- Pipes[i].uid = vuid;
+ DEBUG(5,("open pipes: name %s pnum=%x\n", p->name, p->pnum));
+ }
- Pipes[i].rhdr.data = NULL;
- Pipes[i].rdata.data = NULL;
- Pipes[i].rhdr.offset = 0;
- Pipes[i].rdata.offset = 0;
+ p = (pipes_struct *)malloc(sizeof(*p));
+ if (!p) return NULL;
- Pipes[i].max_rdata_len = 0;
- Pipes[i].hdr_offsets = 0;
+ ZERO_STRUCTP(p);
+ DLIST_ADD(Pipes, p);
- fstrcpy(Pipes[i].name, pipe_name);
+ bitmap_set(bmap, i);
+ i += pipe_handle_offset;
- DEBUG(4,("Opened pipe %s with handle %x\n",
- pipe_name, i + PIPE_HANDLE_OFFSET));
+ pipes_open++;
- set_chain_pnum(i);
+ p->pnum = i;
- return(i);
- }
+ p->open = True;
+ p->device_state = 0;
+ p->priority = 0;
+ p->conn = conn;
+ p->vuid = vuid;
+
+ p->rhdr.data = NULL;
+ p->rdata.data = NULL;
+ p->rhdr.offset = 0;
+ p->rdata.offset = 0;
+
+ p->file_offset = 0;
+ p->prev_pdu_file_offset = 0;
+ p->hdr_offsets = 0;
+
+ p->ntlmssp_validated = False;
+ p->ntlmssp_auth = False;
+
+ fstrcpy(p->name, pipe_name);
+
+ DEBUG(4,("Opened pipe %s with handle %x (pipes_open=%d)\n",
+ pipe_name, i, pipes_open));
+
+ chain_p = p;
+
+ /* OVERWRITE p as a temp variable, to display all open pipes */
+ for (p = Pipes; p; p = p->next)
+ {
+ DEBUG(5,("open pipes: name %s pnum=%x\n", p->name, p->pnum));
}
- DEBUG(1,("ERROR! Out of pipe structures - perhaps increase MAX_OPEN_PIPES?\n"));
-
- return(-1);
+ return chain_p;
}
-/****************************************************************************
- reads data from a pipe.
- headers are interspersed with the data at regular intervals. by the time
- this function is called, the start of the data could possibly have been
- read by an SMBtrans (max_rdata_len != 0).
-
- calling create_rpc_request() here is a fudge. the data should already
- have been prepared into arrays of headers + data stream sections.
+/****************************************************************************
+ writes data to a pipe.
+ SERIOUSLY ALPHA CODE!
****************************************************************************/
-int read_pipe(uint16 pnum, char *data, uint32 pos, int n)
+ssize_t write_pipe(pipes_struct *p, char *data, size_t n)
{
- int data_pos = pos;
- pipes_struct *p = &Pipes[pnum - PIPE_HANDLE_OFFSET];
- DEBUG(6,("read_pipe: %x", pnum));
+ prs_struct pd;
+ struct mem_buf data_buf;
- if (VALID_PNUM(pnum - PIPE_HANDLE_OFFSET))
- {
- DEBUG(6,("name: %s cnum: %d open: %s data_pos: %lx len: %lx",
- p->name,
- p->cnum,
- BOOLSTR(p->open),
- data_pos, n));
- }
+ DEBUG(6,("write_pipe: %x", p->pnum));
- if (OPEN_PNUM(pnum - PIPE_HANDLE_OFFSET))
- {
- int num = 0;
- int len = 0;
- uint32 hdr_num = 0;
- uint32 rpc_frag_pos = 0;
+ DEBUG(6,("name: %s open: %s len: %d",
+ p->name, BOOLSTR(p->open), n));
- DEBUG(6,("OK\n"));
+ dump_data(50, data, n);
- if (p->rhdr.data == NULL || p->rhdr.data->data == NULL ||
- p->rhdr.data->data_used == 0)
- {
- return 0;
- }
+ /* fake up a data buffer from the write_pipe data parameters */
+ mem_create(&data_buf, data, 0, n, 0, False);
+ data_buf.offset.start = 0;
+ data_buf.offset.end = n;
- DEBUG(6,("read_pipe: p: %p max_rdata_len: %d data_pos: %d num: %d\n",
- p, p->max_rdata_len, data_pos, num));
+ /* fake up a parsing structure */
+ pd.data = &data_buf;
+ pd.align = 4;
+ pd.io = True;
+ pd.offset = 0;
- /* the read request starts from where the SMBtrans2 left off. */
- data_pos += p->max_rdata_len;
+ return rpc_command(p, &pd) ? ((ssize_t)n) : -1;
+}
- rpc_frag_pos = data_pos % p->hdr.frag_len;
- /* headers accumulate an offset */
- data_pos -= p->hdr_offsets;
+/****************************************************************************
+ reads data from a pipe.
- len = mem_buf_len(p->rhdr.data);
- num = len - (int)data_pos;
+ headers are interspersed with the data at regular intervals. by the time
+ this function is called, the start of the data could possibly have been
+ read by an SMBtrans (file_offset != 0).
- if (num > n) num = n;
+ calling create_rpc_reply() here is a fudge. the data should already
+ have been prepared into arrays of headers + data stream sections.
- if (!IS_BITS_SET_ALL(p->hdr.flags, RPC_FLG_LAST))
- {
- DEBUG(5,("read_pipe: hdr_offsets: %d rpc_frag_pos: %d frag_len: %d\n",
- p->hdr_offsets, rpc_frag_pos, p->hdr.frag_len));
+ ****************************************************************************/
+int read_pipe(pipes_struct *p, char *data, uint32 pos, int n)
+{
+ int num = 0;
+ int pdu_len = 0;
+ uint32 hdr_num = 0;
+ int pdu_data_sent; /* amount of current pdu already sent */
+ int data_pos; /* entire rpc data sent - no headers, no auth verifiers */
+ int this_pdu_data_pos;
+
+ DEBUG(6,("read_pipe: %x name: %s open: %s pos: %d len: %d",
+ p->pnum, p->name, BOOLSTR(p->open),
+ pos, n));
+
+ if (!p || !p->open)
+ {
+ DEBUG(6,("pipe not open\n"));
+ return -1;
+ }
- if (rpc_frag_pos == 0)
- {
- /* this is subtracted from the total data bytes, later */
- hdr_num = 0x18;
- /* create and copy in a new header. */
- create_rpc_reply(p, data_pos, p->rdata.offset);
- mem_buf_copy(data, p->rhdr.data, 0, 0x18);
+ if (p->rhdr.data == NULL || p->rhdr.data->data == NULL ||
+ p->rhdr.data->data_used == 0)
+ {
+ return 0;
+ }
- /* make room in data stream for header */
- p->hdr_offsets += 0x18;
- data += 0x18;
+ DEBUG(6,("read_pipe: p: %p file_offset: %d file_pos: %d\n",
+ p, p->file_offset, n));
- DEBUG(6,("read_pipe: hdr_offsets: %d\n", p->hdr_offsets));
- }
- }
+ /* the read request starts from where the SMBtrans2 left off. */
+ data_pos = p->file_offset - p->hdr_offsets;
+ pdu_data_sent = p->file_offset - p->prev_pdu_file_offset;
+ this_pdu_data_pos = (pdu_data_sent == 0) ? 0 : (pdu_data_sent - 0x18);
- if (num > 0)
+ if (!IS_BITS_SET_ALL(p->hdr.flags, RPC_FLG_LAST))
+ {
+ /* intermediate fragment - possibility of another header */
+
+ DEBUG(5,("read_pipe: frag_len: %d data_pos: %d pdu_data_sent: %d\n",
+ p->hdr.frag_len, data_pos, pdu_data_sent));
+
+ if (pdu_data_sent == 0)
{
- DEBUG(6,("read_pipe: adjusted data_pos: %d num: %d\n",
- data_pos, num - hdr_num));
- mem_buf_copy(data, p->rhdr.data, data_pos, num - hdr_num);
+ DEBUG(6,("read_pipe: next fragment header\n"));
- return num;
- }
-
- return 0;
+ /* this is subtracted from the total data bytes, later */
+ hdr_num = 0x18;
+ p->hdr_offsets += 0x18;
+ data_pos -= 0x18;
+ /* create and copy in a new header. */
+ create_rpc_reply(p, data_pos, p->rdata.offset);
+ }
}
- else
+
+ pdu_len = mem_buf_len(p->rhdr.data);
+ num = pdu_len - this_pdu_data_pos;
+
+ DEBUG(6,("read_pipe: pdu_len: %d num: %d n: %d\n", pdu_len, num, n));
+
+ if (num > n) num = n;
+ if (num <= 0)
{
- DEBUG(6,("NOT\n"));
- return -1;
+ DEBUG(5,("read_pipe: 0 or -ve data length\n"));
+ return 0;
}
-}
-
-/****************************************************************************
- gets the name of a pipe
-****************************************************************************/
-BOOL get_rpc_pipe(int pnum, pipes_struct **p)
-{
- DEBUG(6,("get_rpc_pipe: "));
-
- /* mapping is PIPE_HANDLE_OFFSET up... */
- if (VALID_PNUM(pnum - PIPE_HANDLE_OFFSET))
+ if (num < hdr_num)
{
- DEBUG(6,("name: %s cnum: %d open: %s ",
- Pipes[pnum - PIPE_HANDLE_OFFSET].name,
- Pipes[pnum - PIPE_HANDLE_OFFSET].cnum,
- BOOLSTR(Pipes[pnum - PIPE_HANDLE_OFFSET].open)));
+ DEBUG(5,("read_pipe: warning - data read only part of a header\n"));
}
- if (OPEN_PNUM(pnum - PIPE_HANDLE_OFFSET))
+
+ mem_buf_copy(data, p->rhdr.data, pdu_data_sent, num);
+
+ p->file_offset += num;
+ pdu_data_sent += num;
+
+ if (hdr_num == 0x18 && num == 0x18)
{
- DEBUG(6,("OK\n"));
- (*p) = &(Pipes[pnum - PIPE_HANDLE_OFFSET]);
- return True;
+ DEBUG(6,("read_pipe: just header read\n"));
}
- else
+
+ if (pdu_data_sent == p->hdr.frag_len)
{
- DEBUG(6,("NOT\n"));
- return False;
+ DEBUG(6,("read_pipe: next fragment expected\n"));
+ p->prev_pdu_file_offset = p->file_offset;
}
+
+ return num;
}
+
/****************************************************************************
- gets the name of a pipe
+ wait device state on a pipe. exactly what this is for is unknown...
****************************************************************************/
-char *get_rpc_pipe_hnd_name(int pnum)
+BOOL wait_rpc_pipe_hnd_state(pipes_struct *p, uint16 priority)
{
- pipes_struct *p = NULL;
- get_rpc_pipe(pnum, &p);
- return p != NULL ? p->name : NULL;
+ if (p == NULL) return False;
+
+ if (p->open)
+ {
+ DEBUG(3,("%s Setting pipe wait state priority=%x on pipe (name=%s)\n",
+ timestring(), priority, p->name));
+
+ p->priority = priority;
+
+ return True;
+ }
+
+ DEBUG(3,("%s Error setting pipe wait state priority=%x (name=%s)\n",
+ timestring(), priority, p->name));
+ return False;
}
+
/****************************************************************************
set device state on a pipe. exactly what this is for is unknown...
****************************************************************************/
{
if (p == NULL) return False;
- if (P_OPEN(p))
- {
- DEBUG(3,("%s Setting pipe device state=%x on pipe (name=%s cnum=%d)\n",
- timestring(), device_state, p->name, p->cnum));
+ if (p->open) {
+ DEBUG(3,("%s Setting pipe device state=%x on pipe (name=%s)\n",
+ timestring(), device_state, p->name));
p->device_state = device_state;
-
+
return True;
- }
- else
- {
- DEBUG(3,("%s Error setting pipe device state=%x (name=%s cnum=%d)\n",
- timestring(), device_state, p->name, p->cnum));
- return False;
- }
+ }
+
+ DEBUG(3,("%s Error setting pipe device state=%x (name=%s)\n",
+ timestring(), device_state, p->name));
+ return False;
}
+
/****************************************************************************
close an rpc pipe
****************************************************************************/
-BOOL close_rpc_pipe_hnd(int pnum, int cnum)
+BOOL close_rpc_pipe_hnd(pipes_struct *p, connection_struct *conn)
{
- pipes_struct *p = NULL;
- get_rpc_pipe(pnum, &p);
- /* mapping is PIPE_HANDLE_OFFSET up... */
-
- if (p != NULL && P_OK(p, cnum))
- {
- DEBUG(3,("%s Closed pipe name %s pnum=%x cnum=%d\n",
- timestring(),Pipes[pnum-PIPE_HANDLE_OFFSET].name, pnum,cnum));
-
- p->open = False;
+ if (!p) {
+ DEBUG(0,("Invalid pipe in close_rpc_pipe_hnd\n"));
+ return False;
+ }
- p->rdata.offset = 0;
- p->rhdr.offset = 0;
mem_buf_free(&(p->rdata.data));
mem_buf_free(&(p->rhdr .data));
- return True;
- }
- else
- {
- DEBUG(3,("%s Error closing pipe pnum=%x cnum=%d\n",
- timestring(),pnum, cnum));
- return False;
- }
+ bitmap_clear(bmap, p->pnum - pipe_handle_offset);
+
+ pipes_open--;
+
+ DEBUG(4,("closed pipe name %s pnum=%x (pipes_open=%d)\n",
+ p->name, p->pnum, pipes_open));
+
+ DLIST_REMOVE(Pipes, p);
+
+ ZERO_STRUCTP(p);
+
+ free(p);
+
+ return True;
}
/****************************************************************************
close an rpc pipe
****************************************************************************/
-int get_rpc_pipe_num(char *buf, int where)
+pipes_struct *get_rpc_pipe_p(char *buf, int where)
{
- return (chain_pnum != -1 ? chain_pnum : SVAL(buf,where));
+ int pnum = SVAL(buf,where);
+
+ if (chain_p) return chain_p;
+
+ return get_rpc_pipe(pnum);
+}
+
+/****************************************************************************
+ close an rpc pipe
+****************************************************************************/
+pipes_struct *get_rpc_pipe(int pnum)
+{
+ pipes_struct *p;
+
+ DEBUG(4,("search for pipe pnum=%x\n", pnum));
+
+ for (p=Pipes;p;p=p->next)
+ {
+ DEBUG(5,("pipe name %s pnum=%x (pipes_open=%d)\n",
+ p->name, p->pnum, pipes_open));
+ }
+
+ for (p=Pipes;p;p=p->next)
+ {
+ if (p->pnum == pnum)
+ {
+ chain_p = p;
+ return p;
+ }
+ }
+
+ return NULL;
}
git.samba.org / samba.git / blobdiff