2 * Unix SMB/CIFS implementation.
3 * Virtual Windows Registry Layer
4 * Copyright (C) Gerald Carter 2002-2005
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
20 /* Implementation of registry virtual views for printing information */
26 #define DBGC_CLASS DBGC_REGISTRY
28 /* registrt paths used in the print_registry[] */
30 #define KEY_MONITORS "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/MONITORS"
31 #define KEY_FORMS "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/FORMS"
32 #define KEY_CONTROL_PRINTERS "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/PRINTERS"
33 #define KEY_ENVIRONMENTS "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/ENVIRONMENTS"
34 #define KEY_CONTROL_PRINT "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT"
35 #define KEY_WINNT_PRINTERS "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT/PRINTERS"
36 #define KEY_WINNT_PRINT "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT"
37 #define KEY_PORTS "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PORTS"
39 /* callback table for various registry paths below the ones we service in this module */
42 /* full key path in normalized form */
45 /* callbscks for fetch/store operations */
46 int ( *fetch_subkeys
) ( const char *path
, struct regsubkey_ctr
*subkeys
);
47 bool (*store_subkeys
) ( const char *path
, struct regsubkey_ctr
*subkeys
);
48 int (*fetch_values
) ( const char *path
, struct regval_ctr
*values
);
49 bool (*store_values
) ( const char *path
, struct regval_ctr
*values
);
52 /*********************************************************************
53 *********************************************************************
55 *********************************************************************
56 *********************************************************************/
58 /***********************************************************************
59 simple function to prune a pathname down to the basename of a file
60 **********************************************************************/
62 static const char *dos_basename(const char *path
)
66 if (!(p
= strrchr( path
, '\\'))) {
75 /*********************************************************************
76 *********************************************************************
77 ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/FORMS"
78 *********************************************************************
79 *********************************************************************/
81 static int key_forms_fetch_keys(const char *key
, struct regsubkey_ctr
*subkeys
)
83 char *p
= reg_remaining_path(talloc_tos(), key
+ strlen(KEY_FORMS
));
85 /* no keys below Forms */
94 /**********************************************************************
95 *********************************************************************/
97 static int key_forms_fetch_values(const char *key
, struct regval_ctr
*values
)
100 int i
, num_values
, form_index
= 1;
101 nt_forms_struct
*forms_list
= NULL
;
102 nt_forms_struct
*form
;
104 DEBUG(10,("print_values_forms: key=>[%s]\n", key
? key
: "NULL" ));
106 num_values
= get_ntforms( &forms_list
);
108 DEBUG(10,("hive_forms_fetch_values: [%d] user defined forms returned\n",
111 /* handle user defined forms */
113 for ( i
=0; i
<num_values
; i
++ ) {
114 form
= &forms_list
[i
];
116 data
[0] = form
->width
;
117 data
[1] = form
->length
;
118 data
[2] = form
->left
;
120 data
[4] = form
->right
;
121 data
[5] = form
->bottom
;
122 data
[6] = form_index
++;
123 data
[7] = form
->flag
;
125 regval_ctr_addvalue( values
, form
->name
, REG_BINARY
, (char*)data
, sizeof(data
) );
128 SAFE_FREE( forms_list
);
131 /* handle built-on forms */
133 num_values
= get_builtin_ntforms( &forms_list
);
135 DEBUG(10,("print_subpath_values_forms: [%d] built-in forms returned\n",
138 for ( i
=0; i
<num_values
; i
++ ) {
139 form
= &forms_list
[i
];
141 data
[0] = form
->width
;
142 data
[1] = form
->length
;
143 data
[2] = form
->left
;
145 data
[4] = form
->right
;
146 data
[5] = form
->bottom
;
147 data
[6] = form_index
++;
148 data
[7] = form
->flag
;
150 regval_ctr_addvalue(values
, form
->name
, REG_BINARY
, (char*)data
, sizeof(data
) );
153 SAFE_FREE(forms_list
);
155 return regval_ctr_numvals(values
);
158 /*********************************************************************
159 *********************************************************************
160 ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/PRINTERS"
161 ** "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT/PRINTERS"
162 *********************************************************************
163 *********************************************************************/
165 /*********************************************************************
166 strip off prefix for printers key. DOes return a pointer to static
168 *********************************************************************/
170 static char *strip_printers_prefix(const char *key
)
172 char *subkeypath
= NULL
;
174 TALLOC_CTX
*ctx
= talloc_tos();
176 path
= talloc_strdup(ctx
, key
);
180 path
= normalize_reg_path(ctx
, path
);
185 /* normalizing the path does not change length, just key delimiters and case */
187 if (strncmp(path
, KEY_WINNT_PRINTERS
, strlen(KEY_WINNT_PRINTERS
)) == 0) {
188 subkeypath
= reg_remaining_path(ctx
, key
+ strlen(KEY_WINNT_PRINTERS
));
190 subkeypath
= reg_remaining_path(ctx
, key
+ strlen(KEY_CONTROL_PRINTERS
));
197 /*********************************************************************
198 *********************************************************************/
200 static int key_printers_fetch_keys( const char *key
, struct regsubkey_ctr
*subkeys
)
202 int n_services
= lp_numservices();
208 char *printername
, *printerdatakey
;
209 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
210 fstring
*subkey_names
= NULL
;
212 DEBUG(10,("key_printers_fetch_keys: key=>[%s]\n", key
? key
: "NULL" ));
214 printers_key
= strip_printers_prefix( key
);
216 if ( !printers_key
) {
217 /* enumerate all printers */
219 for (snum
=0; snum
<n_services
; snum
++) {
220 if ( !(lp_snum_ok(snum
) && lp_print_ok(snum
) ) )
223 /* don't report the [printers] share */
225 if ( strequal( lp_servicename(snum
), PRINTERS_NAME
) )
228 fstrcpy( sname
, lp_servicename(snum
) );
230 regsubkey_ctr_addkey( subkeys
, sname
);
233 num_subkeys
= regsubkey_ctr_numkeys( subkeys
);
237 /* get information for a specific printer */
239 if (!reg_split_path( printers_key
, &printername
, &printerdatakey
)) {
243 /* validate the printer name */
245 for (snum
=0; snum
<n_services
; snum
++) {
246 if ( !lp_snum_ok(snum
) || !lp_print_ok(snum
) )
248 if (strequal( lp_servicename(snum
), printername
) )
252 if ( snum
>=n_services
253 || !W_ERROR_IS_OK( get_a_printer(NULL
, &printer
, 2, printername
) ) )
258 num_subkeys
= get_printer_subkeys( printer
->info_2
->data
, printerdatakey
?printerdatakey
:"", &subkey_names
);
260 for ( i
=0; i
<num_subkeys
; i
++ )
261 regsubkey_ctr_addkey( subkeys
, subkey_names
[i
] );
263 free_a_printer( &printer
, 2 );
265 /* no other subkeys below here */
268 SAFE_FREE( subkey_names
);
273 /**********************************************************************
274 Take a list of names and call add_printer_hook() if necessary
275 Note that we do this a little differently from Windows since the
276 keyname is the sharename and not the printer name.
277 *********************************************************************/
279 static bool add_printers_by_registry( struct regsubkey_ctr
*subkeys
)
281 int i
, num_keys
, snum
;
283 NT_PRINTER_INFO_LEVEL_2 info2
;
284 NT_PRINTER_INFO_LEVEL printer
;
286 ZERO_STRUCT( info2
);
287 printer
.info_2
= &info2
;
289 num_keys
= regsubkey_ctr_numkeys( subkeys
);
292 for ( i
=0; i
<num_keys
; i
++ ) {
293 printername
= regsubkey_ctr_specific_key( subkeys
, i
);
294 snum
= find_service( printername
);
296 /* just verify a valied snum for now */
298 fstrcpy( info2
.printername
, printername
);
299 fstrcpy( info2
.sharename
, printername
);
300 if ( !add_printer_hook(talloc_tos(), NULL
, &printer
) ) {
301 DEBUG(0,("add_printers_by_registry: Failed to add printer [%s]\n",
311 /**********************************************************************
312 *********************************************************************/
314 static bool key_printers_store_keys( const char *key
, struct regsubkey_ctr
*subkeys
)
317 char *printername
, *printerdatakey
;
318 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
319 int i
, num_subkeys
, num_existing_keys
;
321 fstring
*existing_subkeys
= NULL
;
323 printers_key
= strip_printers_prefix( key
);
325 if ( !printers_key
) {
326 /* have to deal with some new or deleted printer */
327 return add_printers_by_registry( subkeys
);
330 if (!reg_split_path( printers_key
, &printername
, &printerdatakey
)) {
334 /* lookup the printer */
336 if ( !W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2, printername
)) ) {
337 DEBUG(0,("key_printers_store_keys: Tried to store subkey for bad printername %s\n",
342 /* get the top level printer keys */
344 num_existing_keys
= get_printer_subkeys( printer
->info_2
->data
, "", &existing_subkeys
);
346 for ( i
=0; i
<num_existing_keys
; i
++ ) {
348 /* remove the key if it has been deleted */
350 if ( !regsubkey_ctr_key_exists( subkeys
, existing_subkeys
[i
] ) ) {
351 DEBUG(5,("key_printers_store_keys: deleting key %s\n",
352 existing_subkeys
[i
]));
353 delete_printer_key( printer
->info_2
->data
, existing_subkeys
[i
] );
357 num_subkeys
= regsubkey_ctr_numkeys( subkeys
);
358 for ( i
=0; i
<num_subkeys
; i
++ ) {
359 subkeyname
= regsubkey_ctr_specific_key(subkeys
, i
);
360 /* add any missing printer keys */
361 if ( lookup_printerkey(printer
->info_2
->data
, subkeyname
) == -1 ) {
362 DEBUG(5,("key_printers_store_keys: adding key %s\n",
363 existing_subkeys
[i
]));
364 if ( add_new_printer_key( printer
->info_2
->data
, subkeyname
) == -1 ) {
365 SAFE_FREE( existing_subkeys
);
371 /* write back to disk */
373 mod_a_printer( printer
, 2 );
377 free_a_printer( &printer
, 2 );
379 SAFE_FREE( existing_subkeys
);
384 /**********************************************************************
385 *********************************************************************/
387 static void fill_in_printer_values(NT_PRINTER_INFO_LEVEL_2
*info2
, struct regval_ctr
*values
)
389 struct spoolss_DeviceMode
*devmode
;
391 uint32 printer_status
= PRINTER_STATUS_OK
;
393 regval_ctr_addvalue( values
, "Attributes", REG_DWORD
, (char*)&info2
->attributes
, sizeof(info2
->attributes
) );
394 regval_ctr_addvalue( values
, "Priority", REG_DWORD
, (char*)&info2
->priority
, sizeof(info2
->attributes
) );
395 regval_ctr_addvalue( values
, "ChangeID", REG_DWORD
, (char*)&info2
->changeid
, sizeof(info2
->changeid
) );
396 regval_ctr_addvalue( values
, "Default Priority", REG_DWORD
, (char*)&info2
->default_priority
, sizeof(info2
->default_priority
) );
398 /* lie and say everything is ok since we don't want to call print_queue_length() to get the real status */
399 regval_ctr_addvalue( values
, "Status", REG_DWORD
, (char*)&printer_status
, sizeof(info2
->status
) );
401 regval_ctr_addvalue( values
, "StartTime", REG_DWORD
, (char*)&info2
->starttime
, sizeof(info2
->starttime
) );
402 regval_ctr_addvalue( values
, "UntilTime", REG_DWORD
, (char*)&info2
->untiltime
, sizeof(info2
->untiltime
) );
404 /* strip the \\server\ from this string */
405 if ( !(p
= strrchr( info2
->printername
, '\\' ) ) )
406 p
= info2
->printername
;
410 regval_ctr_addvalue_sz(values
, "Name", p
);
411 regval_ctr_addvalue_sz(values
, "Location", info2
->location
);
412 regval_ctr_addvalue_sz(values
, "Description", info2
->comment
);
413 regval_ctr_addvalue_sz(values
, "Parameters", info2
->parameters
);
414 regval_ctr_addvalue_sz(values
, "Port", info2
->portname
);
415 regval_ctr_addvalue_sz(values
, "Share Name", info2
->sharename
);
416 regval_ctr_addvalue_sz(values
, "Printer Driver", info2
->drivername
);
417 regval_ctr_addvalue_sz(values
, "Separator File", info2
->sepfile
);
418 regval_ctr_addvalue_sz(values
, "Print Processor", info2
->printprocessor
);
419 regval_ctr_addvalue_sz(values
, "Datatype", info2
->datatype
);
421 /* stream the device mode */
423 devmode
= construct_dev_mode(values
,info2
->sharename
);
426 enum ndr_err_code ndr_err
;
428 ndr_err
= ndr_push_struct_blob(&blob
, values
, devmode
,
429 (ndr_push_flags_fn_t
)ndr_push_spoolss_DeviceMode
);
431 if (NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
432 regval_ctr_addvalue(values
, "Default Devmode", REG_BINARY
,
433 (const char *)blob
.data
, blob
.length
);
437 /* stream the printer security descriptor */
439 if (info2
->secdesc_buf
&&
440 info2
->secdesc_buf
->sd
&&
441 info2
->secdesc_buf
->sd_size
)
446 status
= marshall_sec_desc(values
, info2
->secdesc_buf
->sd
,
447 &blob
.data
, &blob
.length
);
448 if (NT_STATUS_IS_OK(status
)) {
449 regval_ctr_addvalue(values
, "Security", REG_BINARY
,
450 (const char *)blob
.data
, blob
.length
);
457 /**********************************************************************
458 *********************************************************************/
460 static int key_printers_fetch_values(const char *key
, struct regval_ctr
*values
)
464 char *printername
, *printerdatakey
;
465 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
466 NT_PRINTER_DATA
*p_data
;
469 printers_key
= strip_printers_prefix( key
);
471 /* top level key values stored in the registry has no values */
473 if ( !printers_key
) {
474 /* normalize to the 'HKLM\SOFTWARE\...\Print\Printers' key */
475 return regdb_fetch_values( KEY_WINNT_PRINTERS
, values
);
478 /* lookup the printer object */
480 if (!reg_split_path( printers_key
, &printername
, &printerdatakey
)) {
484 if ( !W_ERROR_IS_OK( get_a_printer(NULL
, &printer
, 2, printername
) ) )
487 if ( !printerdatakey
) {
488 fill_in_printer_values( printer
->info_2
, values
);
492 /* iterate over all printer data keys and fill the regval container */
494 p_data
= printer
->info_2
->data
;
495 if ( (key_index
= lookup_printerkey( p_data
, printerdatakey
)) == -1 ) {
496 /* failure....should never happen if the client has a valid open handle first */
497 DEBUG(10,("key_printers_fetch_values: Unknown keyname [%s]\n", printerdatakey
));
498 free_a_printer( &printer
, 2 );
502 num_values
= regval_ctr_numvals( p_data
->keys
[key_index
].values
);
503 for ( i
=0; i
<num_values
; i
++ )
504 regval_ctr_copyvalue( values
, regval_ctr_specific_value(p_data
->keys
[key_index
].values
, i
) );
509 free_a_printer( &printer
, 2 );
511 return regval_ctr_numvals( values
);
514 /**********************************************************************
515 *********************************************************************/
517 #define REG_IDX_ATTRIBUTES 1
518 #define REG_IDX_PRIORITY 2
519 #define REG_IDX_DEFAULT_PRIORITY 3
520 #define REG_IDX_CHANGEID 4
521 #define REG_IDX_STATUS 5
522 #define REG_IDX_STARTTIME 6
523 #define REG_IDX_NAME 7
524 #define REG_IDX_LOCATION 8
525 #define REG_IDX_DESCRIPTION 9
526 #define REG_IDX_PARAMETERS 10
527 #define REG_IDX_PORT 12
528 #define REG_IDX_SHARENAME 13
529 #define REG_IDX_DRIVER 14
530 #define REG_IDX_SEP_FILE 15
531 #define REG_IDX_PRINTPROC 16
532 #define REG_IDX_DATATYPE 17
533 #define REG_IDX_DEVMODE 18
534 #define REG_IDX_SECDESC 19
535 #define REG_IDX_UNTILTIME 20
540 } printer_values_map
[] = {
541 { "Attributes", REG_IDX_ATTRIBUTES
},
542 { "Priority", REG_IDX_PRIORITY
},
543 { "Default Priority", REG_IDX_DEFAULT_PRIORITY
},
544 { "ChangeID", REG_IDX_CHANGEID
},
545 { "Status", REG_IDX_STATUS
},
546 { "StartTime", REG_IDX_STARTTIME
},
547 { "UntilTime", REG_IDX_UNTILTIME
},
548 { "Name", REG_IDX_NAME
},
549 { "Location", REG_IDX_LOCATION
},
550 { "Description", REG_IDX_DESCRIPTION
},
551 { "Parameters", REG_IDX_PARAMETERS
},
552 { "Port", REG_IDX_PORT
},
553 { "Share Name", REG_IDX_SHARENAME
},
554 { "Printer Driver", REG_IDX_DRIVER
},
555 { "Separator File", REG_IDX_SEP_FILE
},
556 { "Print Processor", REG_IDX_PRINTPROC
},
557 { "Datatype", REG_IDX_DATATYPE
},
558 { "Default Devmode", REG_IDX_DEVMODE
},
559 { "Security", REG_IDX_SECDESC
},
564 static int find_valuename_index( const char *valuename
)
568 for ( i
=0; printer_values_map
[i
].name
; i
++ ) {
569 if ( strequal( valuename
, printer_values_map
[i
].name
) )
570 return printer_values_map
[i
].index
;
576 /**********************************************************************
577 *********************************************************************/
579 static void pull_reg_sz_fstring(TALLOC_CTX
*mem_ctx
, const DATA_BLOB
*blob
, fstring s
)
582 pull_reg_sz(mem_ctx
, blob
, &str
);
586 static void convert_values_to_printer_info_2(TALLOC_CTX
*mem_ctx
,
587 NT_PRINTER_INFO_LEVEL_2
*printer2
,
588 struct regval_ctr
*values
)
590 int num_values
= regval_ctr_numvals( values
);
592 struct regval_blob
*val
;
595 for ( i
=0; i
<num_values
; i
++ ) {
597 val
= regval_ctr_specific_value( values
, i
);
598 value_index
= find_valuename_index( regval_name( val
) );
600 blob
= data_blob_const(regval_data_p(val
), regval_size(val
));
602 switch( value_index
) {
603 case REG_IDX_ATTRIBUTES
:
604 printer2
->attributes
= (uint32
)(*regval_data_p(val
));
606 case REG_IDX_PRIORITY
:
607 printer2
->priority
= (uint32
)(*regval_data_p(val
));
609 case REG_IDX_DEFAULT_PRIORITY
:
610 printer2
->default_priority
= (uint32
)(*regval_data_p(val
));
612 case REG_IDX_CHANGEID
:
613 printer2
->changeid
= (uint32
)(*regval_data_p(val
));
615 case REG_IDX_STARTTIME
:
616 printer2
->starttime
= (uint32
)(*regval_data_p(val
));
618 case REG_IDX_UNTILTIME
:
619 printer2
->untiltime
= (uint32
)(*regval_data_p(val
));
622 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->printername
);
624 case REG_IDX_LOCATION
:
625 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->location
);
627 case REG_IDX_DESCRIPTION
:
628 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->comment
);
630 case REG_IDX_PARAMETERS
:
631 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->parameters
);
634 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->portname
);
636 case REG_IDX_SHARENAME
:
637 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->sharename
);
640 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->drivername
);
642 case REG_IDX_SEP_FILE
:
643 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->sepfile
);
645 case REG_IDX_PRINTPROC
:
646 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->printprocessor
);
648 case REG_IDX_DATATYPE
:
649 pull_reg_sz_fstring(mem_ctx
, &blob
, printer2
->datatype
);
651 case REG_IDX_DEVMODE
:
653 case REG_IDX_SECDESC
:
656 /* unsupported value...throw away */
657 DEBUG(8,("convert_values_to_printer_info_2: Unsupported registry value [%s]\n",
658 regval_name( val
) ));
665 /**********************************************************************
666 *********************************************************************/
668 static bool key_printers_store_values(const char *key
, struct regval_ctr
*values
)
671 char *printername
, *keyname
;
672 NT_PRINTER_INFO_LEVEL
*printer
= NULL
;
674 TALLOC_CTX
*mem_ctx
= talloc_init("key_printers_store_values");
676 printers_key
= strip_printers_prefix( key
);
678 /* values in the top level key get stored in the registry */
680 if ( !printers_key
) {
681 /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
682 return regdb_store_values( KEY_WINNT_PRINTERS
, values
);
685 if (!reg_split_path( printers_key
, &printername
, &keyname
)) {
689 if ( !W_ERROR_IS_OK(get_a_printer(NULL
, &printer
, 2, printername
) ) )
692 /* deal with setting values directly under the printername */
695 convert_values_to_printer_info_2(mem_ctx
, printer
->info_2
, values
);
698 int num_values
= regval_ctr_numvals( values
);
700 struct regval_blob
*val
;
702 delete_printer_key( printer
->info_2
->data
, keyname
);
704 /* deal with any subkeys */
705 for ( i
=0; i
<num_values
; i
++ ) {
706 val
= regval_ctr_specific_value( values
, i
);
707 result
= set_printer_dataex( printer
, keyname
,
710 regval_data_p( val
),
711 regval_size( val
) );
712 if ( !W_ERROR_IS_OK(result
) ) {
713 DEBUG(0,("key_printers_store_values: failed to set printer data [%s]!\n",
715 free_a_printer( &printer
, 2 );
716 talloc_destroy(mem_ctx
);
722 result
= mod_a_printer( printer
, 2 );
724 free_a_printer( &printer
, 2 );
725 talloc_destroy(mem_ctx
);
727 return W_ERROR_IS_OK(result
);
730 /*********************************************************************
731 *********************************************************************
732 ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/ENVIRONMENTS"
733 *********************************************************************
734 *********************************************************************/
736 static int key_driver_fetch_keys( const char *key
, struct regsubkey_ctr
*subkeys
)
738 const char *environments
[] = {
742 "Windows NT Alpha_AXP",
743 "Windows NT PowerPC",
747 fstring
*drivers
= NULL
;
748 int i
, env_index
, num_drivers
;
749 char *keystr
, *base
, *subkeypath
;
751 int num_subkeys
= -1;
753 TALLOC_CTX
*ctx
= talloc_tos();
755 DEBUG(10,("key_driver_fetch_keys key=>[%s]\n", key
? key
: "NULL" ));
757 keystr
= reg_remaining_path(ctx
, key
+ strlen(KEY_ENVIRONMENTS
) );
759 /* list all possible architectures */
762 for ( num_subkeys
=0; environments
[num_subkeys
]; num_subkeys
++ )
763 regsubkey_ctr_addkey( subkeys
, environments
[num_subkeys
] );
768 /* we are dealing with a subkey of "Environments */
769 key2
= talloc_strdup(ctx
, keystr
);
774 if (!reg_split_path(keystr
, &base
, &subkeypath
)) {
780 for ( env_index
=0; environments
[env_index
]; env_index
++ ) {
781 if ( strequal( environments
[env_index
], base
) )
784 if ( !environments
[env_index
] )
787 /* ...\Print\Environements\...\ */
790 regsubkey_ctr_addkey( subkeys
, "Drivers" );
791 regsubkey_ctr_addkey( subkeys
, "Print Processors" );
796 /* more of the key path to process */
799 if (!reg_split_path( keystr
, &base
, &subkeypath
)) {
803 /* ...\Print\Environements\...\Drivers\ */
806 if ( strequal(base
, "Drivers") ) {
807 switch ( env_index
) {
809 regsubkey_ctr_addkey( subkeys
, "Version-0" );
811 default: /* Windows NT based systems */
812 regsubkey_ctr_addkey( subkeys
, "Version-2" );
813 regsubkey_ctr_addkey( subkeys
, "Version-3" );
817 return regsubkey_ctr_numkeys( subkeys
);
818 } else if ( strequal(base
, "Print Processors") ) {
819 if ( env_index
== 1 || env_index
== 5 || env_index
== 6 )
822 return regsubkey_ctr_numkeys( subkeys
);
824 return -1; /* bad path */
827 /* we finally get to enumerate the drivers */
829 /* only one possible subkey below PrintProc key */
831 if ( strequal(base
, "Print Processors") ) {
833 if (!reg_split_path( keystr
, &base
, &subkeypath
)) {
837 /* no subkeys below this point */
842 /* only allow one keyname here -- 'winprint' */
844 return strequal( base
, "winprint" ) ? 0 : -1;
847 /* only dealing with drivers from here on out */
850 if (!reg_split_path( keystr
, &base
, &subkeypath
)) {
854 version
= atoi(&base
[strlen(base
)-1]);
862 if ( version
!= 2 && version
!= 3 )
869 num_drivers
= get_ntdrivers( &drivers
, environments
[env_index
], version
);
870 for ( i
=0; i
<num_drivers
; i
++ )
871 regsubkey_ctr_addkey( subkeys
, drivers
[i
] );
873 return regsubkey_ctr_numkeys( subkeys
);
876 /* if anything else left, just say if has no subkeys */
878 DEBUG(1,("key_driver_fetch_keys unhandled key [%s] (subkey == %s)\n",
885 /**********************************************************************
886 *********************************************************************/
888 static void fill_in_driver_values(const struct spoolss_DriverInfo8
*r
,
889 struct regval_ctr
*values
)
894 const char *filename
;
897 filename
= dos_basename(r
->driver_path
);
898 regval_ctr_addvalue_sz(values
, "Driver", filename
);
900 filename
= dos_basename(r
->config_file
);
901 regval_ctr_addvalue_sz(values
, "Configuration File", filename
);
903 filename
= dos_basename(r
->data_file
);
904 regval_ctr_addvalue_sz(values
, "Data File", filename
);
906 filename
= dos_basename(r
->help_file
);
907 regval_ctr_addvalue_sz(values
, "Help File", filename
);
909 regval_ctr_addvalue_sz(values
, "Datatype", r
->default_datatype
);
910 regval_ctr_addvalue_sz(values
, "Monitor", r
->monitor_name
);
912 regval_ctr_addvalue( values
, "Version", REG_DWORD
, (char*)&r
->version
,
913 sizeof(r
->version
) );
915 if (r
->dependent_files
) {
916 /* place the list of dependent files in a single
917 character buffer, separating each file name by
920 for (i
=0; r
->dependent_files
[i
] && strcmp(r
->dependent_files
[i
], ""); i
++) {
921 /* strip the path to only the file's base name */
923 filename
= dos_basename(r
->dependent_files
[i
]);
925 length
= strlen(filename
);
927 buffer
= (char *)SMB_REALLOC( buffer
, buffer_size
+ (length
+ 1)*sizeof(uint16
) );
932 push_reg_sz(talloc_tos(), &data
, filename
);
933 memcpy( buffer
+buffer_size
, (char*)data
.data
, data
.length
);
935 buffer_size
+= (length
+ 1)*sizeof(uint16
);
938 /* terminated by double NULL. Add the final one here */
940 buffer
= (char *)SMB_REALLOC( buffer
, buffer_size
+ 2 );
944 buffer
[buffer_size
++] = '\0';
945 buffer
[buffer_size
++] = '\0';
949 regval_ctr_addvalue( values
, "Dependent Files", REG_MULTI_SZ
, buffer
, buffer_size
);
956 /**********************************************************************
957 *********************************************************************/
959 static int driver_arch_fetch_values(char *key
, struct regval_ctr
*values
)
961 char *keystr
, *base
, *subkeypath
;
962 fstring arch_environment
;
965 struct spoolss_DriverInfo8
*driver_ctr
;
968 if (!reg_split_path( key
, &base
, &subkeypath
)) {
972 /* no values in 'Environments\Drivers\Windows NT x86' */
977 /* We have the Architecture string and some subkey name:
978 Currently we only support
981 Anything else is an error.
984 fstrcpy( arch_environment
, base
);
987 if (!reg_split_path( keystr
, &base
, &subkeypath
)) {
991 if ( strequal(base
, "Print Processors") )
994 /* only Drivers key can be left */
996 if ( !strequal(base
, "Drivers") )
1002 /* We know that we have Architechure\Drivers with some subkey name
1003 The subkey name has to be Version-XX */
1005 keystr
= subkeypath
;
1006 if (!reg_split_path( keystr
, &base
, &subkeypath
)) {
1013 version
= atoi(&base
[strlen(base
)-1]);
1015 /* BEGIN PRINTER DRIVER NAME BLOCK */
1017 keystr
= subkeypath
;
1018 if (!reg_split_path( keystr
, &base
, &subkeypath
)) {
1022 /* don't go any deeper for now */
1024 fstrcpy( driver
, base
);
1026 w_result
= get_a_printer_driver(talloc_tos(), &driver_ctr
, driver
, arch_environment
, version
);
1028 if ( !W_ERROR_IS_OK(w_result
) )
1031 fill_in_driver_values(driver_ctr
, values
);
1033 free_a_printer_driver(driver_ctr
);
1035 /* END PRINTER DRIVER NAME BLOCK */
1038 DEBUG(8,("key_driver_fetch_values: Exit\n"));
1040 return regval_ctr_numvals( values
);
1043 /**********************************************************************
1044 *********************************************************************/
1046 static int key_driver_fetch_values(const char *key
, struct regval_ctr
*values
)
1048 char *keystr
= NULL
;
1049 char *subkey
= NULL
;
1050 TALLOC_CTX
*ctx
= talloc_tos();
1052 DEBUG(8,("key_driver_fetch_values: Enter key => [%s]\n", key
? key
: "NULL"));
1054 /* no values in the Environments key */
1056 if (!(keystr
= reg_remaining_path(ctx
, key
+ strlen(KEY_ENVIRONMENTS
))))
1059 subkey
= talloc_strdup(ctx
, keystr
);
1064 /* pass off to handle subkeys */
1066 return driver_arch_fetch_values( subkey
, values
);
1069 /*********************************************************************
1070 *********************************************************************
1071 ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT"
1072 *********************************************************************
1073 *********************************************************************/
1075 static int key_print_fetch_keys( const char *key
, struct regsubkey_ctr
*subkeys
)
1077 int key_len
= strlen(key
);
1079 /* no keys below 'Print' handled here */
1081 if ( (key_len
!= strlen(KEY_CONTROL_PRINT
)) && (key_len
!= strlen(KEY_WINNT_PRINT
)) )
1084 regsubkey_ctr_addkey( subkeys
, "Environments" );
1085 regsubkey_ctr_addkey( subkeys
, "Monitors" );
1086 regsubkey_ctr_addkey( subkeys
, "Forms" );
1087 regsubkey_ctr_addkey( subkeys
, "Printers" );
1089 return regsubkey_ctr_numkeys( subkeys
);
1092 /**********************************************************************
1093 *********************************************************************
1094 ** Structure to hold dispatch table of ops for various printer keys.
1095 ** Make sure to always store deeper keys along the same path first so
1096 ** we ge a more specific match.
1097 *********************************************************************
1098 *********************************************************************/
1100 static struct reg_dyn_tree print_registry
[] = {
1101 /* just pass the monitor onto the registry tdb */
1105 ®db_fetch_values
,
1106 ®db_store_values
},
1108 &key_forms_fetch_keys
,
1110 &key_forms_fetch_values
,
1112 { KEY_CONTROL_PRINTERS
,
1113 &key_printers_fetch_keys
,
1114 &key_printers_store_keys
,
1115 &key_printers_fetch_values
,
1116 &key_printers_store_values
},
1118 &key_driver_fetch_keys
,
1120 &key_driver_fetch_values
,
1122 { KEY_CONTROL_PRINT
,
1123 &key_print_fetch_keys
,
1127 { KEY_WINNT_PRINTERS
,
1128 &key_printers_fetch_keys
,
1129 &key_printers_store_keys
,
1130 &key_printers_fetch_values
,
1131 &key_printers_store_values
},
1135 ®db_fetch_values
,
1136 ®db_store_values
},
1138 { NULL
, NULL
, NULL
, NULL
, NULL
}
1142 /**********************************************************************
1143 *********************************************************************
1144 ** Main reg_printing interface functions
1145 *********************************************************************
1146 *********************************************************************/
1148 /***********************************************************************
1149 Lookup a key in the print_registry table, returning its index.
1151 **********************************************************************/
1153 static int match_registry_path(const char *key
)
1157 TALLOC_CTX
*ctx
= talloc_tos();
1162 path
= talloc_strdup(ctx
, key
);
1166 path
= normalize_reg_path(ctx
, path
);
1171 for ( i
=0; print_registry
[i
].path
; i
++ ) {
1172 if (strncmp( path
, print_registry
[i
].path
, strlen(print_registry
[i
].path
) ) == 0 )
1179 /***********************************************************************
1180 **********************************************************************/
1182 static int regprint_fetch_reg_keys( const char *key
, struct regsubkey_ctr
*subkeys
)
1184 int i
= match_registry_path( key
);
1189 if ( !print_registry
[i
].fetch_subkeys
)
1192 return print_registry
[i
].fetch_subkeys( key
, subkeys
);
1195 /**********************************************************************
1196 *********************************************************************/
1198 static bool regprint_store_reg_keys( const char *key
, struct regsubkey_ctr
*subkeys
)
1200 int i
= match_registry_path( key
);
1205 if ( !print_registry
[i
].store_subkeys
)
1208 return print_registry
[i
].store_subkeys( key
, subkeys
);
1211 /**********************************************************************
1212 *********************************************************************/
1214 static int regprint_fetch_reg_values(const char *key
, struct regval_ctr
*values
)
1216 int i
= match_registry_path( key
);
1221 /* return 0 values by default since we know the key had
1222 to exist because the client opened a handle */
1224 if ( !print_registry
[i
].fetch_values
)
1227 return print_registry
[i
].fetch_values( key
, values
);
1230 /**********************************************************************
1231 *********************************************************************/
1233 static bool regprint_store_reg_values(const char *key
, struct regval_ctr
*values
)
1235 int i
= match_registry_path( key
);
1240 if ( !print_registry
[i
].store_values
)
1243 return print_registry
[i
].store_values( key
, values
);
1247 * Table of function pointers for accessing printing data
1250 struct registry_ops printing_ops
= {
1251 .fetch_subkeys
= regprint_fetch_reg_keys
,
1252 .fetch_values
= regprint_fetch_reg_values
,
1253 .store_subkeys
= regprint_store_reg_keys
,
1254 .store_values
= regprint_store_reg_values
,