*
* 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
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ * along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
/* Since the SPOOLSS rpc routines are basically DOS 16-bit calls wrapped
#define MAGIC_DISPLAY_FREQUENCY 0xfade2bad
#define PHANTOM_DEVMODE_KEY "_p_f_a_n_t_0_m_"
-
-/* Table to map the driver version */
-/* to OS */
-static const char * drv_ver_to_os[] = {
- "WIN9X", /* driver version/cversion 0 */
- "", /* unused ? */
- "WINNT", /* driver version/cversion 2 */
- "WIN2K", /* driver version/cversion 3 */
-};
-
-static const char *get_drv_ver_to_os(int ver)
-{
- if (ver < 0 || ver > 3)
- return "";
- return drv_ver_to_os[ver];
-}
-
struct table_node {
const char *long_archi;
const char *short_archi;
static counter_printer_0 *counter_list;
-static struct cli_state notify_cli; /* print notify back-channel */
+static struct rpc_pipe_client *notify_cli_pipe; /* print notify back-channel pipe handle*/
static uint32 smb_connections=0;
/* in printing/nt_printing.c */
-extern STANDARD_MAPPING printer_std_mapping, printserver_std_mapping;
+extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
+
+/* API table for Xcv Monitor functions */
+
+struct xcv_api_table {
+ const char *name;
+ WERROR(*fn) (NT_USER_TOKEN *token, RPC_BUFFER *in, RPC_BUFFER *out, uint32 *needed);
+};
-#define OUR_HANDLE(hnd) (((hnd)==NULL)?"NULL":(IVAL((hnd)->data5,4)==(uint32)sys_getpid()?"OURS":"OTHER")), \
-((unsigned int)IVAL((hnd)->data5,4)),((unsigned int)sys_getpid())
/* translate between internal status numbers and NT status numbers */
static int nt_printj_status(int v)
return;
}
- result = cli_spoolss_reply_close_printer(¬ify_cli, notify_cli.mem_ctx, handle);
+ result = rpccli_spoolss_reply_close_printer(notify_cli_pipe, notify_cli_pipe->cli->mem_ctx, handle);
if (!W_ERROR_IS_OK(result))
DEBUG(0,("srv_spoolss_replycloseprinter: reply_close_printer failed [%s].\n",
/* if it's the last connection, deconnect the IPC$ share */
if (smb_connections==1) {
- cli_nt_session_close(¬ify_cli);
- cli_ulogoff(¬ify_cli);
- cli_shutdown(¬ify_cli);
- message_deregister(MSG_PRINTER_NOTIFY2);
+
+ cli_shutdown( notify_cli_pipe->cli );
+ notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
+
+ messaging_deregister(smbd_messaging_context(),
+ MSG_PRINTER_NOTIFY2, NULL);
/* Tell the connections db we're no longer interested in
* printer notify messages. */
if (Printer->notify.client_connected==True) {
int snum = -1;
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER) {
+ if ( Printer->printer_type == SPLHND_SERVER) {
snum = -1;
srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
- } else if (Printer->printer_type == PRINTER_HANDLE_IS_PRINTER) {
+ } else if (Printer->printer_type == SPLHND_PRINTER) {
snum = print_queue_snum(Printer->sharename);
if (snum != -1)
srv_spoolss_replycloseprinter(snum,
{
Printer_entry *find_printer = NULL;
- if(!find_policy_by_hnd(p,hnd,(void **)&find_printer)) {
+ if(!find_policy_by_hnd(p,hnd,(void **)(void *)&find_printer)) {
DEBUG(2,("find_printer_index_by_hnd: Printer handle not found: "));
return NULL;
}
return find_printer;
}
-#ifdef ENABLE_PRINT_HND_OBJECT_CACHE
-/****************************************************************************
- look for a printer object cached on an open printer handle
-****************************************************************************/
-
-WERROR find_printer_in_print_hnd_cache( TALLOC_CTX *ctx, NT_PRINTER_INFO_LEVEL_2 **info2,
- const char *servername, const char *printername )
-{
- Printer_entry *p;
-
- DEBUG(10,("find_printer_in_print_hnd_cache: printer [\\\\%s\\%s]\n",
- servername, printername));
-
- for ( p=printers_list; p; p=p->next )
- {
- if ( p->printer_type==PRINTER_HANDLE_IS_PRINTER
- && p->printer_info
- && strequal( p->sharename, printername )
- && strequal( p->servername, servername ) )
- {
- DEBUG(10,("Found printer\n"));
- *info2 = dup_printer_2( ctx, p->printer_info->info_2 );
- if ( *info2 )
- return WERR_OK;
- }
- }
-
- return WERR_INVALID_PRINTER_NAME;
-}
-
-/****************************************************************************
- destroy any cached printer_info_2 structures on open handles
-****************************************************************************/
-
-void invalidate_printer_hnd_cache( char *printername )
-{
- Printer_entry *p;
-
- DEBUG(10,("invalidate_printer_hnd_cache: printer [%s]\n", printername));
-
- for ( p=printers_list; p; p=p->next )
- {
- if ( p->printer_type==PRINTER_HANDLE_IS_PRINTER
- && p->printer_info
- && StrCaseCmp(p->sharename, printername)==0)
- {
- DEBUG(10,("invalidating printer_info cache for handl:\n"));
- free_a_printer( &p->printer_info, 2 );
- p->printer_info = NULL;
- }
- }
-
- return;
-}
-#endif
-
/****************************************************************************
Close printer index by handle.
****************************************************************************/
-static BOOL close_printer_handle(pipes_struct *p, POLICY_HND *hnd)
+static bool close_printer_handle(pipes_struct *p, POLICY_HND *hnd)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
pstring command;
int ret;
SE_PRIV se_printop = SE_PRINT_OPERATOR;
- BOOL is_print_op = False;
+ bool is_print_op = False;
/* can't fail if we don't try */
if ( (ret = smbrun(command, NULL)) == 0 ) {
/* Tell everyone we updated smb.conf. */
- message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
+ message_send_all(smbd_messaging_context(),
+ MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
}
if ( is_print_op )
Return the snum of a printer corresponding to an handle.
****************************************************************************/
-static BOOL get_printer_snum(pipes_struct *p, POLICY_HND *hnd, int *number)
+static bool get_printer_snum(pipes_struct *p, POLICY_HND *hnd, int *number,
+ struct share_params **params)
{
Printer_entry *Printer = find_printer_index_by_hnd(p, hnd);
}
switch (Printer->printer_type) {
- case PRINTER_HANDLE_IS_PRINTER:
+ case SPLHND_PRINTER:
DEBUG(4,("short name:%s\n", Printer->sharename));
*number = print_queue_snum(Printer->sharename);
return (*number != -1);
- case PRINTER_HANDLE_IS_PRINTSERVER:
+ case SPLHND_SERVER:
return False;
default:
return False;
Check if it's \\server or \\server\printer
****************************************************************************/
-static BOOL set_printer_hnd_printertype(Printer_entry *Printer, char *handlename)
+static bool set_printer_hnd_printertype(Printer_entry *Printer, char *handlename)
{
DEBUG(3,("Setting printer type=%s\n", handlename));
/* it's a print server */
if (*handlename=='\\' && *(handlename+1)=='\\' && !strchr_m(handlename+2, '\\')) {
DEBUGADD(4,("Printer is a print server\n"));
- Printer->printer_type = PRINTER_HANDLE_IS_PRINTSERVER;
+ Printer->printer_type = SPLHND_SERVER;
}
- /* it's a printer */
+ /* it's a printer (set_printer_hnd_name() will handle port monitors */
else {
DEBUGADD(4,("Printer is a printer\n"));
- Printer->printer_type = PRINTER_HANDLE_IS_PRINTER;
+ Printer->printer_type = SPLHND_PRINTER;
}
return True;
}
/****************************************************************************
- Set printer handle name.
+ Set printer handle name.. Accept names like \\server, \\server\printer,
+ \\server\SHARE, & "\\server\,XcvMonitor Standard TCP/IP Port" See
+ the MSDN docs regarding OpenPrinter() for details on the XcvData() and
+ XcvDataPort() interface.
****************************************************************************/
-static BOOL set_printer_hnd_name(Printer_entry *Printer, char *handlename)
+static bool set_printer_hnd_name(Printer_entry *Printer, char *handlename)
{
int snum;
int n_services=lp_numservices();
char *aprinter, *printername;
const char *servername;
fstring sname;
- BOOL found=False;
- NT_PRINTER_INFO_LEVEL *printer;
+ bool found=False;
+ NT_PRINTER_INFO_LEVEL *printer = NULL;
WERROR result;
DEBUG(4,("Setting printer name=%s (len=%lu)\n", handlename, (unsigned long)strlen(handlename)));
fstrcpy( Printer->servername, servername );
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER )
+ if ( Printer->printer_type == SPLHND_SERVER )
return True;
- if ( Printer->printer_type != PRINTER_HANDLE_IS_PRINTER )
+ if ( Printer->printer_type != SPLHND_PRINTER )
return False;
DEBUGADD(5, ("searching for [%s]\n", aprinter ));
-
- /* Search all sharenames first as this is easier than pulling
- the printer_info_2 off of disk */
- snum = find_service(aprinter);
+ /* check for the Port Monitor Interface */
- if ( lp_snum_ok(snum) && lp_print_ok(snum) ) {
+ if ( strequal( aprinter, SPL_XCV_MONITOR_TCPMON ) ) {
+ Printer->printer_type = SPLHND_PORTMON_TCP;
+ fstrcpy(sname, SPL_XCV_MONITOR_TCPMON);
+ found = True;
+ }
+ else if ( strequal( aprinter, SPL_XCV_MONITOR_LOCALMON ) ) {
+ Printer->printer_type = SPLHND_PORTMON_LOCAL;
+ fstrcpy(sname, SPL_XCV_MONITOR_LOCALMON);
found = True;
- fstrcpy( sname, aprinter );
}
+ /* Search all sharenames first as this is easier than pulling
+ the printer_info_2 off of disk. Don't use find_service() since
+ that calls out to map_username() */
+
/* do another loop to look for printernames */
for (snum=0; !found && snum<n_services; snum++) {
- /* no point in checking if this is not a printer or
- we aren't allowing printername != sharename */
+ /* no point going on if this is not a printer */
- if ( !(lp_snum_ok(snum)
- && lp_print_ok(snum)
- && !lp_force_printername(snum)) )
- {
+ if ( !(lp_snum_ok(snum) && lp_print_ok(snum)) )
continue;
+
+ fstrcpy(sname, lp_servicename(snum));
+ if ( strequal( aprinter, sname ) ) {
+ found = True;
+ break;
}
+
+ /* no point looking up the printer object if
+ we aren't allowing printername != sharename */
+ if ( lp_force_printername(snum) )
+ continue;
+
fstrcpy(sname, lp_servicename(snum));
printer = NULL;
printername++;
if ( strequal(printername, aprinter) ) {
+ free_a_printer( &printer, 2);
found = True;
+ break;
}
DEBUGADD(10, ("printername: %s\n", printername));
free_a_printer( &printer, 2);
}
+ free_a_printer( &printer, 2);
+
if ( !found ) {
DEBUGADD(4,("Printer not found\n"));
return False;
Find first available printer slot. creates a printer handle for you.
****************************************************************************/
-static BOOL open_printer_hnd(pipes_struct *p, POLICY_HND *hnd, char *name, uint32 access_granted)
+static bool open_printer_hnd(pipes_struct *p, POLICY_HND *hnd, char *name, uint32 access_granted)
{
Printer_entry *new_printer;
given by (notify_type, notify_field).
**************************************************************************/
-static BOOL is_monitoring_event_flags(uint32 flags, uint16 notify_type,
+static bool is_monitoring_event_flags(uint32 flags, uint16 notify_type,
uint16 notify_field)
{
return True;
}
-static BOOL is_monitoring_event(Printer_entry *p, uint16 notify_type,
+static bool is_monitoring_event(Printer_entry *p, uint16 notify_type,
uint16 notify_field)
{
SPOOL_NOTIFY_OPTION *option = p->notify.option;
return;
}
- if (!prs_init(&ps, MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL)) {
+ if (!prs_init(&ps, RPC_MAX_PDU_FRAG_LEN, mem_ctx, MARSHALL)) {
DEBUG(5, ("notify_system_time: prs_init() failed\n"));
return;
}
if (!make_systemtime(&systime, gmtime((time_t *)msg->notify.data))) {
DEBUG(5, ("notify_system_time: unable to make systemtime\n"));
+ prs_mem_free(&ps);
return;
}
- if (!spoolss_io_system_time("", &ps, 0, &systime))
+ if (!spoolss_io_system_time("", &ps, 0, &systime)) {
+ prs_mem_free(&ps);
return;
+ }
data->notify_data.data.length = prs_offset(&ps);
- data->notify_data.data.string = TALLOC(mem_ctx, prs_offset(&ps));
-
- prs_copy_all_data_out((char *)data->notify_data.data.string, &ps);
+ if (prs_offset(&ps)) {
+ data->notify_data.data.string = (uint16 *)
+ TALLOC(mem_ctx, prs_offset(&ps));
+ if (!data->notify_data.data.string) {
+ prs_mem_free(&ps);
+ return;
+ }
+ prs_copy_all_data_out((char *)data->notify_data.data.string, &ps);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
prs_mem_free(&ps);
}
/* need to allocate own copy of data */
if ( msg->len != 0 )
- msg_grp->msgs[new_slot].notify.data = TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
+ msg_grp->msgs[new_slot].notify.data = (char *)
+ TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
return ctr->num_groups;
}
/* For this printer? Print servers always receive
notifications. */
- if ( ( p->printer_type == PRINTER_HANDLE_IS_PRINTER ) &&
+ if ( ( p->printer_type == SPLHND_PRINTER ) &&
( !strequal(msg_group->printername, p->sharename) ) )
continue;
/* allocate the max entries possible */
data = TALLOC_ARRAY( mem_ctx, SPOOL_NOTIFY_INFO_DATA, msg_group->num_msgs);
+ if (!data) {
+ return;
+ }
+
ZERO_STRUCTP(data);
/* build the array of change notifications */
* --jerry
*/
- if ( ( p->printer_type == PRINTER_HANDLE_IS_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
+ if ( ( p->printer_type == SPLHND_PRINTER ) && ( msg->type == PRINTER_NOTIFY_TYPE ) )
id = 0;
else
id = msg->id;
}
if ( sending_msg_count ) {
- cli_spoolss_rrpcn( ¬ify_cli, mem_ctx, &p->notify.client_hnd,
+ rpccli_spoolss_rrpcn( notify_cli_pipe, mem_ctx, &p->notify.client_hnd,
data_len, data, p->notify.change, 0 );
}
}
/***********************************************************************
**********************************************************************/
-static BOOL notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
+static bool notify2_unpack_msg( SPOOLSS_NOTIFY_MSG *msg, struct timeval *tv, void *buf, size_t len )
{
uint32 tv_sec, tv_usec;
/* Unpack message */
- offset += tdb_unpack((char *)buf + offset, len - offset, "f",
+ offset += tdb_unpack((uint8 *)buf + offset, len - offset, "f",
msg->printer);
- offset += tdb_unpack((char *)buf + offset, len - offset, "ddddddd",
+ offset += tdb_unpack((uint8 *)buf + offset, len - offset, "ddddddd",
&tv_sec, &tv_usec,
&msg->type, &msg->field, &msg->id, &msg->len, &msg->flags);
if (msg->len == 0)
- tdb_unpack((char *)buf + offset, len - offset, "dd",
+ tdb_unpack((uint8 *)buf + offset, len - offset, "dd",
&msg->notify.value[0], &msg->notify.value[1]);
else
- tdb_unpack((char *)buf + offset, len - offset, "B",
+ tdb_unpack((uint8 *)buf + offset, len - offset, "B",
&msg->len, &msg->notify.data);
DEBUG(3, ("notify2_unpack_msg: got NOTIFY2 message for printer %s, jobid %u type %d, field 0x%02x, flags 0x%04x\n",
DEBUG(3, ("notify2_unpack_msg: value1 = %d, value2 = %d\n", msg->notify.value[0],
msg->notify.value[1]));
else
- dump_data(3, msg->notify.data, msg->len);
+ dump_data(3, (uint8 *)msg->notify.data, msg->len);
return True;
}
Receive a notify2 message list
********************************************************************/
-static void receive_notify2_message_list(int msg_type, pid_t src, void *msg, size_t len)
+static void receive_notify2_message_list(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
size_t msg_count, i;
- char *buf = (char *)msg;
+ char *buf = (char *)data->data;
char *msg_ptr;
size_t msg_len;
SPOOLSS_NOTIFY_MSG notify;
SPOOLSS_NOTIFY_MSG_CTR messages;
int num_groups;
- if (len < 4) {
+ if (data->length < 4) {
DEBUG(0,("receive_notify2_message_list: bad message format (len < 4)!\n"));
return;
}
for ( i=0; i<msg_count; i++ ) {
struct timeval msg_tv;
- if (msg_ptr + 4 - buf > len) {
+ if (msg_ptr + 4 - buf > data->length) {
DEBUG(0,("receive_notify2_message_list: bad message format (len > buf_size) !\n"));
return;
}
msg_len = IVAL(msg_ptr,0);
msg_ptr += 4;
- if (msg_ptr + msg_len - buf > len) {
+ if (msg_ptr + msg_len - buf > data->length) {
DEBUG(0,("receive_notify2_message_list: bad message format (bad len) !\n"));
return;
}
return;
}
-#ifdef ENABLE_PRINT_HND_OBJECT_CACHE
-/********************************************************************
- callback to MSG_PRINTER_CHANGED. When a printer is changed by
- one smbd, all of processes must clear their printer cache immediately.
- ********************************************************************/
-
-void receive_printer_mod_msg(int msg_type, pid_t src, void *buf, size_t len)
-{
- fstring printername;
-
- fstrcpy( printername, buf );
-
- DEBUG(10,("receive_printer_mod_msg: Printer change [%s]\n", printername ));
-
- invalidate_printer_hnd_cache( printername );
-}
-#endif
-
/********************************************************************
Send a message to ourself about new driver being installed
so we can upgrade the information for each printer bound to this
driver
********************************************************************/
-static BOOL srv_spoolss_drv_upgrade_printer(char* drivername)
+static bool srv_spoolss_drv_upgrade_printer(char* drivername)
{
int len = strlen(drivername);
DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
drivername));
- message_send_pid(sys_getpid(), MSG_PRINTER_DRVUPGRADE, drivername, len+1, False);
+ messaging_send_buf(smbd_messaging_context(), procid_self(),
+ MSG_PRINTER_DRVUPGRADE,
+ (uint8 *)drivername, len+1);
return True;
}
over all printers, upgrading ones as necessary
**********************************************************************/
-void do_drv_upgrade_printer(int msg_type, pid_t src, void *buf, size_t len)
+void do_drv_upgrade_printer(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
fstring drivername;
int snum;
int n_services = lp_numservices();
+ size_t len;
- len = MIN(len,sizeof(drivername)-1);
- strncpy(drivername, buf, len);
+ len = MIN(data->length,sizeof(drivername)-1);
+ strncpy(drivername, (const char *)data->data, len);
DEBUG(10,("do_drv_upgrade_printer: Got message for new driver [%s]\n", drivername ));
client_connected == True */
while ( printer )
{
- if ( (printer->printer_type == PRINTER_HANDLE_IS_PRINTER)
+ if ( (printer->printer_type == SPLHND_PRINTER)
&& printer->notify.client_connected )
{
snum = print_queue_snum(printer->sharename);
driver
********************************************************************/
-static BOOL srv_spoolss_reset_printerdata(char* drivername)
+static bool srv_spoolss_reset_printerdata(char* drivername)
{
int len = strlen(drivername);
DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
drivername));
- message_send_pid(sys_getpid(), MSG_PRINTERDATA_INIT_RESET, drivername, len+1, False);
+ messaging_send_buf(smbd_messaging_context(), procid_self(),
+ MSG_PRINTERDATA_INIT_RESET,
+ (uint8 *)drivername, len+1);
return True;
}
over all printers, resetting printer data as neessary
**********************************************************************/
-void reset_all_printerdata(int msg_type, pid_t src, void *buf, size_t len)
+void reset_all_printerdata(struct messaging_context *msg,
+ void *private_data,
+ uint32_t msg_type,
+ struct server_id server_id,
+ DATA_BLOB *data)
{
fstring drivername;
int snum;
int n_services = lp_numservices();
+ size_t len;
- len = MIN( len, sizeof(drivername)-1 );
- strncpy( drivername, buf, len );
+ len = MIN( data->length, sizeof(drivername)-1 );
+ strncpy( drivername, (const char *)data->data, len );
DEBUG(10,("reset_all_printerdata: Got message for new driver [%s]\n", drivername ));
/* bulk copy first */
- d = TALLOC_MEMDUP(ctx, devmode, sizeof(DEVICEMODE));
+ d = (DEVICEMODE *)TALLOC_MEMDUP(ctx, devmode, sizeof(DEVICEMODE));
if (!d)
return NULL;
len = unistrlen(devmode->devicename.buffer);
if (len != -1) {
d->devicename.buffer = TALLOC_ARRAY(ctx, uint16, len);
+ if (!d->devicename.buffer) {
+ return NULL;
+ }
if (unistrcpy(d->devicename.buffer, devmode->devicename.buffer) != len)
return NULL;
}
len = unistrlen(devmode->formname.buffer);
if (len != -1) {
d->devicename.buffer = TALLOC_ARRAY(ctx, uint16, len);
+ if (!d->devicename.buffer) {
+ return NULL;
+ }
if (unistrcpy(d->formname.buffer, devmode->formname.buffer) != len)
return NULL;
}
- d->dev_private = TALLOC_MEMDUP(ctx, devmode->dev_private, devmode->driverextra);
-
+ if (devmode->driverextra) {
+ d->dev_private = (uint8 *)TALLOC_MEMDUP(ctx, devmode->dev_private,
+ devmode->driverextra);
+ if (!d->dev_private) {
+ return NULL;
+ }
+ } else {
+ d->dev_private = NULL;
+ }
return d;
}
}
/********************************************************************
- * spoolss_open_printer
- *
- * If the openprinterex rpc call contains a devmode,
- * it's a per-user one. This per-user devmode is derivated
- * from the global devmode. Openprinterex() contains a per-user
- * devmode for when you do EMF printing and spooling.
- * In the EMF case, the NT workstation is only doing half the job
- * of rendering the page. The other half is done by running the printer
- * driver on the server.
- * The EMF file doesn't contain the page description (paper size, orientation, ...).
- * The EMF file only contains what is to be printed on the page.
- * So in order for the server to know how to print, the NT client sends
- * a devicemode attached to the openprinterex call.
- * But this devicemode is short lived, it's only valid for the current print job.
- *
- * If Samba would have supported EMF spooling, this devicemode would
- * have been attached to the handle, to sent it to the driver to correctly
- * rasterize the EMF file.
- *
- * As Samba only supports RAW spooling, we only receive a ready-to-print file,
- * we just act as a pass-thru between windows and the printer.
- *
- * In order to know that Samba supports only RAW spooling, NT has to call
- * getprinter() at level 2 (attribute field) or NT has to call startdoc()
- * and until NT sends a RAW job, we refuse it.
- *
- * But to call getprinter() or startdoc(), you first need a valid handle,
- * and to get an handle you have to call openprintex(). Hence why you have
- * a devicemode in the openprinterex() call.
- *
- *
- * Differences between NT4 and NT 2000.
- * NT4:
- * ---
- * On NT4, you only have a global devicemode. This global devicemode can be changed
- * by the administrator (or by a user with enough privs). Everytime a user
- * wants to print, the devicemode is resetted to the default. In Word, everytime
- * you print, the printer's characteristics are always reset to the global devicemode.
- *
- * NT 2000:
- * -------
- * In W2K, there is the notion of per-user devicemode. The first time you use
- * a printer, a per-user devicemode is build from the global devicemode.
- * If you change your per-user devicemode, it is saved in the registry, under the
- * H_KEY_CURRENT_KEY sub_tree. So that everytime you print, you have your default
- * printer preferences available.
- *
- * To change the per-user devicemode: it's the "Printing Preferences ..." button
- * on the General Tab of the printer properties windows.
- *
- * To change the global devicemode: it's the "Printing Defaults..." button
- * on the Advanced Tab of the printer properties window.
- *
- * JFM.
********************************************************************/
WERROR _spoolss_open_printer_ex( pipes_struct *p, SPOOL_Q_OPEN_PRINTER_EX *q_u, SPOOL_R_OPEN_PRINTER_EX *r_u)
fstring name;
int snum;
- struct current_user user;
Printer_entry *Printer=NULL;
if ( !q_u->printername )
/* some sanity check because you can open a printer or a print server */
/* aka: \\server\printer or \\server */
- unistr2_to_ascii(name, q_u->printername, sizeof(name)-1);
+ unistr2_to_ascii(name, q_u->printername, sizeof(name));
DEBUGADD(3,("checking name: %s\n",name));
return WERR_INVALID_PRINTER_NAME;
}
- get_current_user(&user, p);
-
/*
* First case: the user is opening the print server:
*
* Second case: the user is opening a printer:
* NT doesn't let us connect to a printer if the connecting user
* doesn't have print permission.
+ *
+ * Third case: user is opening a Port Monitor
+ * access checks same as opening a handle to the print server.
*/
- if (Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER)
+ switch (Printer->printer_type )
{
+ case SPLHND_SERVER:
+ case SPLHND_PORTMON_TCP:
+ case SPLHND_PORTMON_LOCAL:
/* Printserver handles use global struct... */
snum = -1;
if (printer_default->access_required &
~(SERVER_ACCESS_ADMINISTER | SERVER_ACCESS_ENUMERATE)) {
- DEBUG(3, ("access DENIED for non-printserver bits"));
+ DEBUG(3, ("access DENIED for non-printserver bits\n"));
close_printer_handle(p, handle);
return WERR_ACCESS_DENIED;
}
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
and not a printer admin, then fail */
- if ( user.uid != 0
- && !user_has_privileges( user.nt_user_token, &se_printop )
- && !user_in_list(uidtoname(user.uid), lp_printer_admin(snum), user.groups, user.ngroups) )
- {
+ if ((p->pipe_user.ut.uid != 0) &&
+ !user_has_privileges(p->pipe_user.nt_user_token,
+ &se_printop ) &&
+ !token_contains_name_in_list(
+ uidtoname(p->pipe_user.ut.uid), NULL,
+ p->pipe_user.nt_user_token,
+ lp_printer_admin(snum))) {
close_printer_handle(p, handle);
return WERR_ACCESS_DENIED;
}
? "SERVER_ACCESS_ADMINISTER" : "SERVER_ACCESS_ENUMERATE" ));
/* We fall through to return WERR_OK */
-
- }
- else
- {
+ break;
+
+ case SPLHND_PRINTER:
/* NT doesn't let us connect to a printer if the connecting user
doesn't have print permission. */
- if (!get_printer_snum(p, handle, &snum)) {
+ if (!get_printer_snum(p, handle, &snum, NULL)) {
close_printer_handle(p, handle);
return WERR_BADFID;
}
return WERR_ACCESS_DENIED;
}
- if (!user_ok(uidtoname(user.uid), snum, user.groups, user.ngroups) || !print_access_check(&user, snum, printer_default->access_required)) {
+ if (!user_ok_token(uidtoname(p->pipe_user.ut.uid),
+ p->pipe_user.nt_user_token, snum) ||
+ !print_access_check(&p->pipe_user, snum,
+ printer_default->access_required)) {
DEBUG(3, ("access DENIED for printer open\n"));
close_printer_handle(p, handle);
return WERR_ACCESS_DENIED;
DEBUG(4,("Setting printer access = %s\n", (printer_default->access_required == PRINTER_ACCESS_ADMINISTER)
? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
+ break;
+
+ default:
+ /* sanity check to prevent programmer error */
+ return WERR_BADFID;
}
Printer->access_granted = printer_default->access_required;
* save it here in case we get a job submission on this handle
*/
- if ( (Printer->printer_type != PRINTER_HANDLE_IS_PRINTSERVER)
+ if ( (Printer->printer_type != SPLHND_SERVER)
&& q_u->printer_default.devmode_cont.devmode_ptr )
{
convert_devicemode( Printer->sharename, q_u->printer_default.devmode_cont.devmode,
/****************************************************************************
****************************************************************************/
-static BOOL convert_printer_info(const SPOOL_PRINTER_INFO_LEVEL *uni,
+static bool convert_printer_info(const SPOOL_PRINTER_INFO_LEVEL *uni,
NT_PRINTER_INFO_LEVEL *printer, uint32 level)
{
- BOOL ret = True;
+ bool ret;
switch (level) {
case 2:
- ret = uni_2_asc_printer_info_2(uni->info_2, &printer->info_2);
- break;
- default:
- break;
+ /* allocate memory if needed. Messy because
+ convert_printer_info is used to update an existing
+ printer or build a new one */
+
+ if ( !printer->info_2 ) {
+ printer->info_2 = TALLOC_ZERO_P( printer, NT_PRINTER_INFO_LEVEL_2 );
+ if ( !printer->info_2 ) {
+ DEBUG(0,("convert_printer_info: talloc() failed!\n"));
+ return False;
+ }
+ }
+
+ ret = uni_2_asc_printer_info_2(uni->info_2, printer->info_2);
+ printer->info_2->setuptime = time(NULL);
+
+ return ret;
}
- return ret;
+ return False;
}
-static BOOL convert_printer_driver_info(const SPOOL_PRINTER_DRIVER_INFO_LEVEL *uni,
+static bool convert_printer_driver_info(const SPOOL_PRINTER_DRIVER_INFO_LEVEL *uni,
NT_PRINTER_DRIVER_INFO_LEVEL *printer, uint32 level)
{
- BOOL result = True;
+ bool result = True;
switch (level) {
case 3:
return result;
}
-BOOL convert_devicemode(const char *printername, const DEVICEMODE *devmode,
+bool convert_devicemode(const char *printername, const DEVICEMODE *devmode,
NT_DEVICEMODE **pp_nt_devmode)
{
NT_DEVICEMODE *nt_devmode = *pp_nt_devmode;
return WERR_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
Printer->document_started=False;
- print_job_end(snum, Printer->jobid,True);
+ print_job_end(snum, Printer->jobid,NORMAL_CLOSE);
/* error codes unhandled so far ... */
return WERR_OK;
NT_PRINTER_DRIVER_INFO_LEVEL info;
NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
int version;
- struct current_user user;
WERROR status;
WERROR status_win2k = WERR_ACCESS_DENIED;
+ SE_PRIV se_printop = SE_PRINT_OPERATOR;
- get_current_user(&user, p);
-
- unistr2_to_ascii(driver, &q_u->driver, sizeof(driver)-1 );
- unistr2_to_ascii(arch, &q_u->arch, sizeof(arch)-1 );
+ /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
+ and not a printer admin, then fail */
+
+ if ( (p->pipe_user.ut.uid != 0)
+ && !user_has_privileges(p->pipe_user.nt_user_token, &se_printop )
+ && !token_contains_name_in_list( uidtoname(p->pipe_user.ut.uid),
+ NULL, p->pipe_user.nt_user_token, lp_printer_admin(-1)) )
+ {
+ return WERR_ACCESS_DENIED;
+ }
+
+ unistr2_to_ascii(driver, &q_u->driver, sizeof(driver));
+ unistr2_to_ascii(arch, &q_u->arch, sizeof(arch));
/* check that we have a valid driver name first */
/* if we get to here, we now have 2 driver info structures to remove */
/* remove the Win2k driver first*/
- status_win2k = delete_printer_driver(info_win2k.info_3, &user, 3, False );
+ status_win2k = delete_printer_driver(info_win2k.info_3, &p->pipe_user, 3, False );
free_a_printer_driver( info_win2k, 3 );
/* this should not have failed---if it did, report to client */
if ( !W_ERROR_IS_OK(status_win2k) )
+ {
+ status = status_win2k;
goto done;
+ }
}
}
- status = delete_printer_driver(info.info_3, &user, version, False);
+ status = delete_printer_driver(info.info_3, &p->pipe_user, version, False);
/* if at least one of the deletes succeeded return OK */
NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
int version;
uint32 flags = q_u->delete_flags;
- BOOL delete_files;
- struct current_user user;
+ bool delete_files;
WERROR status;
WERROR status_win2k = WERR_ACCESS_DENIED;
+ SE_PRIV se_printop = SE_PRINT_OPERATOR;
- get_current_user(&user, p);
+ /* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
+ and not a printer admin, then fail */
+
+ if ( (p->pipe_user.ut.uid != 0)
+ && !user_has_privileges(p->pipe_user.nt_user_token, &se_printop )
+ && !token_contains_name_in_list( uidtoname(p->pipe_user.ut.uid),
+ NULL, p->pipe_user.nt_user_token, lp_printer_admin(-1)) )
+ {
+ return WERR_ACCESS_DENIED;
+ }
- unistr2_to_ascii(driver, &q_u->driver, sizeof(driver)-1 );
- unistr2_to_ascii(arch, &q_u->arch, sizeof(arch)-1 );
+ unistr2_to_ascii(driver, &q_u->driver, sizeof(driver));
+ unistr2_to_ascii(arch, &q_u->arch, sizeof(arch));
/* check that we have a valid driver name first */
if ((version=get_version_id(arch)) == -1) {
/* if we get to here, we now have 2 driver info structures to remove */
/* remove the Win2k driver first*/
- status_win2k = delete_printer_driver(info_win2k.info_3, &user, 3, delete_files);
+ status_win2k = delete_printer_driver(info_win2k.info_3, &p->pipe_user, 3, delete_files);
free_a_printer_driver( info_win2k, 3 );
/* this should not have failed---if it did, report to client */
}
}
- status = delete_printer_driver(info.info_3, &user, version, delete_files);
+ status = delete_printer_driver(info.info_3, &p->pipe_user, version, delete_files);
if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
status = WERR_OK;
WERROR set_printer_dataex( NT_PRINTER_INFO_LEVEL *printer, const char *key, const char *value,
uint32 type, uint8 *data, int real_len )
{
- delete_printer_data( printer->info_2, key, value );
-
+ /* the registry objects enforce uniqueness based on value name */
+
return add_printer_data( printer->info_2, key, value, type, data, real_len );
}
*type = REG_DWORD;
if ( !(*data = TALLOC_ARRAY(ctx, uint8, sizeof(uint32) )) )
return WERR_NOMEM;
+ SIVAL(*data, 0, 0x00);
*needed = 0x4;
return WERR_OK;
}
goto done;
}
- unistr2_to_ascii(value, valuename, sizeof(value)-1);
+ unistr2_to_ascii(value, valuename, sizeof(value));
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER )
+ if ( Printer->printer_type == SPLHND_SERVER )
status = getprinterdata_printer_server( p->mem_ctx, value, type, data, needed, *out_size );
else
{
- if ( !get_printer_snum(p,handle, &snum) ) {
+ if ( !get_printer_snum(p,handle, &snum, NULL) ) {
status = WERR_BADFID;
goto done;
}
if ( printer )
free_a_printer( &printer, 2 );
return WERR_NOMEM;
- }
- }
- else {
+ }
+ } else {
*data = NULL;
}
}
Connect to the client machine.
**********************************************************/
-static BOOL spoolss_connect_to_client(struct cli_state *the_cli,
+static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
struct in_addr *client_ip, const char *remote_machine)
{
- ZERO_STRUCTP(the_cli);
-
- if(cli_initialise(the_cli) == NULL) {
- DEBUG(0,("spoolss_connect_to_client: unable to initialize client connection.\n"));
- return False;
- }
-
- if ( is_zero_ip(*client_ip) ) {
- if(!resolve_name( remote_machine, &the_cli->dest_ip, 0x20)) {
- DEBUG(0,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
- cli_shutdown(the_cli);
- return False;
+ NTSTATUS ret;
+ struct cli_state *the_cli;
+ struct in_addr rm_addr;
+
+ if ( is_zero_ip_v4(*client_ip) ) {
+ if ( !resolve_name( remote_machine, &rm_addr, 0x20) ) {
+ DEBUG(2,("spoolss_connect_to_client: Can't resolve address for %s\n", remote_machine));
+ return False;
}
- if (ismyip(the_cli->dest_ip)) {
+ if ( ismyip_v4( rm_addr )) {
DEBUG(0,("spoolss_connect_to_client: Machine %s is one of our addresses. Cannot add to ourselves.\n", remote_machine));
- cli_shutdown(the_cli);
return False;
}
- }
- else {
- the_cli->dest_ip.s_addr = client_ip->s_addr;
+ } else {
+ rm_addr.s_addr = client_ip->s_addr;
DEBUG(5,("spoolss_connect_to_client: Using address %s (no name resolution necessary)\n",
inet_ntoa(*client_ip) ));
}
- if (!cli_connect(the_cli, remote_machine, &the_cli->dest_ip)) {
- DEBUG(0,("spoolss_connect_to_client: unable to connect to SMB server on machine %s. Error was : %s.\n", remote_machine, cli_errstr(the_cli) ));
- cli_shutdown(the_cli);
- return False;
- }
-
- if (!attempt_netbios_session_request(the_cli, global_myname(), remote_machine, &the_cli->dest_ip)) {
- DEBUG(0,("spoolss_connect_to_client: machine %s rejected the NetBIOS session request.\n",
- remote_machine));
- cli_shutdown(the_cli);
- return False;
- }
+ /* setup the connection */
- the_cli->protocol = PROTOCOL_NT1;
- cli_setup_signing_state(the_cli, lp_client_signing());
-
- if (!cli_negprot(the_cli)) {
- DEBUG(0,("spoolss_connect_to_client: machine %s rejected the negotiate protocol. Error was : %s.\n", remote_machine, cli_errstr(the_cli) ));
- cli_shutdown(the_cli);
- return False;
- }
+ ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
+ &rm_addr, 0, "IPC$", "IPC",
+ "", /* username */
+ "", /* domain */
+ "", /* password */
+ 0, lp_client_signing(), NULL );
- if (the_cli->protocol != PROTOCOL_NT1) {
- DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
- cli_shutdown(the_cli);
+ if ( !NT_STATUS_IS_OK( ret ) ) {
+ DEBUG(2,("spoolss_connect_to_client: connection to [%s] failed!\n",
+ remote_machine ));
return False;
- }
-
- /*
- * Do an anonymous session setup.
- */
-
- if (!cli_session_setup(the_cli, "", "", 0, "", 0, "")) {
- DEBUG(0,("spoolss_connect_to_client: machine %s rejected the session setup. Error was : %s.\n", remote_machine, cli_errstr(the_cli) ));
- cli_shutdown(the_cli);
- return False;
- }
-
- if (!(the_cli->sec_mode & 1)) {
- DEBUG(0,("spoolss_connect_to_client: machine %s isn't in user level security mode\n", remote_machine));
+ }
+
+ if ( the_cli->protocol != PROTOCOL_NT1 ) {
+ DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
cli_shutdown(the_cli);
return False;
}
- if (!cli_send_tconX(the_cli, "IPC$", "IPC", "", 1)) {
- DEBUG(0,("spoolss_connect_to_client: machine %s rejected the tconX on the IPC$ share. Error was : %s.\n", remote_machine, cli_errstr(the_cli) ));
- cli_shutdown(the_cli);
- return False;
- }
-
/*
* Ok - we have an anonymous connection to the IPC$ share.
* Now start the NT Domain stuff :-).
*/
- if(cli_nt_session_open(the_cli, PI_SPOOLSS) == False) {
- DEBUG(0,("spoolss_connect_to_client: unable to open the domain client session to machine %s. Error was : %s.\n", remote_machine, cli_errstr(the_cli)));
- cli_nt_session_close(the_cli);
- cli_ulogoff(the_cli);
+ if ( !(*pp_pipe = cli_rpc_pipe_open_noauth(the_cli, PI_SPOOLSS, &ret)) ) {
+ DEBUG(2,("spoolss_connect_to_client: unable to open the spoolss pipe on machine %s. Error was : %s.\n",
+ remote_machine, nt_errstr(ret)));
cli_shutdown(the_cli);
return False;
}
+ /* make sure to save the cli_state pointer. Keep its own talloc_ctx */
+
+ (*pp_pipe)->cli = the_cli;
+
return True;
}
Connect to the client.
****************************************************************************/
-static BOOL srv_spoolss_replyopenprinter(int snum, const char *printer,
+static bool srv_spoolss_replyopenprinter(int snum, const char *printer,
uint32 localprinter, uint32 type,
POLICY_HND *handle, struct in_addr *client_ip)
{
fstrcpy(unix_printer, printer+2); /* the +2 is to strip the leading 2 backslashs */
- ZERO_STRUCT(notify_cli);
-
- if(!spoolss_connect_to_client(¬ify_cli, client_ip, unix_printer))
+ if ( !spoolss_connect_to_client( ¬ify_cli_pipe, client_ip, unix_printer ))
return False;
- message_register(MSG_PRINTER_NOTIFY2, receive_notify2_message_list);
+ messaging_register(smbd_messaging_context(), NULL,
+ MSG_PRINTER_NOTIFY2,
+ receive_notify2_message_list);
/* Tell the connections db we're now interested in printer
* notify messages. */
register_message_flags( True, FLAG_MSG_PRINT_NOTIFY );
smb_connections++;
- result = cli_spoolss_reply_open_printer(¬ify_cli, notify_cli.mem_ctx, printer, localprinter,
+ result = rpccli_spoolss_reply_open_printer(notify_cli_pipe, notify_cli_pipe->cli->mem_ctx, printer, localprinter,
type, handle);
if (!W_ERROR_IS_OK(result))
Printer->notify.option=dup_spool_notify_option(option);
unistr2_to_ascii(Printer->notify.localmachine, localmachine,
- sizeof(Printer->notify.localmachine)-1);
+ sizeof(Printer->notify.localmachine));
/* Connect to the client machine and send a ReplyOpenPrinter */
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER)
+ if ( Printer->printer_type == SPLHND_SERVER)
snum = -1;
- else if ( (Printer->printer_type == PRINTER_HANDLE_IS_PRINTER) &&
- !get_printer_snum(p, handle, &snum) )
+ else if ( (Printer->printer_type == SPLHND_PRINTER) &&
+ !get_printer_snum(p, handle, &snum, NULL) )
return WERR_BADFID;
client_ip.s_addr = inet_addr(p->conn->client_address);
len = rpcstr_push(temp, printer->info_2->servername, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
len = rpcstr_push(temp, p, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
}
-
- memcpy(data->notify_data.data.string, temp, len);
}
/*******************************************************************
len = rpcstr_push(temp, lp_servicename(snum), sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
-
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
}
- memcpy(data->notify_data.data.string, temp, len);
}
/*******************************************************************
len = rpcstr_push(temp, printer->info_2->portname, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
len = rpcstr_push(temp, printer->info_2->drivername, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
len = rpcstr_push(temp, printer->info_2->comment, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
len = rpcstr_push(temp, printer->info_2->location,sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
NT_PRINTER_INFO_LEVEL *printer,
TALLOC_CTX *mem_ctx)
{
+ /* for a dummy implementation we have to zero the fields */
+ data->notify_data.data.length = 0;
+ data->notify_data.data.string = NULL;
}
/*******************************************************************
len = rpcstr_push(temp, printer->info_2->sepfile, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
len = rpcstr_push(temp, printer->info_2->printprocessor, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
len = rpcstr_push(temp, printer->info_2->parameters, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
len = rpcstr_push(temp, printer->info_2->datatype, sizeof(pstring)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
NT_PRINTER_INFO_LEVEL *printer,
TALLOC_CTX *mem_ctx)
{
- data->notify_data.sd.size = printer->info_2->secdesc_buf->len;
- data->notify_data.sd.desc = dup_sec_desc( mem_ctx, printer->info_2->secdesc_buf->sec ) ;
+ data->notify_data.sd.size = printer->info_2->secdesc_buf->sd_size;
+ data->notify_data.sd.desc = dup_sec_desc( mem_ctx, printer->info_2->secdesc_buf->sd ) ;
}
/*******************************************************************
len = rpcstr_push(temp, queue->fs_user, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
len = rpcstr_push(temp, queue->fs_file, sizeof(temp)-2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
len = rpcstr_push(temp, p, sizeof(temp) - 2, STR_TERMINATE);
data->notify_data.data.length = len;
- data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
+ if (len) {
+ data->notify_data.data.string = (uint16 *)TALLOC(mem_ctx, len);
- if (!data->notify_data.data.string) {
- data->notify_data.data.length = 0;
- return;
- }
+ if (!data->notify_data.data.string) {
+ data->notify_data.data.length = 0;
+ return;
+ }
- memcpy(data->notify_data.data.string, temp, len);
+ memcpy(data->notify_data.data.string, temp, len);
+ } else {
+ data->notify_data.data.string = NULL;
+ }
}
/*******************************************************************
{
int i=0;
- for (i = 0; i < sizeof(notify_info_data_table); i++)
- {
+ for (i = 0; i < (sizeof(notify_info_data_table)/sizeof(struct s_notify_info_data_table)); i++) {
if ( (notify_info_data_table[i].type == type)
- && (notify_info_data_table[i].field == field) )
- {
- switch(notify_info_data_table[i].size)
- {
- case NOTIFY_ONE_VALUE:
- case NOTIFY_TWO_VALUE:
- return 1;
- case NOTIFY_STRING:
- return 2;
-
- /* The only pointer notify data I have seen on
- the wire is the submitted time and this has
- the notify size set to 4. -tpot */
-
- case NOTIFY_POINTER:
- return 4;
+ && (notify_info_data_table[i].field == field) ) {
+ switch(notify_info_data_table[i].size) {
+ case NOTIFY_ONE_VALUE:
+ case NOTIFY_TWO_VALUE:
+ return 1;
+ case NOTIFY_STRING:
+ return 2;
+
+ /* The only pointer notify data I have seen on
+ the wire is the submitted time and this has
+ the notify size set to 4. -tpot */
+
+ case NOTIFY_POINTER:
+ return 4;
case NOTIFY_SECDESC:
return 5;
Return the type of notify_info_data.
********************************************************************/
-static int type_of_notify_info_data(uint16 type, uint16 field)
+static uint32 type_of_notify_info_data(uint16 type, uint16 field)
{
- int i=0;
+ uint32 i=0;
- for (i = 0; i < sizeof(notify_info_data_table); i++) {
+ for (i = 0; i < (sizeof(notify_info_data_table)/sizeof(struct s_notify_info_data_table)); i++) {
if (notify_info_data_table[i].type == type &&
notify_info_data_table[i].field == field)
return notify_info_data_table[i].size;
}
- return False;
+ return 0;
}
/****************************************************************************
****************************************************************************/
-static int search_notify(uint16 type, uint16 field, int *value)
+static bool search_notify(uint16 type, uint16 field, int *value)
{
int i;
info_data->enc_type = type_of_notify_info_data(type, field);
info_data->id = id;
-
}
-
/*******************************************************************
*
* fill a notify_info struct with info asked
*
********************************************************************/
-static BOOL construct_notify_printer_info(Printer_entry *print_hnd, SPOOL_NOTIFY_INFO *info, int
+static bool construct_notify_printer_info(Printer_entry *print_hnd, SPOOL_NOTIFY_INFO *info, int
snum, SPOOL_NOTIFY_OPTION_TYPE
*option_type, uint32 id,
TALLOC_CTX *mem_ctx)
uint16 type;
uint16 field;
- SPOOL_NOTIFY_INFO_DATA *current_data, *tid;
+ SPOOL_NOTIFY_INFO_DATA *current_data;
NT_PRINTER_INFO_LEVEL *printer = NULL;
print_queue_struct *queue=NULL;
if (!search_notify(type, field, &j) )
continue;
- if((tid=SMB_REALLOC_ARRAY(info->data, SPOOL_NOTIFY_INFO_DATA, info->count+1)) == NULL) {
+ if((info->data=SMB_REALLOC_ARRAY(info->data, SPOOL_NOTIFY_INFO_DATA, info->count+1)) == NULL) {
DEBUG(2,("construct_notify_printer_info: failed to enlarge buffer info->data!\n"));
+ free_a_printer(&printer, 2);
return False;
- } else
- info->data = tid;
+ }
current_data = &info->data[info->count];
*
********************************************************************/
-static BOOL construct_notify_jobs_info(print_queue_struct *queue,
+static bool construct_notify_jobs_info(print_queue_struct *queue,
SPOOL_NOTIFY_INFO *info,
NT_PRINTER_INFO_LEVEL *printer,
int snum, SPOOL_NOTIFY_OPTION_TYPE
uint16 type;
uint16 field;
- SPOOL_NOTIFY_INFO_DATA *current_data, *tid;
+ SPOOL_NOTIFY_INFO_DATA *current_data;
DEBUG(4,("construct_notify_jobs_info\n"));
if (!search_notify(type, field, &j) )
continue;
- if((tid=SMB_REALLOC_ARRAY(info->data, SPOOL_NOTIFY_INFO_DATA, info->count+1)) == NULL) {
+ if((info->data=SMB_REALLOC_ARRAY(info->data, SPOOL_NOTIFY_INFO_DATA, info->count+1)) == NULL) {
DEBUG(2,("construct_notify_jobs_info: failed to enlarg buffer info->data!\n"));
return False;
}
- else info->data = tid;
current_data=&(info->data[info->count]);
if ( !option )
return WERR_BADFID;
- get_printer_snum(p, hnd, &snum);
+ get_printer_snum(p, hnd, &snum, NULL);
for (i=0; i<option->count; i++) {
option_type=&option->ctr.type[i];
/* just ignore the SPOOL_NOTIFY_OPTION */
switch (Printer->printer_type) {
- case PRINTER_HANDLE_IS_PRINTSERVER:
+ case SPLHND_SERVER:
result = printserver_notify_info(p, handle, info, p->mem_ctx);
break;
- case PRINTER_HANDLE_IS_PRINTER:
+ case SPLHND_PRINTER:
result = printer_notify_info(p, handle, info, p->mem_ctx);
break;
}
* fill a printer_info_0 struct
********************************************************************/
-static BOOL construct_printer_info_0(Printer_entry *print_hnd, PRINTER_INFO_0 *printer, int snum)
+static bool construct_printer_info_0(Printer_entry *print_hnd, PRINTER_INFO_0 *printer, int snum)
{
pstring chaine;
int count;
* construct_printer_info_1
* fill a printer_info_1 struct
********************************************************************/
-static BOOL construct_printer_info_1(Printer_entry *print_hnd, uint32 flags, PRINTER_INFO_1 *printer, int snum)
+static bool construct_printer_info_1(Printer_entry *print_hnd, uint32 flags, PRINTER_INFO_1 *printer, int snum)
{
pstring chaine;
pstring chaine2;
should be valid upon entry
****************************************************************************/
-static BOOL convert_nt_devicemode( DEVICEMODE *devmode, NT_DEVICEMODE *ntdevmode )
+static bool convert_nt_devicemode( DEVICEMODE *devmode, NT_DEVICEMODE *ntdevmode )
{
if ( !devmode || !ntdevmode )
return False;
Create a DEVMODE struct. Returns malloced memory.
****************************************************************************/
-DEVICEMODE *construct_dev_mode(int snum)
+DEVICEMODE *construct_dev_mode(const char *servicename)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
DEVICEMODE *devmode = NULL;
DEBUGADD(8,("getting printer characteristics\n"));
- if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
+ if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
return NULL;
if ( !printer->info_2->devmode ) {
* fill a printer_info_2 struct
********************************************************************/
-static BOOL construct_printer_info_2(Printer_entry *print_hnd, PRINTER_INFO_2 *printer, int snum)
+static bool construct_printer_info_2(Printer_entry *print_hnd, PRINTER_INFO_2 *printer, int snum)
{
int count;
NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
printer->cjobs = count; /* jobs */
printer->averageppm = ntprinter->info_2->averageppm; /* average pages per minute */
- if((printer->devmode = construct_dev_mode(snum)) == NULL) {
+ if ( !(printer->devmode = construct_dev_mode(
+ lp_const_servicename(snum))) )
DEBUG(8, ("Returning NULL Devicemode!\n"));
- }
- if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->len != 0) {
- /* steal the printer info sec_desc structure. [badly done]. */
- printer->secdesc = ntprinter->info_2->secdesc_buf->sec;
- ntprinter->info_2->secdesc_buf->sec = NULL; /* Stolen memory. */
- ntprinter->info_2->secdesc_buf->len = 0; /* Stolen memory. */
- ntprinter->info_2->secdesc_buf->max_len = 0; /* Stolen memory. */
- }
- else {
- printer->secdesc = NULL;
+ printer->secdesc = NULL;
+
+ if ( ntprinter->info_2->secdesc_buf
+ && ntprinter->info_2->secdesc_buf->sd_size != 0 )
+ {
+ /* don't use talloc_steal() here unless you do a deep steal of all
+ the SEC_DESC members */
+
+ printer->secdesc = dup_sec_desc( talloc_tos(),
+ ntprinter->info_2->secdesc_buf->sd );
}
free_a_printer(&ntprinter, 2);
+
return True;
}
* fill a printer_info_3 struct
********************************************************************/
-static BOOL construct_printer_info_3(Printer_entry *print_hnd, PRINTER_INFO_3 **pp_printer, int snum)
+static bool construct_printer_info_3(Printer_entry *print_hnd, PRINTER_INFO_3 **pp_printer, int snum)
{
NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
PRINTER_INFO_3 *printer = NULL;
*pp_printer = NULL;
if ((printer = SMB_MALLOC_P(PRINTER_INFO_3)) == NULL) {
DEBUG(2,("construct_printer_info_3: malloc fail.\n"));
+ free_a_printer(&ntprinter, 2);
return False;
}
ZERO_STRUCTP(printer);
- printer->flags = 4; /* These are the components of the SD we are returning. */
- if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->len != 0) {
- /* steal the printer info sec_desc structure. [badly done]. */
- printer->secdesc = ntprinter->info_2->secdesc_buf->sec;
-
-#if 0
- /*
- * Set the flags for the components we are returning.
- */
-
- if (printer->secdesc->owner_sid)
- printer->flags |= OWNER_SECURITY_INFORMATION;
-
- if (printer->secdesc->grp_sid)
- printer->flags |= GROUP_SECURITY_INFORMATION;
-
- if (printer->secdesc->dacl)
- printer->flags |= DACL_SECURITY_INFORMATION;
+ /* These are the components of the SD we are returning. */
- if (printer->secdesc->sacl)
- printer->flags |= SACL_SECURITY_INFORMATION;
-#endif
+ if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->sd_size != 0) {
+ /* don't use talloc_steal() here unless you do a deep steal of all
+ the SEC_DESC members */
- ntprinter->info_2->secdesc_buf->sec = NULL; /* Stolen the malloced memory. */
- ntprinter->info_2->secdesc_buf->len = 0; /* Stolen the malloced memory. */
- ntprinter->info_2->secdesc_buf->max_len = 0; /* Stolen the malloced memory. */
+ printer->secdesc = dup_sec_desc( talloc_tos(),
+ ntprinter->info_2->secdesc_buf->sd );
}
free_a_printer(&ntprinter, 2);
* fill a printer_info_4 struct
********************************************************************/
-static BOOL construct_printer_info_4(Printer_entry *print_hnd, PRINTER_INFO_4 *printer, int snum)
+static bool construct_printer_info_4(Printer_entry *print_hnd, PRINTER_INFO_4 *printer, int snum)
{
NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
* fill a printer_info_5 struct
********************************************************************/
-static BOOL construct_printer_info_5(Printer_entry *print_hnd, PRINTER_INFO_5 *printer, int snum)
+static bool construct_printer_info_5(Printer_entry *print_hnd, PRINTER_INFO_5 *printer, int snum)
{
NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
return True;
}
+/********************************************************************
+ * construct_printer_info_6
+ * fill a printer_info_6 struct
+ ********************************************************************/
+
+static bool construct_printer_info_6(Printer_entry *print_hnd,
+ PRINTER_INFO_6 *printer,
+ int snum)
+{
+ NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
+ int count;
+ print_status_struct status;
+
+ if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2,
+ lp_const_servicename(snum))))
+ return False;
+
+ count = print_queue_length(snum, &status);
+
+ printer->status = nt_printq_status(status.status);
+
+ free_a_printer(&ntprinter, 2);
+
+ return True;
+}
+
/********************************************************************
* construct_printer_info_7
* fill a printer_info_7 struct
********************************************************************/
-static BOOL construct_printer_info_7(Printer_entry *print_hnd, PRINTER_INFO_7 *printer, int snum)
+static bool construct_printer_info_7(Printer_entry *print_hnd, PRINTER_INFO_7 *printer, int snum)
{
char *guid_str = NULL;
- struct uuid guid;
+ struct GUID guid;
if (is_printer_published(print_hnd, snum, &guid)) {
asprintf(&guid_str, "{%s}", smb_uuid_string_static(guid));
int snum;
int i;
int n_services=lp_numservices();
- PRINTER_INFO_1 *tp, *printers=NULL;
+ PRINTER_INFO_1 *printers=NULL;
PRINTER_INFO_1 current_prt;
WERROR result = WERR_OK;
DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
if (construct_printer_info_1(NULL, flags, ¤t_prt, snum)) {
- if((tp=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_1, *returned +1)) == NULL) {
+ if((printers=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_1, *returned +1)) == NULL) {
DEBUG(2,("enum_all_printers_info_1: failed to enlarge printers buffer!\n"));
- SAFE_FREE(printers);
*returned=0;
return WERR_NOMEM;
}
- else printers = tp;
DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_1\n", *returned));
memcpy(&printers[*returned], ¤t_prt, sizeof(PRINTER_INFO_1));
int snum;
int i;
int n_services=lp_numservices();
- PRINTER_INFO_2 *tp, *printers=NULL;
+ PRINTER_INFO_2 *printers=NULL;
PRINTER_INFO_2 current_prt;
WERROR result = WERR_OK;
+ *returned = 0;
+
for (snum=0; snum<n_services; snum++) {
if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
if (construct_printer_info_2(NULL, ¤t_prt, snum)) {
- if((tp=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_2, *returned +1)) == NULL) {
+ if ( !(printers=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_2, *returned +1)) ) {
DEBUG(2,("enum_all_printers_info_2: failed to enlarge printers buffer!\n"));
- SAFE_FREE(printers);
*returned = 0;
return WERR_NOMEM;
}
- else printers = tp;
- DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_2\n", *returned));
+
+ DEBUG(4,("ReAlloced memory for [%d] PRINTER_INFO_2\n", *returned + 1));
+
memcpy(&printers[*returned], ¤t_prt, sizeof(PRINTER_INFO_2));
+
(*returned)++;
}
}
out:
/* clear memory */
- for (i=0; i<*returned; i++) {
+
+ for (i=0; i<*returned; i++)
free_devmode(printers[i].devmode);
- }
+
SAFE_FREE(printers);
if ( !W_ERROR_IS_OK(result) )
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(4,("_spoolss_enumprinters\n"));
*needed=0;
* Level 5: same as Level 2
*/
- unistr2_to_ascii(name, servername, sizeof(name)-1);
+ unistr2_to_ascii(name, servername, sizeof(name));
strupper_m(name);
switch (level) {
if((printer=SMB_MALLOC_P(PRINTER_INFO_4))==NULL)
return WERR_NOMEM;
- if (!construct_printer_info_4(print_hnd, printer, snum))
+ if (!construct_printer_info_4(print_hnd, printer, snum)) {
+ SAFE_FREE(printer);
return WERR_NOMEM;
+ }
/* check the required size. */
*needed += spoolss_size_printer_info_4(printer);
if((printer=SMB_MALLOC_P(PRINTER_INFO_5))==NULL)
return WERR_NOMEM;
- if (!construct_printer_info_5(print_hnd, printer, snum))
+ if (!construct_printer_info_5(print_hnd, printer, snum)) {
+ free_printer_info_5(printer);
return WERR_NOMEM;
+ }
/* check the required size. */
*needed += spoolss_size_printer_info_5(printer);
return result;
}
+static WERROR getprinter_level_6(Printer_entry *print_hnd,
+ int snum,
+ RPC_BUFFER *buffer, uint32 offered,
+ uint32 *needed)
+{
+ PRINTER_INFO_6 *printer;
+ WERROR result = WERR_OK;
+
+ if ((printer = SMB_MALLOC_P(PRINTER_INFO_6)) == NULL) {
+ return WERR_NOMEM;
+ }
+
+ if (!construct_printer_info_6(print_hnd, printer, snum)) {
+ free_printer_info_6(printer);
+ return WERR_NOMEM;
+ }
+
+ /* check the required size. */
+ *needed += spoolss_size_printer_info_6(printer);
+
+ if (*needed > offered) {
+ result = WERR_INSUFFICIENT_BUFFER;
+ goto out;
+ }
+
+ if (!rpcbuf_alloc_size(buffer, *needed)) {
+ result = WERR_NOMEM;
+ goto out;
+ }
+
+ /* fill the buffer with the structures */
+ smb_io_printer_info_6("", buffer, printer, 0);
+
+out:
+ /* clear memory */
+ free_printer_info_6(printer);
+
+ return result;
+}
+
static WERROR getprinter_level_7(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_7 *printer=NULL;
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
*needed=0;
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
switch (level) {
return getprinter_level_4(Printer, snum, buffer, offered, needed);
case 5:
return getprinter_level_5(Printer, snum, buffer, offered, needed);
+ case 6:
+ return getprinter_level_6(Printer, snum, buffer, offered, needed);
case 7:
return getprinter_level_7(Printer, snum, buffer, offered, needed);
}
if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
return WERR_INVALID_PRINTER_NAME;
- if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version)))
+ if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
+ free_a_printer(&printer, 2);
return WERR_UNKNOWN_PRINTER_DRIVER;
+ }
fill_printer_driver_info_1(info, driver, servername, architecture);
if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
return WERR_INVALID_PRINTER_NAME;
- if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version)))
+ if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
+ free_a_printer(&printer, 2);
return WERR_UNKNOWN_PRINTER_DRIVER;
+ }
fill_printer_driver_info_2(info, driver, servername);
int j=0;
const char *v;
pstring line;
- uint16 *tuary;
DEBUG(6,("init_unistr_array\n"));
*uni_array=NULL;
/* add one extra unit16 for the second terminating NULL */
- if ( (tuary=SMB_REALLOC_ARRAY(*uni_array, uint16, j+1+strlen(line)+2)) == NULL ) {
+ if ( (*uni_array=SMB_REALLOC_ARRAY(*uni_array, uint16, j+1+strlen(line)+2)) == NULL ) {
DEBUG(2,("init_unistr_array: Realloc error\n" ));
return 0;
- } else
- *uni_array = tuary;
-
+ }
+
if ( !strlen(v) )
break;
info->previousdrivernames=NULL;
init_unistr_array(&info->previousdrivernames, &nullstr, servername);
- info->driver_date.low=0;
- info->driver_date.high=0;
+ info->driver_date=0;
info->padding=0;
info->driver_version_low=0;
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(4,("_spoolss_getprinterdriver2\n"));
if ( !(printer = find_printer_index_by_hnd( p, handle )) ) {
*serverminorversion = 0;
fstrcpy(servername, get_server_name( printer ));
- unistr2_to_ascii(architecture, uni_arch, sizeof(architecture)-1);
+ unistr2_to_ascii(architecture, uni_arch, sizeof(architecture));
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
switch (level) {
return WERR_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
Printer->page_started=False;
pstring jobname;
fstring datatype;
Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
- struct current_user user;
if (!Printer) {
DEBUG(2,("_spoolss_startdocprinter: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
return WERR_BADFID;
}
- get_current_user(&user, p);
-
/*
* a nice thing with NT is it doesn't listen to what you tell it.
* when asked to send _only_ RAW datas, it tries to send datas
}
/* get the share number of the printer */
- if (!get_printer_snum(p, handle, &snum)) {
+ if (!get_printer_snum(p, handle, &snum, NULL)) {
return WERR_BADFID;
}
unistr2_to_ascii(jobname, &info_1->docname, sizeof(jobname));
- Printer->jobid = print_job_start(&user, snum, jobname, Printer->nt_devmode);
+ Printer->jobid = print_job_start(&p->pipe_user, snum, jobname, Printer->nt_devmode);
/* An error occured in print_job_start() so return an appropriate
NT error code. */
return WERR_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
(*buffer_written) = (uint32)print_job_write(snum, Printer->jobid, (const char *)buffer,
static WERROR control_printer(POLICY_HND *handle, uint32 command,
pipes_struct *p)
{
- struct current_user user;
int snum;
WERROR errcode = WERR_BADFUNC;
Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
- get_current_user(&user, p);
-
if (!Printer) {
DEBUG(2,("control_printer: Invalid handle (%s:%u:%u)\n", OUR_HANDLE(handle)));
return WERR_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
switch (command) {
case PRINTER_CONTROL_PAUSE:
- if (print_queue_pause(&user, snum, &errcode)) {
+ if (print_queue_pause(&p->pipe_user, snum, &errcode)) {
errcode = WERR_OK;
}
break;
case PRINTER_CONTROL_RESUME:
case PRINTER_CONTROL_UNPAUSE:
- if (print_queue_resume(&user, snum, &errcode)) {
+ if (print_queue_resume(&p->pipe_user, snum, &errcode)) {
errcode = WERR_OK;
}
break;
case PRINTER_CONTROL_PURGE:
- if (print_queue_purge(&user, snum, &errcode)) {
+ if (print_queue_purge(&p->pipe_user, snum, &errcode)) {
errcode = WERR_OK;
}
break;
POLICY_HND *handle = &q_u->handle;
Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
int snum;
- struct current_user user;
WERROR errcode = WERR_OK;
if (!Printer) {
return WERR_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
- get_current_user( &user, p );
-
- print_job_delete( &user, snum, Printer->jobid, &errcode );
+ print_job_delete( &p->pipe_user, snum, Printer->jobid, &errcode );
return errcode;
}
Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
- if (!Printer || !get_printer_snum(p, handle, &snum)) {
+ if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
OUR_HANDLE(handle)));
goto done;
}
+ if (!secdesc_ctr) {
+ DEBUG(10,("update_printer_sec: secdesc_ctr is NULL !\n"));
+ result = WERR_INVALID_PARAM;
+ goto done;
+ }
+
/* Check the user has permissions to change the security
descriptor. By experimentation with two NT machines, the user
requires Full Access to the printer to change security
SEC_ACL *the_acl;
int i;
- the_acl = old_secdesc_ctr->sec->dacl;
+ the_acl = old_secdesc_ctr->sd->dacl;
DEBUG(10, ("old_secdesc_ctr for %s has %d aces:\n",
PRINTERNAME(snum), the_acl->num_aces));
for (i = 0; i < the_acl->num_aces; i++) {
fstring sid_str;
- sid_to_string(sid_str, &the_acl->ace[i].trustee);
+ sid_to_string(sid_str, &the_acl->aces[i].trustee);
DEBUG(10, ("%s 0x%08x\n", sid_str,
- the_acl->ace[i].info.mask));
+ the_acl->aces[i].access_mask));
}
- the_acl = secdesc_ctr->sec->dacl;
+ the_acl = secdesc_ctr->sd->dacl;
if (the_acl) {
DEBUG(10, ("secdesc_ctr for %s has %d aces:\n",
for (i = 0; i < the_acl->num_aces; i++) {
fstring sid_str;
- sid_to_string(sid_str, &the_acl->ace[i].trustee);
+ sid_to_string(sid_str, &the_acl->aces[i].trustee);
DEBUG(10, ("%s 0x%08x\n", sid_str,
- the_acl->ace[i].info.mask));
+ the_acl->aces[i].access_mask));
}
} else {
DEBUG(10, ("dacl for secdesc_ctr is NULL\n"));
}
new_secdesc_ctr = sec_desc_merge(p->mem_ctx, secdesc_ctr, old_secdesc_ctr);
+ if (!new_secdesc_ctr) {
+ result = WERR_NOMEM;
+ goto done;
+ }
- if (sec_desc_equal(new_secdesc_ctr->sec, old_secdesc_ctr->sec)) {
+ if (sec_desc_equal(new_secdesc_ctr->sd, old_secdesc_ctr->sd)) {
result = WERR_OK;
goto done;
}
_spoolss_open_printer_ex().
********************************************************************/
-static BOOL check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
+static bool check_printer_ok(NT_PRINTER_INFO_LEVEL_2 *info, int snum)
{
fstring printername;
const char *p;
global_myname(), p );
}
- info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
- info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
-
+ info->attributes |= PRINTER_ATTRIBUTE_SAMBA;
+ info->attributes &= ~PRINTER_ATTRIBUTE_NOT_SAMBA;
+
+
+
+ return True;
+}
+
+/****************************************************************************
+****************************************************************************/
+
+WERROR add_port_hook(NT_USER_TOKEN *token, const char *portname, const char *uri )
+{
+ char *cmd = lp_addport_cmd();
+ pstring command;
+ int ret;
+ int fd;
+ SE_PRIV se_printop = SE_PRINT_OPERATOR;
+ bool is_print_op = False;
+
+ if ( !*cmd ) {
+ return WERR_ACCESS_DENIED;
+ }
+
+ slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\"", cmd, portname, uri );
+
+ if ( token )
+ is_print_op = user_has_privileges( token, &se_printop );
+
+ DEBUG(10,("Running [%s]\n", command));
+
+ /********* BEGIN SePrintOperatorPrivilege **********/
+
+ if ( is_print_op )
+ become_root();
+ ret = smbrun(command, &fd);
+
+ if ( is_print_op )
+ unbecome_root();
+
+ /********* END SePrintOperatorPrivilege **********/
+
+ DEBUGADD(10,("returned [%d]\n", ret));
+
+ if ( ret != 0 ) {
+ if (fd != -1)
+ close(fd);
+ return WERR_ACCESS_DENIED;
+ }
- return True;
+ return WERR_OK;
}
/****************************************************************************
****************************************************************************/
-BOOL add_printer_hook(NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
+bool add_printer_hook(NT_USER_TOKEN *token, NT_PRINTER_INFO_LEVEL *printer)
{
char *cmd = lp_addprinter_cmd();
char **qlines;
int fd;
fstring remote_machine = "%m";
SE_PRIV se_printop = SE_PRINT_OPERATOR;
- BOOL is_print_op = False;
+ bool is_print_op = False;
- standard_sub_basic(current_user_info.smb_name, remote_machine,sizeof(remote_machine));
+ standard_sub_basic(current_user_info.smb_name,
+ current_user_info.domain,
+ remote_machine,sizeof(remote_machine));
slprintf(command, sizeof(command)-1, "%s \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"",
cmd, printer->info_2->printername, printer->info_2->sharename,
if ( (ret = smbrun(command, &fd)) == 0 ) {
/* Tell everyone we updated smb.conf. */
- message_send_all(conn_tdb_ctx(), MSG_SMB_CONF_UPDATED, NULL, 0, False, NULL);
+ message_send_all(smbd_messaging_context(),
+ MSG_SMB_CONF_UPDATED, NULL, 0, NULL);
}
if ( is_print_op )
numlines = 0;
/* Get lines and convert them back to dos-codepage */
- qlines = fd_lines_load(fd, &numlines);
+ qlines = fd_lines_load(fd, &numlines, 0);
DEBUGADD(10,("Lines returned = [%d]\n", numlines));
close(fd);
return True;
}
+
/********************************************************************
* Called by spoolss_api_setprinter
* when updating a printer description.
goto done;
}
- if (!get_printer_snum(p, handle, &snum)) {
+ if (!get_printer_snum(p, handle, &snum, NULL)) {
result = WERR_BADFID;
goto done;
}
|| !strequal(printer->info_2->portname, old_printer->info_2->portname)
|| !strequal(printer->info_2->location, old_printer->info_2->location)) )
{
+ /* add_printer_hook() will call reload_services() */
+
if ( !add_printer_hook(p->pipe_user.nt_user_token, printer) ) {
result = WERR_ACCESS_DENIED;
goto done;
}
-
- /*
- * make sure we actually reload the services after
- * this as smb.conf could have a new section in it
- * .... shouldn't .... but could
- */
- reload_services(False);
}
/*
#ifdef HAVE_ADS
SPOOL_PRINTER_INFO_LEVEL_7 *info7 = info->info_7;
int snum;
- Printer_entry *Printer = find_printer_index_by_hnd(p, handle);
+ Printer_entry *Printer;
+
+ if ( lp_security() != SEC_ADS ) {
+ return WERR_UNKNOWN_LEVEL;
+ }
+
+ Printer = find_printer_index_by_hnd(p, handle);
DEBUG(5,("publish_or_unpublish_printer, action = %d\n",info7->action));
if (!Printer)
return WERR_BADFID;
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
nt_printer_publish(Printer, snum, info7->action);
if (Printer->notify.client_connected==True) {
int snum = -1;
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER)
+ if ( Printer->printer_type == SPLHND_SERVER)
snum = -1;
- else if ( (Printer->printer_type == PRINTER_HANDLE_IS_PRINTER) &&
- !get_printer_snum(p, handle, &snum) )
+ else if ( (Printer->printer_type == SPLHND_PRINTER) &&
+ !get_printer_snum(p, handle, &snum, NULL) )
return WERR_BADFID;
srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
{
/* that's an [in out] buffer */
- if ( q_u->buffer )
- rpcbuf_move(q_u->buffer, &r_u->buffer);
+ if (!q_u->buffer && (q_u->offered!=0)) {
+ return WERR_INVALID_PARAM;
+ }
+
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
r_u->needed = 0;
return WERR_INVALID_PARAM; /* this is what a NT server
/****************************************************************************
****************************************************************************/
-static void fill_job_info_1(JOB_INFO_1 *job_info, print_queue_struct *queue,
+static void fill_job_info_1(JOB_INFO_1 *job_info, const print_queue_struct *queue,
int position, int snum,
- NT_PRINTER_INFO_LEVEL *ntprinter)
+ const NT_PRINTER_INFO_LEVEL *ntprinter)
{
struct tm *t;
/****************************************************************************
****************************************************************************/
-static BOOL fill_job_info_2(JOB_INFO_2 *job_info, print_queue_struct *queue,
+static bool fill_job_info_2(JOB_INFO_2 *job_info, const print_queue_struct *queue,
int position, int snum,
- NT_PRINTER_INFO_LEVEL *ntprinter,
+ const NT_PRINTER_INFO_LEVEL *ntprinter,
DEVICEMODE *devmode)
{
struct tm *t;
Enumjobs at level 1.
****************************************************************************/
-static WERROR enumjobs_level1(print_queue_struct *queue, int snum,
- NT_PRINTER_INFO_LEVEL *ntprinter,
+static WERROR enumjobs_level1(const print_queue_struct *queue, int snum,
+ const NT_PRINTER_INFO_LEVEL *ntprinter,
RPC_BUFFER *buffer, uint32 offered,
uint32 *needed, uint32 *returned)
{
info=SMB_MALLOC_ARRAY(JOB_INFO_1,*returned);
if (info==NULL) {
- SAFE_FREE(queue);
*returned=0;
return WERR_NOMEM;
}
for (i=0; i<*returned; i++)
fill_job_info_1( &info[i], &queue[i], i, snum, ntprinter );
- SAFE_FREE(queue);
-
/* check the required size. */
for (i=0; i<*returned; i++)
(*needed) += spoolss_size_job_info_1(&info[i]);
Enumjobs at level 2.
****************************************************************************/
-static WERROR enumjobs_level2(print_queue_struct *queue, int snum,
- NT_PRINTER_INFO_LEVEL *ntprinter,
+static WERROR enumjobs_level2(const print_queue_struct *queue, int snum,
+ const NT_PRINTER_INFO_LEVEL *ntprinter,
RPC_BUFFER *buffer, uint32 offered,
uint32 *needed, uint32 *returned)
{
/* this should not be a failure condition if the devmode is NULL */
- devmode = construct_dev_mode(snum);
+ devmode = construct_dev_mode(lp_const_servicename(snum));
for (i=0; i<*returned; i++)
fill_job_info_2(&(info[i]), &queue[i], i, snum, ntprinter, devmode);
- free_a_printer(&ntprinter, 2);
- SAFE_FREE(queue);
-
/* check the required size. */
for (i=0; i<*returned; i++)
(*needed) += spoolss_size_job_info_2(&info[i]);
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(4,("_spoolss_enumjobs\n"));
*needed=0;
/* lookup the printer snum and tdb entry */
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
wret = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
if (*returned == 0) {
SAFE_FREE(queue);
+ free_a_printer(&ntprinter, 2);
return WERR_OK;
}
switch (level) {
case 1:
wret = enumjobs_level1(queue, snum, ntprinter, buffer, offered, needed, returned);
- return wret;
+ break;
case 2:
wret = enumjobs_level2(queue, snum, ntprinter, buffer, offered, needed, returned);
- return wret;
+ break;
default:
- SAFE_FREE(queue);
*returned=0;
wret = WERR_UNKNOWN_LEVEL;
+ break;
}
+ SAFE_FREE(queue);
free_a_printer( &ntprinter, 2 );
return wret;
}
uint32 jobid = q_u->jobid;
uint32 command = q_u->command;
- struct current_user user;
int snum;
WERROR errcode = WERR_BADFUNC;
- if (!get_printer_snum(p, handle, &snum)) {
+ if (!get_printer_snum(p, handle, &snum, NULL)) {
return WERR_BADFID;
}
return WERR_INVALID_PRINTER_NAME;
}
- get_current_user(&user, p);
-
switch (command) {
case JOB_CONTROL_CANCEL:
case JOB_CONTROL_DELETE:
- if (print_job_delete(&user, snum, jobid, &errcode)) {
+ if (print_job_delete(&p->pipe_user, snum, jobid, &errcode)) {
errcode = WERR_OK;
}
break;
case JOB_CONTROL_PAUSE:
- if (print_job_pause(&user, snum, jobid, &errcode)) {
+ if (print_job_pause(&p->pipe_user, snum, jobid, &errcode)) {
errcode = WERR_OK;
}
break;
case JOB_CONTROL_RESTART:
case JOB_CONTROL_RESUME:
- if (print_job_resume(&user, snum, jobid, &errcode)) {
+ if (print_job_resume(&p->pipe_user, snum, jobid, &errcode)) {
errcode = WERR_OK;
}
break;
uint32 version;
fstring *list = NULL;
NT_PRINTER_DRIVER_INFO_LEVEL driver;
- DRIVER_INFO_1 *tdi1, *driver_info_1=NULL;
+ DRIVER_INFO_1 *driver_info_1=NULL;
WERROR result = WERR_OK;
*returned=0;
ndrivers=get_ntdrivers(&list, architecture, version);
DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
- if(ndrivers == -1)
+ if(ndrivers == -1) {
+ SAFE_FREE(driver_info_1);
return WERR_NOMEM;
+ }
if(ndrivers != 0) {
- if((tdi1=SMB_REALLOC_ARRAY(driver_info_1, DRIVER_INFO_1, *returned+ndrivers )) == NULL) {
+ if((driver_info_1=SMB_REALLOC_ARRAY(driver_info_1, DRIVER_INFO_1, *returned+ndrivers )) == NULL) {
DEBUG(0,("enumprinterdrivers_level1: failed to enlarge driver info buffer!\n"));
- SAFE_FREE(driver_info_1);
SAFE_FREE(list);
return WERR_NOMEM;
}
- else driver_info_1 = tdi1;
}
for (i=0; i<ndrivers; i++) {
architecture, version);
if (!W_ERROR_IS_OK(status)) {
SAFE_FREE(list);
+ SAFE_FREE(driver_info_1);
return status;
}
fill_printer_driver_info_1(&driver_info_1[*returned+i], driver, servername, architecture );
uint32 version;
fstring *list = NULL;
NT_PRINTER_DRIVER_INFO_LEVEL driver;
- DRIVER_INFO_2 *tdi2, *driver_info_2=NULL;
+ DRIVER_INFO_2 *driver_info_2=NULL;
WERROR result = WERR_OK;
*returned=0;
ndrivers=get_ntdrivers(&list, architecture, version);
DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
- if(ndrivers == -1)
+ if(ndrivers == -1) {
+ SAFE_FREE(driver_info_2);
return WERR_NOMEM;
+ }
if(ndrivers != 0) {
- if((tdi2=SMB_REALLOC_ARRAY(driver_info_2, DRIVER_INFO_2, *returned+ndrivers )) == NULL) {
+ if((driver_info_2=SMB_REALLOC_ARRAY(driver_info_2, DRIVER_INFO_2, *returned+ndrivers )) == NULL) {
DEBUG(0,("enumprinterdrivers_level2: failed to enlarge driver info buffer!\n"));
- SAFE_FREE(driver_info_2);
SAFE_FREE(list);
return WERR_NOMEM;
}
- else driver_info_2 = tdi2;
}
for (i=0; i<ndrivers; i++) {
architecture, version);
if (!W_ERROR_IS_OK(status)) {
SAFE_FREE(list);
+ SAFE_FREE(driver_info_2);
return status;
}
fill_printer_driver_info_2(&driver_info_2[*returned+i], driver, servername);
int ndrivers;
uint32 version;
fstring *list = NULL;
+ DRIVER_INFO_3 *driver_info_3=NULL;
NT_PRINTER_DRIVER_INFO_LEVEL driver;
- DRIVER_INFO_3 *tdi3, *driver_info_3=NULL;
WERROR result = WERR_OK;
*returned=0;
ndrivers=get_ntdrivers(&list, architecture, version);
DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n", ndrivers, architecture, version));
- if(ndrivers == -1)
+ if(ndrivers == -1) {
+ SAFE_FREE(driver_info_3);
return WERR_NOMEM;
+ }
if(ndrivers != 0) {
- if((tdi3=SMB_REALLOC_ARRAY(driver_info_3, DRIVER_INFO_3, *returned+ndrivers )) == NULL) {
+ if((driver_info_3=SMB_REALLOC_ARRAY(driver_info_3, DRIVER_INFO_3, *returned+ndrivers )) == NULL) {
DEBUG(0,("enumprinterdrivers_level3: failed to enlarge driver info buffer!\n"));
- SAFE_FREE(driver_info_3);
SAFE_FREE(list);
return WERR_NOMEM;
}
- else driver_info_3 = tdi3;
}
for (i=0; i<ndrivers; i++) {
architecture, version);
if (!W_ERROR_IS_OK(status)) {
SAFE_FREE(list);
+ SAFE_FREE(driver_info_3);
return status;
}
fill_printer_driver_info_3(&driver_info_3[*returned+i], driver, servername);
}
out:
- for (i=0; i<*returned; i++)
+ for (i=0; i<*returned; i++) {
SAFE_FREE(driver_info_3[i].dependentfiles);
+ }
SAFE_FREE(driver_info_3);
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(4,("_spoolss_enumprinterdrivers\n"));
*needed = 0;
*returned = 0;
- unistr2_to_ascii(architecture, &q_u->environment, sizeof(architecture)-1);
- unistr2_to_ascii(servername, &q_u->name, sizeof(servername)-1);
+ unistr2_to_ascii(architecture, &q_u->environment, sizeof(architecture));
+ unistr2_to_ascii(servername, &q_u->name, sizeof(servername));
if ( !is_myname_or_ipaddr( servername ) )
return WERR_UNKNOWN_PRINTER_DRIVER;
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0) ) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(4,("_spoolss_enumforms\n"));
DEBUGADD(5,("Offered buffer size [%d]\n", offered));
DEBUGADD(5,("Info level [%d]\n", level));
DEBUGADD(5,("Number of user forms [%d]\n", *numofforms));
*numofforms += numbuiltinforms;
- if (*numofforms == 0)
+ if (*numofforms == 0) {
+ SAFE_FREE(builtinlist);
+ SAFE_FREE(list);
return WERR_NO_MORE_ITEMS;
+ }
switch (level) {
case 1:
if ((forms_1=SMB_MALLOC_ARRAY(FORM_1, *numofforms)) == NULL) {
+ SAFE_FREE(builtinlist);
+ SAFE_FREE(list);
*numofforms=0;
return WERR_NOMEM;
}
SAFE_FREE(builtinlist);
return WERR_UNKNOWN_LEVEL;
}
-
}
/****************************************************************************
nt_forms_struct *list=NULL;
nt_forms_struct builtin_form;
- BOOL foundBuiltin;
+ bool foundBuiltin;
FORM_1 form_1;
fstring form_name;
int buffer_size=0;
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
- unistr2_to_ascii(form_name, uni_formname, sizeof(form_name)-1);
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
+ unistr2_to_ascii(form_name, uni_formname, sizeof(form_name));
DEBUG(4,("_spoolss_getform\n"));
DEBUGADD(5,("Offered buffer size [%d]\n", offered));
}
/****************************************************************************
+ TODO: This probably needs distinguish between TCP/IP and Local ports
+ somehow.
****************************************************************************/
static void fill_port_2(PORT_INFO_2 *port, const char *name)
{
init_unistr(&port->port_name, name);
init_unistr(&port->monitor_name, "Local Monitor");
- init_unistr(&port->description, "Local Port");
+ init_unistr(&port->description, SPL_LOCAL_PORT );
port->port_type=PORT_TYPE_WRITE;
port->reserved=0x0;
}
int ret;
int fd;
+ *count = 0;
+ *lines = NULL;
/* if no hook then just fill in the default port */
if ( !*cmd ) {
- qlines = SMB_MALLOC_ARRAY( char*, 2 );
- qlines[0] = SMB_STRDUP( SAMBA_PRINTER_PORT_NAME );
+ if (!(qlines = SMB_MALLOC_ARRAY( char*, 2 ))) {
+ return WERR_NOMEM;
+ }
+ if (!(qlines[0] = SMB_STRDUP( SAMBA_PRINTER_PORT_NAME ))) {
+ SAFE_FREE(qlines);
+ return WERR_NOMEM;
+ }
qlines[1] = NULL;
numlines = 1;
}
ret = smbrun(command, &fd);
DEBUG(10,("Returned [%d]\n", ret));
if (ret != 0) {
- if (fd != -1)
+ if (fd != -1) {
close(fd);
-
+ }
return WERR_ACCESS_DENIED;
}
numlines = 0;
- qlines = fd_lines_load(fd, &numlines);
+ qlines = fd_lines_load(fd, &numlines, 0);
DEBUGADD(10,("Lines returned = [%d]\n", numlines));
close(fd);
}
PORT_INFO_1 *ports=NULL;
int i=0;
WERROR result = WERR_OK;
- char **qlines;
- int numlines;
+ char **qlines = NULL;
+ int numlines = 0;
- if ( !W_ERROR_IS_OK(result = enumports_hook( &numlines, &qlines )) )
+ result = enumports_hook( &numlines, &qlines );
+ if (!W_ERROR_IS_OK(result)) {
+ file_lines_free(qlines);
return result;
+ }
if(numlines) {
if((ports=SMB_MALLOC_ARRAY( PORT_INFO_1, numlines )) == NULL) {
DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
fill_port_1(&ports[i], qlines[i]);
}
-
- file_lines_free(qlines);
}
+ file_lines_free(qlines);
*returned = numlines;
PORT_INFO_2 *ports=NULL;
int i=0;
WERROR result = WERR_OK;
- char **qlines;
- int numlines;
+ char **qlines = NULL;
+ int numlines = 0;
- if ( !W_ERROR_IS_OK(result = enumports_hook( &numlines, &qlines )) )
+ result = enumports_hook( &numlines, &qlines );
+ if ( !W_ERROR_IS_OK(result)) {
+ file_lines_free(qlines);
return result;
-
+ }
if(numlines) {
if((ports=SMB_MALLOC_ARRAY( PORT_INFO_2, numlines)) == NULL) {
DEBUG(6,("Filling port number [%d] with port [%s]\n", i, qlines[i]));
fill_port_2(&(ports[i]), qlines[i]);
}
-
- file_lines_free(qlines);
}
+ file_lines_free(qlines);
+
*returned = numlines;
/* check the required size. */
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(4,("_spoolss_enumports\n"));
*returned=0;
int snum;
WERROR err = WERR_OK;
- if ((printer = SMB_MALLOC_P(NT_PRINTER_INFO_LEVEL)) == NULL) {
+ if ( !(printer = TALLOC_ZERO_P(NULL, NT_PRINTER_INFO_LEVEL)) ) {
DEBUG(0,("spoolss_addprinterex_level_2: malloc fail.\n"));
return WERR_NOMEM;
}
- ZERO_STRUCTP(printer);
-
/* convert from UNICODE to ASCII - this allocates the info_2 struct inside *printer.*/
if (!convert_printer_info(info, printer, 2)) {
free_a_printer(&printer, 2);
SPOOL_PRINTER_DRIVER_INFO_LEVEL *info = &q_u->info;
WERROR err = WERR_OK;
NT_PRINTER_DRIVER_INFO_LEVEL driver;
- struct current_user user;
fstring driver_name;
uint32 version;
ZERO_STRUCT(driver);
- get_current_user(&user, p);
-
if (!convert_printer_driver_info(info, &driver, level)) {
err = WERR_NOMEM;
goto done;
}
DEBUG(5,("Cleaning driver's information\n"));
- err = clean_up_driver_struct(driver, level, &user);
+ err = clean_up_driver_struct(driver, level, &p->pipe_user);
if (!W_ERROR_IS_OK(err))
goto done;
DEBUG(5,("Moving driver to final destination\n"));
- if( !W_ERROR_IS_OK(err = move_driver_to_download_area(driver, level, &user, &err)) ) {
+ if( !W_ERROR_IS_OK(err = move_driver_to_download_area(driver, level, &p->pipe_user, &err)) ) {
goto done;
}
goto done;
}
- /* BEGIN_ADMIN_LOG */
- switch(level) {
- case 3:
- fstrcpy(driver_name, driver.info_3->name ? driver.info_3->name : "");
- sys_adminlog(LOG_INFO,"Added printer driver. Print driver name: %s. Print driver OS: %s. Administrator name: %s.",
- driver_name, get_drv_ver_to_os(driver.info_3->cversion),uidtoname(user.uid));
- break;
- case 6:
- fstrcpy(driver_name, driver.info_6->name ? driver.info_6->name : "");
- sys_adminlog(LOG_INFO,"Added printer driver. Print driver name: %s. Print driver OS: %s. Administrator name: %s.",
- driver_name, get_drv_ver_to_os(driver.info_6->version),uidtoname(user.uid));
- break;
- }
- /* END_ADMIN_LOG */
-
/*
* I think this is where he DrvUpgradePrinter() hook would be
* be called in a driver's interface DLL on a Windows NT 4.0/2k
DRIVER_DIRECTORY_1 *info=NULL;
WERROR result = WERR_OK;
- unistr2_to_ascii(servername, name, sizeof(servername)-1);
- unistr2_to_ascii(long_archi, uni_environment, sizeof(long_archi)-1);
+ unistr2_to_ascii(servername, name, sizeof(servername));
+ unistr2_to_ascii(long_archi, uni_environment, sizeof(long_archi));
/* check for beginning double '\'s and that the server
long enough */
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(4,("_spoolss_getprinterdriverdirectory\n"));
*needed=0;
int i, key_index, num_values;
int name_length;
- ZERO_STRUCT( printer );
-
*out_type = 0;
*out_max_data_len = 0;
return WERR_BADFID;
}
- if (!get_printer_snum(p,handle, &snum))
+ if (!get_printer_snum(p,handle, &snum, NULL))
return WERR_BADFID;
result = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
if (!W_ERROR_IS_OK(result))
return result;
- p_data = &printer->info_2->data;
+ p_data = printer->info_2->data;
key_index = lookup_printerkey( p_data, SPOOL_PRINTERDATA_KEY );
result = WERR_OK;
biggest_valuesize = 0;
biggest_datasize = 0;
- num_values = regval_ctr_numvals( &p_data->keys[key_index].values );
-
+ num_values = regval_ctr_numvals( p_data->keys[key_index].values );
+
for ( i=0; i<num_values; i++ )
{
- val = regval_ctr_specific_value( &p_data->keys[key_index].values, i );
+ val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
name_length = strlen(val->valuename);
if ( strlen(val->valuename) > biggest_valuesize )
*/
if ( key_index != -1 )
- val = regval_ctr_specific_value( &p_data->keys[key_index].values, idx );
+ val = regval_ctr_specific_value( p_data->keys[key_index].values, idx );
if ( !val )
{
*out_max_value_len=(in_value_len/sizeof(uint16));
- if((*out_value=(uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL)
- {
- result = WERR_NOMEM;
- goto done;
+ if (in_value_len) {
+ if((*out_value=(uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL)
+ {
+ result = WERR_NOMEM;
+ goto done;
+ }
+ *out_value_len = (uint32)rpcstr_push((char *)*out_value, "", in_value_len, 0);
+ } else {
+ *out_value=NULL;
+ *out_value_len = 0;
}
- *out_value_len = (uint32)rpcstr_push((char *)*out_value, "", in_value_len, 0);
-
/* the data is counted in bytes */
*out_max_data_len = in_data_len;
/* name */
*out_max_value_len=(in_value_len/sizeof(uint16));
- if ( (*out_value = (uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL )
- {
- result = WERR_NOMEM;
- goto done;
- }
+ if (in_value_len) {
+ if ( (*out_value = (uint16 *)TALLOC_ZERO(p->mem_ctx, in_value_len*sizeof(uint8))) == NULL )
+ {
+ result = WERR_NOMEM;
+ goto done;
+ }
- *out_value_len = (uint32)rpcstr_push((char *)*out_value, regval_name(val), in_value_len, 0);
+ *out_value_len = (uint32)rpcstr_push((char *)*out_value, regval_name(val), (size_t)in_value_len, 0);
+ } else {
+ *out_value = NULL;
+ *out_value_len = 0;
+ }
/* type */
/* data - counted in bytes */
*out_max_data_len = in_data_len;
- if ( (*data_out = (uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL)
+ if ( in_data_len && (*data_out = (uint8 *)TALLOC_ZERO(p->mem_ctx, in_data_len*sizeof(uint8))) == NULL)
{
result = WERR_NOMEM;
goto done;
}
data_len = regval_size(val);
- memcpy( *data_out, regval_data_p(val), data_len );
+ if ( *data_out && data_len )
+ memcpy( *data_out, regval_data_p(val), data_len );
*out_data_len = data_len;
}
return WERR_BADFID;
}
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER ) {
+ if ( Printer->printer_type == SPLHND_SERVER ) {
DEBUG(10,("_spoolss_setprinterdata: Not implemented for server handles yet\n"));
return WERR_INVALID_PARAM;
}
- if (!get_printer_snum(p,handle, &snum))
+ if (!get_printer_snum(p,handle, &snum, NULL))
return WERR_BADFID;
/*
if (!W_ERROR_IS_OK(status))
return status;
- unistr2_to_ascii( valuename, value, sizeof(valuename)-1 );
+ unistr2_to_ascii(valuename, value, sizeof(valuename));
/*
* When client side code sets a magic printer data key, detect it and save
return WERR_BADFID;
}
- if (!get_printer_snum(p,handle, &snum))
+ if (!get_printer_snum(p,handle, &snum, NULL))
return WERR_BADFID;
return WERR_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
if (!W_ERROR_IS_OK(status))
return status;
- unistr2_to_ascii( valuename, value, sizeof(valuename)-1 );
+ unistr2_to_ascii(valuename, value, sizeof(valuename));
status = delete_printer_dataex( printer, SPOOL_PRINTERDATA_KEY, valuename );
/* forms can be added on printer of on the print server handle */
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
+ if ( Printer->printer_type == SPLHND_PRINTER )
{
- if (!get_printer_snum(p,handle, &snum))
+ if (!get_printer_snum(p,handle, &snum, NULL))
return WERR_BADFID;
status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
* ChangeID must always be set if this is a printer
*/
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
+ if ( Printer->printer_type == SPLHND_PRINTER )
status = mod_a_printer(printer, 2);
done:
/* forms can be deleted on printer of on the print server handle */
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
+ if ( Printer->printer_type == SPLHND_PRINTER )
{
- if (!get_printer_snum(p,handle, &snum))
+ if (!get_printer_snum(p,handle, &snum, NULL))
return WERR_BADFID;
status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
* ChangeID must always be set if this is a printer
*/
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
+ if ( Printer->printer_type == SPLHND_PRINTER )
status = mod_a_printer(printer, 2);
done:
/* forms can be modified on printer of on the print server handle */
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
+ if ( Printer->printer_type == SPLHND_PRINTER )
{
- if (!get_printer_snum(p,handle, &snum))
+ if (!get_printer_snum(p,handle, &snum, NULL))
return WERR_BADFID;
status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
* ChangeID must always be set if this is a printer
*/
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTER )
+ if ( Printer->printer_type == SPLHND_PRINTER )
status = mod_a_printer(printer, 2);
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(5,("spoolss_enumprintprocessors\n"));
/*
static WERROR enumprintprocdatatypes_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
PRINTPROCDATATYPE_1 *info_1=NULL;
- WERROR result = WERR_NOMEM;
+ WERROR result = WERR_OK;
if((info_1 = SMB_MALLOC_P(PRINTPROCDATATYPE_1)) == NULL)
return WERR_NOMEM;
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(5,("_spoolss_enumprintprocdatatypes\n"));
*returned=0;
static WERROR enumprintmonitors_level_1(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
- PRINTMONITOR_1 *info_1=NULL;
+ PRINTMONITOR_1 *info_1;
WERROR result = WERR_OK;
+ int i;
- if((info_1 = SMB_MALLOC_P(PRINTMONITOR_1)) == NULL)
+ if((info_1 = SMB_MALLOC_ARRAY(PRINTMONITOR_1, 2)) == NULL)
return WERR_NOMEM;
- (*returned) = 0x1;
+ *returned = 2;
- init_unistr(&info_1->name, "Local Port");
-
- *needed += spoolss_size_printmonitor_info_1(info_1);
+ init_unistr(&(info_1[0].name), SPL_LOCAL_PORT );
+ init_unistr(&(info_1[1].name), SPL_TCPIP_PORT );
+ for ( i=0; i<*returned; i++ ) {
+ *needed += spoolss_size_printmonitor_info_1(&info_1[i]);
+ }
+
if (*needed > offered) {
result = WERR_INSUFFICIENT_BUFFER;
goto out;
goto out;
}
- smb_io_printmonitor_info_1("", buffer, info_1, 0);
+ for ( i=0; i<*returned; i++ ) {
+ smb_io_printmonitor_info_1("", buffer, &info_1[i], 0);
+ }
out:
SAFE_FREE(info_1);
static WERROR enumprintmonitors_level_2(RPC_BUFFER *buffer, uint32 offered, uint32 *needed, uint32 *returned)
{
- PRINTMONITOR_2 *info_2=NULL;
+ PRINTMONITOR_2 *info_2;
WERROR result = WERR_OK;
+ int i;
- if((info_2 = SMB_MALLOC_P(PRINTMONITOR_2)) == NULL)
+ if((info_2 = SMB_MALLOC_ARRAY(PRINTMONITOR_2, 2)) == NULL)
return WERR_NOMEM;
- (*returned) = 0x1;
+ *returned = 2;
- init_unistr(&info_2->name, "Local Port");
- init_unistr(&info_2->environment, "Windows NT X86");
- init_unistr(&info_2->dll_name, "localmon.dll");
-
- *needed += spoolss_size_printmonitor_info_2(info_2);
+ init_unistr( &(info_2[0].name), SPL_LOCAL_PORT );
+ init_unistr( &(info_2[0].environment), "Windows NT X86" );
+ init_unistr( &(info_2[0].dll_name), "localmon.dll" );
+
+ init_unistr( &(info_2[1].name), SPL_TCPIP_PORT );
+ init_unistr( &(info_2[1].environment), "Windows NT X86" );
+ init_unistr( &(info_2[1].dll_name), "tcpmon.dll" );
+ for ( i=0; i<*returned; i++ ) {
+ *needed += spoolss_size_printmonitor_info_2(&info_2[i]);
+ }
+
if (*needed > offered) {
result = WERR_INSUFFICIENT_BUFFER;
goto out;
goto out;
}
- smb_io_printmonitor_info_2("", buffer, info_2, 0);
+ for ( i=0; i<*returned; i++ ) {
+ smb_io_printmonitor_info_2("", buffer, &info_2[i], 0);
+ }
out:
SAFE_FREE(info_2);
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(5,("spoolss_enumprintmonitors\n"));
/*
uint32 *needed)
{
int i=0;
- BOOL found=False;
+ bool found=False;
JOB_INFO_1 *info_1=NULL;
WERROR result = WERR_OK;
uint32 *needed)
{
int i = 0;
- BOOL found = False;
+ bool found = False;
JOB_INFO_2 *info_2;
WERROR result;
DEVICEMODE *devmode = NULL;
*/
if ( !(nt_devmode=print_job_devmode( lp_const_servicename(snum), jobid )) )
- devmode = construct_dev_mode(snum);
+ devmode = construct_dev_mode(lp_const_servicename(snum));
else {
if ((devmode = SMB_MALLOC_P(DEVICEMODE)) != NULL) {
ZERO_STRUCTP( devmode );
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(5,("spoolss_getjob\n"));
*needed = 0;
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
wstatus = get_a_printer(NULL, &ntprinter, 2, lp_servicename(snum));
DEBUG(4,("_spoolss_getprinterdataex\n"));
- unistr2_to_ascii(keyname, &q_u->keyname, sizeof(keyname) - 1);
- unistr2_to_ascii(valuename, &q_u->valuename, sizeof(valuename) - 1);
+ unistr2_to_ascii(keyname, &q_u->keyname, sizeof(keyname));
+ unistr2_to_ascii(valuename, &q_u->valuename, sizeof(valuename));
DEBUG(10, ("_spoolss_getprinterdataex: key => [%s], value => [%s]\n",
keyname, valuename));
/* Is the handle to a printer or to the server? */
- if (Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER) {
+ if (Printer->printer_type == SPLHND_SERVER) {
DEBUG(10,("_spoolss_getprinterdataex: Not implemented for server handles yet\n"));
status = WERR_INVALID_PARAM;
goto done;
}
- if ( !get_printer_snum(p,handle, &snum) )
+ if ( !get_printer_snum(p,handle, &snum, NULL) )
return WERR_BADFID;
status = get_a_printer(Printer, &printer, 2, lp_servicename(snum));
goto done;
}
- if ( lookup_printerkey( &printer->info_2->data, keyname ) == -1 ) {
+ if ( lookup_printerkey( printer->info_2->data, keyname ) == -1 ) {
DEBUG(4,("_spoolss_getprinterdataex: Invalid keyname [%s]\n", keyname ));
free_a_printer( &printer, 2 );
status = WERR_BADFILE;
status = WERR_NOMEM;
goto done;
}
- }
- else {
+ } else {
*data = NULL;
- }
+ }
}
if ( printer )
return WERR_BADFID;
}
- if ( Printer->printer_type == PRINTER_HANDLE_IS_PRINTSERVER ) {
+ if ( Printer->printer_type == SPLHND_SERVER ) {
DEBUG(10,("_spoolss_setprinterdataex: Not implemented for server handles yet\n"));
return WERR_INVALID_PARAM;
}
- if ( !get_printer_snum(p,handle, &snum) )
+ if ( !get_printer_snum(p,handle, &snum, NULL) )
return WERR_BADFID;
/*
if (!W_ERROR_IS_OK(status))
return status;
- unistr2_to_ascii( valuename, &q_u->value, sizeof(valuename) - 1);
- unistr2_to_ascii( keyname, &q_u->key, sizeof(keyname) - 1);
+ unistr2_to_ascii( valuename, &q_u->value, sizeof(valuename));
+ unistr2_to_ascii( keyname, &q_u->key, sizeof(keyname));
/* check for OID in valuename */
*/
set_printer_dataex( printer, keyname, valuename,
- REG_SZ, (void*)oid_string, strlen(oid_string)+1 );
+ REG_SZ, (uint8 *)oid_string,
+ strlen(oid_string)+1 );
}
status = mod_a_printer(printer, 2);
return WERR_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
if (!W_ERROR_IS_OK(status))
return status;
- unistr2_to_ascii( valuename, value, sizeof(valuename)-1 );
- unistr2_to_ascii( keyname, key, sizeof(keyname)-1 );
+ unistr2_to_ascii(valuename, value, sizeof(valuename));
+ unistr2_to_ascii(keyname, key, sizeof(keyname));
status = delete_printer_dataex( printer, keyname, valuename );
return WERR_BADFID;
}
- if ( !get_printer_snum(p,handle, &snum) )
+ if ( !get_printer_snum(p,handle, &snum, NULL) )
return WERR_BADFID;
status = get_a_printer(Printer, &printer, 2, lp_const_servicename(snum));
/* get the list of subkey names */
- unistr2_to_ascii( key, &q_u->key, sizeof(key)-1 );
- data = &printer->info_2->data;
+ unistr2_to_ascii(key, &q_u->key, sizeof(key));
+ data = printer->info_2->data;
num_keys = get_printer_subkeys( data, key, &keynames );
if ( !q_u->keyname.buffer )
return WERR_INVALID_PARAM;
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
if (Printer->access_granted != PRINTER_ACCESS_ADMINISTER) {
/* delete the key and all subneys */
- unistr2_to_ascii(key, &q_u->keyname, sizeof(key) - 1);
+ unistr2_to_ascii(key, &q_u->keyname, sizeof(key));
status = delete_all_printer_data( printer->info_2, key );
* --jerry
*/
- unistr2_to_ascii(key, &q_u->key, sizeof(key) - 1);
+ unistr2_to_ascii(key, &q_u->key, sizeof(key));
if ( !strlen(key) ) {
result = WERR_INVALID_PARAM;
goto done;
/* get the printer off of disk */
- if (!get_printer_snum(p,handle, &snum))
+ if (!get_printer_snum(p,handle, &snum, NULL))
return WERR_BADFID;
ZERO_STRUCT(printer);
/* now look for a match on the key name */
- p_data = &printer->info_2->data;
+ p_data = printer->info_2->data;
- unistr2_to_ascii(key, &q_u->key, sizeof(key) - 1);
+ unistr2_to_ascii(key, &q_u->key, sizeof(key));
if ( (key_index = lookup_printerkey( p_data, key)) == -1 )
{
DEBUG(10,("_spoolss_enumprinterdataex: Unknown keyname [%s]\n", key));
/* allocate the memory for the array of pointers -- if necessary */
- num_entries = regval_ctr_numvals( &p_data->keys[key_index].values );
+ num_entries = regval_ctr_numvals( p_data->keys[key_index].values );
if ( num_entries )
{
if ( (enum_values=TALLOC_ARRAY(p->mem_ctx, PRINTER_ENUM_VALUES, num_entries)) == NULL )
{
/* lookup the registry value */
- val = regval_ctr_specific_value( &p_data->keys[key_index].values, i );
+ val = regval_ctr_specific_value( p_data->keys[key_index].values, i );
DEBUG(10,("retrieved value number [%d] [%s]\n", i, regval_name(val) ));
/* copy the data */
data_len = regval_size( val );
if ( data_len ) {
- if ( !(enum_values[i].data = TALLOC_MEMDUP(p->mem_ctx, regval_data_p(val), data_len)) )
+ if ( !(enum_values[i].data = (uint8 *)TALLOC_MEMDUP(p->mem_ctx, regval_data_p(val), data_len)) )
{
- DEBUG(0,("talloc_memdup failed to allocate memory [data_len=%d] for data!\n",
+ DEBUG(0,("TALLOC_MEMDUP failed to allocate memory [data_len=%d] for data!\n",
data_len ));
result = WERR_NOMEM;
goto done;
/* housekeeping information in the reply */
+ /* Fix from Martin Zielinski <mz@seh.de> - ensure
+ * the hand marshalled container size is a multiple
+ * of 4 bytes for RPC alignment.
+ */
+
+ if (needed % 4) {
+ needed += 4-(needed % 4);
+ }
+
r_u->needed = needed;
r_u->returned = num_entries;
/* copy data into the reply */
r_u->ctr.size = r_u->needed;
+
r_u->ctr.size_of_array = r_u->returned;
r_u->ctr.values = enum_values;
PRINTPROCESSOR_DIRECTORY_1 *info=NULL;
WERROR result = WERR_OK;
- unistr2_to_ascii(long_archi, environment, sizeof(long_archi)-1);
+ unistr2_to_ascii(long_archi, environment, sizeof(long_archi));
if (!get_short_archi(long_archi))
return WERR_INVALID_ENVIRONMENT;
/* that's an [in out] buffer */
- if ( q_u->buffer ) {
- rpcbuf_move(q_u->buffer, &r_u->buffer);
- buffer = r_u->buffer;
+ if (!q_u->buffer && (offered!=0)) {
+ return WERR_INVALID_PARAM;
}
+ rpcbuf_move(q_u->buffer, &r_u->buffer);
+ buffer = r_u->buffer;
+
DEBUG(5,("_spoolss_getprintprocessordirectory\n"));
*needed=0;
return result;
}
-#if 0
+/*******************************************************************
+ Streams the monitor UI DLL name in UNICODE
+*******************************************************************/
+
+static WERROR xcvtcp_monitorui( NT_USER_TOKEN *token, RPC_BUFFER *in,
+ RPC_BUFFER *out, uint32 *needed )
+{
+ const char *dllname = "tcpmonui.dll";
+
+ *needed = (strlen(dllname)+1) * 2;
+
+ if ( rpcbuf_get_size(out) < *needed ) {
+ return WERR_INSUFFICIENT_BUFFER;
+ }
+
+ if ( !make_monitorui_buf( out, dllname ) ) {
+ return WERR_NOMEM;
+ }
+
+ return WERR_OK;
+}
+
+/*******************************************************************
+ Create a new TCP/IP port
+*******************************************************************/
-WERROR _spoolss_replyopenprinter(pipes_struct *p, SPOOL_Q_REPLYOPENPRINTER *q_u,
- SPOOL_R_REPLYOPENPRINTER *r_u)
+static WERROR xcvtcp_addport( NT_USER_TOKEN *token, RPC_BUFFER *in,
+ RPC_BUFFER *out, uint32 *needed )
{
- DEBUG(5,("_spoolss_replyopenprinter\n"));
+ NT_PORT_DATA_1 port1;
+ pstring device_uri;
- DEBUG(10, ("replyopenprinter for localprinter %d\n", q_u->printer));
+ ZERO_STRUCT( port1 );
- return WERR_OK;
+ /* convert to our internal port data structure */
+
+ if ( !convert_port_data_1( &port1, in ) ) {
+ return WERR_NOMEM;
+ }
+
+ /* create the device URI and call the add_port_hook() */
+
+ switch ( port1.protocol ) {
+ case PORT_PROTOCOL_DIRECT:
+ pstr_sprintf( device_uri, "socket://%s:%d/", port1.hostaddr, port1.port );
+ break;
+
+ case PORT_PROTOCOL_LPR:
+ pstr_sprintf( device_uri, "lpr://%s/%s", port1.hostaddr, port1.queue );
+ break;
+
+ default:
+ return WERR_UNKNOWN_PORT;
+ }
+
+ return add_port_hook( token, port1.name, device_uri );
+}
+
+/*******************************************************************
+*******************************************************************/
+
+struct xcv_api_table xcvtcp_cmds[] = {
+ { "MonitorUI", xcvtcp_monitorui },
+ { "AddPort", xcvtcp_addport},
+ { NULL, NULL }
+};
+
+static WERROR process_xcvtcp_command( NT_USER_TOKEN *token, const char *command,
+ RPC_BUFFER *inbuf, RPC_BUFFER *outbuf,
+ uint32 *needed )
+{
+ int i;
+
+ DEBUG(10,("process_xcvtcp_command: Received command \"%s\"\n", command));
+
+ for ( i=0; xcvtcp_cmds[i].name; i++ ) {
+ if ( strcmp( command, xcvtcp_cmds[i].name ) == 0 )
+ return xcvtcp_cmds[i].fn( token, inbuf, outbuf, needed );
+ }
+
+ return WERR_BADFUNC;
}
-WERROR _spoolss_replycloseprinter(pipes_struct *p, SPOOL_Q_REPLYCLOSEPRINTER *q_u,
- SPOOL_R_REPLYCLOSEPRINTER *r_u)
+/*******************************************************************
+*******************************************************************/
+#if 0 /* don't support management using the "Local Port" monitor */
+
+static WERROR xcvlocal_monitorui( NT_USER_TOKEN *token, RPC_BUFFER *in,
+ RPC_BUFFER *out, uint32 *needed )
{
- DEBUG(5,("_spoolss_replycloseprinter\n"));
+ const char *dllname = "localui.dll";
+
+ *needed = (strlen(dllname)+1) * 2;
+
+ if ( rpcbuf_get_size(out) < *needed ) {
+ return WERR_INSUFFICIENT_BUFFER;
+ }
+
+ if ( !make_monitorui_buf( out, dllname )) {
+ return WERR_NOMEM;
+ }
+
return WERR_OK;
}
+/*******************************************************************
+*******************************************************************/
+
+struct xcv_api_table xcvlocal_cmds[] = {
+ { "MonitorUI", xcvlocal_monitorui },
+ { NULL, NULL }
+};
+#else
+struct xcv_api_table xcvlocal_cmds[] = {
+ { NULL, NULL }
+};
#endif
+
+
+
+/*******************************************************************
+*******************************************************************/
+
+static WERROR process_xcvlocal_command( NT_USER_TOKEN *token, const char *command,
+ RPC_BUFFER *inbuf, RPC_BUFFER *outbuf,
+ uint32 *needed )
+{
+ int i;
+
+ DEBUG(10,("process_xcvlocal_command: Received command \"%s\"\n", command));
+
+ for ( i=0; xcvlocal_cmds[i].name; i++ ) {
+ if ( strcmp( command, xcvlocal_cmds[i].name ) == 0 )
+ return xcvlocal_cmds[i].fn( token, inbuf, outbuf , needed );
+ }
+ return WERR_BADFUNC;
+}
+
+/*******************************************************************
+*******************************************************************/
+
+WERROR _spoolss_xcvdataport(pipes_struct *p, SPOOL_Q_XCVDATAPORT *q_u, SPOOL_R_XCVDATAPORT *r_u)
+{
+ Printer_entry *Printer = find_printer_index_by_hnd(p, &q_u->handle);
+ fstring command;
+
+ if (!Printer) {
+ DEBUG(2,("_spoolss_xcvdataport: Invalid handle (%s:%u:%u).\n", OUR_HANDLE(&q_u->handle)));
+ return WERR_BADFID;
+ }
+
+ /* Has to be a handle to the TCP/IP port monitor */
+
+ if ( !(Printer->printer_type & (SPLHND_PORTMON_LOCAL|SPLHND_PORTMON_TCP)) ) {
+ DEBUG(2,("_spoolss_xcvdataport: Call only valid for Port Monitors\n"));
+ return WERR_BADFID;
+ }
+
+ /* requires administrative access to the server */
+
+ if ( !(Printer->access_granted & SERVER_ACCESS_ADMINISTER) ) {
+ DEBUG(2,("_spoolss_xcvdataport: denied by handle permissions.\n"));
+ return WERR_ACCESS_DENIED;
+ }
+
+ /* Get the command name. There's numerous commands supported by the
+ TCPMON interface. */
+
+ rpcstr_pull(command, q_u->dataname.buffer, sizeof(command),
+ q_u->dataname.uni_str_len*2, 0);
+
+ /* Allocate the outgoing buffer */
+
+ rpcbuf_init( &r_u->outdata, q_u->offered, p->mem_ctx );
+
+ switch ( Printer->printer_type ) {
+ case SPLHND_PORTMON_TCP:
+ return process_xcvtcp_command( p->pipe_user.nt_user_token, command,
+ &q_u->indata, &r_u->outdata, &r_u->needed );
+ case SPLHND_PORTMON_LOCAL:
+ return process_xcvlocal_command( p->pipe_user.nt_user_token, command,
+ &q_u->indata, &r_u->outdata, &r_u->needed );
+ }
+
+ return WERR_INVALID_PRINT_MONITOR;
+}
+
+
git.samba.org / kai / samba.git / blobdiff