source4/scripting/libjs/winreg.js

   1 /*
   2         winreg rpc utility functions
   3         Copyright Andrew Tridgell 2005
   4         released under the GNU GPL version 3 or later
   5 */
   6
   7 libinclude("base.js");
   8
   9 /*
  10   close a handle
  11 */
  12 function __winreg_close(handle)
  13 {
  14         var io = irpcObj();
  15         io.input.handle = handle;
  16         this.winreg_CloseKey(io);
  17 }
  18
  19
  20 /*
  21   open a hive
  22 */
  23 function __winreg_open_hive(hive)
  24 {
  25         var io = irpcObj();
  26         io.input.system_name = NULL;
  27         io.input.access_mask = this.SEC_FLAG_MAXIMUM_ALLOWED;
  28         var status;
  29         if (hive == "HKLM") {
  30                 status = this.winreg_OpenHKLM(io);
  31         } else if (hive == "HKCR") {
  32                 status = this.winreg_OpenHKCR(io);
  33         } else if (hive == "HKPD") {
  34                 status = this.winreg_OpenHKPD(io);
  35         } else if (hive == "HKU") {
  36                 status = this.winreg_OpenHKU(io);
  37         } else {
  38                 this._last_error = "Unknown hive " + hive;
  39                 return undefined;
  40         }
  41         if (!status.is_ok) {
  42                 return undefined;
  43         }
  44         return io.output.handle;
  45 }
  46
  47 /*
  48   open a handle to a path
  49 */
  50 function __winreg_open_path(path)
  51 {
  52         var s = string_init();
  53         var i, components = s.split('\\', path);
  54
  55         /* cope with a leading slash */
  56         if (components[0] == '') {
  57                 for (i=0;i<(components.length-1);i++) {
  58                         components[i] = components[i+1];
  59                 }
  60                 delete(components[i]);
  61         }
  62
  63         if (components.length == 0) {
  64                 return undefined;
  65         }
  66
  67         var handle = this.open_hive(components[0]);
  68         if (handle == undefined) {
  69                 return undefined;
  70         }
  71
  72         if (components.length == 1) {
  73                 return handle;
  74         }
  75
  76         var hpath = components[1];
  77
  78         for (i=2;i<components.length;i++) {
  79                 hpath = hpath + "\\" + components[i];
  80         }
  81
  82         io = irpcObj();
  83         io.input.parent_handle  = handle;
  84         io.input.keyname = hpath;
  85         io.input.unknown = 0;
  86         io.input.access_mask = this.SEC_FLAG_MAXIMUM_ALLOWED;
  87         var status = this.winreg_OpenKey(io);
  88
  89         this.close(handle);
  90
  91         if (!status.is_ok) {
  92                 return undefined;
  93         }
  94         if (io.output.result != "WERR_OK") {
  95                 return undefined;
  96         }
  97
  98         return io.output.handle;
  99 }
 100
 101 /*
 102         return a list of keys for a winreg server given a path
 103         usage:
 104            list = reg.enum_path(path);
 105 */
 106 function __winreg_enum_path(path)
 107 {
 108         var list = new Array(0);
 109
 110         if (path == null || path == "\\" || path == "") {
 111                 return new Array("HKLM", "HKU");
 112         }
 113
 114         var handle = this.open_path(path);
 115         if (handle == undefined) {
 116                 return undefined;
 117         }
 118
 119         var io = irpcObj();
 120         io.input.handle            = handle;
 121         io.input.name = new Object();
 122         io.input.name.length = 0;
 123         io.input.name.size   = 32;
 124         io.input.name.name   = NULL;
 125         io.input.keyclass = new Object();
 126         io.input.keyclass.length = 0;
 127         io.input.keyclass.size   = 1024;
 128         io.input.keyclass.name   = NULL;
 129         io.input.last_changed_time = 0;
 130
 131         var idx = 0;
 132         for (idx=0;idx >= 0;idx++) {
 133                 io.input.enum_index = idx;
 134                 var status = this.winreg_EnumKey(io);
 135                 if (!status.is_ok) {
 136                         this.close(handle);
 137                         return list;
 138                 }
 139                 var out = io.output;
 140                 if (out.result == "WERR_MORE_DATA") {
 141                         io.input.name.size = io.input.name.size * 2;
 142                         idx--;
 143                         if (io.input.name.size > 32000) {
 144                                 this.close(handle);
 145                                 return list;
 146                         }
 147                         continue;
 148                 }
 149                 if (out.result != "WERR_OK") {
 150                         this.close(handle);
 151                         return list;
 152                 }
 153                 list[list.length] = out.name.name;
 154         }
 155
 156         this.close(handle);
 157         return list;
 158 }
 159
 160
 161 /*
 162         return a list of values for a winreg server given a path
 163         usage:
 164            list = reg.enum_values(path);
 165
 166         each returned list element is an object containing a name, a
 167         type and a value
 168 */
 169 function __winreg_enum_values(path)
 170 {
 171         var data = datablob_init();
 172         var list = new Array(0);
 173
 174         var handle = this.open_path(path);
 175         if (handle == undefined) {
 176                 return undefined;
 177         }
 178
 179         var io = irpcObj();
 180         io.input.handle      = handle;
 181         io.input.name        = new Object();
 182         io.input.name.length = 0;
 183         io.input.name.size   = 128;
 184         io.input.name.name   = "";
 185         io.input.type        = 0;
 186         io.input.value       = new Array(0);
 187         io.input.size        = 1024;
 188         io.input.length      = 0;
 189
 190         var idx;
 191         for (idx=0;idx >= 0;idx++) {
 192                 io.input.enum_index = idx;
 193                 var status = this.winreg_EnumValue(io);
 194                 if (!status.is_ok) {
 195                         this.close(handle);
 196                         return list;
 197                 }
 198                 var out = io.output;
 199                 if (out.result == "WERR_MORE_DATA") {
 200                         io.input.size = io.input.size * 2;
 201                         io.input.name.size = io.input.name.size * 2;
 202                         idx--;
 203                         /* limit blobs to 1M */
 204                         if (io.input.size > 1000000) {
 205                                 this.close(handle);
 206                                 return list;
 207                         }
 208                         continue;
 209                 }
 210                 if (out.result != "WERR_OK") {
 211                         this.close(handle);
 212                         return list;
 213                 }
 214                 var el   = new Object();
 215                 el.name  = out.name.name;
 216                 el.type  = out.type;
 217                 el.rawvalue = out.value;
 218                 el.value = data.regToVar(el.rawvalue, el.type);
 219                 el.size  = out.size;
 220                 list[list.length] = el;
 221         }
 222
 223         this.close(handle);
 224         return list;
 225 }
 226
 227
 228 /*
 229   create a new key
 230     ok = reg.create_key(path, key);
 231 */
 232 function __winreg_create_key(path, key)
 233 {
 234         var handle = this.open_path(path);
 235         if (handle == undefined) {
 236                 return undefined;
 237         }
 238
 239         var io = irpcObj();
 240         io.input.handle = handle;
 241         io.input.name = key;
 242         io.input.keyclass = NULL;
 243         io.input.options = 0;
 244         io.input.access_mask = this.SEC_FLAG_MAXIMUM_ALLOWED;
 245         io.input.secdesc = NULL;
 246         io.input.action_taken = 0;
 247
 248         var status = this.winreg_CreateKey(io);
 249         this.close(handle);
 250         if (!status.is_ok) {
 251                 return false;
 252         }
 253         if (io.output.result != "WERR_OK") {
 254                 return false;
 255         }
 256         this.close(io.output.new_handle);
 257         return true;
 258 }
 259
 260
 261 /*
 262   return a string for a winreg type
 263 */
 264 function __winreg_typestring(type)
 265 {
 266         return this.typenames[type];
 267 }
 268
 269 /*
 270   initialise the winreg lib, returning an object
 271 */
 272 function winregObj()
 273 {
 274         var reg = winreg_init();
 275         security_init(reg);
 276
 277         reg.typenames = new Array("REG_NONE", "REG_SZ", "REG_EXPAND_SZ", "REG_BINARY",
 278                                   "REG_DWORD", "REG_DWORD_BIG_ENDIAN", "REG_LINK", "REG_MULTI_SZ",
 279                                   "REG_RESOURCE_LIST", "REG_FULL_RESOURCE_DESCRIPTOR",
 280                                   "REG_RESOURCE_REQUIREMENTS_LIST", "REG_QWORD");
 281
 282         reg.close       = __winreg_close;
 283         reg.open_hive   = __winreg_open_hive;
 284         reg.open_path   = __winreg_open_path;
 285         reg.enum_path   = __winreg_enum_path;
 286         reg.enum_values = __winreg_enum_values;
 287         reg.create_key  = __winreg_create_key;
 288         reg.typestring  = __winreg_typestring;
 289
 290         return reg;
 291 }