BOOL (*store_values) ( const char *path, REGVAL_CTR *values );
};
+/*********************************************************************
+ *********************************************************************
+ ** Utility Functions
+ *********************************************************************
+ *********************************************************************/
/**********************************************************************
move to next non-delimter character
return p;
}
-/**********************************************************************
+/*********************************************************************
+ *********************************************************************
+ ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/FORMS"
+ *********************************************************************
*********************************************************************/
static int key_forms_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
return 0;
}
+/**********************************************************************
+ *********************************************************************/
+
static int key_forms_fetch_values( const char *key, REGVAL_CTR *values )
{
uint32 data[8];
return regval_ctr_numvals( values );
}
-/**********************************************************************
+/*********************************************************************
+ *********************************************************************
+ ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/PRINTERS"
+ ** "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PRINT/PRINTERS"
+ *********************************************************************
*********************************************************************/
-static int key_printer_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
+/*********************************************************************
+ strip off prefix for printers key. DOes return a pointer to static
+ memory.
+ *********************************************************************/
+
+static char* strip_printers_prefix( const char *key )
{
- int n_services = lp_numservices();
- int snum;
- fstring sname;
- int i;
- int num_subkeys = 0;
- char *keystr;
- char *base, *new_path;
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- fstring *subkey_names = NULL;
+ char *subkeypath;
pstring path;
- DEBUG(10,("print_subpath_printers: key=>[%s]\n", key ? key : "NULL" ));
-
pstrcpy( path, key );
normalize_reg_path( path );
/* normalizing the path does not change length, just key delimiters and case */
if ( strncmp( path, KEY_WINNT_PRINTERS, strlen(KEY_WINNT_PRINTERS) ) == 0 )
- keystr = remaining_path( key + strlen(KEY_WINNT_PRINTERS) );
+ subkeypath = remaining_path( key + strlen(KEY_WINNT_PRINTERS) );
else
- keystr = remaining_path( key + strlen(KEY_CONTROL_PRINTERS) );
+ subkeypath = remaining_path( key + strlen(KEY_CONTROL_PRINTERS) );
+
+ return subkeypath;
+}
+
+/*********************************************************************
+ *********************************************************************/
+
+static int key_printers_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
+{
+ int n_services = lp_numservices();
+ int snum;
+ fstring sname;
+ int i;
+ int num_subkeys = 0;
+ char *printers_key;
+ char *printername, *printerdatakey;
+ NT_PRINTER_INFO_LEVEL *printer = NULL;
+ fstring *subkey_names = NULL;
+ fstring sharename;
+ DEBUG(10,("key_printers_fetch_keys: key=>[%s]\n", key ? key : "NULL" ));
- if ( !keystr ) {
+ printers_key = strip_printers_prefix( key );
+
+ if ( !printers_key ) {
/* enumerate all printers */
for (snum=0; snum<n_services; snum++) {
/* get information for a specific printer */
- reg_split_path( keystr, &base, &new_path );
+ reg_split_path( printers_key, &printername, &printerdatakey );
- if ( !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, base) ) )
- goto done;
+ alpha_strcpy( sharename, printername, "", sizeof(sharename)-1);
- num_subkeys = get_printer_subkeys( &printer->info_2->data, new_path?new_path:"", &subkey_names );
+ if ( find_service(sharename) == -1
+ || !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, sharename) ) )
+ {
+ return -1;
+ }
+
+ num_subkeys = get_printer_subkeys( &printer->info_2->data, printerdatakey?printerdatakey:"", &subkey_names );
for ( i=0; i<num_subkeys; i++ )
regsubkey_ctr_addkey( subkeys, subkey_names[i] );
return num_subkeys;
}
-static BOOL key_printer_store_keys( const char *key, REGSUBKEY_CTR *subkeys )
+/**********************************************************************
+ 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.
+ *********************************************************************/
+
+static BOOL add_printers_by_registry( REGSUBKEY_CTR *subkeys )
{
+ 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 );
+ alpha_strcpy( info2.sharename, printername, "", sizeof(info2.sharename)-1);
+ if ( !add_printer_hook( NULL, &printer ) ) {
+ DEBUG(0,("add_printers_by_registry: Failed to add printer [%s]\n",
+ printername));
+ }
+ }
+ }
+ unbecome_root();
+
return True;
}
-static int key_printer_fetch_values( const char *key, REGVAL_CTR *values )
-{
- int num_values = 0;
- char *keystr, *key2 = NULL;
- char *base, *new_path;
- NT_PRINTER_INFO_LEVEL *printer = NULL;
- NT_PRINTER_INFO_LEVEL_2 *info2;
- DEVICEMODE *devmode;
- prs_struct prs;
- uint32 offset;
- int snum;
- fstring printername;
- NT_PRINTER_DATA *p_data;
- int i, key_index;
- UNISTR2 data;
- pstring path;
-
- /*
- * Theres are tw cases to deal with here
- * (1) enumeration of printer_info_2 values
- * (2) enumeration of the PrinterDriverData subney
- */
-
- pstrcpy( path, key );
- normalize_reg_path( path );
-
- /* normalizing the path does not change length, just key delimiters and case */
+/**********************************************************************
+ *********************************************************************/
- if ( strncmp( path, KEY_WINNT_PRINTERS, strlen(KEY_WINNT_PRINTERS) ) == 0 )
- keystr = remaining_path( key + strlen(KEY_WINNT_PRINTERS) );
- else
- keystr = remaining_path( key + strlen(KEY_CONTROL_PRINTERS) );
+static BOOL key_printers_store_keys( const char *key, REGSUBKEY_CTR *subkeys )
+{
+ char *printers_key;
+ char *printername, *printerdatakey;
+ NT_PRINTER_INFO_LEVEL *printer = NULL;
+ int i, num_subkeys, num_existing_keys;
+ char *subkeyname;
+ fstring *existing_subkeys = NULL;
- if ( !keystr ) {
- /* top level key has no values */
- goto done;
+ printers_key = strip_printers_prefix( key );
+
+ if ( !printers_key ) {
+ /* have to deal with some new or deleted printer */
+ return add_printers_by_registry( subkeys );
}
- key2 = SMB_STRDUP( keystr );
- keystr = key2;
- reg_split_path( keystr, &base, &new_path );
+ reg_split_path( printers_key, &printername, &printerdatakey );
- fstrcpy( printername, base );
+ /* lookup the printer */
- if ( !new_path ) {
- char *p;
- uint32 printer_status = PRINTER_STATUS_OK;
-
- /* we are dealing with the printer itself */
+ 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));
+ return False;
+ }
+
+ /* get the top level printer keys */
+
+ num_existing_keys = get_printer_subkeys( &printer->info_2->data, "", &existing_subkeys );
+
+ 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]));
+ delete_printer_key( &printer->info_2->data, existing_subkeys[i] );
+ }
+ }
- if ( !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, printername) ) )
- goto done;
+ 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 */
+ if ( lookup_printerkey(&printer->info_2->data, subkeyname) == -1 ) {
+ DEBUG(5,("key_printers_store_keys: adding key %s\n",
+ existing_subkeys[i]));
+ if ( add_new_printer_key( &printer->info_2->data, subkeyname ) == -1 )
+ return False;
+ }
+ }
+
+ /* write back to disk */
+
+ mod_a_printer( printer, 2 );
+
+ /* cleanup */
+
+ if ( printer )
+ free_a_printer( &printer, 2 );
- info2 = printer->info_2;
-
+ return True;
+}
- 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) );
+/**********************************************************************
+ *********************************************************************/
- /* 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) );
+static void fill_in_printer_values( NT_PRINTER_INFO_LEVEL_2 *info2, REGVAL_CTR *values )
+{
+ DEVICEMODE *devmode;
+ prs_struct prs;
+ uint32 offset;
+ UNISTR2 data;
+ char *p;
+ uint32 printer_status = PRINTER_STATUS_OK;
+ int snum;
+
+ 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) );
+
+ /* 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) );
- 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) );
+ 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) );
- /* 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) );
+ /* 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) );
- init_unistr2( &data, info2->location, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Location", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ init_unistr2( &data, info2->location, UNI_STR_TERMINATE);
+ regval_ctr_addvalue( values, "Location", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->comment, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Description", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ init_unistr2( &data, info2->comment, UNI_STR_TERMINATE);
+ regval_ctr_addvalue( values, "Description", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->parameters, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Parameters", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ init_unistr2( &data, info2->parameters, UNI_STR_TERMINATE);
+ regval_ctr_addvalue( values, "Parameters", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, info2->portname, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Port", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ init_unistr2( &data, info2->portname, UNI_STR_TERMINATE);
+ regval_ctr_addvalue( values, "Port", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- 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) );
+ 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) );
- 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) );
+ 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) );
- 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) );
+ 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) );
- init_unistr2( &data, "WinPrint", UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Print Processor", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ init_unistr2( &data, "WinPrint", UNI_STR_TERMINATE);
+ regval_ctr_addvalue( values, "Print Processor", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- init_unistr2( &data, "RAW", UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Datatype", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ init_unistr2( &data, "RAW", UNI_STR_TERMINATE);
+ regval_ctr_addvalue( values, "Datatype", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
- /* use a prs_struct for converting the devmode and security
- descriptor to REG_BINARY */
-
- prs_init( &prs, MAX_PDU_FRAG_LEN, regval_ctr_getctx(values), MARSHALL);
+ /* use a prs_struct for converting the devmode and security
+ descriptor to REG_BINARY */
+
+ prs_init( &prs, MAX_PDU_FRAG_LEN, regval_ctr_getctx(values), MARSHALL);
- /* stream the device mode */
+ /* stream the device mode */
- snum = lp_servicenumber(info2->sharename);
- if ( (devmode = construct_dev_mode( snum )) != NULL )
- {
- if ( spoolss_io_devmode( "devmode", &prs, 0, devmode ) ) {
-
- offset = prs_offset( &prs );
-
- regval_ctr_addvalue( values, "Default Devmode", REG_BINARY, prs_data_p(&prs), offset );
- }
-
-
+ snum = lp_servicenumber(info2->sharename);
+ if ( (devmode = construct_dev_mode( snum )) != NULL ) {
+ if ( spoolss_io_devmode( "devmode", &prs, 0, devmode ) ) {
+ offset = prs_offset( &prs );
+ regval_ctr_addvalue( values, "Default Devmode", REG_BINARY, prs_data_p(&prs), offset );
}
+ }
- prs_mem_clear( &prs );
- prs_set_offset( &prs, 0 );
+ prs_mem_clear( &prs );
+ prs_set_offset( &prs, 0 );
- if ( info2->secdesc_buf && info2->secdesc_buf->len )
- {
- if ( sec_io_desc("sec_desc", &info2->secdesc_buf->sec, &prs, 0 ) ) {
-
- offset = prs_offset( &prs );
-
- regval_ctr_addvalue( values, "Security", REG_BINARY, prs_data_p(&prs), offset );
- }
+ /* stream the printer security descriptor */
+
+ if ( info2->secdesc_buf && info2->secdesc_buf->len ) {
+ if ( sec_io_desc("sec_desc", &info2->secdesc_buf->sec, &prs, 0 ) ) {
+ offset = prs_offset( &prs );
+ regval_ctr_addvalue( values, "Security", REG_BINARY, prs_data_p(&prs), offset );
}
+ }
- prs_mem_free( &prs );
-
- num_values = regval_ctr_numvals( values );
-
- goto done;
-
+ prs_mem_free( &prs );
+
+ return;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static int key_printers_fetch_values( const char *key, REGVAL_CTR *values )
+{
+ int num_values;
+ char *printers_key;
+ char *printername, *printerdatakey;
+ NT_PRINTER_INFO_LEVEL *printer = NULL;
+ NT_PRINTER_DATA *p_data;
+ int i, key_index;
+
+ printers_key = strip_printers_prefix( key );
+
+ /* top level key values stored in the registry has no values */
+
+ if ( !printers_key ) {
+ /* normalize to the 'HKLM\SOFTWARE\...\Print\Printers' ket */
+ return regdb_fetch_values( KEY_WINNT_PRINTERS, values );
}
-
- /* now enumerate the key */
+ /* lookup the printer object */
+
+ reg_split_path( printers_key, &printername, &printerdatakey );
if ( !W_ERROR_IS_OK( get_a_printer(NULL, &printer, 2, printername) ) )
goto done;
-
- /* iterate over all printer data and fill the regval container */
-
- p_data = &printer->info_2->data;
- if ( (key_index = lookup_printerkey( p_data, new_path )) == -1 ) {
- DEBUG(10,("key_printer_fetch_values: Unknown keyname [%s]\n", new_path));
+
+ if ( !printerdatakey ) {
+ fill_in_printer_values( printer->info_2, values );
goto done;
}
+
+ /* iterate over all printer data keys and fill the regval container */
- num_values = regval_ctr_numvals( &p_data->keys[key_index].values );
+ p_data = &printer->info_2->data;
+ if ( (key_index = lookup_printerkey( p_data, printerdatakey )) == -1 ) {
+ /* failure....should never happen if the client has a valid open handle first */
+ DEBUG(10,("key_printers_fetch_values: Unknown keyname [%s]\n", printerdatakey));
+ if ( printer )
+ free_a_printer( &printer, 2 );
+ return -1;
+ }
+ num_values = regval_ctr_numvals( &p_data->keys[key_index].values );
for ( i=0; i<num_values; i++ )
regval_ctr_copyvalue( values, regval_ctr_specific_value(&p_data->keys[key_index].values, i) );
if ( printer )
free_a_printer( &printer, 2 );
- SAFE_FREE( key2 );
-
- return num_values;
+ return regval_ctr_numvals( values );
}
-static BOOL key_printer_store_values( const char *key, REGVAL_CTR *values )
+/**********************************************************************
+ *********************************************************************/
+
+#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 },
+ { "Descrioption", REG_IDX_DESCRIPTION },
+ { "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 )
{
- return True;
+ 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;
}
/**********************************************************************
*********************************************************************/
-#define ENVIRONMENT_DRIVERS 1
-#define ENVIRONMENT_PRINTPROC 2
+
+static void convert_values_to_printer_info_2( NT_PRINTER_INFO_LEVEL_2 *printer2, REGVAL_CTR *values )
+{
+ int num_values = regval_ctr_numvals( values );
+ uint32 value_index;
+ REGISTRY_VALUE *val;
+ int i;
+
+ for ( i=0; i<num_values; i++ ) {
+ val = regval_ctr_specific_value( values, i );
+ value_index = find_valuename_index( regval_name( val ) );
+
+ switch( value_index ) {
+ case REG_IDX_ATTRIBUTES:
+ printer2->attributes = (uint32)(*regval_data_p(val));
+ break;
+ case REG_IDX_PRIORITY:
+ printer2->priority = (uint32)(*regval_data_p(val));
+ break;
+ case REG_IDX_DEFAULT_PRIORITY:
+ printer2->default_priority = (uint32)(*regval_data_p(val));
+ break;
+ case REG_IDX_CHANGEID:
+ printer2->changeid = (uint32)(*regval_data_p(val));
+ break;
+ case REG_IDX_STARTTIME:
+ printer2->starttime = (uint32)(*regval_data_p(val));
+ break;
+ case REG_IDX_UNTILTIME:
+ printer2->untiltime = (uint32)(*regval_data_p(val));
+ break;
+ case REG_IDX_NAME:
+ rpcstr_pull( printer2->printername, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_LOCATION:
+ rpcstr_pull( printer2->location, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_DESCRIPTION:
+ rpcstr_pull( printer2->comment, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_PARAMETERS:
+ rpcstr_pull( printer2->parameters, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_PORT:
+ rpcstr_pull( printer2->portname, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_SHARENAME:
+ rpcstr_pull( printer2->sharename, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_DRIVER:
+ rpcstr_pull( printer2->drivername, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_SEP_FILE:
+ rpcstr_pull( printer2->sepfile, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_PRINTPROC:
+ rpcstr_pull( printer2->printprocessor, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_DATATYPE:
+ rpcstr_pull( printer2->datatype, regval_data_p(val), sizeof(fstring), regval_size(val), 0 );
+ break;
+ case REG_IDX_DEVMODE:
+ break;
+ case REG_IDX_SECDESC:
+ break;
+ default:
+ /* unsupported value...throw away */
+ DEBUG(8,("convert_values_to_printer_info_2: Unsupported registry value [%s]\n",
+ regval_name( val ) ));
+ }
+ }
+
+ return;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static BOOL key_printers_store_values( const char *key, REGVAL_CTR *values )
+{
+ char *printers_key;
+ char *printername, *keyname;
+ NT_PRINTER_INFO_LEVEL *printer = NULL;
+ WERROR result;
+
+ printers_key = strip_printers_prefix( key );
+
+ /* values in the top level key get stored in the registry */
+
+ if ( !printers_key ) {
+ /* normalize on the 'HKLM\SOFTWARE\....\Print\Printers' key */
+ return regdb_store_values( KEY_WINNT_PRINTERS, values );
+ }
+
+ reg_split_path( printers_key, &printername, &keyname );
+
+ 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;
+ REGISTRY_VALUE *val;
+
+ delete_printer_key( &printer->info_2->data, keyname );
+
+ /* 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);
+}
+
+/*********************************************************************
+ *********************************************************************
+ ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT/ENVIRONMENTS"
+ *********************************************************************
+ *********************************************************************/
static int key_driver_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
{
char *keystr, *base, *subkeypath;
pstring key2;
int num_subkeys = -1;
- int env_subkey_type = 0;
int version;
DEBUG(10,("key_driver_fetch_keys key=>[%s]\n", key ? key : "NULL" ));
/* ...\Print\Environements\...\Drivers\ */
- if ( strequal(base, "Drivers") )
- env_subkey_type = ENVIRONMENT_DRIVERS;
- else if ( strequal(base, "Print Processors") )
- env_subkey_type = ENVIRONMENT_PRINTPROC;
- else
- /* invalid path */
- return -1;
-
if ( !subkeypath ) {
- switch ( env_subkey_type ) {
- case ENVIRONMENT_DRIVERS:
+ if ( strequal(base, "Drivers") ) {
switch ( env_index ) {
case 0: /* Win9x */
regsubkey_ctr_addkey( subkeys, "Version-0" );
}
return regsubkey_ctr_numkeys( subkeys );
-
- case ENVIRONMENT_PRINTPROC:
+ } else if ( strequal(base, "Print Processors") ) {
if ( env_index == 1 || env_index == 5 || env_index == 6 )
regsubkey_ctr_addkey( subkeys, "winprint" );
return regsubkey_ctr_numkeys( subkeys );
- }
+ } else
+ return -1; /* bad path */
}
/* we finally get to enumerate the drivers */
- keystr = subkeypath;
- reg_split_path( keystr, &base, &subkeypath );
+ /* only one possible subkey below PrintProc key */
+
+ if ( strequal(base, "Print Processors") ) {
+ keystr = subkeypath;
+ reg_split_path( keystr, &base, &subkeypath );
- /* get thr print processors key out of the way */
- if ( env_subkey_type == ENVIRONMENT_PRINTPROC ) {
- if ( !strequal( base, "winprint" ) )
+ /* no subkeys below this point */
+
+ if ( subkeypath )
return -1;
- return !subkeypath ? 0 : -1;
+
+ /* only allow one keyname here -- 'winprint' */
+
+ return strequal( base, "winprint" ) ? 0 : -1;
}
/* only dealing with drivers from here on out */
-
+
+ keystr = subkeypath;
+ reg_split_path( keystr, &base, &subkeypath );
version = atoi(&base[strlen(base)-1]);
switch (env_index) {
return 0;
}
-static BOOL key_driver_store_keys( const char *key, REGSUBKEY_CTR *subkeys )
-{
- return True;
-}
-
-static int key_driver_fetch_values( const char *key, REGVAL_CTR *values )
-{
- char *keystr, *base, *subkeypath;
- pstring key2;
- fstring arch_environment;
- fstring driver;
- int version;
- NT_PRINTER_DRIVER_INFO_LEVEL driver_ctr;
- NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3;
- WERROR w_result;
- char *buffer = NULL;
- char *buffer2 = NULL;
- int buffer_size = 0;
- int i, length;
- char *filename;
- UNISTR2 data;
- int env_subkey_type = 0;
-
-
- DEBUG(8,("print_subpath_values_environments: Enter key => [%s]\n", key ? key : "NULL"));
-
- keystr = remaining_path( key + strlen(KEY_ENVIRONMENTS) );
-
- if ( !keystr )
- return 0;
-
- /* The only keys below KEY_PRINTING\Environments is the
- specific printer driver info */
-
- /* environment */
-
- pstrcpy( key2, keystr);
- keystr = key2;
- reg_split_path( keystr, &base, &subkeypath );
- if ( !subkeypath )
- return 0;
- fstrcpy( arch_environment, base );
-
- /* Driver */
-
- keystr = subkeypath;
- reg_split_path( keystr, &base, &subkeypath );
-
- if ( strequal(base, "Drivers") )
- env_subkey_type = ENVIRONMENT_DRIVERS;
- else if ( strequal(base, "Print Processors") )
- env_subkey_type = ENVIRONMENT_PRINTPROC;
- else
- /* invalid path */
- return -1;
-
- if ( !subkeypath )
- return 0;
-
- /* for now bail out if we are seeing anything other than the drivers key */
-
- if ( env_subkey_type == ENVIRONMENT_PRINTPROC )
- return 0;
-
- keystr = subkeypath;
- reg_split_path( keystr, &base, &subkeypath );
-
- version = atoi(&base[strlen(base)-1]);
-
- /* printer driver name */
-
- keystr = subkeypath;
- reg_split_path( keystr, &base, &subkeypath );
- /* don't go any deeper for now */
- if ( subkeypath )
- return 0;
- fstrcpy( driver, base );
- w_result = get_a_printer_driver( &driver_ctr, 3, driver, arch_environment, version );
+/**********************************************************************
+ *********************************************************************/
- if ( !W_ERROR_IS_OK(w_result) )
- return -1;
-
- /* build the values out of the driver information */
- info3 = driver_ctr.info_3;
+static void fill_in_driver_values( NT_PRINTER_DRIVER_INFO_LEVEL_3 *info3, REGVAL_CTR *values )
+{
+ char *buffer = NULL;
+ char *buffer2 = NULL;
+ int buffer_size = 0;
+ int i, length;
+ char *filename;
+ UNISTR2 data;
filename = dos_basename( info3->driverpath );
init_unistr2( &data, filename, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Driver", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ regval_ctr_addvalue( values, "Driver", REG_SZ, (char*)data.buffer,
+ data.uni_str_len*sizeof(uint16) );
filename = dos_basename( info3->configfile );
init_unistr2( &data, filename, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Configuration File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ regval_ctr_addvalue( values, "Configuration File", REG_SZ, (char*)data.buffer,
+ data.uni_str_len*sizeof(uint16) );
filename = dos_basename( info3->datafile );
init_unistr2( &data, filename, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Data File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ regval_ctr_addvalue( values, "Data File", REG_SZ, (char*)data.buffer,
+ data.uni_str_len*sizeof(uint16) );
filename = dos_basename( info3->helpfile );
init_unistr2( &data, filename, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Help File", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ regval_ctr_addvalue( values, "Help File", REG_SZ, (char*)data.buffer,
+ data.uni_str_len*sizeof(uint16) );
init_unistr2( &data, info3->defaultdatatype, UNI_STR_TERMINATE);
- regval_ctr_addvalue( values, "Data Type", REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
+ regval_ctr_addvalue( values, "Data Type", REG_SZ, (char*)data.buffer,
+ data.uni_str_len*sizeof(uint16) );
- regval_ctr_addvalue( values, "Version", REG_DWORD, (char*)&info3->cversion, sizeof(info3->cversion) );
+ regval_ctr_addvalue( values, "Version", REG_DWORD, (char*)&info3->cversion,
+ sizeof(info3->cversion) );
if ( info3->dependentfiles ) {
/* place the list of dependent files in a single
}
regval_ctr_addvalue( values, "Dependent Files", REG_MULTI_SZ, buffer, buffer_size );
+
+ SAFE_FREE( buffer );
- free_a_printer_driver( driver_ctr, 3 );
+ return;
+}
+
+/**********************************************************************
+ *********************************************************************/
+
+static int driver_arch_fetch_values( char *key, REGVAL_CTR *values )
+{
+ char *keystr, *base, *subkeypath;
+ fstring arch_environment;
+ fstring driver;
+ int version;
+ NT_PRINTER_DRIVER_INFO_LEVEL driver_ctr;
+ WERROR w_result;
+
+ reg_split_path( key, &base, &subkeypath );
- SAFE_FREE( buffer );
+ /* no values in 'Environments\Drivers\Windows NT x86' */
+
+ if ( !subkeypath )
+ return 0;
- DEBUG(8,("print_subpath_values_environments: Exit\n"));
+ /* 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 );
+
+ keystr = subkeypath;
+ reg_split_path( keystr, &base, &subkeypath );
+
+ if ( strequal(base, "Print Processors") )
+ return 0;
+
+ /* only Drivers key can be left */
+
+ if ( !strequal(base, "Drivers") )
+ return -1;
+
+ if ( !subkeypath )
+ return 0;
+
+ /* We know that we have Architechure\Drivers with some subkey name
+ The subkey name has to be Version-XX */
+
+ keystr = subkeypath;
+ reg_split_path( keystr, &base, &subkeypath );
+
+ if ( !subkeypath )
+ return 0;
+
+ version = atoi(&base[strlen(base)-1]);
+
+ /* BEGIN PRINTER DRIVER NAME BLOCK */
+
+ keystr = subkeypath;
+ reg_split_path( keystr, &base, &subkeypath );
+
+ /* don't go any deeper for now */
+
+ fstrcpy( driver, base );
+
+ w_result = get_a_printer_driver( &driver_ctr, 3, driver, arch_environment, version );
+
+ if ( !W_ERROR_IS_OK(w_result) )
+ return -1;
+
+ fill_in_driver_values( driver_ctr.info_3, values );
+
+ free_a_printer_driver( driver_ctr, 3 );
+
+ /* END PRINTER DRIVER NAME BLOCK */
+
+
+ DEBUG(8,("key_driver_fetch_values: Exit\n"));
return regval_ctr_numvals( values );
}
-static BOOL key_driver_store_values( const char *key, REGVAL_CTR *values )
+/**********************************************************************
+ *********************************************************************/
+
+static int key_driver_fetch_values( const char *key, REGVAL_CTR *values )
{
- return True;
+ char *keystr;
+ pstring subkey;
+
+ DEBUG(8,("key_driver_fetch_values: Enter key => [%s]\n", key ? key : "NULL"));
+
+ /* no values in the Environments key */
+
+ if ( !(keystr = remaining_path( key + strlen(KEY_ENVIRONMENTS) )) )
+ return 0;
+
+ pstrcpy( subkey, keystr);
+
+ /* pass off to handle subkeys */
+
+ return driver_arch_fetch_values( subkey, values );
}
-/**********************************************************************
- Deal with the 'Print' key the same whether it came from SYSTEM
- or SOFTWARE
+/*********************************************************************
+ *********************************************************************
+ ** "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRINT"
+ *********************************************************************
*********************************************************************/
static int key_print_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
}
/**********************************************************************
- If I can get rid of the 'enumports command', this code becomes
- a tdb lookup.
- *********************************************************************/
-
-static int key_ports_fetch_keys( const char *key, REGSUBKEY_CTR *subkeys )
-{
- /* no keys below ports */
-
- if ( remaining_path( key + strlen(KEY_PORTS) ) )
- return -1;
-
- return 0;
-}
-
-static BOOL key_ports_store_keys( const char *key, REGSUBKEY_CTR *subkeys )
-{
- return True;
-}
-
-static int key_ports_fetch_values( const char *key, REGVAL_CTR *values )
-{
- int numlines, i;
- char **lines;
- UNISTR2 data;
- WERROR result;
- char *p = remaining_path( key + strlen(KEY_PORTS) );
-
- /* no keys below ports */
- if ( p )
- return -1;
-
- if ( !W_ERROR_IS_OK(result = enumports_hook( &numlines, &lines )) )
- return -1;
-
- init_unistr2( &data, "", UNI_STR_TERMINATE);
- for ( i=0; i<numlines; i++ )
- regval_ctr_addvalue( values, lines[i], REG_SZ, (char*)data.buffer, data.uni_str_len*sizeof(uint16) );
-
- return regval_ctr_numvals( values );
-}
-
-static BOOL key_ports_store_values( const char *key, REGVAL_CTR *values )
-{
- return True;
-}
-
-/**********************************************************************
- Structure to hold dispatch table of ops for various printer keys.
- Make sure to always store deeper keys along the same path first so
- we ge a more specific match.
+ *********************************************************************
+ ** Structure to hold dispatch table of ops for various printer keys.
+ ** Make sure to always store deeper keys along the same path first so
+ ** we ge a more specific match.
+ *********************************************************************
*********************************************************************/
static struct reg_dyn_tree print_registry[] = {
&key_forms_fetch_values,
NULL },
{ KEY_CONTROL_PRINTERS,
- &key_printer_fetch_keys,
- &key_printer_store_keys,
- &key_printer_fetch_values,
- &key_printer_store_values },
+ &key_printers_fetch_keys,
+ &key_printers_store_keys,
+ &key_printers_fetch_values,
+ &key_printers_store_values },
{ KEY_ENVIRONMENTS,
&key_driver_fetch_keys,
- &key_driver_store_keys,
+ NULL,
&key_driver_fetch_values,
- &key_driver_store_values },
+ NULL },
{ KEY_CONTROL_PRINT,
&key_print_fetch_keys,
NULL,
NULL,
NULL },
{ KEY_WINNT_PRINTERS,
- &key_printer_fetch_keys,
- &key_printer_store_keys,
- &key_printer_fetch_values,
- &key_printer_store_values },
+ &key_printers_fetch_keys,
+ &key_printers_store_keys,
+ &key_printers_fetch_values,
+ &key_printers_store_values },
{ KEY_PORTS,
- &key_ports_fetch_keys,
- &key_ports_store_keys,
- &key_ports_fetch_values,
- &key_ports_store_values },
+ ®db_fetch_keys,
+ ®db_store_keys,
+ ®db_fetch_values,
+ ®db_store_values },
{ NULL, NULL, NULL, NULL, NULL }
};
/**********************************************************************
+ *********************************************************************
+ ** Main reg_printing interface functions
+ *********************************************************************
*********************************************************************/
-
+
+/***********************************************************************
+ Lookup a key in the print_registry table, returning its index.
+ -1 on failure
+ **********************************************************************/
+
static int match_registry_path( const char *key )
{
int i;
return -1;
}
-/**********************************************************************
- *********************************************************************/
-
+/***********************************************************************
+ **********************************************************************/
+
static int regprint_fetch_reg_keys( const char *key, REGSUBKEY_CTR *subkeys )
{
int i = match_registry_path( key );
git.samba.org / ira / wip.git / blobdiff