#include "serverid.h"
#include "../libcli/registry/util_reg.h"
#include "smbd/smbd.h"
+#include "smbd/globals.h"
#include "auth.h"
#include "messages.h"
#include "rpc_server/spoolss/srv_spoolss_nt.h"
#include "util_tdb.h"
#include "libsmb/libsmb.h"
#include "printing/printer_list.h"
+#include "../lib/tsocket/tsocket.h"
+#include "rpc_client/cli_winreg_spoolss.h"
/* macros stolen from s4 spoolss server */
#define SPOOLSS_BUFFER_UNION(fn,info,level) \
/* print notify back-channel pipe handle*/
struct rpc_pipe_client *cli_pipe;
- struct dcerpc_binding_handle *binding_handle;
uint32_t active_connections;
};
/* weird if the test succeeds !!! */
if (prn_hnd->notify.cli_chan == NULL ||
+ prn_hnd->notify.cli_chan->cli_pipe == NULL ||
+ prn_hnd->notify.cli_chan->cli_pipe->binding_handle == NULL ||
prn_hnd->notify.cli_chan->active_connections == 0) {
DEBUG(0, ("Trying to close unexisting backchannel!\n"));
DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
}
status = dcerpc_spoolss_ReplyClosePrinter(
- prn_hnd->notify.cli_chan->binding_handle,
+ prn_hnd->notify.cli_chan->cli_pipe->binding_handle,
talloc_tos(),
&prn_hnd->notify.cli_hnd,
&result);
/* if it's the last connection, deconnect the IPC$ share */
if (prn_hnd->notify.cli_chan->active_connections == 1) {
- prn_hnd->notify.cli_chan->binding_handle = NULL;
cli_shutdown(rpc_pipe_np_smb_conn(prn_hnd->notify.cli_chan->cli_pipe));
DLIST_REMOVE(back_channels, prn_hnd->notify.cli_chan);
TALLOC_FREE(prn_hnd->notify.cli_chan);
if (prn_hnd->notify.msg_ctx != NULL) {
messaging_deregister(prn_hnd->notify.msg_ctx,
MSG_PRINTER_NOTIFY2, NULL);
-
- /*
- * Tell the serverid.tdb we're no longer
- * interested in printer notify messages.
- */
-
- serverid_register_msg_flags(
- messaging_server_id(prn_hnd->notify.msg_ctx),
- false, FLAG_MSG_PRINT_NOTIFY);
}
}
if (prn_hnd->notify.cli_chan) {
prn_hnd->notify.cli_chan->active_connections--;
+ prn_hnd->notify.cli_chan = NULL;
}
}
if (ret != 0)
return WERR_BADFID; /* What to return here? */
- /* go ahead and re-read the services immediately */
- become_root();
- reload_services(msg_ctx, -1, false);
- unbecome_root();
-
- if ( lp_servicenumber( sharename ) >= 0 )
- return WERR_ACCESS_DENIED;
-
return WERR_OK;
}
/* this does not need a become root since the access check has been
done on the handle already */
- result = winreg_delete_printer_key(p->mem_ctx,
+ result = winreg_delete_printer_key_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
Printer->sharename,
****************************************************************************/
static WERROR set_printer_hnd_name(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
struct printer_handle *Printer,
const char *handlename)
continue;
}
- result = winreg_get_printer(mem_ctx,
+ result = winreg_get_printer_internal(mem_ctx,
session_info,
msg_ctx,
sname,
if ( i == ctr->num_groups ) {
ctr->num_groups++;
- if ( !(groups = TALLOC_REALLOC_ARRAY( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
+ if ( !(groups = talloc_realloc( ctr->ctx, ctr->msg_groups, SPOOLSS_NOTIFY_MSG_GROUP, ctr->num_groups)) ) {
DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed!\n"));
return 0;
}
msg_grp->num_msgs++;
- if ( !(msg_list = TALLOC_REALLOC_ARRAY( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
+ if ( !(msg_list = talloc_realloc( ctr->ctx, msg_grp->msgs, SPOOLSS_NOTIFY_MSG, msg_grp->num_msgs )) ) {
DEBUG(0,("notify_msg_ctr_addmsg: talloc_realloc() failed for new message [%d]!\n", msg_grp->num_msgs));
return 0;
}
if ( msg->len != 0 )
msg_grp->msgs[new_slot].notify.data = (char *)
- TALLOC_MEMDUP( ctr->ctx, msg->notify.data, msg->len );
+ talloc_memdup( ctr->ctx, msg->notify.data, msg->len );
return ctr->num_groups;
}
/* Is there notification on this handle? */
if (prn_hnd->notify.cli_chan == NULL ||
+ prn_hnd->notify.cli_chan->cli_pipe == NULL ||
+ prn_hnd->notify.cli_chan->cli_pipe->binding_handle == NULL ||
prn_hnd->notify.cli_chan->active_connections == 0) {
return 0;
}
info.info0 = &info0;
status = dcerpc_spoolss_RouterReplyPrinterEx(
- prn_hnd->notify.cli_chan->binding_handle,
+ prn_hnd->notify.cli_chan->cli_pipe->binding_handle,
mem_ctx,
&prn_hnd->notify.cli_hnd,
prn_hnd->notify.change, /* color */
DATA_BLOB *data)
{
TALLOC_CTX *tmp_ctx;
- struct auth_serversupplied_info *session_info = NULL;
+ const struct auth_session_info *session_info = get_session_info_system();
struct spoolss_PrinterInfo2 *pinfo2;
- NTSTATUS status;
WERROR result;
const char *drivername;
int snum;
int n_services = lp_numservices();
+ struct dcerpc_binding_handle *b = NULL;
tmp_ctx = talloc_new(NULL);
if (!tmp_ctx) return;
- status = make_session_info_system(tmp_ctx, &session_info);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0, ("do_drv_upgrade_printer: "
- "Could not create system session_info\n"));
- goto done;
- }
-
drivername = talloc_strndup(tmp_ctx, (const char *)data->data, data->length);
if (!drivername) {
DEBUG(0, ("do_drv_upgrade_printer: Out of memoery ?!\n"));
continue;
}
- result = winreg_get_printer(tmp_ctx, session_info, msg,
+ if (b == NULL) {
+ result = winreg_printer_binding_handle(tmp_ctx,
+ session_info,
+ msg,
+ &b);
+ if (!W_ERROR_IS_OK(result)) {
+ break;
+ }
+ }
+
+ result = winreg_get_printer(tmp_ctx, b,
lp_const_servicename(snum),
&pinfo2);
DEBUG(6,("Updating printer [%s]\n", pinfo2->printername));
/* all we care about currently is the change_id */
- result = winreg_printer_update_changeid(tmp_ctx,
- session_info,
- msg,
+ result = winreg_printer_update_changeid(tmp_ctx, b,
pinfo2->printername);
if (!W_ERROR_IS_OK(result)) {
struct spoolss_OpenPrinterEx *r)
{
int snum;
+ char *raddr;
+ char *rhost;
struct printer_handle *Printer=NULL;
WERROR result;
+ int rc;
if (!r->in.printername) {
return WERR_INVALID_PARAM;
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
and not a printer admin, then fail */
- if ((p->session_info->utok.uid != sec_initial_uid()) &&
+ if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
!security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR) &&
!nt_token_check_sid(&global_sid_Builtin_Print_Operators, p->session_info->security_token) &&
!token_contains_name_in_list(
- uidtoname(p->session_info->utok.uid),
- p->session_info->info3->base.domain.string,
+ uidtoname(p->session_info->unix_token->uid),
+ p->session_info->info->domain_name,
NULL,
p->session_info->security_token,
lp_printer_admin(snum))) {
}
/* check smb.conf parameters and the the sec_desc */
+ raddr = tsocket_address_inet_addr_string(p->remote_address,
+ p->mem_ctx);
+ if (raddr == NULL) {
+ return WERR_NOMEM;
+ }
+
+ rc = get_remote_hostname(p->remote_address,
+ &rhost,
+ p->mem_ctx);
+ if (rc < 0) {
+ return WERR_NOMEM;
+ }
+ if (strequal(rhost, "UNKNOWN")) {
+ rhost = raddr;
+ }
if (!allow_access(lp_hostsdeny(snum), lp_hostsallow(snum),
- p->client_id->name, p->client_id->addr)) {
+ rhost, raddr)) {
DEBUG(3, ("access DENIED (hosts allow/deny) for printer open\n"));
ZERO_STRUCTP(r->out.handle);
return WERR_ACCESS_DENIED;
}
- if (!user_ok_token(uidtoname(p->session_info->utok.uid), NULL,
+ if (!user_ok_token(uidtoname(p->session_info->unix_token->uid), NULL,
p->session_info->security_token, snum) ||
!print_access_check(p->session_info,
p->msg_ctx,
DEBUG(4,("Setting printer access = %s\n", (r->in.access_mask == PRINTER_ACCESS_ADMINISTER)
? "PRINTER_ACCESS_ADMINISTER" : "PRINTER_ACCESS_USE" ));
- winreg_create_printer(p->mem_ctx,
+ winreg_create_printer_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_const_servicename(snum));
}
if (get_printer_snum(p, r->in.handle, &snum, NULL)) {
- winreg_delete_printer_key(p->mem_ctx,
+ winreg_delete_printer_key_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_const_servicename(snum),
struct spoolss_DriverInfo8 *info_win2k = NULL;
int version;
WERROR status;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx = NULL;
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
and not a printer admin, then fail */
- if ( (p->session_info->utok.uid != sec_initial_uid())
+ if ( (p->session_info->unix_token->uid != sec_initial_uid())
&& !security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR)
&& !token_contains_name_in_list(
- uidtoname(p->session_info->utok.uid),
- p->session_info->info3->base.domain.string,
+ uidtoname(p->session_info->unix_token->uid),
+ p->session_info->info->domain_name,
NULL,
p->session_info->security_token,
lp_printer_admin(-1)) )
/* check that we have a valid driver name first */
- if ((version = get_version_id(r->in.architecture)) == -1)
+ if ((version = get_version_id(r->in.architecture)) == -1) {
return WERR_INVALID_ENVIRONMENT;
+ }
- status = winreg_get_driver(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ status = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(status)) {
+ goto done;
+ }
+
+ status = winreg_get_driver(tmp_ctx, b,
r->in.architecture, r->in.driver,
version, &info);
if (!W_ERROR_IS_OK(status)) {
if ( version == 2 ) {
version = 3;
- status = winreg_get_driver(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_get_driver(tmp_ctx, b,
r->in.architecture,
r->in.driver,
version, &info);
}
- if (printer_driver_in_use(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ if (printer_driver_in_use(tmp_ctx,
+ b,
info)) {
status = WERR_PRINTER_DRIVER_IN_USE;
goto done;
}
if (version == 2) {
- status = winreg_get_driver(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_get_driver(tmp_ctx, b,
r->in.architecture,
r->in.driver, 3, &info_win2k);
if (W_ERROR_IS_OK(status)) {
/* if we get to here, we now have 2 driver info structures to remove */
/* remove the Win2k driver first*/
- status = winreg_del_driver(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_del_driver(tmp_ctx, b,
info_win2k, 3);
talloc_free(info_win2k);
}
}
- status = winreg_del_driver(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_del_driver(tmp_ctx, b,
info, version);
done:
- talloc_free(info);
+ talloc_free(tmp_ctx);
return status;
}
int version;
bool delete_files;
WERROR status;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx = NULL;
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
and not a printer admin, then fail */
- if ( (p->session_info->utok.uid != sec_initial_uid())
+ if ( (p->session_info->unix_token->uid != sec_initial_uid())
&& !security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR)
&& !token_contains_name_in_list(
- uidtoname(p->session_info->utok.uid),
- p->session_info->info3->base.domain.string,
+ uidtoname(p->session_info->unix_token->uid),
+ p->session_info->info->domain_name,
NULL,
p->session_info->security_token, lp_printer_admin(-1)) )
{
return WERR_INVALID_ENVIRONMENT;
}
- if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
+ if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) {
version = r->in.version;
+ }
- status = winreg_get_driver(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ status = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(status)) {
+ goto done;
+ }
+
+ status = winreg_get_driver(tmp_ctx, b,
r->in.architecture,
r->in.driver,
version,
/* try for Win2k driver if "Windows NT x86" */
version = 3;
- status = winreg_get_driver(info,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_get_driver(tmp_ctx, b,
r->in.architecture,
r->in.driver,
version, &info);
}
}
- if (printer_driver_in_use(info,
- get_session_info_system(),
- p->msg_ctx,
+ if (printer_driver_in_use(tmp_ctx,
+ b,
info)) {
status = WERR_PRINTER_DRIVER_IN_USE;
goto done;
if (delete_files &&
(r->in.delete_flags & DPD_DELETE_ALL_FILES) &&
- printer_driver_files_in_use(info,
- get_session_info_system(),
- p->msg_ctx,
+ printer_driver_files_in_use(tmp_ctx,
+ b,
info)) {
/* no idea of the correct error here */
status = WERR_ACCESS_DENIED;
/* also check for W32X86/3 if necessary; maybe we already have? */
if ( (version == 2) && ((r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION) != DPD_DELETE_SPECIFIC_VERSION) ) {
- status = winreg_get_driver(info,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_get_driver(tmp_ctx, b,
r->in.architecture,
r->in.driver, 3, &info_win2k);
if (W_ERROR_IS_OK(status)) {
if (delete_files &&
(r->in.delete_flags & DPD_DELETE_ALL_FILES) &&
printer_driver_files_in_use(info,
- get_session_info_system(),
- p->msg_ctx,
+ b,
info_win2k)) {
/* no idea of the correct error here */
talloc_free(info_win2k);
/* if we get to here, we now have 2 driver info structures to remove */
/* remove the Win2k driver first*/
- status = winreg_del_driver(info,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_del_driver(tmp_ctx, b,
info_win2k,
3);
}
}
- status = winreg_del_driver(info,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_del_driver(tmp_ctx, b,
info,
version);
if (!W_ERROR_IS_OK(status)) {
}
done:
- talloc_free(info);
+ talloc_free(tmp_ctx);
return status;
}
{
DEBUG(8,("getprinterdata_printer_server:%s\n", value));
- if (!StrCaseCmp(value, "W3SvcInstalled")) {
+ if (!strcasecmp_m(value, "W3SvcInstalled")) {
*type = REG_DWORD;
data->value = 0x00;
return WERR_OK;
}
- if (!StrCaseCmp(value, "BeepEnabled")) {
+ if (!strcasecmp_m(value, "BeepEnabled")) {
*type = REG_DWORD;
data->value = 0x00;
return WERR_OK;
}
- if (!StrCaseCmp(value, "EventLog")) {
+ if (!strcasecmp_m(value, "EventLog")) {
*type = REG_DWORD;
/* formally was 0x1b */
data->value = 0x00;
return WERR_OK;
}
- if (!StrCaseCmp(value, "NetPopup")) {
+ if (!strcasecmp_m(value, "NetPopup")) {
*type = REG_DWORD;
data->value = 0x00;
return WERR_OK;
}
- if (!StrCaseCmp(value, "MajorVersion")) {
+ if (!strcasecmp_m(value, "MajorVersion")) {
*type = REG_DWORD;
/* Windows NT 4.0 seems to not allow uploading of drivers
return WERR_OK;
}
- if (!StrCaseCmp(value, "MinorVersion")) {
+ if (!strcasecmp_m(value, "MinorVersion")) {
*type = REG_DWORD;
data->value = 0x00;
return WERR_OK;
* uint32_t build = [2195|2600]
* extra unicode string = e.g. "Service Pack 3"
*/
- if (!StrCaseCmp(value, "OSVersion")) {
+ if (!strcasecmp_m(value, "OSVersion")) {
DATA_BLOB blob;
enum ndr_err_code ndr_err;
struct spoolss_OSVersion os;
}
- if (!StrCaseCmp(value, "DefaultSpoolDirectory")) {
+ if (!strcasecmp_m(value, "DefaultSpoolDirectory")) {
*type = REG_SZ;
data->string = talloc_strdup(mem_ctx, "C:\\PRINTERS");
return WERR_OK;
}
- if (!StrCaseCmp(value, "Architecture")) {
+ if (!strcasecmp_m(value, "Architecture")) {
*type = REG_SZ;
data->string = talloc_strdup(mem_ctx,
lp_parm_const_string(GLOBAL_SECTION_SNUM, "spoolss", "architecture", SPOOLSS_ARCHITECTURE_NT_X86));
return WERR_OK;
}
- if (!StrCaseCmp(value, "DsPresent")) {
+ if (!strcasecmp_m(value, "DsPresent")) {
*type = REG_DWORD;
/* only show the publish check box if we are a
return WERR_OK;
}
- if (!StrCaseCmp(value, "DNSMachineName")) {
+ if (!strcasecmp_m(value, "DNSMachineName")) {
const char *hostname = get_mydnsfullname();
if (!hostname) {
}
/* setup the connection */
- ret = cli_full_connection( &the_cli, global_myname(), remote_machine,
+ ret = cli_full_connection( &the_cli, lp_netbios_name(), remote_machine,
&rm_addr, 0, "IPC$", "IPC",
"", /* username */
"", /* domain */
return false;
}
- if ( the_cli->protocol != PROTOCOL_NT1 ) {
+ if ( cli_state_protocol(the_cli) != PROTOCOL_NT1 ) {
DEBUG(0,("spoolss_connect_to_client: machine %s didn't negotiate NT protocol.\n", remote_machine));
cli_shutdown(the_cli);
return false;
/* the +2 is to strip the leading 2 backslashs */
fstrcpy(unix_printer, printer + 2);
- chan = talloc_zero(back_channels, struct notify_back_channel);
+ chan = talloc_zero(NULL, struct notify_back_channel);
if (!chan) {
return false;
}
TALLOC_FREE(chan);
return false;
}
- chan->binding_handle = chan->cli_pipe->binding_handle;
DLIST_ADD(back_channels, chan);
messaging_register(msg_ctx, NULL, MSG_PRINTER_NOTIFY2,
receive_notify2_message_list);
- /* Tell the connections db we're now interested in printer
- * notify messages. */
- serverid_register_msg_flags(messaging_server_id(msg_ctx),
- true, FLAG_MSG_PRINT_NOTIFY);
+ }
+
+ if (chan->cli_pipe == NULL ||
+ chan->cli_pipe->binding_handle == NULL) {
+ DEBUG(0, ("srv_spoolss_replyopenprinter: error - "
+ "NULL %s for printer %s\n",
+ chan->cli_pipe == NULL ?
+ "chan->cli_pipe" : "chan->cli_pipe->binding_handle",
+ printer));
+ return false;
}
/*
printer));
}
- status = dcerpc_spoolss_ReplyOpenPrinter(chan->binding_handle,
+ status = dcerpc_spoolss_ReplyOpenPrinter(chan->cli_pipe->binding_handle,
talloc_tos(),
printer,
localprinter,
int snum = -1;
struct spoolss_NotifyOption *option = r->in.notify_options;
struct sockaddr_storage client_ss;
+ socklen_t client_len;
/* store the notify value in the printer struct */
return WERR_BADFID;
DEBUG(10,("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
- "client_address is %s\n", p->client_id->addr));
+ "remote_address is %s\n",
+ tsocket_address_string(p->remote_address, p->mem_ctx)));
if (!lp_print_notify_backchannel(snum)) {
DEBUG(10, ("_spoolss_RemoteFindFirstPrinterChangeNotifyEx: "
return WERR_SERVER_UNAVAILABLE;
}
- if (!interpret_string_addr(&client_ss, p->client_id->addr,
- AI_NUMERICHOST)) {
- return WERR_SERVER_UNAVAILABLE;
+ client_len = tsocket_address_bsd_sockaddr(p->remote_address,
+ (struct sockaddr *) &client_ss,
+ sizeof(struct sockaddr_storage));
+ if (client_len < 0) {
+ return WERR_NOMEM;
}
if(!srv_spoolss_replyopenprinter(snum, Printer->notify.localmachine,
if (!search_notify(type, field, &j) )
continue;
- info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
+ info->notifies = talloc_realloc(info, info->notifies,
struct spoolss_Notify,
info->count + 1);
if (info->notifies == NULL) {
if (!search_notify(type, field, &j) )
continue;
- info->notifies = TALLOC_REALLOC_ARRAY(info, info->notifies,
+ info->notifies = talloc_realloc(info, info->notifies,
struct spoolss_Notify,
info->count + 1);
if (info->notifies == NULL) {
}
/* Maybe we should use the SYSTEM session_info here... */
- result = winreg_get_printer(mem_ctx,
+ result = winreg_get_printer_internal(mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_servicename(snum),
}
/* Maybe we should use the SYSTEM session_info here... */
- result = winreg_get_printer(mem_ctx,
+ result = winreg_get_printer_internal(mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_servicename(snum), &pinfo2);
return WERR_BADFID;
}
+ /*
+ * When sending a PRINTER_NOTIFY_FIELD_SERVER_NAME we should send the
+ * correct servername.
+ */
+ pinfo2->servername = talloc_strdup(pinfo2, Printer->servername);
+ if (pinfo2->servername == NULL) {
+ return WERR_NOMEM;
+ }
+
for (i=0; i<option->count; i++) {
option_type = option->types[i];
********************************************************************/
static WERROR construct_printer_info0(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
struct spoolss_PrinterInfo2 *info2,
const char *servername,
r->high_part_total_bytes = 0x0;
/* ChangeID in milliseconds*/
- winreg_printer_get_changeid(mem_ctx, session_info, msg_ctx,
+ winreg_printer_get_changeid_internal(mem_ctx, session_info, msg_ctx,
info2->sharename, &r->change_id);
r->last_error = WERR_OK;
struct spoolss_PrinterInfo6 *r,
int snum)
{
- int count;
print_status_struct status;
- count = print_queue_length(msg_ctx, snum, &status);
+ print_queue_length(msg_ctx, snum, &status);
r->status = nt_printq_status(status.status);
struct spoolss_PrinterInfo7 *r,
int snum)
{
- struct auth_serversupplied_info *session_info;
+ const struct auth_session_info *session_info = get_session_info_system();
struct GUID guid;
- NTSTATUS status;
-
- status = make_session_info_system(mem_ctx, &session_info);
- if (!NT_STATUS_IS_OK(status)) {
- DEBUG(0, ("construct_printer_info7: "
- "Could not create system session_info\n"));
- return WERR_NOMEM;
- }
if (is_printer_published(mem_ctx, session_info, msg_ctx,
servername,
}
W_ERROR_HAVE_NO_MEMORY(r->guid);
- TALLOC_FREE(session_info);
return WERR_OK;
}
********************************************************************/
static WERROR enum_all_printers_info_level(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
const char *servername,
uint32_t level,
union spoolss_PrinterInfo *info = NULL;
uint32_t count = 0;
WERROR result = WERR_OK;
+ struct dcerpc_binding_handle *b = NULL;
+ TALLOC_CTX *tmp_ctx = NULL;
+
+ tmp_ctx = talloc_new(mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
*count_p = 0;
*info_p = NULL;
DEBUG(4,("Found a printer in smb.conf: %s[%x]\n",
printer, snum));
- result = winreg_create_printer(mem_ctx,
- session_info,
- msg_ctx,
+ if (b == NULL) {
+ result = winreg_printer_binding_handle(tmp_ctx,
+ session_info,
+ msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(result)) {
+ goto out;
+ }
+ }
+
+ result = winreg_create_printer(tmp_ctx, b,
printer);
if (!W_ERROR_IS_OK(result)) {
goto out;
}
- info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
+ info = talloc_realloc(tmp_ctx, info,
union spoolss_PrinterInfo,
count + 1);
if (!info) {
goto out;
}
- result = winreg_get_printer(mem_ctx, session_info, msg_ctx,
+ result = winreg_get_printer(tmp_ctx, b,
printer, &info2);
if (!W_ERROR_IS_OK(result)) {
goto out;
count++;
}
- *count_p = count;
- *info_p = info;
-
- out:
- if (!W_ERROR_IS_OK(result)) {
- TALLOC_FREE(info);
- return result;
+out:
+ if (W_ERROR_IS_OK(result)) {
+ *info_p = talloc_move(mem_ctx, &info);
+ *count_p = count;
}
- *info_p = info;
+ talloc_free(tmp_ctx);
- return WERR_OK;
+ return result;
}
/********************************************************************
********************************************************************/
static WERROR enumprinters_level0(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
uint32_t flags,
const char *servername,
********************************************************************/
static WERROR enum_all_printers_info_1(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
const char *servername,
uint32_t flags,
*********************************************************************/
static WERROR enum_all_printers_info_1_local(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
const char *servername,
union spoolss_PrinterInfo **info,
*********************************************************************/
static WERROR enum_all_printers_info_1_name(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
const char *servername,
union spoolss_PrinterInfo **info,
*********************************************************************/
static WERROR enum_all_printers_info_1_network(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
const char *servername,
union spoolss_PrinterInfo **info,
********************************************************************/
static WERROR enum_all_printers_info_2(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
const char *servername,
union spoolss_PrinterInfo **info,
********************************************************************/
static WERROR enumprinters_level1(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
uint32_t flags,
const char *servername,
********************************************************************/
static WERROR enumprinters_level2(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
uint32_t flags,
const char *servername,
********************************************************************/
static WERROR enumprinters_level4(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
uint32_t flags,
const char *servername,
********************************************************************/
static WERROR enumprinters_level5(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
uint32_t flags,
const char *servername,
WERROR _spoolss_EnumPrinters(struct pipes_struct *p,
struct spoolss_EnumPrinters *r)
{
- const struct auth_serversupplied_info *session_info = get_session_info_system();
+ const struct auth_session_info *session_info = get_session_info_system();
WERROR result;
/* that's an [in out] buffer */
return WERR_BADFID;
}
- result = winreg_get_printer(p->mem_ctx,
+ result = winreg_get_printer_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_const_servicename(snum),
result = WERR_UNKNOWN_LEVEL;
break;
}
+ TALLOC_FREE(info2);
out:
if (!W_ERROR_IS_OK(result)) {
*count_p = 0;
if (strlen(driver->driver_path)) {
- info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
+ info = talloc_realloc(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
W_ERROR_HAVE_NO_MEMORY(info);
}
if (strlen(driver->config_file)) {
- info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
+ info = talloc_realloc(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
W_ERROR_HAVE_NO_MEMORY(info);
}
if (strlen(driver->data_file)) {
- info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
+ info = talloc_realloc(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
W_ERROR_HAVE_NO_MEMORY(info);
}
if (strlen(driver->help_file)) {
- info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
+ info = talloc_realloc(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
W_ERROR_HAVE_NO_MEMORY(info);
}
for (i=0; driver->dependent_files[i] && driver->dependent_files[i][0] != '\0'; i++) {
- info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
+ info = talloc_realloc(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
W_ERROR_HAVE_NO_MEMORY(info);
********************************************************************/
static WERROR construct_printer_driver_info_level(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
uint32_t level,
union spoolss_DriverInfo *r,
struct spoolss_PrinterInfo2 *pinfo2 = NULL;
struct spoolss_DriverInfo8 *driver;
WERROR result;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx = NULL;
if (level == 101) {
return WERR_UNKNOWN_LEVEL;
}
- result = winreg_get_printer(mem_ctx,
- session_info,
- msg_ctx,
+ tmp_ctx = talloc_new(mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ result = winreg_printer_binding_handle(tmp_ctx,
+ session_info,
+ msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
+
+ result = winreg_get_printer(tmp_ctx, b,
lp_const_servicename(snum),
&pinfo2);
win_errstr(result)));
if (!W_ERROR_IS_OK(result)) {
- return WERR_INVALID_PRINTER_NAME;
+ result = WERR_INVALID_PRINTER_NAME;
+ goto done;
}
- result = winreg_get_driver(mem_ctx, session_info, msg_ctx,
+ result = winreg_get_driver(tmp_ctx, b,
architecture,
pinfo2->drivername, version, &driver);
*/
if (version < 3) {
- talloc_free(pinfo2);
- return WERR_UNKNOWN_PRINTER_DRIVER;
+ result = WERR_UNKNOWN_PRINTER_DRIVER;
+ goto done;
}
/* Yes - try again with a WinNT driver. */
version = 2;
- result = winreg_get_driver(mem_ctx, session_info, msg_ctx,
+ result = winreg_get_driver(tmp_ctx, b,
architecture,
pinfo2->drivername,
version, &driver);
DEBUG(8,("construct_printer_driver_level: status: %s\n",
win_errstr(result)));
if (!W_ERROR_IS_OK(result)) {
- talloc_free(pinfo2);
- return WERR_UNKNOWN_PRINTER_DRIVER;
+ result = WERR_UNKNOWN_PRINTER_DRIVER;
+ goto done;
}
}
+ /* these are allocated on mem_ctx and not tmp_ctx because they are
+ * the 'return value' and need to utlive this call */
switch (level) {
case 1:
result = fill_printer_driver_info1(mem_ctx, &r->info1, driver, servername);
break;
}
- talloc_free(pinfo2);
- talloc_free(driver);
-
+done:
+ talloc_free(tmp_ctx);
return result;
}
int snum;
struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
WERROR werr;
+ char *rhost;
+ int rc;
if (!Printer) {
DEBUG(2,("_spoolss_StartDocPrinter: "
return WERR_BADFID;
}
+ rc = get_remote_hostname(p->remote_address,
+ &rhost,
+ p->mem_ctx);
+ if (rc < 0) {
+ return WERR_NOMEM;
+ }
+ if (strequal(rhost,"UNKNOWN")) {
+ rhost = tsocket_address_inet_addr_string(p->remote_address,
+ p->mem_ctx);
+ if (rhost == NULL) {
+ return WERR_NOMEM;
+ }
+ }
+
werr = print_job_start(p->session_info,
p->msg_ctx,
- p->client_id->name,
+ rhost,
snum,
info_1->document_name,
info_1->output_file,
static WERROR control_printer(struct policy_handle *handle, uint32_t command,
struct pipes_struct *p)
{
- const struct auth_serversupplied_info *session_info = p->session_info;
+ const struct auth_session_info *session_info = p->session_info;
int snum;
WERROR errcode = WERR_BADFUNC;
struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
const char *printer;
WERROR result;
int snum;
-
struct printer_handle *Printer = find_printer_index_by_hnd(p, handle);
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx = NULL;
if (!Printer || !get_printer_snum(p, handle, &snum, NULL)) {
DEBUG(2,("update_printer_sec: Invalid handle (%s:%u:%u)\n",
goto done;
}
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ result = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
+
/* NT seems to like setting the security descriptor even though
nothing may have actually changed. */
- result = winreg_get_printer_secdesc(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ result = winreg_get_printer_secdesc(tmp_ctx, b,
printer,
&old_secdesc);
if (!W_ERROR_IS_OK(result)) {
- DEBUG(2,("update_printer_sec: winreg_get_printer_secdesc() failed\n"));
+ DEBUG(2,("update_printer_sec: winreg_get_printer_secdesc_internal() failed\n"));
result = WERR_BADFID;
goto done;
}
}
}
- new_secdesc = sec_desc_merge(p->mem_ctx, secdesc_ctr->sd, old_secdesc);
+ new_secdesc = sec_desc_merge(tmp_ctx, secdesc_ctr->sd, old_secdesc);
if (new_secdesc == NULL) {
result = WERR_NOMEM;
goto done;
goto done;
}
- result = winreg_set_printer_secdesc(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ result = winreg_set_printer_secdesc(tmp_ctx, b,
printer,
new_secdesc);
- done:
+done:
+ talloc_free(tmp_ctx);
return result;
}
info2->location));
/* we force some elements to "correct" values */
- info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", global_myname());
+ info2->servername = talloc_asprintf(mem_ctx, "\\\\%s", lp_netbios_name());
if (info2->servername == NULL) {
return false;
}
/* check to see if we allow printername != sharename */
if (lp_force_printername(snum)) {
info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
- global_myname(), info2->sharename);
+ lp_netbios_name(), info2->sharename);
} else {
/* make sure printername is in \\server\printername format */
fstrcpy(printername, info2->printername);
}
info2->printername = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
- global_myname(), p);
+ lp_netbios_name(), p);
}
if (info2->printername == NULL) {
return false;
}
static WERROR update_dsspooler(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
int snum,
struct spoolss_SetPrinterInfo2 *printer,
const char *spooling;
DATA_BLOB buffer;
WERROR result = WERR_OK;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx;
+
+ tmp_ctx = talloc_new(mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ result = winreg_printer_binding_handle(tmp_ctx,
+ session_info,
+ msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
if (force_update || !strequal(printer->drivername, old_printer->drivername)) {
- push_reg_sz(mem_ctx, &buffer, printer->drivername);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, printer->drivername);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_DRIVERNAME,
}
if (force_update || !strequal(printer->comment, old_printer->comment)) {
- push_reg_sz(mem_ctx, &buffer, printer->comment);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, printer->comment);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_DESCRIPTION,
}
if (force_update || !strequal(printer->sharename, old_printer->sharename)) {
- push_reg_sz(mem_ctx, &buffer, printer->sharename);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, printer->sharename);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTSHARENAME,
p = printer->printername;
}
- push_reg_sz(mem_ctx, &buffer, p);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, p);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTERNAME,
}
if (force_update || !strequal(printer->portname, old_printer->portname)) {
- push_reg_sz(mem_ctx, &buffer, printer->portname);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, printer->portname);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PORTNAME,
}
if (force_update || !strequal(printer->location, old_printer->location)) {
- push_reg_sz(mem_ctx, &buffer, printer->location);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, printer->location);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_LOCATION,
}
if (force_update || !strequal(printer->sepfile, old_printer->sepfile)) {
- push_reg_sz(mem_ctx, &buffer, printer->sepfile);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, printer->sepfile);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTSEPARATORFILE,
}
if (force_update || printer->starttime != old_printer->starttime) {
- buffer = data_blob_talloc(mem_ctx, NULL, 4);
+ buffer = data_blob_talloc(tmp_ctx, NULL, 4);
SIVAL(buffer.data, 0, printer->starttime);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTSTARTTIME,
}
if (force_update || printer->untiltime != old_printer->untiltime) {
- buffer = data_blob_talloc(mem_ctx, NULL, 4);
+ buffer = data_blob_talloc(tmp_ctx, NULL, 4);
SIVAL(buffer.data, 0, printer->untiltime);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTENDTIME,
}
if (force_update || printer->priority != old_printer->priority) {
- buffer = data_blob_talloc(mem_ctx, NULL, 4);
+ buffer = data_blob_talloc(tmp_ctx, NULL, 4);
SIVAL(buffer.data, 0, printer->priority);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRIORITY,
}
if (force_update || printer->attributes != old_printer->attributes) {
- buffer = data_blob_talloc(mem_ctx, NULL, 4);
+ buffer = data_blob_talloc(tmp_ctx, NULL, 4);
SIVAL(buffer.data, 0, (printer->attributes &
PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS));
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTKEEPPRINTEDJOBS,
default:
spooling = "unknown";
}
- push_reg_sz(mem_ctx, &buffer, spooling);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, spooling);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_PRINTSPOOLING,
buffer.length);
}
- push_reg_sz(mem_ctx, &buffer, global_myname());
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, lp_netbios_name());
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_SHORTSERVERNAME,
dnsdomname = get_mydnsfullname();
if (dnsdomname != NULL && dnsdomname[0] != '\0') {
- longname = talloc_strdup(mem_ctx, dnsdomname);
+ longname = talloc_strdup(tmp_ctx, dnsdomname);
} else {
- longname = talloc_strdup(mem_ctx, global_myname());
+ longname = talloc_strdup(tmp_ctx, lp_netbios_name());
}
if (longname == NULL) {
result = WERR_NOMEM;
goto done;
}
- push_reg_sz(mem_ctx, &buffer, longname);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ push_reg_sz(tmp_ctx, &buffer, longname);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_SERVERNAME,
buffer.data,
buffer.length);
- uncname = talloc_asprintf(mem_ctx, "\\\\%s\\%s",
- global_myname(), printer->sharename);
- push_reg_sz(mem_ctx, &buffer, uncname);
- winreg_set_printer_dataex(mem_ctx,
- session_info,
- msg_ctx,
+ uncname = talloc_asprintf(tmp_ctx, "\\\\%s\\%s",
+ lp_netbios_name(), printer->sharename);
+ push_reg_sz(tmp_ctx, &buffer, uncname);
+ winreg_set_printer_dataex(tmp_ctx, b,
printer->sharename,
SPOOL_DSSPOOLER_KEY,
SPOOL_REG_UNCNAME,
buffer.length);
done:
+ talloc_free(tmp_ctx);
return result;
}
int snum;
WERROR result = WERR_OK;
TALLOC_CTX *tmp_ctx;
+ struct dcerpc_binding_handle *b;
DEBUG(8,("update_printer\n"));
goto done;
}
- result = winreg_get_printer(tmp_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ result = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
+
+ result = winreg_get_printer(tmp_ctx, b,
lp_const_servicename(snum),
&old_printer);
if (!W_ERROR_IS_OK(result)) {
!strequal(printer->portname, old_printer->portname) ||
!strequal(printer->location, old_printer->location)) )
{
+ char *raddr;
+
+ raddr = tsocket_address_inet_addr_string(p->remote_address,
+ p->mem_ctx);
+ if (raddr == NULL) {
+ return WERR_NOMEM;
+ }
+
/* add_printer_hook() will call reload_services() */
if (!add_printer_hook(tmp_ctx, p->session_info->security_token,
- printer, p->client_id->addr,
+ printer, raddr,
p->msg_ctx)) {
result = WERR_ACCESS_DENIED;
goto done;
if (devmode == NULL) {
printer_mask &= ~SPOOLSS_PRINTER_INFO_DEVMODE;
}
- result = winreg_update_printer(tmp_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ result = winreg_update_printer(tmp_ctx, b,
printer->sharename,
printer_mask,
printer,
if (!get_printer_snum(p, handle, &snum, NULL))
return WERR_BADFID;
- result = winreg_get_printer(p->mem_ctx,
+ result = winreg_get_printer_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_servicename(snum),
return WERR_ACCESS_DENIED;
}
- return winreg_update_printer(p->mem_ctx,
+ return winreg_update_printer_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_const_servicename(snum),
int i;
WERROR result = WERR_OK;
- info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
+ info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
W_ERROR_HAVE_NO_MEMORY(info);
*count = num_queues;
int i;
WERROR result = WERR_OK;
- info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
+ info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
W_ERROR_HAVE_NO_MEMORY(info);
*count = num_queues;
int i;
WERROR result = WERR_OK;
- info = TALLOC_ARRAY(mem_ctx, union spoolss_JobInfo, num_queues);
+ info = talloc_array(mem_ctx, union spoolss_JobInfo, num_queues);
W_ERROR_HAVE_NO_MEMORY(info);
*count = num_queues;
return WERR_BADFID;
}
- result = winreg_get_printer(p->mem_ctx,
+ result = winreg_get_printer_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_const_servicename(snum),
WERROR _spoolss_SetJob(struct pipes_struct *p,
struct spoolss_SetJob *r)
{
- const struct auth_serversupplied_info *session_info = p->session_info;
+ const struct auth_session_info *session_info = p->session_info;
int snum;
WERROR errcode = WERR_BADFUNC;
****************************************************************************/
static WERROR enumprinterdrivers_level_by_architecture(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
const char *servername,
const char *architecture,
WERROR result = WERR_OK;
uint32_t num_drivers;
const char **drivers;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx = NULL;
*count_p = 0;
*info_p = NULL;
+ tmp_ctx = talloc_new(mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ result = winreg_printer_binding_handle(tmp_ctx,
+ session_info,
+ msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(result)) {
+ goto out;
+ }
+
for (version=0; version<DRIVER_MAX_VERSION; version++) {
- result = winreg_get_driver_list(mem_ctx, session_info, msg_ctx,
+ result = winreg_get_driver_list(tmp_ctx, b,
architecture, version,
&num_drivers, &drivers);
if (!W_ERROR_IS_OK(result)) {
num_drivers, architecture, version));
if (num_drivers != 0) {
- info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
+ info = talloc_realloc(tmp_ctx, info,
union spoolss_DriverInfo,
count + num_drivers);
if (!info) {
for (i = 0; i < num_drivers; i++) {
DEBUG(5, ("\tdriver: [%s]\n", drivers[i]));
- result = winreg_get_driver(mem_ctx, session_info,
- msg_ctx,
+ result = winreg_get_driver(tmp_ctx, b,
architecture, drivers[i],
version, &driver);
if (!W_ERROR_IS_OK(result)) {
TALLOC_FREE(drivers);
}
- out:
- TALLOC_FREE(drivers);
-
- if (!W_ERROR_IS_OK(result)) {
- TALLOC_FREE(info);
- return result;
+out:
+ if (W_ERROR_IS_OK(result)) {
+ *info_p = talloc_move(mem_ctx, &info);
+ *count_p = count;
}
- *info_p = info;
- *count_p = count;
-
- return WERR_OK;
+ talloc_free(tmp_ctx);
+ return result;
}
/****************************************************************************
****************************************************************************/
static WERROR enumprinterdrivers_level(TALLOC_CTX *mem_ctx,
- const struct auth_serversupplied_info *session_info,
+ const struct auth_session_info *session_info,
struct messaging_context *msg_ctx,
const char *servername,
const char *architecture,
switch (r->in.level) {
case 1:
- result = winreg_printer_enumforms1(p->mem_ctx,
+ result = winreg_printer_enumforms1_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
r->out.count,
switch (r->in.level) {
case 1:
- result = winreg_printer_getform1(p->mem_ctx,
+ result = winreg_printer_getform1_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
r->in.form_name,
/* if no hook then just fill in the default port */
if ( !*cmd ) {
- if (!(qlines = TALLOC_ARRAY( NULL, char*, 2 ))) {
+ if (!(qlines = talloc_array( NULL, char*, 2 ))) {
return WERR_NOMEM;
}
if (!(qlines[0] = talloc_strdup(qlines, SAMBA_PRINTER_PORT_NAME ))) {
}
if (numlines) {
- info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
+ info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
if (!info) {
DEBUG(10,("Returning WERR_NOMEM\n"));
result = WERR_NOMEM;
}
if (numlines) {
- info = TALLOC_ARRAY(mem_ctx, union spoolss_PortInfo, numlines);
+ info = talloc_array(mem_ctx, union spoolss_PortInfo, numlines);
if (!info) {
DEBUG(10,("Returning WERR_NOMEM\n"));
result = WERR_NOMEM;
trying to add a printer like this --jerry */
if (*lp_addprinter_cmd() ) {
+ char *raddr;
+
+ raddr = tsocket_address_inet_addr_string(p->remote_address,
+ p->mem_ctx);
+ if (raddr == NULL) {
+ return WERR_NOMEM;
+ }
+
if ( !add_printer_hook(p->mem_ctx, p->session_info->security_token,
- info2, p->client_id->addr,
+ info2, raddr,
p->msg_ctx) ) {
return WERR_ACCESS_DENIED;
}
info2,
NULL);
- err = winreg_update_printer(p->mem_ctx,
+ err = winreg_update_printer_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
info2->sharename,
goto done;
}
- err = winreg_add_driver(p->mem_ctx,
+ err = winreg_add_driver_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
r->in.info_ctr,
struct spoolss_AddFormInfo1 *form = r->in.info.info1;
int snum = -1;
WERROR status = WERR_OK;
-
struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx = NULL;
DEBUG(5,("_spoolss_AddForm\n"));
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
and not a printer admin, then fail */
- if ((p->session_info->utok.uid != sec_initial_uid()) &&
+ if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
!security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR) &&
- !token_contains_name_in_list(uidtoname(p->session_info->utok.uid),
- p->session_info->info3->base.domain.string,
+ !token_contains_name_in_list(uidtoname(p->session_info->unix_token->uid),
+ p->session_info->info->domain_name,
NULL,
p->session_info->security_token,
lp_printer_admin(snum))) {
return WERR_INVALID_PARAM;
}
- status = winreg_printer_addform1(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
- form);
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ status = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(status)) {
+ goto done;
+ }
+
+ status = winreg_printer_addform1(tmp_ctx, b, form);
if (!W_ERROR_IS_OK(status)) {
- return status;
+ goto done;
}
/*
*/
if (Printer->printer_type == SPLHND_PRINTER) {
if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
- return WERR_BADFID;
+ status = WERR_BADFID;
+ goto done;
}
- status = winreg_printer_update_changeid(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_printer_update_changeid(tmp_ctx, b,
lp_const_servicename(snum));
- if (!W_ERROR_IS_OK(status)) {
- return status;
- }
}
+done:
+ talloc_free(tmp_ctx);
return status;
}
struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
int snum = -1;
WERROR status = WERR_OK;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx = NULL;
DEBUG(5,("_spoolss_DeleteForm\n"));
return WERR_BADFID;
}
- if ((p->session_info->utok.uid != sec_initial_uid()) &&
+ if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
!security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR) &&
- !token_contains_name_in_list(uidtoname(p->session_info->utok.uid),
- p->session_info->info3->base.domain.string,
+ !token_contains_name_in_list(uidtoname(p->session_info->unix_token->uid),
+ p->session_info->info->domain_name,
NULL,
p->session_info->security_token,
lp_printer_admin(snum))) {
return WERR_ACCESS_DENIED;
}
- status = winreg_printer_deleteform1(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
- form_name);
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ status = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(status)) {
+ goto done;
+ }
+
+ status = winreg_printer_deleteform1(tmp_ctx, b, form_name);
if (!W_ERROR_IS_OK(status)) {
- return status;
+ goto done;
}
/*
*/
if (Printer->printer_type == SPLHND_PRINTER) {
if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
- return WERR_BADFID;
+ status = WERR_BADFID;
+ goto done;
}
- status = winreg_printer_update_changeid(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_printer_update_changeid(tmp_ctx, b,
lp_const_servicename(snum));
- if (!W_ERROR_IS_OK(status)) {
- return status;
- }
}
+done:
+ talloc_free(tmp_ctx);
return status;
}
const char *form_name = r->in.form_name;
int snum = -1;
WERROR status = WERR_OK;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx = NULL;
struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
/* if the user is not root, doesn't have SE_PRINT_OPERATOR privilege,
and not a printer admin, then fail */
- if ((p->session_info->utok.uid != sec_initial_uid()) &&
+ if ((p->session_info->unix_token->uid != sec_initial_uid()) &&
!security_token_has_privilege(p->session_info->security_token, SEC_PRIV_PRINT_OPERATOR) &&
- !token_contains_name_in_list(uidtoname(p->session_info->utok.uid),
- p->session_info->info3->base.domain.string,
+ !token_contains_name_in_list(uidtoname(p->session_info->unix_token->uid),
+ p->session_info->info->domain_name,
NULL,
p->session_info->security_token,
lp_printer_admin(snum))) {
return WERR_ACCESS_DENIED;
}
- status = winreg_printer_setform1(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ status = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(status)) {
+ goto done;
+ }
+
+ status = winreg_printer_setform1(tmp_ctx, b,
form_name,
form);
if (!W_ERROR_IS_OK(status)) {
- return status;
+ goto done;
}
/*
*/
if (Printer->printer_type == SPLHND_PRINTER) {
if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
- return WERR_BADFID;
+ status = WERR_BADFID;
+ goto done;
}
- status = winreg_printer_update_changeid(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_printer_update_changeid(tmp_ctx, b,
lp_const_servicename(snum));
- if (!W_ERROR_IS_OK(status)) {
- return status;
- }
}
+done:
+ talloc_free(tmp_ctx);
return status;
}
union spoolss_PrintProcessorInfo *info;
WERROR result;
- info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcessorInfo, 1);
+ info = talloc_array(mem_ctx, union spoolss_PrintProcessorInfo, 1);
W_ERROR_HAVE_NO_MEMORY(info);
*count = 1;
WERROR result;
union spoolss_PrintProcDataTypesInfo *info;
- info = TALLOC_ARRAY(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
+ info = talloc_array(mem_ctx, union spoolss_PrintProcDataTypesInfo, 1);
W_ERROR_HAVE_NO_MEMORY(info);
*count = 1;
return WERR_UNKNOWN_LEVEL;
}
+ if (!W_ERROR_IS_OK(result)) {
+ return result;
+ }
+
*r->out.needed = SPOOLSS_BUFFER_UNION_ARRAY(p->mem_ctx,
spoolss_EnumPrintProcDataTypes,
*r->out.info, r->in.level,
union spoolss_MonitorInfo *info;
WERROR result = WERR_OK;
- info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
+ info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
W_ERROR_HAVE_NO_MEMORY(info);
*count = 2;
union spoolss_MonitorInfo *info;
WERROR result = WERR_OK;
- info = TALLOC_ARRAY(mem_ctx, union spoolss_MonitorInfo, 2);
+ info = talloc_array(mem_ctx, union spoolss_MonitorInfo, 2);
W_ERROR_HAVE_NO_MEMORY(info);
*count = 2;
return WERR_BADFID;
}
- result = winreg_get_printer(p->mem_ctx,
+ result = winreg_get_printer_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_const_servicename(snum),
int snum = 0;
WERROR result = WERR_OK;
DATA_BLOB blob;
- enum winreg_Type val_type;
- uint8_t *val_data;
- uint32_t val_size;
-
+ enum winreg_Type val_type = REG_NONE;
+ uint8_t *val_data = NULL;
+ uint32_t val_size = 0;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx;
DEBUG(4,("_spoolss_GetPrinterDataEx\n"));
*r->out.needed = 0;
*r->out.type = REG_NONE;
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
if (!Printer) {
DEBUG(2,("_spoolss_GetPrinterDataEx: Invalid handle (%s:%u:%u).\n",
OUR_HANDLE(r->in.handle)));
goto done;
}
+ /* check to see if the keyname is valid */
+ if (!strlen(r->in.key_name)) {
+ result = WERR_INVALID_PARAM;
+ goto done;
+ }
+
/* Is the handle to a printer or to the server? */
if (Printer->printer_type == SPLHND_SERVER) {
union spoolss_PrinterData data;
- result = getprinterdata_printer_server(p->mem_ctx,
+ result = getprinterdata_printer_server(tmp_ctx,
r->in.value_name,
r->out.type,
&data);
if (!W_ERROR_IS_OK(result)) {
- return result;
+ goto done;
}
- result = push_spoolss_PrinterData(p->mem_ctx, &blob,
+ result = push_spoolss_PrinterData(tmp_ctx, &blob,
*r->out.type, &data);
if (!W_ERROR_IS_OK(result)) {
- return result;
+ goto done;
}
*r->out.needed = blob.length;
memcpy(r->out.data, blob.data, blob.length);
}
- return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
+ result = WERR_OK;
+ goto done;
}
if (!get_printer_snum(p, r->in.handle, &snum, NULL)) {
- return WERR_BADFID;
+ result = WERR_BADFID;
+ goto done;
}
printer = lp_const_servicename(snum);
- /* check to see if the keyname is valid */
- if (!strlen(r->in.key_name)) {
- return WERR_INVALID_PARAM;
+ result = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
}
/* XP sends this and wants the ChangeID value from PRINTER_INFO_0 */
if (r->in.offered >= *r->out.needed) {
uint32_t changeid = 0;
- result = winreg_printer_get_changeid(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ result = winreg_printer_get_changeid(tmp_ctx, b,
printer,
&changeid);
if (!W_ERROR_IS_OK(result)) {
- return result;
+ goto done;
}
SIVAL(r->out.data, 0, changeid);
goto done;
}
- result = winreg_get_printer_dataex(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ result = winreg_get_printer_dataex(tmp_ctx, b,
printer,
r->in.key_name,
r->in.value_name,
&val_data,
&val_size);
if (!W_ERROR_IS_OK(result)) {
- return result;
+ goto done;
}
*r->out.needed = val_size;
memcpy(r->out.data, val_data, val_size);
}
- done:
- /* retain type when returning WERR_MORE_DATA */
- r->out.data = SPOOLSS_BUFFER_OK(r->out.data, r->out.data);
+done:
+ /* NOTE: do not replace type when returning WERR_MORE_DATA */
- return SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
+ if (W_ERROR_IS_OK(result)) {
+ result = SPOOLSS_BUFFER_OK(WERR_OK, WERR_MORE_DATA);
+ }
+
+ talloc_free(tmp_ctx);
+ return result;
}
/****************************************************************
WERROR result = WERR_OK;
struct printer_handle *Printer = find_printer_index_by_hnd(p, r->in.handle);
char *oid_string;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx;
DEBUG(4,("_spoolss_SetPrinterDataEx\n"));
return WERR_ACCESS_DENIED;
}
- result = winreg_get_printer(Printer,
- get_session_info_system(),
- p->msg_ctx,
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ result = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(result)) {
+ goto done;
+ }
+
+ result = winreg_get_printer(tmp_ctx, b,
lp_servicename(snum),
&pinfo2);
if (!W_ERROR_IS_OK(result)) {
- return result;
+ goto done;
}
/* check for OID in valuename */
/* save the registry data */
- result = winreg_set_printer_dataex(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ result = winreg_set_printer_dataex(tmp_ctx, b,
pinfo2->sharename,
r->in.key_name,
r->in.value_name,
if (W_ERROR_IS_OK(result)) {
/* save the OID if one was specified */
if (oid_string) {
- char *str = talloc_asprintf(p->mem_ctx, "%s\\%s",
+ char *str = talloc_asprintf(tmp_ctx, "%s\\%s",
r->in.key_name, SPOOL_OID_KEY);
if (!str) {
result = WERR_NOMEM;
* previous set_printer_dataex() call. I have no idea if
* this is right. --jerry
*/
- winreg_set_printer_dataex(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ winreg_set_printer_dataex(tmp_ctx, b,
pinfo2->sharename,
str,
r->in.value_name,
strlen(oid_string) + 1);
}
- result = winreg_printer_update_changeid(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ result = winreg_printer_update_changeid(tmp_ctx, b,
lp_const_servicename(snum));
}
done:
- talloc_free(pinfo2);
+ talloc_free(tmp_ctx);
return result;
}
}
printer = lp_const_servicename(snum);
- status = winreg_delete_printer_dataex(p->mem_ctx,
+ status = winreg_delete_printer_dataex_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
printer,
r->in.key_name,
r->in.value_name);
if (W_ERROR_IS_OK(status)) {
- status = winreg_printer_update_changeid(p->mem_ctx,
+ status = winreg_printer_update_changeid_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
printer);
return WERR_BADFID;
}
- result = winreg_enum_printer_key(p->mem_ctx,
+ result = winreg_enum_printer_key_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_const_servicename(snum),
int snum=0;
WERROR status;
const char *printer;
+ struct dcerpc_binding_handle *b;
+ TALLOC_CTX *tmp_ctx;
DEBUG(5,("_spoolss_DeletePrinterKey\n"));
printer = lp_const_servicename(snum);
+ tmp_ctx = talloc_new(p->mem_ctx);
+ if (!tmp_ctx) {
+ return WERR_NOMEM;
+ }
+
+ status = winreg_printer_binding_handle(tmp_ctx,
+ get_session_info_system(),
+ p->msg_ctx,
+ &b);
+ if (!W_ERROR_IS_OK(status)) {
+ goto done;
+ }
+
/* delete the key and all subkeys */
- status = winreg_delete_printer_key(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_delete_printer_key(tmp_ctx, b,
printer,
r->in.key_name);
if (W_ERROR_IS_OK(status)) {
- status = winreg_printer_update_changeid(p->mem_ctx,
- get_session_info_system(),
- p->msg_ctx,
+ status = winreg_printer_update_changeid(tmp_ctx, b,
printer);
}
+done:
+ talloc_free(tmp_ctx);
return status;
}
}
/* now look for a match on the key name */
- result = winreg_enum_printer_dataex(p->mem_ctx,
+ result = winreg_enum_printer_dataex_internal(p->mem_ctx,
get_session_info_system(),
p->msg_ctx,
lp_const_servicename(snum),