*
* 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
/* in printing/nt_printing.c */
-extern STANDARD_MAPPING printer_std_mapping, printserver_std_mapping;
-
-#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())
-
+extern struct standard_mapping printer_std_mapping, printserver_std_mapping;
/* API table for Xcv Monitor functions */
cli_shutdown( notify_cli_pipe->cli );
notify_cli_pipe = NULL; /* The above call shuts downn the pipe also. */
- message_deregister(MSG_PRINTER_NOTIFY2);
+ messaging_deregister(smbd_messaging_context(),
+ MSG_PRINTER_NOTIFY2, NULL);
/* Tell the connections db we're no longer interested in
* printer notify messages. */
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 )
/* go ahead and re-read the services immediately */
reload_services( False );
- if ( share_defined( sharename ) )
+ if ( lp_servicenumber( sharename ) < 0 )
return WERR_ACCESS_DENIED;
return WERR_OK;
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);
}
data->notify_data.data.length = 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;
+ 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_copy_all_data_out((char *)data->notify_data.data.string, &ps);
-
prs_mem_free(&ps);
}
/* 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, struct process_id 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;
}
DEBUG(10,("srv_spoolss_drv_upgrade_printer: Sending message about driver upgrade [%s]\n",
drivername));
- message_send_pid(pid_to_procid(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, struct process_id 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, (const char *)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 ));
DEBUG(10,("srv_spoolss_reset_printerdata: Sending message about resetting printerdata [%s]\n",
drivername));
- message_send_pid(pid_to_procid(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, struct process_id 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, (const char *)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 ));
return NULL;
}
- d->dev_private = (uint8 *)TALLOC_MEMDUP(ctx, devmode->dev_private,
+ if (devmode->driverextra) {
+ d->dev_private = (uint8 *)TALLOC_MEMDUP(ctx, devmode->dev_private,
devmode->driverextra);
- if (!d->dev_private) {
- return NULL;
- }
+ if (!d->dev_private) {
+ return NULL;
+ }
+ } else {
+ d->dev_private = NULL;
+ }
return d;
}
/* 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));
/* 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_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
Printer->document_started=False;
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 */
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) {
*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 == 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;
}
}
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 );
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 == SPLHND_SERVER)
snum = -1;
else if ( (Printer->printer_type == SPLHND_PRINTER) &&
- !get_printer_snum(p, handle, &snum) )
+ !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;
+ }
}
/*******************************************************************
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];
DEBUGADD(8,("getting printer characteristics\n"));
- if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
+ if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, servicename)))
return NULL;
if ( !printer->info_2->devmode ) {
printer->cjobs = count; /* jobs */
printer->averageppm = ntprinter->info_2->averageppm; /* average pages per minute */
- if ( !(printer->devmode = construct_dev_mode(lp_const_servicename(snum))) )
+ if ( !(printer->devmode = construct_dev_mode(
+ lp_const_servicename(snum))) )
DEBUG(8, ("Returning NULL Devicemode!\n"));
printer->secdesc = NULL;
if ( ntprinter->info_2->secdesc_buf
- && ntprinter->info_2->secdesc_buf->len != 0 )
+ && 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( get_talloc_ctx(),
- ntprinter->info_2->secdesc_buf->sec );
+ printer->secdesc = dup_sec_desc( talloc_tos(),
+ ntprinter->info_2->secdesc_buf->sd );
}
free_a_printer(&ntprinter, 2);
/* These are the components of the SD we are returning. */
- printer->flags = 0x4;
-
- if (ntprinter->info_2->secdesc_buf && ntprinter->info_2->secdesc_buf->len != 0) {
+ 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( get_talloc_ctx(),
- ntprinter->info_2->secdesc_buf->sec );
+ printer->secdesc = dup_sec_desc( talloc_tos(),
+ ntprinter->info_2->secdesc_buf->sd );
}
free_a_printer(&ntprinter, 2);
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)
{
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));
* 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) {
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;
*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);
}
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;
*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;
}
/* 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;
}
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,
return WERR_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
switch (command) {
return WERR_BADFID;
}
- if (!get_printer_snum(p, handle, &snum))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
print_job_delete( &p->pipe_user, snum, Printer->jobid, &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"));
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;
}
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 )
goto done;
}
- if (!get_printer_snum(p, handle, &snum)) {
+ if (!get_printer_snum(p, handle, &snum, NULL)) {
result = WERR_BADFID;
goto done;
}
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->printer_type == SPLHND_SERVER)
snum = -1;
else if ( (Printer->printer_type == SPLHND_PRINTER) &&
- !get_printer_snum(p, handle, &snum) )
+ !get_printer_snum(p, handle, &snum, NULL) )
return WERR_BADFID;
srv_spoolss_replycloseprinter(snum, &Printer->notify.client_hnd);
/* 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));
int snum;
WERROR errcode = WERR_BADFUNC;
- if (!get_printer_snum(p, handle, &snum)) {
+ if (!get_printer_snum(p, handle, &snum, NULL)) {
return WERR_BADFID;
}
*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;
rpcbuf_move(q_u->buffer, &r_u->buffer);
buffer = r_u->buffer;
- unistr2_to_ascii(form_name, uni_formname, sizeof(form_name)-1);
+ unistr2_to_ascii(form_name, uni_formname, sizeof(form_name));
DEBUG(4,("_spoolss_getform\n"));
DEBUGADD(5,("Offered buffer size [%d]\n", offered));
/* 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;
}
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 */
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));
*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), (size_t)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 */
goto done;
}
data_len = regval_size(val);
- if ( *data_out )
+ if ( *data_out && data_len )
memcpy( *data_out, regval_data_p(val), data_len );
*out_data_len = data_len;
}
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 );
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));
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));
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));
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;
*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));
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));
status = WERR_NOMEM;
goto done;
}
- }
- else {
+ } else {
*data = NULL;
- }
+ }
}
if ( printer )
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 */
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 );
+ 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);
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));
if ( 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;