2007-11-27 04:24:56 +03:00
/*
2002-07-19 03:00:24 +04:00
* Unix SMB / CIFS implementation .
2005-05-23 20:25:31 +04:00
* Virtual Windows Registry Layer
* Copyright ( C ) Gerald Carter 2002 - 2005
2002-07-19 03:00:24 +04:00
*
* This program is free software ; you can redistribute it and / or modify
* it under the terms of the GNU General Public License as published by
2007-07-09 23:25:36 +04:00
* the Free Software Foundation ; either version 3 of the License , or
2002-07-19 03:00:24 +04:00
* ( at your option ) any later version .
2007-11-27 04:24:56 +03:00
*
2002-07-19 03:00:24 +04:00
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU General Public License for more details .
2007-11-27 04:24:56 +03:00
*
2002-07-19 03:00:24 +04:00
* You should have received a copy of the GNU General Public License
2007-07-10 09:23:25 +04:00
* along with this program ; if not , see < http : //www.gnu.org/licenses/>.
2002-07-19 03:00:24 +04:00
*/
/* Implementation of registry virtual views for printing information */
# include "includes.h"
# undef DBGC_CLASS
2007-09-29 03:05:52 +04:00
# define DBGC_CLASS DBGC_REGISTRY
2002-07-19 03:00:24 +04:00
2005-06-30 07:29:48 +04:00
/* registrt paths used in the print_registry[] */
# define KEY_MONITORS "HKLM / SYSTEM / CURRENTCONTROLSET / CONTROL / PRINT / MONITORS"
# define KEY_FORMS "HKLM / SYSTEM / CURRENTCONTROLSET / CONTROL / PRINT / FORMS"
# define KEY_CONTROL_PRINTERS "HKLM / SYSTEM / CURRENTCONTROLSET / CONTROL / PRINT / PRINTERS"
# define KEY_ENVIRONMENTS "HKLM / SYSTEM / CURRENTCONTROLSET / CONTROL / PRINT / ENVIRONMENTS"
# define KEY_CONTROL_PRINT "HKLM / SYSTEM / CURRENTCONTROLSET / CONTROL / PRINT"
# define KEY_WINNT_PRINTERS "HKLM / SOFTWARE / MICROSOFT / WINDOWS NT / CURRENTVERSION / PRINT / PRINTERS"
# define KEY_WINNT_PRINT "HKLM / SOFTWARE / MICROSOFT / WINDOWS NT / CURRENTVERSION / PRINT"
# define KEY_PORTS "HKLM / SOFTWARE / MICROSOFT / WINDOWS NT / CURRENTVERSION / PORTS"
/* callback table for various registry paths below the ones we service in this module */
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
struct reg_dyn_tree {
/* full key path in normalized form */
const char * path ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
/* callbscks for fetch/store operations */
2009-02-24 17:19:18 +03:00
int ( * fetch_subkeys ) ( const char * path , struct regsubkey_ctr * subkeys ) ;
bool ( * store_subkeys ) ( const char * path , struct regsubkey_ctr * subkeys ) ;
2009-03-23 20:14:17 +03:00
int ( * fetch_values ) ( const char * path , struct regval_ctr * values ) ;
bool ( * store_values ) ( const char * path , struct regval_ctr * values ) ;
2005-06-30 06:59:29 +04:00
} ;
2005-07-01 23:15:07 +04:00
/*********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * Utility Functions
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-06-30 23:43:53 +04:00
/***********************************************************************
2007-11-27 04:24:56 +03:00
simple function to prune a pathname down to the basename of a file
2005-06-30 23:43:53 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-27 04:24:56 +03:00
static const char * dos_basename ( const char * path )
2005-06-30 23:43:53 +04:00
{
2007-11-27 04:24:56 +03:00
const char * p ;
if ( ! ( p = strrchr ( path , ' \\ ' ) ) ) {
2005-06-30 23:43:53 +04:00
p = path ;
2007-11-27 04:24:56 +03:00
} else {
2005-06-30 23:43:53 +04:00
p + + ;
2007-11-27 04:24:56 +03:00
}
2005-06-30 23:43:53 +04:00
return p ;
}
2005-07-01 23:15:07 +04:00
/*********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * " HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/FORMS "
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2005-06-30 23:43:53 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-24 17:19:18 +03:00
static int key_forms_fetch_keys ( const char * key , struct regsubkey_ctr * subkeys )
2005-06-30 23:43:53 +04:00
{
2007-11-27 04:24:56 +03:00
char * p = reg_remaining_path ( talloc_tos ( ) , key + strlen ( KEY_FORMS ) ) ;
2005-06-30 23:43:53 +04:00
/* no keys below Forms */
2007-11-27 04:24:56 +03:00
if ( p ) {
2005-06-30 23:43:53 +04:00
return - 1 ;
2007-11-27 04:24:56 +03:00
}
2005-06-30 23:43:53 +04:00
return 0 ;
}
2005-07-01 23:15:07 +04:00
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-23 20:14:17 +03:00
static int key_forms_fetch_values ( const char * key , struct regval_ctr * values )
2005-06-30 23:43:53 +04:00
{
uint32 data [ 8 ] ;
int i , num_values , form_index = 1 ;
nt_forms_struct * forms_list = NULL ;
nt_forms_struct * form ;
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
DEBUG ( 10 , ( " print_values_forms: key=>[%s] \n " , key ? key : " NULL " ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
num_values = get_ntforms ( & forms_list ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
DEBUG ( 10 , ( " hive_forms_fetch_values: [%d] user defined forms returned \n " ,
num_values ) ) ;
/* handle user defined forms */
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
for ( i = 0 ; i < num_values ; i + + ) {
form = & forms_list [ i ] ;
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
data [ 0 ] = form - > width ;
data [ 1 ] = form - > length ;
data [ 2 ] = form - > left ;
data [ 3 ] = form - > top ;
data [ 4 ] = form - > right ;
data [ 5 ] = form - > bottom ;
data [ 6 ] = form_index + + ;
data [ 7 ] = form - > flag ;
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
regval_ctr_addvalue ( values , form - > name , REG_BINARY , ( char * ) data , sizeof ( data ) ) ;
}
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
SAFE_FREE ( forms_list ) ;
forms_list = NULL ;
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
/* handle built-on forms */
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
num_values = get_builtin_ntforms ( & forms_list ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
DEBUG ( 10 , ( " print_subpath_values_forms: [%d] built-in forms returned \n " ,
num_values ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
for ( i = 0 ; i < num_values ; i + + ) {
form = & forms_list [ i ] ;
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
data [ 0 ] = form - > width ;
data [ 1 ] = form - > length ;
data [ 2 ] = form - > left ;
data [ 3 ] = form - > top ;
data [ 4 ] = form - > right ;
data [ 5 ] = form - > bottom ;
data [ 6 ] = form_index + + ;
data [ 7 ] = form - > flag ;
2007-11-27 04:24:56 +03:00
regval_ctr_addvalue ( values , form - > name , REG_BINARY , ( char * ) data , sizeof ( data ) ) ;
2005-06-30 23:43:53 +04:00
}
2007-11-27 04:24:56 +03:00
SAFE_FREE ( forms_list ) ;
return regval_ctr_numvals ( values ) ;
2005-06-30 23:43:53 +04:00
}
2005-07-01 23:15:07 +04:00
/*********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * " HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/PRINTERS "
* * " HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT/PRINTERS "
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2005-06-30 23:43:53 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-07-02 02:24:00 +04:00
/*********************************************************************
2007-11-27 04:24:56 +03:00
strip off prefix for printers key . DOes return a pointer to static
2005-07-02 02:24:00 +04:00
memory .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-27 04:24:56 +03:00
static char * strip_printers_prefix ( const char * key )
2005-07-02 02:24:00 +04:00
{
2007-11-27 04:24:56 +03:00
char * subkeypath = NULL ;
char * path = NULL ;
TALLOC_CTX * ctx = talloc_tos ( ) ;
path = talloc_strdup ( ctx , key ) ;
if ( ! path ) {
return NULL ;
}
path = normalize_reg_path ( ctx , path ) ;
if ( ! path ) {
return NULL ;
}
2005-07-02 02:24:00 +04:00
/* normalizing the path does not change length, just key delimiters and case */
2007-11-27 04:24:56 +03:00
if ( strncmp ( path , KEY_WINNT_PRINTERS , strlen ( KEY_WINNT_PRINTERS ) ) = = 0 ) {
subkeypath = reg_remaining_path ( ctx , key + strlen ( KEY_WINNT_PRINTERS ) ) ;
} else {
subkeypath = reg_remaining_path ( ctx , key + strlen ( KEY_CONTROL_PRINTERS ) ) ;
}
TALLOC_FREE ( path ) ;
2005-07-02 02:24:00 +04:00
return subkeypath ;
}
/*********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-27 04:24:56 +03:00
2009-02-24 17:19:18 +03:00
static int key_printers_fetch_keys ( const char * key , struct regsubkey_ctr * subkeys )
2002-07-19 22:49:44 +04:00
{
2007-11-27 04:24:56 +03:00
int n_services = lp_numservices ( ) ;
2005-06-30 21:46:06 +04:00
int snum ;
fstring sname ;
int i ;
int num_subkeys = 0 ;
2005-07-02 02:24:00 +04:00
char * printers_key ;
2005-07-02 05:23:21 +04:00
char * printername , * printerdatakey ;
2005-06-30 21:46:06 +04:00
NT_PRINTER_INFO_LEVEL * printer = NULL ;
fstring * subkey_names = NULL ;
2007-11-27 04:24:56 +03:00
2005-07-02 05:23:21 +04:00
DEBUG ( 10 , ( " key_printers_fetch_keys: key=>[%s] \n " , key ? key : " NULL " ) ) ;
2007-11-27 04:24:56 +03:00
printers_key = strip_printers_prefix ( key ) ;
2005-07-02 02:24:00 +04:00
if ( ! printers_key ) {
2005-06-30 21:46:06 +04:00
/* enumerate all printers */
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
for ( snum = 0 ; snum < n_services ; snum + + ) {
if ( ! ( lp_snum_ok ( snum ) & & lp_print_ok ( snum ) ) )
continue ;
2002-07-24 10:42:09 +04:00
2005-06-30 21:46:06 +04:00
/* don't report the [printers] share */
if ( strequal ( lp_servicename ( snum ) , PRINTERS_NAME ) )
continue ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
fstrcpy ( sname , lp_servicename ( snum ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
regsubkey_ctr_addkey ( subkeys , sname ) ;
2005-05-23 20:25:31 +04:00
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
num_subkeys = regsubkey_ctr_numkeys ( subkeys ) ;
goto done ;
2002-07-24 10:42:09 +04:00
}
2005-05-23 20:25:31 +04:00
2005-06-30 21:46:06 +04:00
/* get information for a specific printer */
2007-11-27 04:24:56 +03:00
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( printers_key , & printername , & printerdatakey ) ) {
return - 1 ;
}
2005-05-23 20:25:31 +04:00
2005-11-22 18:52:22 +03:00
/* validate the printer name */
for ( snum = 0 ; snum < n_services ; snum + + ) {
if ( ! lp_snum_ok ( snum ) | | ! lp_print_ok ( snum ) )
continue ;
if ( strequal ( lp_servicename ( snum ) , printername ) )
break ;
}
if ( snum > = n_services
2005-07-11 23:18:15 +04:00
| | ! W_ERROR_IS_OK ( get_a_printer ( NULL , & printer , 2 , printername ) ) )
2005-07-11 22:27:22 +04:00
{
return - 1 ;
}
2005-06-30 21:46:06 +04:00
2005-08-29 18:55:40 +04:00
num_subkeys = get_printer_subkeys ( printer - > info_2 - > data , printerdatakey ? printerdatakey : " " , & subkey_names ) ;
2005-05-23 20:25:31 +04:00
2005-06-30 21:46:06 +04:00
for ( i = 0 ; i < num_subkeys ; i + + )
regsubkey_ctr_addkey ( subkeys , subkey_names [ i ] ) ;
2005-05-23 20:25:31 +04:00
2005-06-30 21:46:06 +04:00
free_a_printer ( & printer , 2 ) ;
/* no other subkeys below here */
2002-07-24 10:42:09 +04:00
2005-06-30 21:46:06 +04:00
done :
SAFE_FREE ( subkey_names ) ;
2002-07-24 10:42:09 +04:00
2005-06-30 21:46:06 +04:00
return num_subkeys ;
2002-07-24 10:42:09 +04:00
}
2005-07-01 23:15:07 +04:00
/**********************************************************************
2005-07-11 22:27:22 +04:00
Take a list of names and call add_printer_hook ( ) if necessary
Note that we do this a little differently from Windows since the
keyname is the sharename and not the printer name .
2005-07-01 23:15:07 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-24 17:19:18 +03:00
static bool add_printers_by_registry ( struct regsubkey_ctr * subkeys )
2005-07-02 05:23:21 +04:00
{
2005-07-11 22:27:22 +04:00
int i , num_keys , snum ;
char * printername ;
NT_PRINTER_INFO_LEVEL_2 info2 ;
NT_PRINTER_INFO_LEVEL printer ;
ZERO_STRUCT ( info2 ) ;
printer . info_2 = & info2 ;
num_keys = regsubkey_ctr_numkeys ( subkeys ) ;
become_root ( ) ;
for ( i = 0 ; i < num_keys ; i + + ) {
printername = regsubkey_ctr_specific_key ( subkeys , i ) ;
snum = find_service ( printername ) ;
/* just verify a valied snum for now */
if ( snum = = - 1 ) {
fstrcpy ( info2 . printername , printername ) ;
2005-07-11 22:37:15 +04:00
fstrcpy ( info2 . sharename , printername ) ;
2007-11-28 06:05:08 +03:00
if ( ! add_printer_hook ( talloc_tos ( ) , NULL , & printer ) ) {
2005-07-11 22:27:22 +04:00
DEBUG ( 0 , ( " add_printers_by_registry: Failed to add printer [%s] \n " ,
printername ) ) ;
}
}
}
unbecome_root ( ) ;
return True ;
2005-07-02 05:23:21 +04:00
}
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-24 17:19:18 +03:00
static bool key_printers_store_keys ( const char * key , struct regsubkey_ctr * subkeys )
2005-06-30 23:43:53 +04:00
{
2005-07-02 02:24:00 +04:00
char * printers_key ;
2005-07-02 05:23:21 +04:00
char * printername , * printerdatakey ;
NT_PRINTER_INFO_LEVEL * printer = NULL ;
2005-07-03 06:05:01 +04:00
int i , num_subkeys , num_existing_keys ;
2005-07-02 05:23:21 +04:00
char * subkeyname ;
2005-07-03 06:05:01 +04:00
fstring * existing_subkeys = NULL ;
2005-07-02 02:24:00 +04:00
printers_key = strip_printers_prefix ( key ) ;
if ( ! printers_key ) {
/* have to deal with some new or deleted printer */
2005-07-02 05:23:21 +04:00
return add_printers_by_registry ( subkeys ) ;
}
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( printers_key , & printername , & printerdatakey ) ) {
return False ;
}
2005-07-02 05:23:21 +04:00
/* lookup the printer */
if ( ! W_ERROR_IS_OK ( get_a_printer ( NULL , & printer , 2 , printername ) ) ) {
DEBUG ( 0 , ( " key_printers_store_keys: Tried to store subkey for bad printername %s \n " ,
printername ) ) ;
2005-07-02 02:24:00 +04:00
return False ;
}
2005-07-03 06:05:01 +04:00
/* get the top level printer keys */
2005-08-29 18:55:40 +04:00
num_existing_keys = get_printer_subkeys ( printer - > info_2 - > data , " " , & existing_subkeys ) ;
2005-07-03 06:05:01 +04:00
for ( i = 0 ; i < num_existing_keys ; i + + ) {
/* remove the key if it has been deleted */
if ( ! regsubkey_ctr_key_exists ( subkeys , existing_subkeys [ i ] ) ) {
DEBUG ( 5 , ( " key_printers_store_keys: deleting key %s \n " ,
existing_subkeys [ i ] ) ) ;
2005-08-29 18:55:40 +04:00
delete_printer_key ( printer - > info_2 - > data , existing_subkeys [ i ] ) ;
2005-07-03 06:05:01 +04:00
}
}
2005-07-02 02:24:00 +04:00
2005-07-02 05:23:21 +04:00
num_subkeys = regsubkey_ctr_numkeys ( subkeys ) ;
for ( i = 0 ; i < num_subkeys ; i + + ) {
subkeyname = regsubkey_ctr_specific_key ( subkeys , i ) ;
/* add any missing printer keys */
2005-08-29 18:55:40 +04:00
if ( lookup_printerkey ( printer - > info_2 - > data , subkeyname ) = = - 1 ) {
2005-07-03 06:05:01 +04:00
DEBUG ( 5 , ( " key_printers_store_keys: adding key %s \n " ,
existing_subkeys [ i ] ) ) ;
2006-06-20 23:06:57 +04:00
if ( add_new_printer_key ( printer - > info_2 - > data , subkeyname ) = = - 1 ) {
SAFE_FREE ( existing_subkeys ) ;
2005-07-02 05:23:21 +04:00
return False ;
2006-06-20 23:06:57 +04:00
}
2005-07-02 05:23:21 +04:00
}
}
/* write back to disk */
mod_a_printer ( printer , 2 ) ;
/* cleanup */
2008-03-23 19:58:26 +03:00
free_a_printer ( & printer , 2 ) ;
2005-07-02 05:23:21 +04:00
2006-06-20 23:06:57 +04:00
SAFE_FREE ( existing_subkeys ) ;
2005-07-02 05:23:21 +04:00
return True ;
2005-06-30 23:43:53 +04:00
}
2005-07-01 23:15:07 +04:00
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-23 20:14:17 +03:00
static void fill_in_printer_values ( NT_PRINTER_INFO_LEVEL_2 * info2 , struct regval_ctr * values )
2002-07-24 10:42:09 +04:00
{
2009-03-17 17:22:22 +03:00
struct spoolss_DeviceMode * devmode ;
2005-05-23 20:25:31 +04:00
UNISTR2 data ;
2005-07-01 23:15:07 +04:00
char * p ;
uint32 printer_status = PRINTER_STATUS_OK ;
2002-07-24 10:42:09 +04:00
2005-07-01 23:15:07 +04:00
regval_ctr_addvalue ( values , " Attributes " , REG_DWORD , ( char * ) & info2 - > attributes , sizeof ( info2 - > attributes ) ) ;
regval_ctr_addvalue ( values , " Priority " , REG_DWORD , ( char * ) & info2 - > priority , sizeof ( info2 - > attributes ) ) ;
regval_ctr_addvalue ( values , " ChangeID " , REG_DWORD , ( char * ) & info2 - > changeid , sizeof ( info2 - > changeid ) ) ;
regval_ctr_addvalue ( values , " Default Priority " , REG_DWORD , ( char * ) & info2 - > default_priority , sizeof ( info2 - > default_priority ) ) ;
2002-07-24 10:42:09 +04:00
2005-07-01 23:15:07 +04:00
/* lie and say everything is ok since we don't want to call print_queue_length() to get the real status */
regval_ctr_addvalue ( values , " Status " , REG_DWORD , ( char * ) & printer_status , sizeof ( info2 - > status ) ) ;
2005-06-22 22:03:38 +04:00
2005-07-01 23:15:07 +04:00
regval_ctr_addvalue ( values , " StartTime " , REG_DWORD , ( char * ) & info2 - > starttime , sizeof ( info2 - > starttime ) ) ;
regval_ctr_addvalue ( values , " UntilTime " , REG_DWORD , ( char * ) & info2 - > untiltime , sizeof ( info2 - > untiltime ) ) ;
2002-09-25 19:19:00 +04:00
2005-07-01 23:15:07 +04:00
/* strip the \\server\ from this string */
if ( ! ( p = strrchr ( info2 - > printername , ' \\ ' ) ) )
p = info2 - > printername ;
else
p + + ;
init_unistr2 ( & data , p , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Name " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
init_unistr2 ( & data , info2 - > location , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Location " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
init_unistr2 ( & data , info2 - > comment , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Description " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
init_unistr2 ( & data , info2 - > parameters , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Parameters " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
init_unistr2 ( & data , info2 - > portname , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Port " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
init_unistr2 ( & data , info2 - > sharename , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Share Name " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
init_unistr2 ( & data , info2 - > drivername , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Printer Driver " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
init_unistr2 ( & data , info2 - > sepfile , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Separator File " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
init_unistr2 ( & data , " WinPrint " , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Print Processor " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
init_unistr2 ( & data , " RAW " , UNI_STR_TERMINATE ) ;
regval_ctr_addvalue ( values , " Datatype " , REG_SZ , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2005-05-23 20:25:31 +04:00
2005-07-01 23:15:07 +04:00
/* stream the device mode */
2009-03-17 17:22:22 +03:00
2009-03-17 17:23:30 +03:00
devmode = construct_dev_mode ( values , info2 - > sharename ) ;
2009-03-17 17:22:22 +03:00
if ( devmode ) {
DATA_BLOB blob ;
enum ndr_err_code ndr_err ;
ndr_err = ndr_push_struct_blob ( & blob , values , NULL , devmode ,
( ndr_push_flags_fn_t ) ndr_push_spoolss_DeviceMode ) ;
if ( NDR_ERR_CODE_IS_SUCCESS ( ndr_err ) ) {
regval_ctr_addvalue ( values , " Default Devmode " , REG_BINARY ,
( const char * ) blob . data , blob . length ) ;
2002-07-24 12:58:03 +04:00
}
2005-07-01 23:15:07 +04:00
}
2009-03-17 17:22:22 +03:00
2005-07-01 23:15:07 +04:00
/* stream the printer security descriptor */
2009-03-17 17:21:06 +03:00
if ( info2 - > secdesc_buf & &
info2 - > secdesc_buf - > sd & &
info2 - > secdesc_buf - > sd_size )
2007-06-13 15:04:31 +04:00
{
2009-03-17 17:21:06 +03:00
NTSTATUS status ;
DATA_BLOB blob ;
status = marshall_sec_desc ( values , info2 - > secdesc_buf - > sd ,
& blob . data , & blob . length ) ;
if ( NT_STATUS_IS_OK ( status ) ) {
regval_ctr_addvalue ( values , " Security " , REG_BINARY ,
( const char * ) blob . data , blob . length ) ;
2002-07-24 12:58:03 +04:00
}
2005-07-01 23:15:07 +04:00
}
2002-07-24 12:58:03 +04:00
2009-03-17 17:22:22 +03:00
return ;
2005-07-01 23:15:07 +04:00
}
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-23 20:14:17 +03:00
static int key_printers_fetch_values ( const char * key , struct regval_ctr * values )
2005-07-01 23:15:07 +04:00
{
int num_values ;
2005-07-02 02:24:00 +04:00
char * printers_key ;
2005-07-01 23:15:07 +04:00
char * printername , * printerdatakey ;
NT_PRINTER_INFO_LEVEL * printer = NULL ;
NT_PRINTER_DATA * p_data ;
int i , key_index ;
2005-07-02 02:24:00 +04:00
printers_key = strip_printers_prefix ( key ) ;
2005-07-01 23:15:07 +04:00
2005-07-02 02:24:00 +04:00
/* top level key values stored in the registry has no values */
2005-07-01 23:15:07 +04:00
2005-07-02 02:24:00 +04:00
if ( ! printers_key ) {
2006-12-16 12:36:10 +03:00
/* normalize to the 'HKLM\SOFTWARE\...\Print\Printers' key */
2005-07-02 02:24:00 +04:00
return regdb_fetch_values ( KEY_WINNT_PRINTERS , values ) ;
}
2005-07-01 23:15:07 +04:00
/* lookup the printer object */
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( printers_key , & printername , & printerdatakey ) ) {
return - 1 ;
}
2005-07-01 23:15:07 +04:00
if ( ! W_ERROR_IS_OK ( get_a_printer ( NULL , & printer , 2 , printername ) ) )
2002-07-24 12:58:03 +04:00
goto done ;
2005-07-01 23:15:07 +04:00
if ( ! printerdatakey ) {
fill_in_printer_values ( printer - > info_2 , values ) ;
goto done ;
2002-07-20 08:27:30 +04:00
}
2002-07-24 12:58:03 +04:00
2005-07-02 02:24:00 +04:00
/* iterate over all printer data keys and fill the regval container */
2002-07-24 12:58:03 +04:00
2005-08-29 18:55:40 +04:00
p_data = printer - > info_2 - > data ;
2005-07-01 23:15:07 +04:00
if ( ( key_index = lookup_printerkey ( p_data , printerdatakey ) ) = = - 1 ) {
2005-07-02 02:24:00 +04:00
/* failure....should never happen if the client has a valid open handle first */
2005-07-02 05:23:21 +04:00
DEBUG ( 10 , ( " key_printers_fetch_values: Unknown keyname [%s] \n " , printerdatakey ) ) ;
2008-03-23 19:57:01 +03:00
free_a_printer ( & printer , 2 ) ;
2005-07-02 02:24:00 +04:00
return - 1 ;
2002-07-20 08:27:30 +04:00
}
2002-07-24 12:58:03 +04:00
2005-08-29 18:55:40 +04:00
num_values = regval_ctr_numvals ( p_data - > keys [ key_index ] . values ) ;
2002-09-25 19:19:00 +04:00
for ( i = 0 ; i < num_values ; i + + )
2005-08-29 18:55:40 +04:00
regval_ctr_copyvalue ( values , regval_ctr_specific_value ( p_data - > keys [ key_index ] . values , i ) ) ;
2002-09-25 19:19:00 +04:00
2002-07-24 12:58:03 +04:00
done :
2002-09-25 19:19:00 +04:00
if ( printer )
free_a_printer ( & printer , 2 ) ;
2005-07-01 23:15:07 +04:00
return regval_ctr_numvals ( values ) ;
2002-07-19 22:49:44 +04:00
}
2005-07-11 20:55:10 +04:00
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# define REG_IDX_ATTRIBUTES 1
# define REG_IDX_PRIORITY 2
# define REG_IDX_DEFAULT_PRIORITY 3
# define REG_IDX_CHANGEID 4
# define REG_IDX_STATUS 5
# define REG_IDX_STARTTIME 6
# define REG_IDX_NAME 7
# define REG_IDX_LOCATION 8
# define REG_IDX_DESCRIPTION 9
# define REG_IDX_PARAMETERS 10
# define REG_IDX_PORT 12
# define REG_IDX_SHARENAME 13
# define REG_IDX_DRIVER 14
# define REG_IDX_SEP_FILE 15
# define REG_IDX_PRINTPROC 16
# define REG_IDX_DATATYPE 17
# define REG_IDX_DEVMODE 18
# define REG_IDX_SECDESC 19
# define REG_IDX_UNTILTIME 20
struct {
const char * name ;
int index ;
} printer_values_map [ ] = {
{ " Attributes " , REG_IDX_ATTRIBUTES } ,
{ " Priority " , REG_IDX_PRIORITY } ,
{ " Default Priority " , REG_IDX_DEFAULT_PRIORITY } ,
{ " ChangeID " , REG_IDX_CHANGEID } ,
{ " Status " , REG_IDX_STATUS } ,
{ " StartTime " , REG_IDX_STARTTIME } ,
{ " UntilTime " , REG_IDX_UNTILTIME } ,
{ " Name " , REG_IDX_NAME } ,
{ " Location " , REG_IDX_LOCATION } ,
2007-02-07 23:20:56 +03:00
{ " Description " , REG_IDX_DESCRIPTION } ,
2005-07-11 20:55:10 +04:00
{ " Parameters " , REG_IDX_PARAMETERS } ,
{ " Port " , REG_IDX_PORT } ,
{ " Share Name " , REG_IDX_SHARENAME } ,
{ " Printer Driver " , REG_IDX_DRIVER } ,
{ " Separator File " , REG_IDX_SEP_FILE } ,
{ " Print Processor " , REG_IDX_PRINTPROC } ,
{ " Datatype " , REG_IDX_DATATYPE } ,
{ " Default Devmode " , REG_IDX_DEVMODE } ,
{ " Security " , REG_IDX_SECDESC } ,
{ NULL , - 1 }
} ;
static int find_valuename_index ( const char * valuename )
{
int i ;
for ( i = 0 ; printer_values_map [ i ] . name ; i + + ) {
if ( strequal ( valuename , printer_values_map [ i ] . name ) )
return printer_values_map [ i ] . index ;
}
return - 1 ;
}
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-23 20:14:17 +03:00
static void convert_values_to_printer_info_2 ( NT_PRINTER_INFO_LEVEL_2 * printer2 , struct regval_ctr * values )
2005-07-11 20:55:10 +04:00
{
int num_values = regval_ctr_numvals ( values ) ;
uint32 value_index ;
2009-03-24 00:27:59 +03:00
struct regval_blob * val ;
2005-07-11 20:55:10 +04:00
int i ;
for ( i = 0 ; i < num_values ; i + + ) {
2005-07-11 21:17:50 +04:00
val = regval_ctr_specific_value ( values , i ) ;
value_index = find_valuename_index ( regval_name ( val ) ) ;
2005-07-11 20:55:10 +04:00
switch ( value_index ) {
case REG_IDX_ATTRIBUTES :
2005-07-11 21:17:50 +04:00
printer2 - > attributes = ( uint32 ) ( * regval_data_p ( val ) ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_PRIORITY :
2005-07-11 21:17:50 +04:00
printer2 - > priority = ( uint32 ) ( * regval_data_p ( val ) ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_DEFAULT_PRIORITY :
2005-07-11 21:17:50 +04:00
printer2 - > default_priority = ( uint32 ) ( * regval_data_p ( val ) ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_CHANGEID :
2005-07-11 21:17:50 +04:00
printer2 - > changeid = ( uint32 ) ( * regval_data_p ( val ) ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_STARTTIME :
2005-07-11 21:17:50 +04:00
printer2 - > starttime = ( uint32 ) ( * regval_data_p ( val ) ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_UNTILTIME :
2005-07-11 21:17:50 +04:00
printer2 - > untiltime = ( uint32 ) ( * regval_data_p ( val ) ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_NAME :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > printername , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_LOCATION :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > location , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_DESCRIPTION :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > comment , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_PARAMETERS :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > parameters , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_PORT :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > portname , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_SHARENAME :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > sharename , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_DRIVER :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > drivername , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_SEP_FILE :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > sepfile , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_PRINTPROC :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > printprocessor , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_DATATYPE :
2005-07-11 21:17:50 +04:00
rpcstr_pull ( printer2 - > datatype , regval_data_p ( val ) , sizeof ( fstring ) , regval_size ( val ) , 0 ) ;
2005-07-11 20:55:10 +04:00
break ;
case REG_IDX_DEVMODE :
break ;
case REG_IDX_SECDESC :
break ;
default :
2005-07-11 21:17:50 +04:00
/* unsupported value...throw away */
DEBUG ( 8 , ( " convert_values_to_printer_info_2: Unsupported registry value [%s] \n " ,
regval_name ( val ) ) ) ;
2005-07-11 20:55:10 +04:00
}
}
return ;
}
2005-07-01 23:15:07 +04:00
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-23 20:14:17 +03:00
static bool key_printers_store_values ( const char * key , struct regval_ctr * values )
2005-06-30 21:46:06 +04:00
{
2005-07-02 02:24:00 +04:00
char * printers_key ;
2005-07-11 20:55:10 +04:00
char * printername , * keyname ;
NT_PRINTER_INFO_LEVEL * printer = NULL ;
WERROR result ;
2005-07-02 02:24:00 +04:00
printers_key = strip_printers_prefix ( key ) ;
/* values in the top level key get stored in the registry */
if ( ! printers_key ) {
2005-07-11 20:55:10 +04:00
/* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
2005-07-02 02:24:00 +04:00
return regdb_store_values ( KEY_WINNT_PRINTERS , values ) ;
}
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( printers_key , & printername , & keyname ) ) {
return False ;
}
2005-07-11 20:55:10 +04:00
if ( ! W_ERROR_IS_OK ( get_a_printer ( NULL , & printer , 2 , printername ) ) )
return False ;
/* deal with setting values directly under the printername */
if ( ! keyname ) {
convert_values_to_printer_info_2 ( printer - > info_2 , values ) ;
}
else {
int num_values = regval_ctr_numvals ( values ) ;
int i ;
2009-03-24 00:27:59 +03:00
struct regval_blob * val ;
2005-07-11 20:55:10 +04:00
2005-08-29 18:55:40 +04:00
delete_printer_key ( printer - > info_2 - > data , keyname ) ;
2005-07-11 20:55:10 +04:00
/* deal with any subkeys */
for ( i = 0 ; i < num_values ; i + + ) {
val = regval_ctr_specific_value ( values , i ) ;
result = set_printer_dataex ( printer , keyname ,
regval_name ( val ) ,
regval_type ( val ) ,
regval_data_p ( val ) ,
regval_size ( val ) ) ;
if ( ! W_ERROR_IS_OK ( result ) ) {
DEBUG ( 0 , ( " key_printers_store_values: failed to set printer data [%s]! \n " ,
keyname ) ) ;
free_a_printer ( & printer , 2 ) ;
return False ;
}
}
}
result = mod_a_printer ( printer , 2 ) ;
free_a_printer ( & printer , 2 ) ;
return W_ERROR_IS_OK ( result ) ;
2005-06-30 21:46:06 +04:00
}
2005-07-01 23:15:07 +04:00
/*********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * " HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/ENVIRONMENTS "
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2005-06-30 21:46:06 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-24 17:19:18 +03:00
static int key_driver_fetch_keys ( const char * key , struct regsubkey_ctr * subkeys )
2005-06-30 21:46:06 +04:00
{
const char * environments [ ] = {
" Windows 4.0 " ,
" Windows NT x86 " ,
" Windows NT R4000 " ,
" Windows NT Alpha_AXP " ,
" Windows NT PowerPC " ,
" Windows IA64 " ,
" Windows x64 " ,
NULL } ;
fstring * drivers = NULL ;
int i , env_index , num_drivers ;
char * keystr , * base , * subkeypath ;
2007-11-27 04:24:56 +03:00
char * key2 = NULL ;
2005-06-30 21:46:06 +04:00
int num_subkeys = - 1 ;
int version ;
2007-11-27 04:24:56 +03:00
TALLOC_CTX * ctx = talloc_tos ( ) ;
2005-06-30 21:46:06 +04:00
2005-06-30 23:43:53 +04:00
DEBUG ( 10 , ( " key_driver_fetch_keys key=>[%s] \n " , key ? key : " NULL " ) ) ;
2007-11-27 04:24:56 +03:00
keystr = reg_remaining_path ( ctx , key + strlen ( KEY_ENVIRONMENTS ) ) ;
2005-06-30 21:46:06 +04:00
/* list all possible architectures */
2007-11-27 04:24:56 +03:00
2005-06-30 23:43:53 +04:00
if ( ! keystr ) {
2007-11-27 04:24:56 +03:00
for ( num_subkeys = 0 ; environments [ num_subkeys ] ; num_subkeys + + )
2005-06-30 21:46:06 +04:00
regsubkey_ctr_addkey ( subkeys , environments [ num_subkeys ] ) ;
return num_subkeys ;
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
/* we are dealing with a subkey of "Environments */
2007-11-27 04:24:56 +03:00
key2 = talloc_strdup ( ctx , keystr ) ;
if ( ! key2 ) {
return - 1 ;
}
2005-06-30 21:46:06 +04:00
keystr = key2 ;
2007-11-27 04:24:56 +03:00
if ( ! reg_split_path ( keystr , & base , & subkeypath ) ) {
2006-06-28 06:22:28 +04:00
return - 1 ;
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
/* sanity check */
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
for ( env_index = 0 ; environments [ env_index ] ; env_index + + ) {
if ( strequal ( environments [ env_index ] , base ) )
break ;
}
if ( ! environments [ env_index ] )
return - 1 ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
/* ...\Print\Environements\...\ */
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
if ( ! subkeypath ) {
regsubkey_ctr_addkey ( subkeys , " Drivers " ) ;
regsubkey_ctr_addkey ( subkeys , " Print Processors " ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
return 2 ;
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
/* more of the key path to process */
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
keystr = subkeypath ;
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( keystr , & base , & subkeypath ) ) {
return - 1 ;
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
/* ...\Print\Environements\...\Drivers\ */
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
if ( ! subkeypath ) {
2005-07-01 23:15:07 +04:00
if ( strequal ( base , " Drivers " ) ) {
2005-06-30 21:46:06 +04:00
switch ( env_index ) {
case 0 : /* Win9x */
regsubkey_ctr_addkey ( subkeys , " Version-0 " ) ;
break ;
default : /* Windows NT based systems */
regsubkey_ctr_addkey ( subkeys , " Version-2 " ) ;
regsubkey_ctr_addkey ( subkeys , " Version-3 " ) ;
2007-11-27 04:24:56 +03:00
break ;
2005-06-30 21:46:06 +04:00
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
return regsubkey_ctr_numkeys ( subkeys ) ;
2005-07-01 23:15:07 +04:00
} else if ( strequal ( base , " Print Processors " ) ) {
2005-06-30 21:46:06 +04:00
if ( env_index = = 1 | | env_index = = 5 | | env_index = = 6 )
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
return regsubkey_ctr_numkeys ( subkeys ) ;
2005-07-01 23:15:07 +04:00
} else
return - 1 ; /* bad path */
2005-06-30 21:46:06 +04:00
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
/* we finally get to enumerate the drivers */
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
/* only one possible subkey below PrintProc key */
if ( strequal ( base , " Print Processors " ) ) {
keystr = subkeypath ;
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( keystr , & base , & subkeypath ) ) {
return - 1 ;
}
2005-07-01 23:15:07 +04:00
/* no subkeys below this point */
2005-06-30 21:46:06 +04:00
2005-07-01 23:15:07 +04:00
if ( subkeypath )
2005-06-30 21:46:06 +04:00
return - 1 ;
2005-07-01 23:15:07 +04:00
/* only allow one keyname here -- 'winprint' */
return strequal ( base , " winprint " ) ? 0 : - 1 ;
2005-06-30 21:46:06 +04:00
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
/* only dealing with drivers from here on out */
2005-07-01 23:15:07 +04:00
keystr = subkeypath ;
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( keystr , & base , & subkeypath ) ) {
return - 1 ;
}
2005-06-30 21:46:06 +04:00
version = atoi ( & base [ strlen ( base ) - 1 ] ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
switch ( env_index ) {
case 0 :
if ( version ! = 0 )
return - 1 ;
break ;
default :
if ( version ! = 2 & & version ! = 3 )
return - 1 ;
break ;
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
if ( ! subkeypath ) {
num_drivers = get_ntdrivers ( & drivers , environments [ env_index ] , version ) ;
for ( i = 0 ; i < num_drivers ; i + + )
regsubkey_ctr_addkey ( subkeys , drivers [ i ] ) ;
2007-11-27 04:24:56 +03:00
return regsubkey_ctr_numkeys ( subkeys ) ;
}
2005-06-30 21:46:06 +04:00
/* if anything else left, just say if has no subkeys */
2007-11-27 04:24:56 +03:00
DEBUG ( 1 , ( " key_driver_fetch_keys unhandled key [%s] (subkey == %s \n " ,
2005-06-30 21:46:06 +04:00
key , subkeypath ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
return 0 ;
}
2005-06-30 06:59:29 +04:00
2005-07-01 23:15:07 +04:00
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-06-30 06:59:29 +04:00
2009-03-23 20:14:17 +03:00
static void fill_in_driver_values ( NT_PRINTER_DRIVER_INFO_LEVEL_3 * info3 , struct regval_ctr * values )
2005-07-01 23:15:07 +04:00
{
char * buffer = NULL ;
int buffer_size = 0 ;
int i , length ;
2007-11-27 04:24:56 +03:00
const char * filename ;
2005-07-01 23:15:07 +04:00
UNISTR2 data ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
filename = dos_basename ( info3 - > driverpath ) ;
init_unistr2 ( & data , filename , UNI_STR_TERMINATE ) ;
2007-11-27 04:24:56 +03:00
regval_ctr_addvalue ( values , " Driver " , REG_SZ , ( char * ) data . buffer ,
2005-07-01 23:15:07 +04:00
data . uni_str_len * sizeof ( uint16 ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
filename = dos_basename ( info3 - > configfile ) ;
init_unistr2 ( & data , filename , UNI_STR_TERMINATE ) ;
2005-07-01 23:15:07 +04:00
regval_ctr_addvalue ( values , " Configuration File " , REG_SZ , ( char * ) data . buffer ,
data . uni_str_len * sizeof ( uint16 ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
filename = dos_basename ( info3 - > datafile ) ;
init_unistr2 ( & data , filename , UNI_STR_TERMINATE ) ;
2007-11-27 04:24:56 +03:00
regval_ctr_addvalue ( values , " Data File " , REG_SZ , ( char * ) data . buffer ,
2005-07-01 23:15:07 +04:00
data . uni_str_len * sizeof ( uint16 ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
filename = dos_basename ( info3 - > helpfile ) ;
init_unistr2 ( & data , filename , UNI_STR_TERMINATE ) ;
2007-11-27 04:24:56 +03:00
regval_ctr_addvalue ( values , " Help File " , REG_SZ , ( char * ) data . buffer ,
2005-07-01 23:15:07 +04:00
data . uni_str_len * sizeof ( uint16 ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
init_unistr2 ( & data , info3 - > defaultdatatype , UNI_STR_TERMINATE ) ;
2007-11-27 04:24:56 +03:00
regval_ctr_addvalue ( values , " Data Type " , REG_SZ , ( char * ) data . buffer ,
2005-07-01 23:15:07 +04:00
data . uni_str_len * sizeof ( uint16 ) ) ;
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
regval_ctr_addvalue ( values , " Version " , REG_DWORD , ( char * ) & info3 - > cversion ,
sizeof ( info3 - > cversion ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
if ( info3 - > dependentfiles ) {
2007-11-27 04:24:56 +03:00
/* place the list of dependent files in a single
2005-06-30 21:46:06 +04:00
character buffer , separating each file name by
a NULL */
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
for ( i = 0 ; strcmp ( info3 - > dependentfiles [ i ] , " " ) ; i + + ) {
/* strip the path to only the file's base name */
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
filename = dos_basename ( info3 - > dependentfiles [ i ] ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
length = strlen ( filename ) ;
2007-11-27 04:24:56 +03:00
2006-07-31 07:53:39 +04:00
buffer = ( char * ) SMB_REALLOC ( buffer , buffer_size + ( length + 1 ) * sizeof ( uint16 ) ) ;
r13915: Fixed a very interesting class of realloc() bugs found by Coverity.
realloc can return NULL in one of two cases - (1) the realloc failed,
(2) realloc succeeded but the new size requested was zero, in which
case this is identical to a free() call.
The error paths dealing with these two cases should be different,
but mostly weren't. Secondly the standard idiom for dealing with
realloc when you know the new size is non-zero is the following :
tmp = realloc(p, size);
if (!tmp) {
SAFE_FREE(p);
return error;
} else {
p = tmp;
}
However, there were *many* *many* places in Samba where we were
using the old (broken) idiom of :
p = realloc(p, size)
if (!p) {
return error;
}
which will leak the memory pointed to by p on realloc fail.
This commit (hopefully) fixes all these cases by moving to
a standard idiom of :
p = SMB_REALLOC(p, size)
if (!p) {
return error;
}
Where if the realloc returns null due to the realloc failing
or size == 0 we *guarentee* that the storage pointed to by p
has been freed. This allows me to remove a lot of code that
was dealing with the standard (more verbose) method that required
a tmp pointer. This is almost always what you want. When a
realloc fails you never usually want the old memory, you
want to free it and get into your error processing asap.
For the 11 remaining cases where we really do need to keep the
old pointer I have invented the new macro SMB_REALLOC_KEEP_OLD_ON_ERROR,
which can be used as follows :
tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
if (!tmp) {
SAFE_FREE(p);
return error;
} else {
p = tmp;
}
SMB_REALLOC_KEEP_OLD_ON_ERROR guarentees never to free the
pointer p, even on size == 0 or realloc fail. All this is
done by a hidden extra argument to Realloc(), BOOL free_old_on_error
which is set appropriately by the SMB_REALLOC and SMB_REALLOC_KEEP_OLD_ON_ERROR
macros (and their array counterparts).
It remains to be seen what this will do to our Coverity bug count :-).
Jeremy.
(This used to be commit 1d710d06a214f3f1740e80e0bffd6aab44aac2b0)
2006-03-07 09:31:04 +03:00
if ( ! buffer ) {
2005-06-30 21:46:06 +04:00
break ;
r13915: Fixed a very interesting class of realloc() bugs found by Coverity.
realloc can return NULL in one of two cases - (1) the realloc failed,
(2) realloc succeeded but the new size requested was zero, in which
case this is identical to a free() call.
The error paths dealing with these two cases should be different,
but mostly weren't. Secondly the standard idiom for dealing with
realloc when you know the new size is non-zero is the following :
tmp = realloc(p, size);
if (!tmp) {
SAFE_FREE(p);
return error;
} else {
p = tmp;
}
However, there were *many* *many* places in Samba where we were
using the old (broken) idiom of :
p = realloc(p, size)
if (!p) {
return error;
}
which will leak the memory pointed to by p on realloc fail.
This commit (hopefully) fixes all these cases by moving to
a standard idiom of :
p = SMB_REALLOC(p, size)
if (!p) {
return error;
}
Where if the realloc returns null due to the realloc failing
or size == 0 we *guarentee* that the storage pointed to by p
has been freed. This allows me to remove a lot of code that
was dealing with the standard (more verbose) method that required
a tmp pointer. This is almost always what you want. When a
realloc fails you never usually want the old memory, you
want to free it and get into your error processing asap.
For the 11 remaining cases where we really do need to keep the
old pointer I have invented the new macro SMB_REALLOC_KEEP_OLD_ON_ERROR,
which can be used as follows :
tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
if (!tmp) {
SAFE_FREE(p);
return error;
} else {
p = tmp;
}
SMB_REALLOC_KEEP_OLD_ON_ERROR guarentees never to free the
pointer p, even on size == 0 or realloc fail. All this is
done by a hidden extra argument to Realloc(), BOOL free_old_on_error
which is set appropriately by the SMB_REALLOC and SMB_REALLOC_KEEP_OLD_ON_ERROR
macros (and their array counterparts).
It remains to be seen what this will do to our Coverity bug count :-).
Jeremy.
(This used to be commit 1d710d06a214f3f1740e80e0bffd6aab44aac2b0)
2006-03-07 09:31:04 +03:00
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
init_unistr2 ( & data , filename , UNI_STR_TERMINATE ) ;
memcpy ( buffer + buffer_size , ( char * ) data . buffer , data . uni_str_len * sizeof ( uint16 ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
buffer_size + = ( length + 1 ) * sizeof ( uint16 ) ;
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
/* terminated by double NULL. Add the final one here */
2007-11-27 04:24:56 +03:00
2006-07-31 07:53:39 +04:00
buffer = ( char * ) SMB_REALLOC ( buffer , buffer_size + 2 ) ;
r13915: Fixed a very interesting class of realloc() bugs found by Coverity.
realloc can return NULL in one of two cases - (1) the realloc failed,
(2) realloc succeeded but the new size requested was zero, in which
case this is identical to a free() call.
The error paths dealing with these two cases should be different,
but mostly weren't. Secondly the standard idiom for dealing with
realloc when you know the new size is non-zero is the following :
tmp = realloc(p, size);
if (!tmp) {
SAFE_FREE(p);
return error;
} else {
p = tmp;
}
However, there were *many* *many* places in Samba where we were
using the old (broken) idiom of :
p = realloc(p, size)
if (!p) {
return error;
}
which will leak the memory pointed to by p on realloc fail.
This commit (hopefully) fixes all these cases by moving to
a standard idiom of :
p = SMB_REALLOC(p, size)
if (!p) {
return error;
}
Where if the realloc returns null due to the realloc failing
or size == 0 we *guarentee* that the storage pointed to by p
has been freed. This allows me to remove a lot of code that
was dealing with the standard (more verbose) method that required
a tmp pointer. This is almost always what you want. When a
realloc fails you never usually want the old memory, you
want to free it and get into your error processing asap.
For the 11 remaining cases where we really do need to keep the
old pointer I have invented the new macro SMB_REALLOC_KEEP_OLD_ON_ERROR,
which can be used as follows :
tmp = SMB_REALLOC_KEEP_OLD_ON_ERROR(p, size);
if (!tmp) {
SAFE_FREE(p);
return error;
} else {
p = tmp;
}
SMB_REALLOC_KEEP_OLD_ON_ERROR guarentees never to free the
pointer p, even on size == 0 or realloc fail. All this is
done by a hidden extra argument to Realloc(), BOOL free_old_on_error
which is set appropriately by the SMB_REALLOC and SMB_REALLOC_KEEP_OLD_ON_ERROR
macros (and their array counterparts).
It remains to be seen what this will do to our Coverity bug count :-).
Jeremy.
(This used to be commit 1d710d06a214f3f1740e80e0bffd6aab44aac2b0)
2006-03-07 09:31:04 +03:00
if ( ! buffer ) {
2005-06-30 21:46:06 +04:00
buffer_size = 0 ;
} else {
buffer [ buffer_size + + ] = ' \0 ' ;
buffer [ buffer_size + + ] = ' \0 ' ;
}
2005-06-30 06:59:29 +04:00
}
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
regval_ctr_addvalue ( values , " Dependent Files " , REG_MULTI_SZ , buffer , buffer_size ) ;
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
SAFE_FREE ( buffer ) ;
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
return ;
}
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-23 20:14:17 +03:00
static int driver_arch_fetch_values ( char * key , struct regval_ctr * values )
2005-07-01 23:15:07 +04:00
{
char * keystr , * base , * subkeypath ;
fstring arch_environment ;
fstring driver ;
int version ;
NT_PRINTER_DRIVER_INFO_LEVEL driver_ctr ;
WERROR w_result ;
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( key , & base , & subkeypath ) ) {
return - 1 ;
}
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
/* no values in 'Environments\Drivers\Windows NT x86' */
2007-11-27 04:24:56 +03:00
if ( ! subkeypath )
2005-07-01 23:15:07 +04:00
return 0 ;
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
/* We have the Architecture string and some subkey name:
Currently we only support
* Drivers
* Print Processors
Anything else is an error .
*/
fstrcpy ( arch_environment , base ) ;
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
keystr = subkeypath ;
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( keystr , & base , & subkeypath ) ) {
return - 1 ;
}
2005-07-01 23:15:07 +04:00
if ( strequal ( base , " Print Processors " ) )
return 0 ;
/* only Drivers key can be left */
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
if ( ! strequal ( base , " Drivers " ) )
return - 1 ;
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
if ( ! subkeypath )
return 0 ;
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
/* We know that we have Architechure\Drivers with some subkey name
The subkey name has to be Version - XX */
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
keystr = subkeypath ;
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( keystr , & base , & subkeypath ) ) {
return - 1 ;
}
2005-07-01 23:15:07 +04:00
if ( ! subkeypath )
return 0 ;
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
version = atoi ( & base [ strlen ( base ) - 1 ] ) ;
/* BEGIN PRINTER DRIVER NAME BLOCK */
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
keystr = subkeypath ;
2006-06-28 06:22:28 +04:00
if ( ! reg_split_path ( keystr , & base , & subkeypath ) ) {
return - 1 ;
}
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
/* don't go any deeper for now */
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
fstrcpy ( driver , base ) ;
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
w_result = get_a_printer_driver ( & driver_ctr , 3 , driver , arch_environment , version ) ;
if ( ! W_ERROR_IS_OK ( w_result ) )
return - 1 ;
2007-11-27 04:24:56 +03:00
fill_in_driver_values ( driver_ctr . info_3 , values ) ;
2005-07-01 23:15:07 +04:00
free_a_printer_driver ( driver_ctr , 3 ) ;
/* END PRINTER DRIVER NAME BLOCK */
2007-11-27 04:24:56 +03:00
2005-07-01 00:16:16 +04:00
DEBUG ( 8 , ( " key_driver_fetch_values: Exit \n " ) ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
return regval_ctr_numvals ( values ) ;
}
2005-07-01 23:15:07 +04:00
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-23 20:14:17 +03:00
static int key_driver_fetch_values ( const char * key , struct regval_ctr * values )
2005-06-30 06:59:29 +04:00
{
2007-11-27 04:24:56 +03:00
char * keystr = NULL ;
char * subkey = NULL ;
TALLOC_CTX * ctx = talloc_tos ( ) ;
2005-07-01 23:15:07 +04:00
DEBUG ( 8 , ( " key_driver_fetch_values: Enter key => [%s] \n " , key ? key : " NULL " ) ) ;
/* no values in the Environments key */
2007-11-27 04:24:56 +03:00
if ( ! ( keystr = reg_remaining_path ( ctx , key + strlen ( KEY_ENVIRONMENTS ) ) ) )
2005-07-01 23:15:07 +04:00
return 0 ;
2007-11-27 04:24:56 +03:00
subkey = talloc_strdup ( ctx , keystr ) ;
if ( ! subkey ) {
return 0 ;
}
2005-07-01 23:15:07 +04:00
/* pass off to handle subkeys */
2007-11-27 04:24:56 +03:00
2005-07-01 23:15:07 +04:00
return driver_arch_fetch_values ( subkey , values ) ;
2005-06-30 06:59:29 +04:00
}
2005-07-01 23:15:07 +04:00
/*********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * " HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT "
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2005-06-30 06:59:29 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-24 17:19:18 +03:00
static int key_print_fetch_keys ( const char * key , struct regsubkey_ctr * subkeys )
2007-11-27 04:24:56 +03:00
{
2005-06-30 21:46:06 +04:00
int key_len = strlen ( key ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
/* no keys below 'Print' handled here */
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
if ( ( key_len ! = strlen ( KEY_CONTROL_PRINT ) ) & & ( key_len ! = strlen ( KEY_WINNT_PRINT ) ) )
return - 1 ;
2005-06-30 06:59:29 +04:00
2005-06-30 21:46:06 +04:00
regsubkey_ctr_addkey ( subkeys , " Environments " ) ;
regsubkey_ctr_addkey ( subkeys , " Monitors " ) ;
regsubkey_ctr_addkey ( subkeys , " Forms " ) ;
regsubkey_ctr_addkey ( subkeys , " Printers " ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
return regsubkey_ctr_numkeys ( subkeys ) ;
2005-06-30 06:59:29 +04:00
}
/**********************************************************************
2005-07-01 23:15:07 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * Structure to hold dispatch table of ops for various printer keys .
2007-11-27 04:24:56 +03:00
* * Make sure to always store deeper keys along the same path first so
2005-07-01 23:15:07 +04:00
* * we ge a more specific match .
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2005-06-30 06:59:29 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
static struct reg_dyn_tree print_registry [ ] = {
2005-06-30 23:43:53 +04:00
/* just pass the monitor onto the registry tdb */
2005-06-30 07:29:48 +04:00
{ KEY_MONITORS ,
2007-11-27 04:24:56 +03:00
& regdb_fetch_keys ,
2005-06-30 21:46:06 +04:00
& regdb_store_keys ,
& regdb_fetch_values ,
& regdb_store_values } ,
2007-11-27 04:24:56 +03:00
{ KEY_FORMS ,
& key_forms_fetch_keys ,
NULL ,
2005-06-30 06:59:29 +04:00
& key_forms_fetch_values ,
2005-06-30 23:43:53 +04:00
NULL } ,
2007-11-27 04:24:56 +03:00
{ KEY_CONTROL_PRINTERS ,
2005-07-02 05:23:21 +04:00
& key_printers_fetch_keys ,
& key_printers_store_keys ,
& key_printers_fetch_values ,
& key_printers_store_values } ,
2005-06-30 07:29:48 +04:00
{ KEY_ENVIRONMENTS ,
2005-06-30 06:59:29 +04:00
& key_driver_fetch_keys ,
2005-07-01 23:15:07 +04:00
NULL ,
2005-06-30 06:59:29 +04:00
& key_driver_fetch_values ,
2005-07-01 23:15:07 +04:00
NULL } ,
2005-06-30 07:29:48 +04:00
{ KEY_CONTROL_PRINT ,
2005-06-30 06:59:29 +04:00
& key_print_fetch_keys ,
2005-06-30 21:46:06 +04:00
NULL ,
NULL ,
NULL } ,
2005-06-30 07:29:48 +04:00
{ KEY_WINNT_PRINTERS ,
2005-07-02 05:23:21 +04:00
& key_printers_fetch_keys ,
& key_printers_store_keys ,
& key_printers_fetch_values ,
& key_printers_store_values } ,
2005-06-30 07:29:48 +04:00
{ KEY_PORTS ,
2007-11-27 04:24:56 +03:00
& regdb_fetch_keys ,
2005-07-01 23:15:07 +04:00
& regdb_store_keys ,
& regdb_fetch_values ,
& regdb_store_values } ,
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
{ NULL , NULL , NULL , NULL , NULL }
} ;
/**********************************************************************
2005-07-01 23:15:07 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* * Main reg_printing interface functions
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
2005-06-30 06:59:29 +04:00
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2005-07-01 23:15:07 +04:00
/***********************************************************************
Lookup a key in the print_registry table , returning its index .
- 1 on failure
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2007-11-27 04:24:56 +03:00
static int match_registry_path ( const char * key )
2005-06-30 06:59:29 +04:00
{
int i ;
2007-11-27 04:24:56 +03:00
char * path = NULL ;
TALLOC_CTX * ctx = talloc_tos ( ) ;
2005-06-30 06:59:29 +04:00
if ( ! key )
return - 1 ;
2007-11-27 04:24:56 +03:00
path = talloc_strdup ( ctx , key ) ;
if ( ! path ) {
return - 1 ;
}
path = normalize_reg_path ( ctx , path ) ;
if ( ! path ) {
return - 1 ;
}
2005-06-30 06:59:29 +04:00
for ( i = 0 ; print_registry [ i ] . path ; i + + ) {
2007-11-27 04:24:56 +03:00
if ( strncmp ( path , print_registry [ i ] . path , strlen ( print_registry [ i ] . path ) ) = = 0 )
2005-06-30 06:59:29 +04:00
return i ;
}
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
return - 1 ;
}
2005-07-01 23:15:07 +04:00
/***********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-24 17:19:18 +03:00
static int regprint_fetch_reg_keys ( const char * key , struct regsubkey_ctr * subkeys )
2005-06-30 06:59:29 +04:00
{
int i = match_registry_path ( key ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
if ( i = = - 1 )
return - 1 ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
if ( ! print_registry [ i ] . fetch_subkeys )
return - 1 ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
return print_registry [ i ] . fetch_subkeys ( key , subkeys ) ;
}
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-02-24 17:19:18 +03:00
static bool regprint_store_reg_keys ( const char * key , struct regsubkey_ctr * subkeys )
2005-06-30 06:59:29 +04:00
{
int i = match_registry_path ( key ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
if ( i = = - 1 )
return False ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
if ( ! print_registry [ i ] . store_subkeys )
return False ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
return print_registry [ i ] . store_subkeys ( key , subkeys ) ;
}
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-23 20:14:17 +03:00
static int regprint_fetch_reg_values ( const char * key , struct regval_ctr * values )
2005-06-30 06:59:29 +04:00
{
int i = match_registry_path ( key ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
if ( i = = - 1 )
return - 1 ;
2007-11-27 04:24:56 +03:00
/* return 0 values by default since we know the key had
2005-06-30 21:46:06 +04:00
to exist because the client opened a handle */
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
if ( ! print_registry [ i ] . fetch_values )
return 0 ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
return print_registry [ i ] . fetch_values ( key , values ) ;
}
/**********************************************************************
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
2009-03-23 20:14:17 +03:00
static bool regprint_store_reg_values ( const char * key , struct regval_ctr * values )
2005-06-30 06:59:29 +04:00
{
int i = match_registry_path ( key ) ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
if ( i = = - 1 )
return False ;
2007-11-27 04:24:56 +03:00
2005-06-30 21:46:06 +04:00
if ( ! print_registry [ i ] . store_values )
return False ;
2007-11-27 04:24:56 +03:00
2005-06-30 06:59:29 +04:00
return print_registry [ i ] . store_values ( key , values ) ;
}
2007-11-27 04:24:56 +03:00
/*
2002-07-19 03:00:24 +04:00
* Table of function pointers for accessing printing data
*/
2007-11-27 04:24:56 +03:00
2002-07-19 03:00:24 +04:00
REGISTRY_OPS printing_ops = {
2008-01-20 01:06:12 +03:00
. fetch_subkeys = regprint_fetch_reg_keys ,
. fetch_values = regprint_fetch_reg_values ,
. store_subkeys = regprint_store_reg_keys ,
. store_values = regprint_store_reg_values ,
2002-07-19 03:00:24 +04:00
} ;