*
* 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;
+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. */
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 )
/* 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);
case SPLHND_PRINTER:
DEBUG(4,("short name:%s\n", Printer->sharename));
*number = print_queue_snum(Printer->sharename);
- if ((*number != -1) && (params != NULL)) {
- *params = get_share_params(tmp_talloc_ctx(),
- Printer->sharename);
- if (*params == NULL) {
- return False;
- }
- }
return (*number != -1);
case SPLHND_SERVER:
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));
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;
+ bool found=False;
NT_PRINTER_INFO_LEVEL *printer = NULL;
WERROR result;
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;
}
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);
}
/***********************************************************************
**********************************************************************/
-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, 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;
}
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(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 ));
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(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));
/****************************************************************************
****************************************************************************/
-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;
+ bool ret;
switch (level) {
case 2:
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_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 */
NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
int version;
uint32 flags = q_u->delete_flags;
- BOOL delete_files;
+ bool delete_files;
WERROR status;
WERROR status_win2k = WERR_ACCESS_DENIED;
SE_PRIV se_printop = SE_PRINT_OPERATOR;
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 );
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 rpc_pipe_client **pp_pipe,
+static bool spoolss_connect_to_client(struct rpc_pipe_client **pp_pipe,
struct in_addr *client_ip, const char *remote_machine)
{
NTSTATUS ret;
struct cli_state *the_cli;
struct in_addr rm_addr;
- if ( is_zero_ip(*client_ip) ) {
+ 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( rm_addr )) {
+ 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));
return False;
}
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)
{
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 */
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;
+ }
}
/*******************************************************************
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;
+ }
}
/*******************************************************************
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;
+ }
}
/*******************************************************************
/****************************************************************************
****************************************************************************/
-static BOOL search_notify(uint16 type, uint16 field, int *value)
+static bool search_notify(uint16 type, uint16 field, int *value)
{
int i;
*
********************************************************************/
-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)
*
********************************************************************/
-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
* fill a printer_info_0 struct
********************************************************************/
-static BOOL construct_printer_info_0(Printer_entry *print_hnd,
- PRINTER_INFO_0 *printer,
- const struct share_params *params)
+static bool construct_printer_info_0(Printer_entry *print_hnd, PRINTER_INFO_0 *printer, int snum)
{
pstring chaine;
int count;
time_t setuptime;
print_status_struct status;
- if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2,
- lp_const_servicename(params->service))))
+ if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
return False;
- count = print_queue_length(params->service, &status);
+ count = print_queue_length(snum, &status);
/* check if we already have a counter for this printer */
for(session_counter = counter_list; session_counter; session_counter = session_counter->next) {
- if (session_counter->snum == params->service)
+ if (session_counter->snum == snum)
break;
}
return False;
}
ZERO_STRUCTP(session_counter);
- session_counter->snum=params->service;
+ session_counter->snum=snum;
session_counter->counter=0;
DLIST_ADD(counter_list, session_counter);
}
* 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,
- const struct share_params *params)
+static bool construct_printer_info_1(Printer_entry *print_hnd, uint32 flags, PRINTER_INFO_1 *printer, int snum)
{
pstring chaine;
pstring chaine2;
NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
- if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2,
- lp_const_servicename(params->service))))
+ if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
return False;
printer->flags=flags;
if (*ntprinter->info_2->comment == '\0') {
- init_unistr(&printer->comment, lp_comment(params->service));
+ init_unistr(&printer->comment, lp_comment(snum));
slprintf(chaine,sizeof(chaine)-1,"%s,%s,%s", ntprinter->info_2->printername,
- ntprinter->info_2->drivername,
- lp_comment(params->service));
+ ntprinter->info_2->drivername, lp_comment(snum));
}
else {
init_unistr(&printer->comment, ntprinter->info_2->comment); /* saved comment. */
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;
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 ) {
* fill a printer_info_2 struct
********************************************************************/
-static BOOL construct_printer_info_2(Printer_entry *print_hnd,
- PRINTER_INFO_2 *printer,
- const struct share_params *params)
+static bool construct_printer_info_2(Printer_entry *print_hnd, PRINTER_INFO_2 *printer, int snum)
{
int count;
NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
print_status_struct status;
- if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2,
- lp_const_servicename(params->service))))
+ if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
return False;
- count = print_queue_length(params->service, &status);
+ count = print_queue_length(snum, &status);
init_unistr(&printer->servername, ntprinter->info_2->servername); /* servername*/
init_unistr(&printer->printername, ntprinter->info_2->printername); /* printername*/
- init_unistr(&printer->sharename, lp_servicename(params->service)); /* sharename */
+ init_unistr(&printer->sharename, lp_servicename(snum)); /* sharename */
init_unistr(&printer->portname, ntprinter->info_2->portname); /* port */
init_unistr(&printer->drivername, ntprinter->info_2->drivername); /* drivername */
if (*ntprinter->info_2->comment == '\0')
- init_unistr(&printer->comment, lp_comment(params->service)); /* comment */
+ init_unistr(&printer->comment, lp_comment(snum)); /* comment */
else
init_unistr(&printer->comment, ntprinter->info_2->comment); /* saved comment. */
printer->averageppm = ntprinter->info_2->averageppm; /* average pages per minute */
if ( !(printer->devmode = construct_dev_mode(
- lp_const_servicename(params->service))) )
+ lp_const_servicename(snum))) )
DEBUG(8, ("Returning NULL Devicemode!\n"));
printer->secdesc = NULL;
/* 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(),
+ printer->secdesc = dup_sec_desc( talloc_tos(),
ntprinter->info_2->secdesc_buf->sd );
}
* fill a printer_info_3 struct
********************************************************************/
-static BOOL construct_printer_info_3(Printer_entry *print_hnd,
- PRINTER_INFO_3 **pp_printer,
- const struct share_params *params)
+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;
- if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2,
- lp_const_servicename(params->service))))
+ if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
return False;
*pp_printer = NULL;
/* These are the components of the SD we are returning. */
- printer->flags = 0x4;
-
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(),
+ printer->secdesc = dup_sec_desc( talloc_tos(),
ntprinter->info_2->secdesc_buf->sd );
}
* fill a printer_info_4 struct
********************************************************************/
-static BOOL construct_printer_info_4(Printer_entry *print_hnd,
- PRINTER_INFO_4 *printer,
- const struct share_params *params)
+static bool construct_printer_info_4(Printer_entry *print_hnd, PRINTER_INFO_4 *printer, int snum)
{
NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
- if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2,
- lp_const_servicename(params->service))))
+ if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
return False;
init_unistr(&printer->printername, ntprinter->info_2->printername); /* printername*/
* fill a printer_info_5 struct
********************************************************************/
-static BOOL construct_printer_info_5(Printer_entry *print_hnd,
- PRINTER_INFO_5 *printer,
- const struct share_params *params)
+static bool construct_printer_info_5(Printer_entry *print_hnd, PRINTER_INFO_5 *printer, int snum)
{
NT_PRINTER_INFO_LEVEL *ntprinter = NULL;
- if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2,
- lp_const_servicename(params->service))))
+ if (!W_ERROR_IS_OK(get_a_printer(print_hnd, &ntprinter, 2, lp_const_servicename(snum))))
return False;
init_unistr(&printer->printername, ntprinter->info_2->printername);
* fill a printer_info_6 struct
********************************************************************/
-static BOOL construct_printer_info_6(Printer_entry *print_hnd,
+static bool construct_printer_info_6(Printer_entry *print_hnd,
PRINTER_INFO_6 *printer,
- const struct share_params *params)
+ 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(params->service))))
+ lp_const_servicename(snum))))
return False;
- count = print_queue_length(params->service, &status);
+ count = print_queue_length(snum, &status);
printer->status = nt_printq_status(status.status);
* fill a printer_info_7 struct
********************************************************************/
-static BOOL construct_printer_info_7(Printer_entry *print_hnd,
- PRINTER_INFO_7 *printer,
- const struct share_params *params)
+static bool construct_printer_info_7(Printer_entry *print_hnd, PRINTER_INFO_7 *printer, int snum)
{
char *guid_str = NULL;
struct GUID guid;
- if (is_printer_published(print_hnd, params->service, &guid)) {
+ if (is_printer_published(print_hnd, snum, &guid)) {
asprintf(&guid_str, "{%s}", smb_uuid_string_static(guid));
strupper_m(guid_str);
init_unistr(&printer->guid, guid_str);
for (snum=0; snum<n_services; snum++) {
if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
- struct share_params params;
- params.service = snum;
-
DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
- if (construct_printer_info_1(NULL, flags, ¤t_prt, ¶ms)) {
+ if (construct_printer_info_1(NULL, flags, ¤t_prt, snum)) {
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"));
*returned=0;
for (snum=0; snum<n_services; snum++) {
if (lp_browseable(snum) && lp_snum_ok(snum) && lp_print_ok(snum) ) {
- struct share_params params;
- params.service = snum;
DEBUG(4,("Found a printer in smb.conf: %s[%x]\n", lp_servicename(snum), snum));
-
- if (construct_printer_info_2(NULL, ¤t_prt, ¶ms)) {
+
+ if (construct_printer_info_2(NULL, ¤t_prt, snum)) {
if ( !(printers=SMB_REALLOC_ARRAY(printers, PRINTER_INFO_2, *returned +1)) ) {
DEBUG(2,("enum_all_printers_info_2: failed to enlarge printers buffer!\n"));
*returned = 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) {
/****************************************************************************
****************************************************************************/
-static WERROR getprinter_level_0(Printer_entry *print_hnd,
- const struct share_params *params,
- RPC_BUFFER *buffer, uint32 offered,
- uint32 *needed)
+static WERROR getprinter_level_0(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_0 *printer=NULL;
WERROR result = WERR_OK;
if((printer=SMB_MALLOC_P(PRINTER_INFO_0)) == NULL)
return WERR_NOMEM;
- construct_printer_info_0(print_hnd, printer, params);
+ construct_printer_info_0(print_hnd, printer, snum);
/* check the required size. */
*needed += spoolss_size_printer_info_0(printer);
/****************************************************************************
****************************************************************************/
-static WERROR getprinter_level_1(Printer_entry *print_hnd,
- const struct share_params *params,
- RPC_BUFFER *buffer, uint32 offered,
- uint32 *needed)
+static WERROR getprinter_level_1(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_1 *printer=NULL;
WERROR result = WERR_OK;
if((printer=SMB_MALLOC_P(PRINTER_INFO_1)) == NULL)
return WERR_NOMEM;
- construct_printer_info_1(print_hnd, PRINTER_ENUM_ICON8, printer,
- params);
+ construct_printer_info_1(print_hnd, PRINTER_ENUM_ICON8, printer, snum);
/* check the required size. */
*needed += spoolss_size_printer_info_1(printer);
/****************************************************************************
****************************************************************************/
-static WERROR getprinter_level_2(Printer_entry *print_hnd,
- const struct share_params *params,
- RPC_BUFFER *buffer, uint32 offered,
- uint32 *needed)
+static WERROR getprinter_level_2(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_2 *printer=NULL;
WERROR result = WERR_OK;
if((printer=SMB_MALLOC_P(PRINTER_INFO_2))==NULL)
return WERR_NOMEM;
- construct_printer_info_2(print_hnd, printer, params);
+ construct_printer_info_2(print_hnd, printer, snum);
/* check the required size. */
*needed += spoolss_size_printer_info_2(printer);
/****************************************************************************
****************************************************************************/
-static WERROR getprinter_level_3(Printer_entry *print_hnd,
- const struct share_params *params,
- RPC_BUFFER *buffer, uint32 offered,
- uint32 *needed)
+static WERROR getprinter_level_3(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_3 *printer=NULL;
WERROR result = WERR_OK;
- if (!construct_printer_info_3(print_hnd, &printer, params))
+ if (!construct_printer_info_3(print_hnd, &printer, snum))
return WERR_NOMEM;
/* check the required size. */
/****************************************************************************
****************************************************************************/
-static WERROR getprinter_level_4(Printer_entry *print_hnd,
- const struct share_params *params,
- RPC_BUFFER *buffer, uint32 offered,
- uint32 *needed)
+static WERROR getprinter_level_4(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_4 *printer=NULL;
WERROR result = WERR_OK;
if((printer=SMB_MALLOC_P(PRINTER_INFO_4))==NULL)
return WERR_NOMEM;
- if (!construct_printer_info_4(print_hnd, printer, params)) {
+ if (!construct_printer_info_4(print_hnd, printer, snum)) {
SAFE_FREE(printer);
return WERR_NOMEM;
}
/****************************************************************************
****************************************************************************/
-static WERROR getprinter_level_5(Printer_entry *print_hnd,
- const struct share_params *params,
- RPC_BUFFER *buffer, uint32 offered,
- uint32 *needed)
+static WERROR getprinter_level_5(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_5 *printer=NULL;
WERROR result = WERR_OK;
if((printer=SMB_MALLOC_P(PRINTER_INFO_5))==NULL)
return WERR_NOMEM;
- if (!construct_printer_info_5(print_hnd, printer, params)) {
+ if (!construct_printer_info_5(print_hnd, printer, snum)) {
free_printer_info_5(printer);
return WERR_NOMEM;
}
}
static WERROR getprinter_level_6(Printer_entry *print_hnd,
- const struct share_params *params,
+ int snum,
RPC_BUFFER *buffer, uint32 offered,
uint32 *needed)
{
return WERR_NOMEM;
}
- if (!construct_printer_info_6(print_hnd, printer, params)) {
+ if (!construct_printer_info_6(print_hnd, printer, snum)) {
free_printer_info_6(printer);
return WERR_NOMEM;
}
return result;
}
-static WERROR getprinter_level_7(Printer_entry *print_hnd,
- const struct share_params *params,
- RPC_BUFFER *buffer, uint32 offered,
- uint32 *needed)
+static WERROR getprinter_level_7(Printer_entry *print_hnd, int snum, RPC_BUFFER *buffer, uint32 offered, uint32 *needed)
{
PRINTER_INFO_7 *printer=NULL;
WERROR result = WERR_OK;
if((printer=SMB_MALLOC_P(PRINTER_INFO_7))==NULL)
return WERR_NOMEM;
- if (!construct_printer_info_7(print_hnd, printer, params))
+ if (!construct_printer_info_7(print_hnd, printer, snum))
return WERR_NOMEM;
/* check the required size. */
uint32 offered = q_u->offered;
uint32 *needed = &r_u->needed;
Printer_entry *Printer=find_printer_index_by_hnd(p, handle);
- struct share_params *params;
int snum;
*needed=0;
- if (!get_printer_snum(p, handle, &snum, ¶ms))
+ if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
switch (level) {
case 0:
- return getprinter_level_0(Printer, params, buffer, offered,
- needed);
+ return getprinter_level_0(Printer, snum, buffer, offered, needed);
case 1:
- return getprinter_level_1(Printer, params, buffer, offered,
- needed);
+ return getprinter_level_1(Printer, snum, buffer, offered, needed);
case 2:
- return getprinter_level_2(Printer, params, buffer, offered,
- needed);
+ return getprinter_level_2(Printer, snum, buffer, offered, needed);
case 3:
- return getprinter_level_3(Printer, params, buffer, offered,
- needed);
+ return getprinter_level_3(Printer, snum, buffer, offered, needed);
case 4:
- return getprinter_level_4(Printer, params, buffer, offered,
- needed);
+ return getprinter_level_4(Printer, snum, buffer, offered, needed);
case 5:
- return getprinter_level_5(Printer, params, buffer, offered,
- needed);
- case 6:
- return getprinter_level_6(Printer, params, buffer, offered,
- needed);
+ 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, params, buffer, offered,
- needed);
+ return getprinter_level_7(Printer, snum, buffer, offered, needed);
}
return WERR_UNKNOWN_LEVEL;
}
*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, NULL))
return WERR_BADFID;
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
_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;
int ret;
int fd;
SE_PRIV se_printop = SE_PRINT_OPERATOR;
- BOOL is_print_op = False;
+ bool is_print_op = False;
if ( !*cmd ) {
return WERR_ACCESS_DENIED;
/****************************************************************************
****************************************************************************/
-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,
current_user_info.domain,
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 )
/****************************************************************************
****************************************************************************/
-static BOOL fill_job_info_2(JOB_INFO_2 *job_info, const print_queue_struct *queue,
+static bool fill_job_info_2(JOB_INFO_2 *job_info, const print_queue_struct *queue,
int position, int snum,
const NT_PRINTER_INFO_LEVEL *ntprinter,
DEVICEMODE *devmode)
*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;
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;
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 */
*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;
}
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
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 );
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;
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;
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));
status = WERR_NOMEM;
goto done;
}
- }
- else {
+ } else {
*data = NULL;
- }
+ }
}
if ( printer )
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 */
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 );
/* 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 );
/* 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;
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;