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  It is safe to assume that every registry path passed into on of
  44  the exported functions here begins with KEY_PRINTING else
  45  these functions would have never been called.  This is a small utility
  46  function to strip the beginning of the path and make a copy that the
  47  caller can modify.  Note that the caller is responsible for releasing
  48  the memory allocated here.
  49  **********************************************************************/
  50
  51 static char* trim_reg_path( char *path )
  52 {
  53         char *p;
  54
  55         p = path + strlen(KEY_PRINTING);
  56
  57         if ( *p )
  58                 return strdup(p);
  59         else
  60                 return NULL;
  61 }
  62
  63 /**********************************************************************
  64  handle enumeration of subkeys below KEY_PRINTING.
  65  *********************************************************************/
  66
  67 static int handle_printing_subpath( char *key, char **subkeys, uint32 index )
  68 {
  69         int result = 0;
  70         char *p, *base;
  71         int i;
  72
  73
  74         /*
  75          * break off the first part of the path
  76          * topmost base **must** be one of the strings
  77          * in top_level_keys[]
  78          */
  79
  80         base = key;
  81         p = strchr( key, '\\' );
  82         if ( p )
  83                 *p = '\0';
  84
  85         for ( i=0; i<MAX_TOP_LEVEL_KEYS; i++ ) {
  86                 if ( StrCaseCmp( top_level_keys[i], base ) == 0 )
  87                         break;
  88         }
  89
  90         if ( !(i < MAX_TOP_LEVEL_KEYS) )
  91                 return -1;
  92
  93         /* Call routine to handle each top level key */
  94         switch ( i )
  95         {
  96                 case KEY_INDEX_ENVIR:
  97                         break;
  98
  99                 case KEY_INDEX_FORMS:
 100                         break;
 101
 102                 case KEY_INDEX_PRINTER:
 103                         break;
 104
 105                 /* default case for top level key that has no handler */
 106
 107                 default:
 108                         break;
 109         }
 110
 111
 112
 113         return result;
 114
 115 }
 116 /**********************************************************************
 117  Enumerate registry subkey names given a registry path.
 118  Caller is responsible for freeing memory to **subkeys
 119  *********************************************************************/
 120
 121 int printing_subkey_info( char *key, char **subkeys )
 122 {
 123         char            *path;
 124         BOOL            top_level = False;
 125         int             num_subkeys = 0;
 126
 127         DEBUG(10,("printing_subkey_info: key=>[%s]\n", key));
 128
 129         path = trim_reg_path( key );
 130
 131         /* check to see if we are dealing with the top level key */
 132
 133         if ( !path )
 134                 top_level = True;
 135
 136         if ( top_level ) {
 137                 if ( ! (*subkeys = malloc( sizeof(top_level_keys) )) )
 138                         goto done;
 139
 140                 num_subkeys = MAX_TOP_LEVEL_KEYS;
 141                 memcpy( *subkeys, top_level_keys, sizeof(top_level_keys) );
 142         }
 143         else
 144                 num_subkeys = handle_printing_subpath( path, subkeys, -1 );
 145
 146 done:
 147         SAFE_FREE( path );
 148         return num_subkeys;
 149 }
 150
 151 /**********************************************************************
 152  Count the registry subkey names given a registry path.
 153  Caller is responsible for freeing memory to **subkey
 154  *********************************************************************/
 155
 156 BOOL printing_subkey_specific( char *key, char** subkey, uint32 index )
 157 {
 158         char            *path;
 159         BOOL            top_level = False;
 160         BOOL            result = False;
 161
 162         DEBUG(10,("printing_subkey_specific: key=>[%s], index=>[%d]\n", key, index));
 163
 164         path = trim_reg_path( key );
 165
 166         /* check to see if we are dealing with the top level key */
 167
 168         if ( !path )
 169                 top_level = True;
 170
 171
 172
 173         if ( top_level ) {
 174
 175                 /* make sure the index is in range */
 176
 177                 if ( !(index < MAX_TOP_LEVEL_KEYS) )
 178                         goto done;
 179
 180                 if ( !(*subkey = malloc( strlen(top_level_keys[index])+1 )) )
 181                         goto done;
 182
 183                 strncpy( *subkey, top_level_keys[index], strlen(top_level_keys[index])+1 );
 184
 185                 result = True;
 186         }
 187         else {
 188                 if ( handle_printing_subpath( path, subkey, index ) != -1 )
 189                         result = True;
 190         }
 191
 192 done:
 193         SAFE_FREE( path );
 194
 195         return result;
 196 }
 197
 198 /**********************************************************************
 199  Enumerate registry values given a registry path.
 200  Caller is responsible for freeing memory
 201  *********************************************************************/
 202
 203 int printing_value_info( char *key, REGISTRY_VALUE **val )
 204 {
 205         DEBUG(10,("printing_value_info: key=>[%s]\n", key));
 206
 207         return 0;
 208 }
 209
 210 /**********************************************************************
 211  Stub function which always returns failure since we don't want
 212  people storing printing information directly via regostry calls
 213  (for now at least)
 214  *********************************************************************/
 215
 216 BOOL printing_store_subkey( char *key, char **subkeys, uint32 num_subkeys )
 217 {
 218         return False;
 219 }
 220
 221 /**********************************************************************
 222  Stub function which always returns failure since we don't want
 223  people storing printing information directly via regostry calls
 224  (for now at least)
 225  *********************************************************************/
 226
 227 BOOL printing_store_value( char *key, REGISTRY_VALUE **val, uint32 num_values )
 228 {
 229         return False;
 230 }
 231
 232 /*
 233  * Table of function pointers for accessing printing data
 234  */
 235
 236 REGISTRY_OPS printing_ops = {
 237         printing_subkey_info,
 238         printing_subkey_specific,
 239         printing_value_info,
 240         printing_store_subkey,
 241         printing_store_value
 242 };
 243