regfs.cpp

Go to the documentation of this file.
00001 /*
00002  * Copyright 2004 Martin Fuchs
00003  *
00004  * This library is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU Lesser General Public
00006  * License as published by the Free Software Foundation; either
00007  * version 2.1 of the License, or (at your option) any later version.
00008  *
00009  * This library is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012  * Lesser General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU Lesser General Public
00015  * License along with this library; if not, write to the Free Software
00016  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00017  */
00018 
00019 
00020  //
00021  // Explorer clone
00022  //
00023  // ntobjfs.cpp
00024  //
00025  // Martin Fuchs, 31.01.2004
00026  //
00027 
00028 
00029 #include <precomp.h>
00030 
00031 #include "regfs.h"
00032 
00033 
00034 void RegDirectory::read_directory(int scan_flags)
00035 {
00036     CONTEXT("RegDirectory::read_directory()");
00037 
00038     Entry* first_entry = NULL;
00039     int level = _level + 1;
00040 
00041     TCHAR buffer[MAX_PATH];
00042 
00043     _tcscpy(buffer, (LPCTSTR)_path);
00044     LPTSTR pname = buffer + _tcslen(buffer);
00045     int plen = MAX_PATH - _tcslen(buffer);
00046 
00047     HKEY hkey;
00048 
00049     if (!RegOpenKeyEx(_hKeyRoot, *buffer=='\\'?buffer+1:buffer, 0, STANDARD_RIGHTS_READ|KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS, &hkey)) {
00050         if (pname[-1] != '\\')
00051             *pname++ = '\\', plen--;
00052 
00053         TCHAR name[MAX_PATH], class_name[MAX_PATH];
00054         WIN32_FIND_DATA w32fd;
00055         Entry* last = NULL;
00056         RegEntry* entry;
00057 
00058         for(int idx=0; ; ++idx) {
00059             memset(&w32fd, 0, sizeof(WIN32_FIND_DATA));
00060 
00061             DWORD name_len = MAX_PATH;
00062             DWORD class_len = MAX_PATH;
00063 
00064             if (RegEnumKeyEx(hkey, idx, name, &name_len, 0, class_name, &class_len, &w32fd.ftLastWriteTime))
00065                 break;
00066 
00067             w32fd.dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
00068             _tcsncpy(w32fd.cFileName, name, name_len);
00069 
00070             _tcscpy_s(pname, plen, name);
00071             entry = new RegDirectory(this, buffer, _hKeyRoot);
00072 
00073             memcpy(&entry->_data, &w32fd, sizeof(WIN32_FIND_DATA));
00074 
00075             if (class_len)
00076                 entry->_type_name = _tcsdup(String(class_name, class_len));
00077 
00078             if (!first_entry)
00079                 first_entry = entry;
00080 
00081             if (last)
00082                 last->_next = entry;
00083 
00084             entry->_level = level;
00085 
00086             last = entry;
00087         }
00088 /*
00089         TCHAR value[MAX_PATH];
00090         LONG value_len = sizeof(value);
00091 
00092         if (!RegQueryValue(hkey, NULL, value, &value_len) && value_len>1) {
00093             memset(&w32fd, 0, sizeof(WIN32_FIND_DATA));
00094 
00095             lstrcpy(w32fd.cFileName, TEXT("(Default)"));
00096 
00097             entry = new RegEntry(this);
00098 
00099             memcpy(&entry->_data, &w32fd, sizeof(WIN32_FIND_DATA));
00100 
00101             entry->_content = _tcsdup(value);
00102 
00103             if (!first_entry)
00104                 first_entry = entry;
00105 
00106             if (last)
00107                 last->_next = entry;
00108 
00109             entry->_level = level;
00110 
00111             last = entry;
00112         }
00113 */
00114         DWORD type;
00115         for(int idx=0; ; ++idx) {
00116             DWORD name_len = MAX_PATH;
00117 
00118             if (RegEnumValue(hkey, idx, name, &name_len, 0, &type, NULL, NULL))
00119                 break;
00120 
00121             memset(&w32fd, 0, sizeof(WIN32_FIND_DATA));
00122 
00123             if (name[0])
00124                 lstrcpy(w32fd.cFileName, name);
00125             else
00126                 lstrcpy(w32fd.cFileName, TEXT("(Default)"));
00127 
00128             entry = new RegEntry(this);
00129 
00130             memcpy(&entry->_data, &w32fd, sizeof(WIN32_FIND_DATA));
00131 
00132             switch(type) {
00133               case REG_NONE:                        entry->_type_name = _tcsdup(TEXT("REG_NONE"));                      break;
00134               case REG_SZ:                          entry->_type_name = _tcsdup(TEXT("REG_SZ"));                        break;
00135               case REG_EXPAND_SZ:                   entry->_type_name = _tcsdup(TEXT("REG_EXPAND_SZ"));                 break;
00136               case REG_BINARY:                      entry->_type_name = _tcsdup(TEXT("REG_BINARY"));                    break;
00137               case REG_DWORD:                       entry->_type_name = _tcsdup(TEXT("REG_DWORD"));                     break;
00138               case REG_DWORD_BIG_ENDIAN:            entry->_type_name = _tcsdup(TEXT("REG_DWORD_BIG_ENDIAN"));          break;
00139               case REG_LINK:                        entry->_type_name = _tcsdup(TEXT("REG_LINK"));                      break;
00140               case REG_MULTI_SZ:                    entry->_type_name = _tcsdup(TEXT("REG_MULTI_SZ"));                  break;
00141               case REG_RESOURCE_LIST:               entry->_type_name = _tcsdup(TEXT("REG_RESOURCE_LIST"));             break;
00142               case REG_FULL_RESOURCE_DESCRIPTOR:    entry->_type_name = _tcsdup(TEXT("REG_FULL_RESOURCE_DESCRIPTOR"));  break;
00143               case REG_RESOURCE_REQUIREMENTS_LIST:  entry->_type_name = _tcsdup(TEXT("REG_RESOURCE_REQUIREMENTS_LIST"));break;
00144               case REG_QWORD:                       entry->_type_name = _tcsdup(TEXT("REG_QWORD"));                     break;
00145             }
00146 
00147              ///@todo This can also be done in the RegEnumValue() call if we dynamically adjust the return buffer size.
00148             TCHAR value[MAX_PATH];
00149             DWORD value_len = sizeof(value);
00150 
00151             if (!RegQueryValueEx(hkey, name, NULL, NULL, (LPBYTE)value, &value_len)) {
00152                 if (type==REG_SZ || type==REG_EXPAND_SZ || type==REG_LINK)
00153                     entry->_content = _tcsdup(value);
00154                 else if (type == REG_DWORD) {
00155                     TCHAR b[32];
00156                     _stprintf(b, TEXT("%ld"), *(DWORD*)&value);
00157                     entry->_content = _tcsdup(b);
00158                 }
00159             }
00160 
00161             if (!first_entry)
00162                 first_entry = entry;
00163 
00164             if (last)
00165                 last->_next = entry;
00166 
00167             entry->_level = level;
00168 
00169             last = entry;
00170         }
00171 
00172         if (last)
00173             last->_next = NULL;
00174 
00175         RegCloseKey(hkey);
00176     }
00177 
00178     _down = first_entry;
00179     _scanned = true;
00180 }
00181 
00182 
00183 const void* RegDirectory::get_next_path_component(const void* p) const
00184 {
00185     LPCTSTR s = (LPCTSTR) p;
00186 
00187     while(*s && *s!=TEXT('\\'))
00188         ++s;
00189 
00190     while(*s==TEXT('\\'))
00191         ++s;
00192 
00193     if (!*s)
00194         return NULL;
00195 
00196     return s;
00197 }
00198 
00199 
00200 Entry* RegDirectory::find_entry(const void* p)
00201 {
00202     LPCTSTR name = (LPCTSTR)p;
00203 
00204     for(Entry*entry=_down; entry; entry=entry->_next) {
00205         LPCTSTR p = name;
00206         LPCTSTR q = entry->_data.cFileName;
00207 
00208         do {
00209             if (!*p || *p==TEXT('\\') || *p==TEXT('/'))
00210                 return entry;
00211         } while(tolower(*p++) == tolower(*q++));
00212 
00213         p = name;
00214         q = entry->_data.cAlternateFileName;
00215 
00216         do {
00217             if (!*p || *p==TEXT('\\') || *p==TEXT('/'))
00218                 return entry;
00219         } while(tolower(*p++) == tolower(*q++));
00220     }
00221 
00222     return NULL;
00223 }
00224 
00225 
00226  // get full path of specified registry entry
00227 bool RegEntry::get_path(PTSTR path, size_t path_count) const
00228 {
00229     return get_path_base ( path, path_count, ET_REGISTRY );
00230 }
00231 
00232 BOOL RegEntry::launch_entry(HWND hwnd, UINT nCmdShow)
00233 {
00234     return FALSE;
00235 }
00236 
00237 
00238 RegDirectory::RegDirectory(Entry* parent, LPCTSTR path, HKEY hKeyRoot)
00239  :  RegEntry(parent),
00240     _hKeyRoot(hKeyRoot)
00241 {
00242     _path = _tcsdup(path);
00243 
00244     memset(&_data, 0, sizeof(WIN32_FIND_DATA));
00245     _data.dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
00246 }
00247 
00248 
00249 void RegistryRoot::read_directory(int scan_flags)
00250 {
00251     Entry *entry, *last, *first_entry;
00252     int level = _level + 1;
00253 
00254     _data.dwFileAttributes |= FILE_ATTRIBUTE_DIRECTORY;
00255 
00256     entry = new RegDirectory(this, TEXT("\\"), HKEY_CURRENT_USER);
00257     _tcscpy(entry->_data.cFileName, TEXT("HKEY_CURRENT_USER"));
00258     entry->_level = level;
00259 
00260     first_entry = entry;
00261     last = entry;
00262 
00263     entry = new RegDirectory(this, TEXT("\\"), HKEY_LOCAL_MACHINE);
00264     _tcscpy(entry->_data.cFileName, TEXT("HKEY_LOCAL_MACHINE"));
00265     entry->_level = level;
00266 
00267     last->_next = entry;
00268     last = entry;
00269 
00270     entry = new RegDirectory(this, TEXT("\\"), HKEY_CLASSES_ROOT);
00271     _tcscpy(entry->_data.cFileName, TEXT("HKEY_CLASSES_ROOT"));
00272     entry->_level = level;
00273 
00274     last->_next = entry;
00275     last = entry;
00276 
00277     entry = new RegDirectory(this, TEXT("\\"), HKEY_USERS);
00278     _tcscpy(entry->_data.cFileName, TEXT("HKEY_USERS"));
00279     entry->_level = level;
00280 
00281     last->_next = entry;
00282     last = entry;
00283 /*
00284     entry = new RegDirectory(this, TEXT("\\"), HKEY_PERFORMANCE_DATA);
00285     _tcscpy(entry->_data.cFileName, TEXT("HKEY_PERFORMANCE_DATA"));
00286     entry->_level = level;
00287 
00288     last->_next = entry;
00289     last = entry;
00290 */
00291     entry = new RegDirectory(this, TEXT("\\"), HKEY_CURRENT_CONFIG);
00292     _tcscpy(entry->_data.cFileName, TEXT("HKEY_CURRENT_CONFIG"));
00293     entry->_level = level;
00294 
00295     last->_next = entry;
00296     last = entry;
00297 /*
00298     entry = new RegDirectory(this, TEXT("\\"), HKEY_DYN_DATA);
00299     _tcscpy(entry->_data.cFileName, TEXT("HKEY_DYN_DATA"));
00300     entry->_level = level;
00301 
00302     last->_next = entry;
00303     last = entry;
00304 */
00305     last->_next = NULL;
00306 
00307     _down = first_entry;
00308     _scanned = true;
00309 }

ROS Explorer Source Code Documentation
generated on 02.01.2013 by doxygen

ROS Explorer Homepage