source/registry/reg_dynamic.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Virtual Windows Registry Layer
   4  *  Copyright (C) Gerald Carter                     2002-2005
   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 3 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, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /* Implementation of registry frontend view functions. */
  21
  22 #include "includes.h"
  23
  24 #undef DBGC_CLASS
  25 #define DBGC_CLASS DBGC_REGISTRY
  26
  27 struct reg_dyn_values {
  28         const char *path;
  29         int (*fetch_values) ( REGVAL_CTR *val );
  30 };
  31
  32 /***********************************************************************
  33 ***********************************************************************/
  34
  35 static int netlogon_params( REGVAL_CTR *regvals )
  36 {
  37         uint32 dwValue;
  38
  39         if ( !pdb_get_account_policy(AP_REFUSE_MACHINE_PW_CHANGE, &dwValue) )
  40                 dwValue = 0;
  41
  42         regval_ctr_addvalue( regvals, "RefusePasswordChange", REG_DWORD,
  43                 (char*)&dwValue, sizeof(dwValue) );
  44
  45         return regval_ctr_numvals( regvals );
  46 }
  47
  48 /***********************************************************************
  49 ***********************************************************************/
  50
  51 static int prod_options( REGVAL_CTR *regvals )
  52 {
  53         const char              *value_ascii = "";
  54         fstring                 value;
  55         int                     value_length;
  56
  57         switch (lp_server_role()) {
  58                 case ROLE_DOMAIN_PDC:
  59                 case ROLE_DOMAIN_BDC:
  60                         value_ascii = "LanmanNT";
  61                         break;
  62                 case ROLE_STANDALONE:
  63                         value_ascii = "ServerNT";
  64                         break;
  65                 case ROLE_DOMAIN_MEMBER:
  66                         value_ascii = "WinNT";
  67                         break;
  68         }
  69
  70         value_length = push_ucs2( value, value, value_ascii, sizeof(value),
  71                 STR_TERMINATE|STR_NOALIGN );
  72         regval_ctr_addvalue( regvals, "ProductType", REG_SZ, value,
  73                 value_length );
  74
  75         return regval_ctr_numvals( regvals );
  76 }
  77
  78 /***********************************************************************
  79 ***********************************************************************/
  80
  81 static int tcpip_params( REGVAL_CTR *regvals )
  82 {
  83         fstring                 value;
  84         int                     value_length;
  85         char                    *hname;
  86         char *mydomainname = NULL;
  87
  88         hname = myhostname();
  89         value_length = push_ucs2( value, value, hname, sizeof(value), STR_TERMINATE|STR_NOALIGN);
  90         regval_ctr_addvalue( regvals, "Hostname",REG_SZ, value, value_length );
  91
  92         mydomainname = get_mydnsdomname(talloc_tos());
  93         if (!mydomainname) {
  94                 return -1;
  95         }
  96
  97         value_length = push_ucs2( value, value, mydomainname, sizeof(value), STR_TERMINATE|STR_NOALIGN);
  98         regval_ctr_addvalue( regvals, "Domain", REG_SZ, value, value_length );
  99
 100         return regval_ctr_numvals( regvals );
 101 }
 102
 103 /***********************************************************************
 104 ***********************************************************************/
 105
 106 static int perflib_params( REGVAL_CTR *regvals )
 107 {
 108         int base_index = -1;
 109         int last_counter = -1;
 110         int last_help = -1;
 111         int version = 0x00010001;
 112
 113         base_index = reg_perfcount_get_base_index();
 114         regval_ctr_addvalue(regvals, "Base Index", REG_DWORD, (char *)&base_index, sizeof(base_index));
 115         last_counter = reg_perfcount_get_last_counter(base_index);
 116         regval_ctr_addvalue(regvals, "Last Counter", REG_DWORD, (char *)&last_counter, sizeof(last_counter));
 117         last_help = reg_perfcount_get_last_help(last_counter);
 118         regval_ctr_addvalue(regvals, "Last Help", REG_DWORD, (char *)&last_help, sizeof(last_help));
 119         regval_ctr_addvalue(regvals, "Version", REG_DWORD, (char *)&version, sizeof(version));
 120
 121         return regval_ctr_numvals( regvals );
 122 }
 123
 124 /***********************************************************************
 125 ***********************************************************************/
 126
 127 static int perflib_009_params( REGVAL_CTR *regvals )
 128 {
 129         int base_index;
 130         int buffer_size;
 131         char *buffer = NULL;
 132
 133         base_index = reg_perfcount_get_base_index();
 134         buffer_size = reg_perfcount_get_counter_names(base_index, &buffer);
 135         regval_ctr_addvalue(regvals, "Counter", REG_MULTI_SZ, buffer, buffer_size);
 136         if(buffer_size > 0)
 137                 SAFE_FREE(buffer);
 138         buffer_size = reg_perfcount_get_counter_help(base_index, &buffer);
 139         regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, buffer, buffer_size);
 140         if(buffer_size > 0)
 141                 SAFE_FREE(buffer);
 142
 143         return regval_ctr_numvals( regvals );
 144 }
 145
 146 /***********************************************************************
 147 ***********************************************************************/
 148
 149 static int hkpt_params( REGVAL_CTR *regvals )
 150 {
 151         uint32 base_index;
 152         uint32 buffer_size;
 153         char *buffer = NULL;
 154
 155         /* This is ALMOST the same as perflib_009_params, but HKPT has
 156            a "Counters" entry instead of a "Counter" key. <Grrrr> */
 157
 158         base_index = reg_perfcount_get_base_index();
 159         buffer_size = reg_perfcount_get_counter_names(base_index, &buffer);
 160         regval_ctr_addvalue(regvals, "Counters", REG_MULTI_SZ, buffer, buffer_size);
 161
 162         if(buffer_size > 0)
 163                 SAFE_FREE(buffer);
 164
 165         buffer_size = reg_perfcount_get_counter_help(base_index, &buffer);
 166         regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, buffer, buffer_size);
 167         if(buffer_size > 0)
 168                 SAFE_FREE(buffer);
 169
 170         return regval_ctr_numvals( regvals );
 171 }
 172
 173 /***********************************************************************
 174 ***********************************************************************/
 175
 176 static int current_version( REGVAL_CTR *values )
 177 {
 178         const char *sysroot_string = "c:\\Windows";
 179         fstring sysversion;
 180         fstring value;
 181         uint32 value_length;
 182
 183         value_length = push_ucs2( value, value, sysroot_string, sizeof(value),
 184                 STR_TERMINATE|STR_NOALIGN );
 185         regval_ctr_addvalue( values, "SystemRoot", REG_SZ, value, value_length );
 186
 187         fstr_sprintf( sysversion, "%d.%d", lp_major_announce_version(), lp_minor_announce_version() );
 188         value_length = push_ucs2( value, value, sysversion, sizeof(value),
 189                 STR_TERMINATE|STR_NOALIGN );
 190         regval_ctr_addvalue( values, "CurrentVersion", REG_SZ, value, value_length );
 191
 192
 193         return regval_ctr_numvals( values );
 194 }
 195
 196
 197 /***********************************************************************
 198  Structure holding the registry paths and pointers to the value
 199  enumeration functions
 200 ***********************************************************************/
 201
 202 static struct reg_dyn_values dynamic_values[] = {
 203         { "HKLM/SYSTEM/CURRENTCONTROLSET/SERVICES/NETLOGON/PARAMETERS", &netlogon_params  },
 204         { "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRODUCTOPTIONS",       &prod_options     },
 205         { "HKLM/SYSTEM/CURRENTCONTROLSET/SERVICES/TCPIP/PARAMETERS",    &tcpip_params     },
 206         { "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PERFLIB",  &perflib_params   },
 207         { "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PERFLIB/009", &perflib_009_params },
 208         { "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION",          &current_version },
 209         { "HKPT", &hkpt_params },
 210         { NULL, NULL }
 211 };
 212
 213 /***********************************************************************
 214 ***********************************************************************/
 215
 216 int fetch_dynamic_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
 217 {
 218         int i;
 219         char *path = NULL;
 220         TALLOC_CTX *ctx = talloc_tos();
 221
 222         path = talloc_strdup(ctx, key->name);
 223         if (!path) {
 224                 return -1;
 225         }
 226         path = normalize_reg_path(ctx, path);
 227         if (!path) {
 228                 return -1;
 229         }
 230
 231         for ( i=0; dynamic_values[i].path; i++ ) {
 232                 if ( strcmp( path, dynamic_values[i].path ) == 0 )
 233                         return dynamic_values[i].fetch_values( val );
 234         }
 235
 236         return -1;
 237 }
 238
 239 /***********************************************************************
 240 ***********************************************************************/
 241
 242 bool check_dynamic_reg_values( REGISTRY_KEY *key )
 243 {
 244         int i;
 245         char *path = NULL;
 246         TALLOC_CTX *ctx = talloc_tos();
 247
 248         path = talloc_strdup(ctx, key->name);
 249         if (!path) {
 250                 return false;
 251         }
 252         path = normalize_reg_path(ctx, path);
 253         if (!path) {
 254                 return false;
 255         }
 256
 257         for ( i=0; dynamic_values[i].path; i++ ) {
 258                 /* can't write to dynamic keys */
 259                 if ( strcmp( path, dynamic_values[i].path ) == 0 )
 260                         return true;
 261         }
 262
 263         return false;
 264 }