source/registry/reg_printing.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Gerald Carter                     2002.
   5  *
   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 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  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.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 /* Implementation of registry virtual views for printing information */
  22
  23 #include "includes.h"
  24
  25 #undef DBGC_CLASS
  26 #define DBGC_CLASS DBGC_RPC_SRV
  27
  28 #define MAX_TOP_LEVEL_KEYS      3
  29
  30 /* some symbolic indexes into the top_level_keys */
  31
  32 #define KEY_INDEX_ENVIR         0
  33 #define KEY_INDEX_FORMS         1
  34 #define KEY_INDEX_PRINTER       2
  35
  36 static char *top_level_keys[MAX_TOP_LEVEL_KEYS] = {
  37         "Environments",
  38         "Forms",
  39         "Printers"
  40 };
  41
  42
  43 /**********************************************************************
  44  It is safe to assume that every registry path passed into on of
  45  the exported functions here begins with KEY_PRINTING else
  46  these functions would have never been called.  This is a small utility
  47  function to strip the beginning of the path and make a copy that the
  48  caller can modify.  Note that the caller is responsible for releasing
  49  the memory allocated here.
  50  **********************************************************************/
  51
  52 static char* trim_reg_path( char *path )
  53 {
  54         char *p;
  55         uint16 key_len = strlen(KEY_PRINTING);
  56
  57         /*
  58          * sanity check...this really should never be True.
  59          * It is only here to prevent us from accessing outside
  60          * the path buffer in the extreme case.
  61          */
  62
  63         if ( strlen(path) < key_len ) {
  64                 DEBUG(0,("trim_reg_path: Registry path too short! [%s]\n", path));
  65                 DEBUG(0,("trim_reg_path: KEY_PRINTING => [%s]!\n", KEY_PRINTING));
  66                 return NULL;
  67         }
  68
  69
  70         p = path + strlen( KEY_PRINTING );
  71
  72         if ( *p == '\\' )
  73                 p++;
  74
  75         if ( *p )
  76                 return strdup(p);
  77         else
  78                 return NULL;
  79 }
  80
  81 /**********************************************************************
  82  handle enumeration of subkeys below KEY_PRINTING\Environments
  83  *********************************************************************/
  84
  85 static int print_subpath_environments( char *key, REGSUBKEY_CTR *subkeys )
  86 {
  87         DEBUG(10,("print_subpath_environments: key=>[%s]\n", key ? key : "NULL" ));
  88
  89         if ( !key )
  90         {
  91                 /* listed architectures of installed drivers */
  92
  93         }
  94
  95
  96         return 0;
  97 }
  98
  99 /**********************************************************************
 100  handle enumeration of subkeys below KEY_PRINTING\Forms
 101  Really just a stub function, but left here in case it needs to
 102  be expanded later on
 103  *********************************************************************/
 104
 105 static int print_subpath_forms( char *key, REGSUBKEY_CTR *subkeys )
 106 {
 107         DEBUG(10,("print_subpath_forms: key=>[%s]\n", key ? key : "NULL" ));
 108
 109         /* there are no subkeys */
 110
 111         if ( key )
 112                 return -1;
 113
 114         return 0;
 115 }
 116
 117 /**********************************************************************
 118  handle enumeration of values below KEY_PRINTING\Forms
 119  *********************************************************************/
 120
 121 static int print_subpath_values_forms( char *key, REGVAL_CTR *val )
 122 {
 123         int             num_values = 0;
 124         uint32          data[8];
 125         int             form_index = 1;
 126
 127         DEBUG(10,("print_values_forms: key=>[%s]\n", key ? key : "NULL" ));
 128
 129         /* handle ..\Forms\ */
 130
 131         if ( !key )
 132         {
 133                 nt_forms_struct *forms_list = NULL;
 134                 nt_forms_struct *form = NULL;
 135                 int i;
 136
 137                 if ( (num_values = get_ntforms( &forms_list )) == 0 )
 138                         return 0;
 139
 140                 DEBUG(10,("print_subpath_values_forms: [%d] user defined forms returned\n",
 141                         num_values));
 142
 143                 /* handle user defined forms */
 144
 145                 for ( i=0; i<num_values; i++ )
 146                 {
 147                         form = &forms_list[i];
 148
 149                         data[0] = form->width;
 150                         data[1] = form->length;
 151                         data[2] = form->left;
 152                         data[3] = form->top;
 153                         data[4] = form->right;
 154                         data[5] = form->bottom;
 155                         data[6] = form_index++;
 156                         data[7] = form->flag;
 157
 158                         regval_ctr_addvalue( val, form->name, REG_BINARY, (char*)data, sizeof(data) );
 159
 160                 }
 161
 162                 SAFE_FREE( forms_list );
 163                 forms_list = NULL;
 164
 165                 /* handle built-on forms */
 166
 167                 if ( (num_values = get_builtin_ntforms( &forms_list )) == 0 )
 168                         return 0;
 169
 170                 DEBUG(10,("print_subpath_values_forms: [%d] built-in forms returned\n",
 171                         num_values));
 172
 173                 for ( i=0; i<num_values; i++ )
 174                 {
 175                         form = &forms_list[i];
 176
 177                         data[0] = form->width;
 178                         data[1] = form->length;
 179                         data[2] = form->left;
 180                         data[3] = form->top;
 181                         data[4] = form->right;
 182                         data[5] = form->bottom;
 183                         data[6] = form_index++;
 184                         data[7] = form->flag;
 185
 186                         regval_ctr_addvalue( val, form->name, REG_BINARY, (char*)data, sizeof(data) );
 187                 }
 188
 189                 SAFE_FREE( forms_list );
 190         }
 191
 192         return num_values;
 193 }
 194
 195 /**********************************************************************
 196  handle enumeration of subkeys below KEY_PRINTING\Printers
 197  *********************************************************************/
 198
 199 static int print_subpath_printers( char *key, REGSUBKEY_CTR *subkeys )
 200 {
 201         int n_services = lp_numservices();
 202         int snum;
 203         fstring sname;
 204
 205         DEBUG(10,("print_subpath_printers: key=>[%s]\n", key ? key : "NULL" ));
 206
 207         if ( !key )
 208         {
 209                 /* enumerate all printers */
 210
 211                 for (snum=0; snum<n_services; snum++) {
 212                         if ( !(lp_snum_ok(snum) && lp_print_ok(snum) ) )
 213                                 continue;
 214
 215                         fstrcpy( sname, lp_servicename(snum) );
 216
 217                         regsubkey_ctr_addkey( subkeys, sname );
 218                 }
 219         }
 220         else
 221         {
 222                 /* get information for a specific printer */
 223         }
 224
 225         return regsubkey_ctr_numkeys( subkeys );
 226 }
 227
 228 /**********************************************************************
 229  Routine to handle enumeration of subkeys and values
 230  below KEY_PRINTING (depending on whether or not subkeys/val are
 231  valid pointers.
 232  *********************************************************************/
 233
 234 static int handle_printing_subpath( char *key, REGSUBKEY_CTR *subkeys, REGVAL_CTR *val )
 235 {
 236         int result = 0;
 237         char *p, *base;
 238         int i;
 239
 240         DEBUG(10,("handle_printing_subpath: key=>[%s]\n", key ));
 241
 242         /*
 243          * break off the first part of the path
 244          * topmost base **must** be one of the strings
 245          * in top_level_keys[]
 246          */
 247
 248         reg_split_path( key, &base, &p);
 249
 250         for ( i=0; i<MAX_TOP_LEVEL_KEYS; i++ ) {
 251                 if ( StrCaseCmp( top_level_keys[i], base ) == 0 )
 252                         break;
 253         }
 254
 255         DEBUG(10,("handle_printing_subpath: base=>[%s], i==[%d]\n", base, i));
 256
 257         if ( !(i < MAX_TOP_LEVEL_KEYS) )
 258                 return -1;
 259
 260         /* Call routine to handle each top level key */
 261         switch ( i )
 262         {
 263                 case KEY_INDEX_ENVIR:
 264                         if ( subkeys )
 265                                 print_subpath_environments( p, subkeys );
 266                         break;
 267
 268                 case KEY_INDEX_FORMS:
 269                         if ( subkeys )
 270                                 print_subpath_forms( p, subkeys );
 271                         if ( val )
 272                                 print_subpath_values_forms( p, val );
 273                         break;
 274
 275                 case KEY_INDEX_PRINTER:
 276                         if ( subkeys )
 277                                 print_subpath_printers( p, subkeys );
 278                         break;
 279
 280                 /* default case for top level key that has no handler */
 281
 282                 default:
 283                         break;
 284         }
 285
 286
 287
 288         return result;
 289
 290 }
 291 /**********************************************************************
 292  Enumerate registry subkey names given a registry path.
 293  Caller is responsible for freeing memory to **subkeys
 294  *********************************************************************/
 295
 296 int printing_subkey_info( char *key, REGSUBKEY_CTR *subkey_ctr )
 297 {
 298         char            *path;
 299         BOOL            top_level = False;
 300         int             num_subkeys = 0;
 301
 302         DEBUG(10,("printing_subkey_info: key=>[%s]\n", key));
 303
 304         path = trim_reg_path( key );
 305
 306         /* check to see if we are dealing with the top level key */
 307
 308         if ( !path )
 309                 top_level = True;
 310
 311         if ( top_level ) {
 312                 for ( num_subkeys=0; num_subkeys<MAX_TOP_LEVEL_KEYS; num_subkeys++ )
 313                         regsubkey_ctr_addkey( subkey_ctr, top_level_keys[num_subkeys] );
 314         }
 315         else
 316                 num_subkeys = handle_printing_subpath( path, subkey_ctr, NULL );
 317
 318         SAFE_FREE( path );
 319
 320         return num_subkeys;
 321 }
 322
 323 /**********************************************************************
 324  Enumerate registry values given a registry path.
 325  Caller is responsible for freeing memory
 326  *********************************************************************/
 327
 328 int printing_value_info( char *key, REGVAL_CTR *val )
 329 {
 330         char            *path;
 331         BOOL            top_level = False;
 332         int             num_values = 0;
 333
 334         DEBUG(10,("printing_value_info: key=>[%s]\n", key));
 335
 336         path = trim_reg_path( key );
 337
 338         /* check to see if we are dealing with the top level key */
 339
 340         if ( !path )
 341                 top_level = True;
 342
 343         /* fill in values from the getprinterdata_printer_server() */
 344         if ( top_level )
 345                 num_values = 0;
 346         else
 347                 num_values = handle_printing_subpath( path, NULL, val );
 348
 349
 350         return num_values;
 351 }
 352
 353 /**********************************************************************
 354  Stub function which always returns failure since we don't want
 355  people storing printing information directly via regostry calls
 356  (for now at least)
 357  *********************************************************************/
 358
 359 BOOL printing_store_subkey( char *key, REGSUBKEY_CTR *subkeys )
 360 {
 361         return False;
 362 }
 363
 364 /**********************************************************************
 365  Stub function which always returns failure since we don't want
 366  people storing printing information directly via regostry calls
 367  (for now at least)
 368  *********************************************************************/
 369
 370 BOOL printing_store_value( char *key, REGVAL_CTR *val )
 371 {
 372         return False;
 373 }
 374
 375 /*
 376  * Table of function pointers for accessing printing data
 377  */
 378
 379 REGISTRY_OPS printing_ops = {
 380         printing_subkey_info,
 381         printing_value_info,
 382         printing_store_subkey,
 383         printing_store_value
 384 };
 385
 386