/****************************************************************************
****************************************************************************/
-static WERROR get_a_printer_driver_3_default(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr, const char *driver, const char *arch)
-{
- NT_PRINTER_DRIVER_INFO_LEVEL_3 info;
-
- ZERO_STRUCT(info);
-
- fstrcpy(info.name, driver);
- fstrcpy(info.defaultdatatype, "RAW");
- fstrcpy(info.driverpath, "");
- fstrcpy(info.datafile, "");
- fstrcpy(info.configfile, "");
- fstrcpy(info.helpfile, "");
-
- if ((info.dependentfiles= SMB_MALLOC_ARRAY(fstring, 2)) == NULL)
+static WERROR get_a_printer_driver_3_default(TALLOC_CTX *mem_ctx,
+ struct spoolss_DriverInfo3 *info,
+ const char *driver, const char *arch)
+{
+ info->driver_name = talloc_strdup(mem_ctx, driver);
+ if (!info->driver_name) {
return WERR_NOMEM;
+ }
- memset(info.dependentfiles, '\0', 2*sizeof(fstring));
- fstrcpy(info.dependentfiles[0], "");
+ info->default_datatype = talloc_strdup(mem_ctx, "RAW");
+ if (!info->default_datatype) {
+ return WERR_NOMEM;
+ }
- *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&info, sizeof(info));
- if (!*info_ptr) {
- SAFE_FREE(info.dependentfiles);
+ info->driver_path = talloc_strdup(mem_ctx, "");
+ info->data_file = talloc_strdup(mem_ctx, "");
+ info->config_file = talloc_strdup(mem_ctx, "");
+ info->help_file = talloc_strdup(mem_ctx, "");
+ if (!info->driver_path || !info->data_file || !info->config_file || !info->help_file) {
return WERR_NOMEM;
}
/****************************************************************************
****************************************************************************/
-static WERROR get_a_printer_driver_3(NT_PRINTER_DRIVER_INFO_LEVEL_3 **info_ptr,
+
+static WERROR get_a_printer_driver_3(TALLOC_CTX *mem_ctx,
+ struct spoolss_DriverInfo3 *driver,
const char *drivername, const char *arch,
uint32_t version)
{
- NT_PRINTER_DRIVER_INFO_LEVEL_3 driver;
TDB_DATA dbuf;
const char *architecture;
int len = 0;
int i;
char *key = NULL;
-
- ZERO_STRUCT(driver);
+ fstring name, driverpath, environment, datafile, configfile, helpfile, monitorname, defaultdatatype;
architecture = get_short_archi(arch);
if ( !architecture ) {
}
len += tdb_unpack(dbuf.dptr, dbuf.dsize, "dffffffff",
- &driver.cversion,
- driver.name,
- driver.environment,
- driver.driverpath,
- driver.datafile,
- driver.configfile,
- driver.helpfile,
- driver.monitorname,
- driver.defaultdatatype);
+ &driver->version,
+ name,
+ environment,
+ driverpath,
+ datafile,
+ configfile,
+ helpfile,
+ monitorname,
+ defaultdatatype);
+
+ driver->driver_name = talloc_strdup(mem_ctx, name);
+ driver->architecture = talloc_strdup(mem_ctx, environment);
+ driver->driver_path = talloc_strdup(mem_ctx, driverpath);
+ driver->data_file = talloc_strdup(mem_ctx, datafile);
+ driver->config_file = talloc_strdup(mem_ctx, configfile);
+ driver->help_file = talloc_strdup(mem_ctx, helpfile);
+ driver->monitor_name = talloc_strdup(mem_ctx, monitorname);
+ driver->default_datatype = talloc_strdup(mem_ctx, defaultdatatype);
i=0;
+
while (len < dbuf.dsize) {
- driver.dependentfiles = SMB_REALLOC_ARRAY(driver.dependentfiles, fstring, i+2);
- if ( !driver.dependentfiles ) {
+
+ fstring file;
+
+ driver->dependent_files = talloc_realloc(mem_ctx, driver->dependent_files, const char *, i+2);
+ if (!driver->dependent_files ) {
DEBUG(0,("get_a_printer_driver_3: failed to enlarge buffer!\n"));
break;
}
len += tdb_unpack(dbuf.dptr+len, dbuf.dsize-len, "f",
- &driver.dependentfiles[i]);
+ &file);
+
+ driver->dependent_files[i] = talloc_strdup(mem_ctx, file);
+
i++;
}
- if ( driver.dependentfiles )
- fstrcpy( driver.dependentfiles[i], "" );
+ if (driver->dependent_files)
+ driver->dependent_files[i] = NULL;
SAFE_FREE(dbuf.dptr);
SAFE_FREE(key);
if (len != dbuf.dsize) {
- SAFE_FREE(driver.dependentfiles);
-
- return get_a_printer_driver_3_default(info_ptr, drivername, arch);
- }
-
- *info_ptr = (NT_PRINTER_DRIVER_INFO_LEVEL_3 *)memdup(&driver, sizeof(driver));
- if (!*info_ptr) {
- SAFE_FREE(driver.dependentfiles);
- return WERR_NOMEM;
+ return get_a_printer_driver_3_default(mem_ctx, driver, drivername, arch);
}
return WERR_OK;
/****************************************************************************
****************************************************************************/
-WERROR get_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL *driver, uint32_t level,
+WERROR get_a_printer_driver(TALLOC_CTX *mem_ctx,
+ union spoolss_DriverInfo **driver_p, uint32_t level,
const char *drivername, const char *architecture,
uint32_t version)
{
WERROR result;
+ union spoolss_DriverInfo *driver;
+
+ driver = talloc_zero(mem_ctx, union spoolss_DriverInfo);
+ W_ERROR_HAVE_NO_MEMORY(driver);
switch (level) {
case 3:
if ( version == DRIVER_ANY_VERSION ) {
/* look for Win2k first and then for NT4 */
- result = get_a_printer_driver_3(&driver->info_3, drivername,
- architecture, 3);
+ result = get_a_printer_driver_3(driver,
+ &driver->info3,
+ drivername,
+ architecture, 3);
if ( !W_ERROR_IS_OK(result) ) {
- result = get_a_printer_driver_3( &driver->info_3,
- drivername, architecture, 2 );
+ result = get_a_printer_driver_3(driver,
+ &driver->info3,
+ drivername,
+ architecture, 2);
}
} else {
- result = get_a_printer_driver_3(&driver->info_3, drivername,
- architecture, version);
+ result = get_a_printer_driver_3(driver,
+ &driver->info3,
+ drivername,
+ architecture,
+ version);
}
break;
break;
}
- return result;
+ if (!W_ERROR_IS_OK(result)) {
+ TALLOC_FREE(driver);
+ return result;
+ }
+
+ *driver_p = driver;
+
+ return WERR_OK;
}
/****************************************************************************
****************************************************************************/
-uint32 free_a_printer_driver(NT_PRINTER_DRIVER_INFO_LEVEL driver, uint32 level)
-{
- uint32 result;
- switch (level) {
- case 3:
- {
- NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
- if (driver.info_3 != NULL)
- {
- info3=driver.info_3;
- SAFE_FREE(info3->dependentfiles);
- ZERO_STRUCTP(info3);
- SAFE_FREE(info3);
- result=0;
- } else {
- result=4;
- }
- break;
- }
- case 6:
- {
- NT_PRINTER_DRIVER_INFO_LEVEL_6 *info6;
- if (driver.info_6 != NULL) {
- info6=driver.info_6;
- SAFE_FREE(info6->dependentfiles);
- SAFE_FREE(info6->previousnames);
- ZERO_STRUCTP(info6);
- SAFE_FREE(info6);
- result=0;
- } else {
- result=4;
- }
- break;
- }
- default:
- result=1;
- break;
- }
- return result;
+uint32_t free_a_printer_driver(union spoolss_DriverInfo *driver)
+{
+ talloc_free(driver);
+ return 0;
}
to a printer
****************************************************************************/
-bool printer_driver_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3 )
+bool printer_driver_in_use(const struct spoolss_DriverInfo3 *info_3)
{
int snum;
int n_services = lp_numservices();
if ( !W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_servicename(snum))) )
continue;
- if ( strequal(info_3->name, printer->info_2->drivername) )
+ if (strequal(info_3->driver_name, printer->info_2->drivername))
in_use = True;
free_a_printer( &printer, 2 );
DEBUG(10,("printer_driver_in_use: Completed search through ntprinters.tdb...\n"));
if ( in_use ) {
- NT_PRINTER_DRIVER_INFO_LEVEL d;
+ union spoolss_DriverInfo *d;
WERROR werr;
- DEBUG(5,("printer_driver_in_use: driver \"%s\" is currently in use\n", info_3->name));
+ DEBUG(5,("printer_driver_in_use: driver \"%s\" is currently in use\n", info_3->driver_name));
/* we can still remove the driver if there is one of
"Windows NT x86" version 2 or 3 left */
- if ( !strequal( "Windows NT x86", info_3->environment ) ) {
- werr = get_a_printer_driver( &d, 3, info_3->name, "Windows NT x86", DRIVER_ANY_VERSION );
+ if (!strequal("Windows NT x86", info_3->architecture)) {
+ werr = get_a_printer_driver(talloc_tos(), &d, 3, info_3->driver_name, "Windows NT x86", DRIVER_ANY_VERSION);
}
else {
- switch ( info_3->cversion ) {
+ switch (info_3->version) {
case 2:
- werr = get_a_printer_driver( &d, 3, info_3->name, "Windows NT x86", 3 );
+ werr = get_a_printer_driver(talloc_tos(), &d, 3, info_3->driver_name, "Windows NT x86", 3);
break;
case 3:
- werr = get_a_printer_driver( &d, 3, info_3->name, "Windows NT x86", 2 );
+ werr = get_a_printer_driver(talloc_tos(), &d, 3, info_3->driver_name, "Windows NT x86", 2);
break;
default:
DEBUG(0,("printer_driver_in_use: ERROR! unknown driver version (%d)\n",
- info_3->cversion));
+ info_3->version));
werr = WERR_UNKNOWN_PRINTER_DRIVER;
break;
}
if ( W_ERROR_IS_OK(werr) ) {
/* it's ok to remove the driver, we have other architctures left */
in_use = False;
- free_a_printer_driver( d, 3 );
+ free_a_printer_driver(d);
}
}
Check to see if a ogiven file is in use by *info
*********************************************************************/
-static bool drv_file_in_use( char* file, NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
+static bool drv_file_in_use(const char *file, const struct spoolss_DriverInfo3 *info)
{
int i = 0;
return false;
}
- if ( strequal(file, info->driverpath) )
+ if (strequal(file, info->driver_path))
return True;
- if ( strequal(file, info->datafile) )
+ if (strequal(file, info->data_file))
return True;
- if ( strequal(file, info->configfile) )
+ if (strequal(file, info->config_file))
return True;
- if ( strequal(file, info->helpfile) )
+ if (strequal(file, info->help_file))
return True;
/* see of there are any dependent files to examine */
- if ( !info->dependentfiles )
+ if (!info->dependent_files)
return False;
- while ( *info->dependentfiles[i] ) {
- if ( strequal(file, info->dependentfiles[i]) )
+ while (info->dependent_files[i] && *info->dependent_files[i]) {
+ if (strequal(file, info->dependent_files[i]))
return True;
i++;
}
input parameter from the list
*********************************************************************/
-static void trim_dependent_file( fstring files[], int idx )
+static void trim_dependent_file(TALLOC_CTX *mem_ctx, const char **files, int idx)
{
/* bump everything down a slot */
- while( *files[idx+1] ) {
- fstrcpy( files[idx], files[idx+1] );
+ while (files && files[idx+1]) {
+ files[idx] = talloc_strdup(mem_ctx, files[idx+1]);
idx++;
}
- *files[idx] = '\0';
+ files[idx] = NULL;
return;
}
Check if any of the files used by src are also used by drv
*********************************************************************/
-static bool trim_overlap_drv_files( NT_PRINTER_DRIVER_INFO_LEVEL_3 *src,
- NT_PRINTER_DRIVER_INFO_LEVEL_3 *drv )
+static bool trim_overlap_drv_files(TALLOC_CTX *mem_ctx,
+ struct spoolss_DriverInfo3 *src,
+ const struct spoolss_DriverInfo3 *drv)
{
bool in_use = False;
int i = 0;
/* check each file. Remove it from the src structure if it overlaps */
- if ( drv_file_in_use(src->driverpath, drv) ) {
+ if (drv_file_in_use(src->driver_path, drv)) {
in_use = True;
- DEBUG(10,("Removing driverfile [%s] from list\n", src->driverpath));
- fstrcpy( src->driverpath, "" );
+ DEBUG(10,("Removing driverfile [%s] from list\n", src->driver_path));
+ src->driver_path = talloc_strdup(mem_ctx, "");
+ if (!src->driver_path) { return false; }
}
- if ( drv_file_in_use(src->datafile, drv) ) {
+ if (drv_file_in_use(src->data_file, drv)) {
in_use = True;
- DEBUG(10,("Removing datafile [%s] from list\n", src->datafile));
- fstrcpy( src->datafile, "" );
+ DEBUG(10,("Removing datafile [%s] from list\n", src->data_file));
+ src->data_file = talloc_strdup(mem_ctx, "");
+ if (!src->data_file) { return false; }
}
- if ( drv_file_in_use(src->configfile, drv) ) {
+ if (drv_file_in_use(src->config_file, drv)) {
in_use = True;
- DEBUG(10,("Removing configfile [%s] from list\n", src->configfile));
- fstrcpy( src->configfile, "" );
+ DEBUG(10,("Removing configfile [%s] from list\n", src->config_file));
+ src->config_file = talloc_strdup(mem_ctx, "");
+ if (!src->config_file) { return false; }
}
- if ( drv_file_in_use(src->helpfile, drv) ) {
+ if (drv_file_in_use(src->help_file, drv)) {
in_use = True;
- DEBUG(10,("Removing helpfile [%s] from list\n", src->helpfile));
- fstrcpy( src->helpfile, "" );
+ DEBUG(10,("Removing helpfile [%s] from list\n", src->help_file));
+ src->help_file = talloc_strdup(mem_ctx, "");
+ if (!src->help_file) { return false; }
}
/* are there any dependentfiles to examine? */
- if ( !src->dependentfiles )
+ if (!src->dependent_files)
return in_use;
- while ( *src->dependentfiles[i] ) {
- if ( drv_file_in_use(src->dependentfiles[i], drv) ) {
+ while (src->dependent_files[i] && *src->dependent_files[i]) {
+ if (drv_file_in_use(src->dependent_files[i], drv)) {
in_use = True;
- DEBUG(10,("Removing [%s] from dependent file list\n", src->dependentfiles[i]));
- trim_dependent_file( src->dependentfiles, i );
+ DEBUG(10,("Removing [%s] from dependent file list\n", src->dependent_files[i]));
+ trim_dependent_file(mem_ctx, src->dependent_files, i);
} else
i++;
}
match.
****************************************************************************/
-bool printer_driver_files_in_use ( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info )
+bool printer_driver_files_in_use(TALLOC_CTX *mem_ctx,
+ struct spoolss_DriverInfo3 *info)
{
int i;
int ndrivers;
uint32 version;
fstring *list = NULL;
- NT_PRINTER_DRIVER_INFO_LEVEL driver;
+ union spoolss_DriverInfo *driver;
bool in_use = false;
if ( !info )
return False;
- version = info->cversion;
+ version = info->version;
/* loop over all driver versions */
/* get the list of drivers */
list = NULL;
- ndrivers = get_ntdrivers(&list, info->environment, version);
+ ndrivers = get_ntdrivers(&list, info->architecture, version);
DEBUGADD(4,("we have:[%d] drivers in environment [%s] and version [%d]\n",
- ndrivers, info->environment, version));
+ ndrivers, info->architecture, version));
/* check each driver for overlap in files */
for (i=0; i<ndrivers; i++) {
DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
- ZERO_STRUCT(driver);
+ driver = NULL;
- if ( !W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, list[i], info->environment, version)) ) {
+ if (!W_ERROR_IS_OK(get_a_printer_driver(talloc_tos(), &driver, 3, list[i], info->architecture, version))) {
SAFE_FREE(list);
return True;
}
/* check if d2 uses any files from d1 */
/* only if this is a different driver than the one being deleted */
- if ( !strequal(info->name, driver.info_3->name) ) {
- if ( trim_overlap_drv_files(info, driver.info_3) ) {
+ if (!strequal(info->driver_name, driver->info3.driver_name)) {
+ if (trim_overlap_drv_files(mem_ctx, info, &driver->info3)) {
/* mz: Do not instantly return -
* we need to ensure this file isn't
* also in use by other drivers. */
}
}
- free_a_printer_driver(driver, 3);
+ free_a_printer_driver(driver);
}
SAFE_FREE(list);
DEBUG(5,("printer_driver_files_in_use: Completed search through ntdrivers.tdb...\n"));
- driver.info_3 = info;
-
return in_use;
}
****************************************************************************/
static bool delete_driver_files(struct pipes_struct *rpc_pipe,
- NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3)
+ const struct spoolss_DriverInfo3 *info_3)
{
int i = 0;
char *s;
if ( !info_3 )
return False;
- DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n", info_3->name, info_3->cversion));
+ DEBUG(6,("delete_driver_files: deleting driver [%s] - version [%d]\n",
+ info_3->driver_name, info_3->version));
fstrcpy(printdollar, "print$");
/* now delete the files; must strip the '\print$' string from
fron of path */
- if ( *info_3->driverpath ) {
- if ( (s = strchr( &info_3->driverpath[1], '\\' )) != NULL ) {
+ if (info_3->driver_path && info_3->driver_path[0]) {
+ if ((s = strchr(&info_3->driver_path[1], '\\')) != NULL) {
file = s;
DEBUG(10,("deleting driverfile [%s]\n", s));
driver_unlink_internals(conn, file);
}
}
- if ( *info_3->configfile ) {
- if ( (s = strchr( &info_3->configfile[1], '\\' )) != NULL ) {
+ if (info_3->config_file && info_3->config_file[0]) {
+ if ((s = strchr(&info_3->config_file[1], '\\')) != NULL) {
file = s;
DEBUG(10,("deleting configfile [%s]\n", s));
driver_unlink_internals(conn, file);
}
}
- if ( *info_3->datafile ) {
- if ( (s = strchr( &info_3->datafile[1], '\\' )) != NULL ) {
+ if (info_3->data_file && info_3->data_file[0]) {
+ if ((s = strchr(&info_3->data_file[1], '\\')) != NULL) {
file = s;
DEBUG(10,("deleting datafile [%s]\n", s));
driver_unlink_internals(conn, file);
}
}
- if ( *info_3->helpfile ) {
- if ( (s = strchr( &info_3->helpfile[1], '\\' )) != NULL ) {
+ if (info_3->help_file && info_3->help_file[0]) {
+ if ((s = strchr( &info_3->help_file[1], '\\')) != NULL) {
file = s;
DEBUG(10,("deleting helpfile [%s]\n", s));
driver_unlink_internals(conn, file);
/* check if we are done removing files */
- if ( info_3->dependentfiles ) {
- while ( info_3->dependentfiles[i][0] ) {
+ if (info_3->dependent_files) {
+ while (info_3->dependent_files[i] && info_3->dependent_files[i][0]) {
char *p;
/* bypass the "\print$" portion of the path */
- if ( (p = strchr( info_3->dependentfiles[i]+1, '\\' )) != NULL ) {
+ if ((p = strchr(info_3->dependent_files[i]+1, '\\')) != NULL) {
file = p;
DEBUG(10,("deleting dependent file [%s]\n", file));
driver_unlink_internals(conn, file);
***************************************************************************/
WERROR delete_printer_driver(struct pipes_struct *rpc_pipe,
- NT_PRINTER_DRIVER_INFO_LEVEL_3 *info_3,
+ const struct spoolss_DriverInfo3 *info_3,
uint32 version, bool delete_files )
{
char *key = NULL;
const char *arch;
TDB_DATA dbuf;
- NT_PRINTER_DRIVER_INFO_LEVEL ctr;
/* delete the tdb data first */
- arch = get_short_archi(info_3->environment);
+ arch = get_short_archi(info_3->architecture);
if (!arch) {
return WERR_UNKNOWN_PRINTER_DRIVER;
}
if (asprintf(&key, "%s%s/%d/%s", DRIVERS_PREFIX,
- arch, version, info_3->name) < 0) {
+ arch, version, info_3->driver_name) < 0) {
return WERR_NOMEM;
}
DEBUG(5,("delete_printer_driver: key = [%s] delete_files = %s\n",
key, delete_files ? "TRUE" : "FALSE" ));
- ctr.info_3 = info_3;
-
/* check if the driver actually exists for this environment */
dbuf = tdb_fetch_bystring( tdb_drivers, key );
WERROR _spoolss_DeletePrinterDriver(pipes_struct *p,
struct spoolss_DeletePrinterDriver *r)
{
- NT_PRINTER_DRIVER_INFO_LEVEL info;
- NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
+
+ union spoolss_DriverInfo *info = NULL;
+ union spoolss_DriverInfo *info_win2k = NULL;
int version;
WERROR status;
WERROR status_win2k = WERR_ACCESS_DENIED;
if ((version = get_version_id(r->in.architecture)) == -1)
return WERR_INVALID_ENVIRONMENT;
- ZERO_STRUCT(info);
- ZERO_STRUCT(info_win2k);
-
- if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
+ if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, 3, r->in.driver,
r->in.architecture,
version)))
{
if ( version == 2 ) {
version = 3;
- if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3,
+ if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
+ &info, 3,
r->in.driver,
r->in.architecture,
version))) {
}
- if (printer_driver_in_use(info.info_3)) {
+ if (printer_driver_in_use(&info->info3)) {
status = WERR_PRINTER_DRIVER_IN_USE;
goto done;
}
if ( version == 2 )
{
- if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
+ if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx,
+ &info_win2k, 3,
r->in.driver,
r->in.architecture, 3)))
{
/* remove the Win2k driver first*/
status_win2k = delete_printer_driver(
- p, info_win2k.info_3, 3, false);
- free_a_printer_driver( info_win2k, 3 );
+ p, &info_win2k->info3, 3, false);
+ free_a_printer_driver(info_win2k);
/* this should not have failed---if it did, report to client */
if ( !W_ERROR_IS_OK(status_win2k) )
}
}
- status = delete_printer_driver(p, info.info_3, version, false);
+ status = delete_printer_driver(p, &info->info3, version, false);
/* if at least one of the deletes succeeded return OK */
status = WERR_OK;
done:
- free_a_printer_driver( info, 3 );
+ free_a_printer_driver(info);
return status;
}
WERROR _spoolss_DeletePrinterDriverEx(pipes_struct *p,
struct spoolss_DeletePrinterDriverEx *r)
{
- NT_PRINTER_DRIVER_INFO_LEVEL info;
- NT_PRINTER_DRIVER_INFO_LEVEL info_win2k;
+ union spoolss_DriverInfo *info = NULL;
+ union spoolss_DriverInfo *info_win2k = NULL;
int version;
bool delete_files;
WERROR status;
if (r->in.delete_flags & DPD_DELETE_SPECIFIC_VERSION)
version = r->in.version;
- ZERO_STRUCT(info);
- ZERO_STRUCT(info_win2k);
-
- status = get_a_printer_driver(&info, 3, r->in.driver,
+ status = get_a_printer_driver(p->mem_ctx, &info, 3, r->in.driver,
r->in.architecture, version);
if ( !W_ERROR_IS_OK(status) )
/* try for Win2k driver if "Windows NT x86" */
version = 3;
- if (!W_ERROR_IS_OK(get_a_printer_driver(&info, 3, r->in.driver,
+ if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info, 3, r->in.driver,
r->in.architecture,
version))) {
status = WERR_UNKNOWN_PRINTER_DRIVER;
}
}
- if ( printer_driver_in_use(info.info_3) ) {
+ if ( printer_driver_in_use(&info->info3) ) {
status = WERR_PRINTER_DRIVER_IN_USE;
goto done;
}
/* fail if any files are in use and DPD_DELETE_ALL_FILES is set */
- if ( delete_files && printer_driver_files_in_use(info.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
+ if ( delete_files && printer_driver_files_in_use(info, &info->info3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
/* no idea of the correct error here */
status = WERR_ACCESS_DENIED;
goto done;
/* 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) ) {
- if (W_ERROR_IS_OK(get_a_printer_driver(&info_win2k, 3,
+ if (W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &info_win2k, 3,
r->in.driver,
r->in.architecture, 3)))
{
- if ( delete_files && printer_driver_files_in_use(info_win2k.info_3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
+ if ( delete_files && printer_driver_files_in_use(info, &info_win2k->info3) & (r->in.delete_flags & DPD_DELETE_ALL_FILES) ) {
/* no idea of the correct error here */
- free_a_printer_driver( info_win2k, 3 );
+ free_a_printer_driver(info_win2k);
status = WERR_ACCESS_DENIED;
goto done;
}
/* remove the Win2k driver first*/
status_win2k = delete_printer_driver(
- p, info_win2k.info_3, 3, delete_files);
- free_a_printer_driver( info_win2k, 3 );
+ p, &info_win2k->info3, 3, delete_files);
+ free_a_printer_driver(info_win2k);
/* this should not have failed---if it did, report to client */
}
}
- status = delete_printer_driver(p, info.info_3, version, delete_files);
+ status = delete_printer_driver(p, &info->info3, version, delete_files);
if ( W_ERROR_IS_OK(status) || W_ERROR_IS_OK(status_win2k) )
status = WERR_OK;
done:
- free_a_printer_driver( info, 3 );
+ free_a_printer_driver(info);
return status;
}
********************************************************************/
static const char **string_array_from_driver_info(TALLOC_CTX *mem_ctx,
- fstring *fstring_array,
+ const char **string_array,
const char *cservername)
{
int i, num_strings = 0;
const char **array = NULL;
- for (i=0; fstring_array && fstring_array[i][0] != '\0'; i++) {
+ if (!string_array) {
+ return NULL;
+ }
+
+ for (i=0; string_array[i] && string_array[i][0] != '\0'; i++) {
const char *str = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, fstring_array[i]);
+ cservername, string_array[i]);
if (!str) {
TALLOC_FREE(array);
return NULL;
static WERROR fill_printer_driver_info1(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo1 *r,
- const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
+ const union spoolss_DriverInfo *driver,
const char *servername,
const char *architecture)
{
- r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
return WERR_OK;
static WERROR fill_printer_driver_info2(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo2 *r,
- const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
+ const union spoolss_DriverInfo *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info_3->cversion;
+ r->version = driver->info3.version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
+ r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info_3->driverpath)) {
+ if (strlen(driver->info3.driver_path)) {
r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->driverpath);
+ cservername, driver->info3.driver_path);
} else {
r->driver_path = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->driver_path);
- if (strlen(driver->info_3->datafile)) {
+ if (strlen(driver->info3.data_file)) {
r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->datafile);
+ cservername, driver->info3.data_file);
} else {
r->data_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->data_file);
- if (strlen(driver->info_3->configfile)) {
+ if (strlen(driver->info3.config_file)) {
r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->configfile);
+ cservername, driver->info3.config_file);
} else {
r->config_file = talloc_strdup(mem_ctx, "");
}
static WERROR fill_printer_driver_info3(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo3 *r,
- const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
+ const union spoolss_DriverInfo *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info_3->cversion;
+ r->version = driver->info3.version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
+ r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info_3->driverpath)) {
+ if (strlen(driver->info3.driver_path)) {
r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->driverpath);
+ cservername, driver->info3.driver_path);
} else {
r->driver_path = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->driver_path);
- if (strlen(driver->info_3->datafile)) {
+ if (strlen(driver->info3.data_file)) {
r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->datafile);
+ cservername, driver->info3.data_file);
} else {
r->data_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->data_file);
- if (strlen(driver->info_3->configfile)) {
+ if (strlen(driver->info3.config_file)) {
r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->configfile);
+ cservername, driver->info3.config_file);
} else {
r->config_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->config_file);
- if (strlen(driver->info_3->helpfile)) {
+ if (strlen(driver->info3.help_file)) {
r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->helpfile);
+ cservername, driver->info3.help_file);
} else {
r->help_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->help_file);
- r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
+ r->monitor_name = talloc_strdup(mem_ctx, driver->info3.monitor_name);
W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
- r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
+ r->default_datatype = talloc_strdup(mem_ctx, driver->info3.default_datatype);
W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
r->dependent_files = string_array_from_driver_info(mem_ctx,
- driver->info_3->dependentfiles,
+ driver->info3.dependent_files,
cservername);
return WERR_OK;
}
static WERROR fill_printer_driver_info4(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo4 *r,
- const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
+ const union spoolss_DriverInfo *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info_3->cversion;
+ r->version = driver->info3.version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
+ r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info_3->driverpath)) {
+ if (strlen(driver->info3.driver_path)) {
r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->driverpath);
+ cservername, driver->info3.driver_path);
} else {
r->driver_path = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->driver_path);
- if (strlen(driver->info_3->datafile)) {
+ if (strlen(driver->info3.data_file)) {
r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->datafile);
+ cservername, driver->info3.data_file);
} else {
r->data_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->data_file);
- if (strlen(driver->info_3->configfile)) {
+ if (strlen(driver->info3.config_file)) {
r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->configfile);
+ cservername, driver->info3.config_file);
} else {
r->config_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->config_file);
- if (strlen(driver->info_3->helpfile)) {
+ if (strlen(driver->info3.help_file)) {
r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->helpfile);
+ cservername, driver->info3.help_file);
} else {
r->help_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->help_file);
r->dependent_files = string_array_from_driver_info(mem_ctx,
- driver->info_3->dependentfiles,
+ driver->info3.dependent_files,
cservername);
- r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
+ r->monitor_name = talloc_strdup(mem_ctx, driver->info3.monitor_name);
W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
- r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
+ r->default_datatype = talloc_strdup(mem_ctx, driver->info3.default_datatype);
W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
r->previous_names = string_array_from_driver_info(mem_ctx,
static WERROR fill_printer_driver_info5(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo5 *r,
- const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
+ const union spoolss_DriverInfo *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info_3->cversion;
+ r->version = driver->info3.version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
+ r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info_3->driverpath)) {
+ if (strlen(driver->info3.driver_path)) {
r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->driverpath);
+ cservername, driver->info3.driver_path);
} else {
r->driver_path = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->driver_path);
- if (strlen(driver->info_3->datafile)) {
+ if (strlen(driver->info3.data_file)) {
r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->datafile);
+ cservername, driver->info3.data_file);
} else {
r->data_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->data_file);
- if (strlen(driver->info_3->configfile)) {
+ if (strlen(driver->info3.config_file)) {
r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->configfile);
+ cservername, driver->info3.config_file);
} else {
r->config_file = talloc_strdup(mem_ctx, "");
}
static WERROR fill_printer_driver_info6(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo6 *r,
- const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
+ const union spoolss_DriverInfo *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
- r->version = driver->info_3->cversion;
+ r->version = driver->info3.version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
+ r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
- if (strlen(driver->info_3->driverpath)) {
+ if (strlen(driver->info3.driver_path)) {
r->driver_path = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->driverpath);
+ cservername, driver->info3.driver_path);
} else {
r->driver_path = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->driver_path);
- if (strlen(driver->info_3->datafile)) {
+ if (strlen(driver->info3.data_file)) {
r->data_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->datafile);
+ cservername, driver->info3.data_file);
} else {
r->data_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->data_file);
- if (strlen(driver->info_3->configfile)) {
+ if (strlen(driver->info3.config_file)) {
r->config_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->configfile);
+ cservername, driver->info3.config_file);
} else {
r->config_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->config_file);
- if (strlen(driver->info_3->helpfile)) {
+ if (strlen(driver->info3.help_file)) {
r->help_file = talloc_asprintf(mem_ctx, "\\\\%s%s",
- cservername, driver->info_3->helpfile);
+ cservername, driver->info3.help_file);
} else {
r->help_file = talloc_strdup(mem_ctx, "");
}
W_ERROR_HAVE_NO_MEMORY(r->help_file);
- r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
+ r->monitor_name = talloc_strdup(mem_ctx, driver->info3.monitor_name);
W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
- r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
+ r->default_datatype = talloc_strdup(mem_ctx, driver->info3.default_datatype);
W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
r->dependent_files = string_array_from_driver_info(mem_ctx,
- driver->info_3->dependentfiles,
+ driver->info3.dependent_files,
cservername);
r->previous_names = string_array_from_driver_info(mem_ctx,
NULL,
********************************************************************/
static WERROR spoolss_DriverFileInfo_from_driver(TALLOC_CTX *mem_ctx,
- const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
+ const union spoolss_DriverInfo *driver,
const char *cservername,
struct spoolss_DriverFileInfo **info_p,
uint32_t *count_p)
*info_p = NULL;
*count_p = 0;
- if (strlen(driver->info_3->driverpath)) {
+ if (strlen(driver->info3.driver_path)) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info_3->driverpath,
+ driver->info3.driver_path,
SPOOLSS_DRIVER_FILE_TYPE_RENDERING,
0);
W_ERROR_NOT_OK_RETURN(result);
count++;
}
- if (strlen(driver->info_3->configfile)) {
+ if (strlen(driver->info3.config_file)) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info_3->configfile,
+ driver->info3.config_file,
SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION,
0);
W_ERROR_NOT_OK_RETURN(result);
count++;
}
- if (strlen(driver->info_3->datafile)) {
+ if (strlen(driver->info3.data_file)) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info_3->datafile,
+ driver->info3.data_file,
SPOOLSS_DRIVER_FILE_TYPE_DATA,
0);
W_ERROR_NOT_OK_RETURN(result);
count++;
}
- if (strlen(driver->info_3->helpfile)) {
+ if (strlen(driver->info3.help_file)) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info_3->helpfile,
+ driver->info3.help_file,
SPOOLSS_DRIVER_FILE_TYPE_HELP,
0);
W_ERROR_NOT_OK_RETURN(result);
count++;
}
- for (i=0; driver->info_3->dependentfiles[i][0] != '\0'; i++) {
+ for (i=0; driver->info3.dependent_files[i][0] != '\0'; i++) {
info = TALLOC_REALLOC_ARRAY(mem_ctx, info,
struct spoolss_DriverFileInfo,
count + 1);
result = fill_spoolss_DriverFileInfo(info,
&info[count],
cservername,
- driver->info_3->dependentfiles[i],
+ driver->info3.dependent_files[i],
SPOOLSS_DRIVER_FILE_TYPE_OTHER,
0);
W_ERROR_NOT_OK_RETURN(result);
static WERROR fill_printer_driver_info101(TALLOC_CTX *mem_ctx,
struct spoolss_DriverInfo101 *r,
- const NT_PRINTER_DRIVER_INFO_LEVEL *driver,
+ const union spoolss_DriverInfo *driver,
const char *servername)
{
const char *cservername = canon_servername(servername);
WERROR result;
- r->version = driver->info_3->cversion;
+ r->version = driver->info3.version;
- r->driver_name = talloc_strdup(mem_ctx, driver->info_3->name);
+ r->driver_name = talloc_strdup(mem_ctx, driver->info3.driver_name);
W_ERROR_HAVE_NO_MEMORY(r->driver_name);
- r->architecture = talloc_strdup(mem_ctx, driver->info_3->environment);
+ r->architecture = talloc_strdup(mem_ctx, driver->info3.architecture);
W_ERROR_HAVE_NO_MEMORY(r->architecture);
result = spoolss_DriverFileInfo_from_driver(mem_ctx, driver,
return result;
}
- r->monitor_name = talloc_strdup(mem_ctx, driver->info_3->monitorname);
+ r->monitor_name = talloc_strdup(mem_ctx, driver->info3.monitor_name);
W_ERROR_HAVE_NO_MEMORY(r->monitor_name);
- r->default_datatype = talloc_strdup(mem_ctx, driver->info_3->defaultdatatype);
+ r->default_datatype = talloc_strdup(mem_ctx, driver->info3.default_datatype);
W_ERROR_HAVE_NO_MEMORY(r->default_datatype);
r->previous_names = string_array_from_driver_info(mem_ctx,
uint32_t version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
- NT_PRINTER_DRIVER_INFO_LEVEL driver;
+ union spoolss_DriverInfo *driver;
WERROR result;
- ZERO_STRUCT(driver);
-
if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
return WERR_INVALID_PRINTER_NAME;
- if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
+ if (!W_ERROR_IS_OK(get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version))) {
free_a_printer(&printer, 2);
return WERR_UNKNOWN_PRINTER_DRIVER;
}
- result = fill_printer_driver_info1(mem_ctx, r, &driver, servername, architecture);
+ result = fill_printer_driver_info1(mem_ctx, r, driver, servername, architecture);
+ free_a_printer_driver(driver);
free_a_printer(&printer,2);
return result;
uint32_t version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
- NT_PRINTER_DRIVER_INFO_LEVEL driver;
+ union spoolss_DriverInfo *driver;
WERROR result;
ZERO_STRUCT(printer);
- ZERO_STRUCT(driver);
if (!W_ERROR_IS_OK(get_a_printer(NULL, &printer, 2, lp_const_servicename(snum))))
return WERR_INVALID_PRINTER_NAME;
- if (!W_ERROR_IS_OK(get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version))) {
+ if (!W_ERROR_IS_OK(get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version))) {
free_a_printer(&printer, 2);
return WERR_UNKNOWN_PRINTER_DRIVER;
}
- result = fill_printer_driver_info2(mem_ctx, r, &driver, servername);
+ result = fill_printer_driver_info2(mem_ctx, r, driver, servername);
+ free_a_printer_driver(driver);
free_a_printer(&printer,2);
return result;
uint32_t version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
- NT_PRINTER_DRIVER_INFO_LEVEL driver;
+ union spoolss_DriverInfo *driver;
WERROR status;
ZERO_STRUCT(driver);
if (!W_ERROR_IS_OK(status))
return WERR_INVALID_PRINTER_NAME;
- status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
+ status = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version);
DEBUG(8,("construct_printer_driver_info_3: status: %s\n", win_errstr(status)));
#if 0 /* JERRY */
#endif
- status = fill_printer_driver_info3(mem_ctx, r, &driver, servername);
+ status = fill_printer_driver_info3(mem_ctx, r, driver, servername);
+ free_a_printer_driver(driver);
free_a_printer(&printer,2);
return status;
uint32_t version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
- NT_PRINTER_DRIVER_INFO_LEVEL driver;
+ union spoolss_DriverInfo *driver;
WERROR status;
- ZERO_STRUCT(driver);
-
status=get_a_printer(NULL, &printer, 2, lp_const_servicename(snum) );
DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
if (!W_ERROR_IS_OK(status))
return WERR_INVALID_PRINTER_NAME;
- status = get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
+ status = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version);
DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
/* Yes - try again with a WinNT driver. */
version = 2;
- status=get_a_printer_driver(&driver, 3, printer->info_2->drivername, architecture, version);
+ status = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername, architecture, version);
DEBUG(8,("construct_printer_driver_info_6: status: %s\n", win_errstr(status)));
if (!W_ERROR_IS_OK(status)) {
free_a_printer(&printer,2);
}
}
- status = fill_printer_driver_info6(mem_ctx, r, &driver, servername);
+ status = fill_printer_driver_info6(mem_ctx, r, driver, servername);
free_a_printer(&printer,2);
- free_a_printer_driver(driver, 3);
+ free_a_printer_driver(driver);
return status;
}
uint32_t version)
{
NT_PRINTER_INFO_LEVEL *printer = NULL;
- NT_PRINTER_DRIVER_INFO_LEVEL driver;
+ union spoolss_DriverInfo *driver;
WERROR result;
- ZERO_STRUCT(driver);
-
result = get_a_printer(NULL, &printer, 2, lp_const_servicename(snum));
DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
return WERR_INVALID_PRINTER_NAME;
}
- result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
+ result = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername,
architecture, version);
DEBUG(8,("construct_printer_driver_info_101: status: %s\n",
/* Yes - try again with a WinNT driver. */
version = 2;
- result = get_a_printer_driver(&driver, 3, printer->info_2->drivername,
+ result = get_a_printer_driver(mem_ctx, &driver, 3, printer->info_2->drivername,
architecture, version);
DEBUG(8,("construct_printer_driver_info_6: status: %s\n",
win_errstr(result)));
}
}
- result = fill_printer_driver_info101(mem_ctx, r, &driver, servername);
+ result = fill_printer_driver_info101(mem_ctx, r, driver, servername);
free_a_printer(&printer, 2);
- free_a_printer_driver(driver, 3);
+ free_a_printer_driver(driver);
return result;
}
int ndrivers;
uint32_t version;
fstring *list = NULL;
- NT_PRINTER_DRIVER_INFO_LEVEL driver;
+ union spoolss_DriverInfo *driver;
union spoolss_DriverInfo *info = NULL;
uint32_t count = 0;
WERROR result = WERR_OK;
for (i=0; i<ndrivers; i++) {
DEBUGADD(5,("\tdriver: [%s]\n", list[i]));
ZERO_STRUCT(driver);
- result = get_a_printer_driver(&driver, 3, list[i],
+ result = get_a_printer_driver(mem_ctx, &driver, 3, list[i],
architecture, version);
if (!W_ERROR_IS_OK(result)) {
goto out;
switch (level) {
case 1:
result = fill_printer_driver_info1(info, &info[count+i].info1,
- &driver, servername,
+ driver, servername,
architecture);
break;
case 2:
result = fill_printer_driver_info2(info, &info[count+i].info2,
- &driver, servername);
+ driver, servername);
break;
case 3:
result = fill_printer_driver_info3(info, &info[count+i].info3,
- &driver, servername);
+ driver, servername);
break;
case 4:
result = fill_printer_driver_info4(info, &info[count+i].info4,
- &driver, servername);
+ driver, servername);
break;
case 5:
result = fill_printer_driver_info5(info, &info[count+i].info5,
- &driver, servername);
+ driver, servername);
break;
case 6:
result = fill_printer_driver_info6(info, &info[count+i].info6,
- &driver, servername);
+ driver, servername);
break;
default:
result = WERR_UNKNOWN_LEVEL;
break;
}
+ free_a_printer_driver(driver);
+
if (!W_ERROR_IS_OK(result)) {
- free_a_printer_driver(driver, 3);
goto out;
}
- free_a_printer_driver(driver, 3);
}
count += ndrivers;
*/
case 2:
{
- NT_PRINTER_DRIVER_INFO_LEVEL driver1;
+ union spoolss_DriverInfo *driver1;
- if (!W_ERROR_IS_OK(get_a_printer_driver(&driver1, 3, driver_name, "Windows NT x86", 3))) {
+ if (!W_ERROR_IS_OK(get_a_printer_driver(p->mem_ctx, &driver1, 3, driver_name, "Windows NT x86", 3))) {
/*
* No 2k/Xp driver found, delete init data (if any) for the new Nt driver.
*/
/*
* a 2k/Xp driver was found, don't delete init data because Nt driver will use it.
*/
- free_a_printer_driver(driver1,3);
+ free_a_printer_driver(driver1);
DEBUG(10,("%s: init data not deleted for Nt driver [%s]\n",
fn, driver_name));
}
git.samba.org / samba.git / commitdiff