source3/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         fstring                 mydomainname;
  87
  88
  89         hname = myhostname();
  90         value_length = push_ucs2( value, value, hname, sizeof(value), STR_TERMINATE|STR_NOALIGN);
  91         regval_ctr_addvalue( regvals, "Hostname",REG_SZ, value, value_length );
  92
  93         get_mydnsdomname( mydomainname );
  94         value_length = push_ucs2( value, value, mydomainname, sizeof(value), STR_TERMINATE|STR_NOALIGN);
  95         regval_ctr_addvalue( regvals, "Domain", REG_SZ, value, value_length );
  96
  97         return regval_ctr_numvals( regvals );
  98 }
  99
 100 /***********************************************************************
 101 ***********************************************************************/
 102
 103 static int perflib_params( REGVAL_CTR *regvals )
 104 {
 105         int base_index = -1;
 106         int last_counter = -1;
 107         int last_help = -1;
 108         int version = 0x00010001;
 109
 110         base_index = reg_perfcount_get_base_index();
 111         regval_ctr_addvalue(regvals, "Base Index", REG_DWORD, (char *)&base_index, sizeof(base_index));
 112         last_counter = reg_perfcount_get_last_counter(base_index);
 113         regval_ctr_addvalue(regvals, "Last Counter", REG_DWORD, (char *)&last_counter, sizeof(last_counter));
 114         last_help = reg_perfcount_get_last_help(last_counter);
 115         regval_ctr_addvalue(regvals, "Last Help", REG_DWORD, (char *)&last_help, sizeof(last_help));
 116         regval_ctr_addvalue(regvals, "Version", REG_DWORD, (char *)&version, sizeof(version));
 117
 118         return regval_ctr_numvals( regvals );
 119 }
 120
 121 /***********************************************************************
 122 ***********************************************************************/
 123
 124 static int perflib_009_params( REGVAL_CTR *regvals )
 125 {
 126         int base_index;
 127         int buffer_size;
 128         char *buffer = NULL;
 129
 130         base_index = reg_perfcount_get_base_index();
 131         buffer_size = reg_perfcount_get_counter_names(base_index, &buffer);
 132         regval_ctr_addvalue(regvals, "Counter", REG_MULTI_SZ, buffer, buffer_size);
 133         if(buffer_size > 0)
 134                 SAFE_FREE(buffer);
 135         buffer_size = reg_perfcount_get_counter_help(base_index, &buffer);
 136         regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, buffer, buffer_size);
 137         if(buffer_size > 0)
 138                 SAFE_FREE(buffer);
 139
 140         return regval_ctr_numvals( regvals );
 141 }
 142
 143 /***********************************************************************
 144 ***********************************************************************/
 145
 146 static int hkpt_params( REGVAL_CTR *regvals )
 147 {
 148         uint32 base_index;
 149         uint32 buffer_size;
 150         char *buffer = NULL;
 151
 152         /* This is ALMOST the same as perflib_009_params, but HKPT has
 153            a "Counters" entry instead of a "Counter" key. <Grrrr> */
 154
 155         base_index = reg_perfcount_get_base_index();
 156         buffer_size = reg_perfcount_get_counter_names(base_index, &buffer);
 157         regval_ctr_addvalue(regvals, "Counters", REG_MULTI_SZ, buffer, buffer_size);
 158
 159         if(buffer_size > 0)
 160                 SAFE_FREE(buffer);
 161
 162         buffer_size = reg_perfcount_get_counter_help(base_index, &buffer);
 163         regval_ctr_addvalue(regvals, "Help", REG_MULTI_SZ, buffer, buffer_size);
 164         if(buffer_size > 0)
 165                 SAFE_FREE(buffer);
 166
 167         return regval_ctr_numvals( regvals );
 168 }
 169
 170 /***********************************************************************
 171 ***********************************************************************/
 172
 173 static int current_version( REGVAL_CTR *values )
 174 {
 175         const char *sysroot_string = "c:\\Windows";
 176         fstring sysversion;
 177         fstring value;
 178         uint32 value_length;
 179
 180         value_length = push_ucs2( value, value, sysroot_string, sizeof(value),
 181                 STR_TERMINATE|STR_NOALIGN );
 182         regval_ctr_addvalue( values, "SystemRoot", REG_SZ, value, value_length );
 183
 184         fstr_sprintf( sysversion, "%d.%d", lp_major_announce_version(), lp_minor_announce_version() );
 185         value_length = push_ucs2( value, value, sysversion, sizeof(value),
 186                 STR_TERMINATE|STR_NOALIGN );
 187         regval_ctr_addvalue( values, "CurrentVersion", REG_SZ, value, value_length );
 188
 189
 190         return regval_ctr_numvals( values );
 191 }
 192
 193
 194 /***********************************************************************
 195  Structure holding the registry paths and pointers to the value
 196  enumeration functions
 197 ***********************************************************************/
 198
 199 static struct reg_dyn_values dynamic_values[] = {
 200         { "HKLM/SYSTEM/CURRENTCONTROLSET/SERVICES/NETLOGON/PARAMETERS", &netlogon_params  },
 201         { "HKLM/SYSTEM/CURRENTCONTROLSET/CONTROL/PRODUCTOPTIONS",       &prod_options     },
 202         { "HKLM/SYSTEM/CURRENTCONTROLSET/SERVICES/TCPIP/PARAMETERS",    &tcpip_params     },
 203         { "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PERFLIB",  &perflib_params   },
 204         { "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION/PERFLIB/009", &perflib_009_params },
 205         { "HKLM/SOFTWARE/MICROSOFT/WINDOWS NT/CURRENTVERSION",          &current_version },
 206         { "HKPT", &hkpt_params },
 207         { NULL, NULL }
 208 };
 209
 210 /***********************************************************************
 211 ***********************************************************************/
 212
 213 int fetch_dynamic_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
 214 {
 215         int i;
 216         pstring path;
 217
 218         pstrcpy( path, key->name );
 219         normalize_reg_path( path );
 220
 221         for ( i=0; dynamic_values[i].path; i++ ) {
 222                 if ( strcmp( path, dynamic_values[i].path ) == 0 )
 223                         return dynamic_values[i].fetch_values( val );
 224         }
 225
 226         return -1;
 227 }
 228
 229 /***********************************************************************
 230 ***********************************************************************/
 231
 232 bool check_dynamic_reg_values( REGISTRY_KEY *key )
 233 {
 234         int i;
 235         pstring path;
 236
 237         pstrcpy( path, key->name );
 238         normalize_reg_path( path );
 239
 240         for ( i=0; dynamic_values[i].path; i++ ) {
 241                 /* can't write to dynamic keys */
 242                 if ( strcmp( path, dynamic_values[i].path ) == 0 )
 243                         return True;
 244         }
 245
 246         return False;
 247 }
 248