/* * Command Line parameters are: * [/n] Opens in single-paned view for each selected items. This is default * [/e,] Uses Windows Explorer View * [/root,object] Specifies the root level of the view * [/select,object] parent folder is opened and specified object is selected */ static void parse_command_line(LPWSTR commandline,parameters_struct *parameters) { static const WCHAR arg_n[] = {'/','n'}; static const WCHAR arg_e[] = {'/','e',','}; static const WCHAR arg_root[] = {'/','r','o','o','t',','}; static const WCHAR arg_select[] = {'/','s','e','l','e','c','t',','}; static const WCHAR arg_desktop[] = {'/','d','e','s','k','t','o','p'}; LPWSTR p, p2; p2 = commandline; p = strchrW(commandline,'/'); while(p) { if (strncmpW(p, arg_n, sizeof(arg_n)/sizeof(WCHAR))==0) { parameters->explorer_mode = FALSE; p += sizeof(arg_n)/sizeof(WCHAR); } else if (strncmpW(p, arg_e, sizeof(arg_e)/sizeof(WCHAR))==0) { parameters->explorer_mode = TRUE; p += sizeof(arg_e)/sizeof(WCHAR); } else if (strncmpW(p, arg_root, sizeof(arg_root)/sizeof(WCHAR))==0) { p += sizeof(arg_root)/sizeof(WCHAR); p+=copy_path_string(parameters->root,p); } else if (strncmpW(p, arg_select, sizeof(arg_select)/sizeof(WCHAR))==0) { p += sizeof(arg_select)/sizeof(WCHAR); p+=copy_path_string(parameters->selection,p); if (!parameters->root[0]) copy_path_root(parameters->root, parameters->selection); } else if (strncmpW(p, arg_desktop, sizeof(arg_desktop)/sizeof(WCHAR))==0) { p += sizeof(arg_desktop)/sizeof(WCHAR); manage_desktop( p ); /* the rest of the command line is handled by desktop mode */ } else p++; p2 = p; p = strchrW(p,'/'); } if (p2 && *p2) { /* left over command line is generally the path to be opened */ copy_path_string(parameters->root,p2); } }
ULONG do_open_subkey( regkey_t *&key, UNICODE_STRING *name, bool case_insensitive ) { ULONG len; skip_slashes( name ); len = get_next_segment( name ); if (!len) return len; for (regkey_iter i(key->children); i; i.next()) { regkey_t *subkey = i; if (len != subkey->name.Length) continue; if (case_insensitive) { if (strncmpW( name->Buffer, subkey->name.Buffer, len/sizeof(WCHAR) )) continue; } else { if (memcmp( name->Buffer, subkey->name.Buffer, len/sizeof(WCHAR) )) continue; } // advance key = subkey; name->Buffer += len/2; name->Length -= len; return len; } return 0; }
/****************************************************************************** * Open file in binary mode for export. */ static FILE *REGPROC_open_export_file(WCHAR *file_name, BOOL unicode) { FILE *file; WCHAR dash = '-'; if (strncmpW(file_name,&dash,1)==0) { file=stdout; _setmode(_fileno(file), _O_BINARY); } else { WCHAR wb_mode[] = {'w','b',0}; WCHAR regedit[] = {'r','e','g','e','d','i','t',0}; file = _wfopen(file_name, wb_mode); if (!file) { _wperror(regedit); output_message(STRING_CANNOT_OPEN_FILE, file_name); exit(1); } } if(unicode) { const BYTE unicode_seq[] = {0xff,0xfe}; const WCHAR header[] = {'W','i','n','d','o','w','s',' ','R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ','V','e','r','s','i','o','n',' ','5','.','0','0','\r','\n'}; fwrite(unicode_seq, sizeof(BYTE), sizeof(unicode_seq)/sizeof(unicode_seq[0]), file); fwrite(header, sizeof(WCHAR), sizeof(header)/sizeof(header[0]), file); } else { fputs("REGEDIT4\r\n", file); } return file; }
static LPCWSTR COMM_ParseStopBits(LPCWSTR ptr, LPBYTE lpstopbits) { DWORD temp; static const WCHAR stopbits15W[] = {'1','.','5',0}; if(!strncmpW(stopbits15W, ptr, 3)) { ptr += 3; *lpstopbits = ONE5STOPBITS; } else { if(!(ptr = COMM_ParseNumber(ptr, &temp))) return NULL; if(temp == 1) *lpstopbits = ONESTOPBIT; else if(temp == 2) *lpstopbits = TWOSTOPBITS; else return NULL; } return ptr; }
/********************************************************************** * find_entry_by_name * * Find an entry by name in a resource directory */ static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_name( const IMAGE_RESOURCE_DIRECTORY *dir, LPCWSTR name, const void *root, int want_dir ) { const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry; const IMAGE_RESOURCE_DIR_STRING_U *str; int min, max, res, pos, namelen; if (IS_INTRESOURCE(name)) return find_entry_by_id( dir, LOWORD(name), root, want_dir ); entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1); namelen = strlenW(name); min = 0; max = dir->NumberOfNamedEntries - 1; while (min <= max) { pos = (min + max) / 2; str = (const IMAGE_RESOURCE_DIR_STRING_U *)((const char *)root + entry[pos].u.s.NameOffset); res = strncmpW( name, str->NameString, str->Length ); if (!res && namelen == str->Length) { if (!entry[pos].u2.s2.DataIsDirectory == !want_dir) { TRACE("root %p dir %p name %s ret %p\n", root, dir, debugstr_w(name), (const char*)root + entry[pos].u2.s2.OffsetToDirectory); return (const IMAGE_RESOURCE_DIRECTORY *)((const char *)root + entry[pos].u2.s2.OffsetToDirectory); } break; } if (res < 0) max = pos - 1; else min = pos + 1; } TRACE("root %p dir %p name %s not found\n", root, dir, debugstr_w(name) ); return NULL; }
static HRESULT WINAPI FtpProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl, IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, DWORD grfPI, HANDLE_PTR dwReserved) { FtpProtocol *This = PROTOCOL_THIS(iface); IUri *uri; HRESULT hres; static const WCHAR ftpW[] = {'f','t','p',':'}; TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink, pOIBindInfo, grfPI, dwReserved); if(strncmpW(szUrl, ftpW, sizeof(ftpW)/sizeof(WCHAR))) return MK_E_SYNTAX; hres = CreateUri(szUrl, 0, 0, &uri); if(FAILED(hres)) return hres; hres = protocol_start(&This->base, PROTOCOL(This), uri, pOIProtSink, pOIBindInfo); IUri_Release(uri); return hres; }
/****************************************************************************** * Open file in binary mode for export. */ static FILE *REGPROC_open_export_file(WCHAR *file_name, BOOL unicode) { FILE *file; WCHAR dash = '-'; if (strncmpW(file_name,&dash,1)==0) { file=stdout; _setmode(_fileno(file), _O_BINARY); } else { CHAR* file_nameA = GetMultiByteString(file_name); file = fopen(file_nameA, "wb"); if (!file) { perror(""); fprintf(stderr,"%s: Can't open file \"%s\"\n", getAppName(), file_nameA); HeapFree(GetProcessHeap(), 0, file_nameA); exit(1); } HeapFree(GetProcessHeap(), 0, file_nameA); } if(unicode) { const BYTE unicode_seq[] = {0xff,0xfe}; const WCHAR header[] = {'W','i','n','d','o','w','s',' ','R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ','V','e','r','s','i','o','n',' ','5','.','0','0','\r','\n'}; fwrite(unicode_seq, sizeof(BYTE), sizeof(unicode_seq)/sizeof(unicode_seq[0]), file); fwrite(header, sizeof(WCHAR), sizeof(header)/sizeof(header[0]), file); } else { fputs("REGEDIT4\r\n", file); } return file; }
/********************************************************************** * find_entry_by_nameW * * Find an entry by name in a resource directory */ static const IMAGE_RESOURCE_DIRECTORY *find_entry_by_nameW( const IMAGE_RESOURCE_DIRECTORY *dir, LPCWSTR name, const void *root ) { const IMAGE_RESOURCE_DIRECTORY_ENTRY *entry; const IMAGE_RESOURCE_DIR_STRING_U *str; int min, max, res, pos, namelen; if (!HIWORD(name)) return find_entry_by_id( dir, LOWORD(name), root ); if (name[0] == '#') { char buf[16]; if (!WideCharToMultiByte( CP_ACP, 0, name+1, -1, buf, sizeof(buf), NULL, NULL )) return NULL; return find_entry_by_id( dir, atoi(buf), root ); } entry = (const IMAGE_RESOURCE_DIRECTORY_ENTRY *)(dir + 1); namelen = strlenW(name); min = 0; max = dir->NumberOfNamedEntries - 1; while (min <= max) { pos = (min + max) / 2; str = (IMAGE_RESOURCE_DIR_STRING_U *)((char *)root + entry[pos].u1.s1.NameOffset); res = strncmpW( name, str->NameString, str->Length ); if (!res && namelen == str->Length) return (IMAGE_RESOURCE_DIRECTORY *)((char *)root + entry[pos].u2.s3.OffsetToDirectory); if (res < 0) max = pos - 1; else min = pos + 1; } return NULL; }
BOOLEAN unicode_string_equal( PUNICODE_STRING a, PUNICODE_STRING b, BOOLEAN case_insensitive ) { if (a->Length != b->Length) return FALSE; if (case_insensitive) return (0 == strncmpW( a->Buffer, b->Buffer, a->Length/2 )); return (0 == memcmp( a->Buffer, b->Buffer, a->Length )); }
static HRESULT WINAPI HttpProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl, IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, DWORD grfPI, HANDLE_PTR dwReserved) { HttpProtocol *This = PROTOCOL_THIS(iface); static const WCHAR httpW[] = {'h','t','t','p',':'}; static const WCHAR httpsW[] = {'h','t','t','p','s',':'}; TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink, pOIBindInfo, grfPI, dwReserved); if(This->https ? strncmpW(szUrl, httpsW, sizeof(httpsW)/sizeof(WCHAR)) : strncmpW(szUrl, httpW, sizeof(httpW)/sizeof(WCHAR))) return MK_E_SYNTAX; return protocol_start(&This->base, PROTOCOL(This), szUrl, pOIProtSink, pOIBindInfo); }
static DWORD get_type_from_name(LPCWSTR name) { HANDLE hfile; if (!strncmpiW(name, portname_LPT, sizeof(portname_LPT) / sizeof(WCHAR) -1)) return PORT_IS_LPT; if (!strncmpiW(name, portname_COM, sizeof(portname_COM) / sizeof(WCHAR) -1)) return PORT_IS_COM; if (!strcmpiW(name, portname_FILE)) return PORT_IS_FILE; if (name[0] == '/') return PORT_IS_UNIXNAME; if (name[0] == '|') return PORT_IS_PIPE; if (!strncmpW(name, portname_CUPS, sizeof(portname_CUPS) / sizeof(WCHAR) -1)) return PORT_IS_CUPS; if (!strncmpW(name, portname_LPR, sizeof(portname_LPR) / sizeof(WCHAR) -1)) return PORT_IS_LPR; /* Must be a file or a directory. Does the file exist ? */ hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); TRACE("%p for OPEN_EXISTING on %s\n", hfile, debugstr_w(name)); if (hfile == INVALID_HANDLE_VALUE) { /* Can we create the file? */ hfile = CreateFileW(name, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_DELETE_ON_CLOSE, NULL); TRACE("%p for OPEN_ALWAYS\n", hfile); } if (hfile != INVALID_HANDLE_VALUE) { CloseHandle(hfile); return PORT_IS_FILENAME; } /* We can't use the name. use GetLastError() for the reason */ return PORT_IS_UNKNOWN; }
static NTSTATUS set_alg_property( struct algorithm *alg, const WCHAR *prop, UCHAR *value, ULONG size, ULONG flags ) { switch (alg->id) { case ALG_ID_AES: if (!strcmpW( prop, BCRYPT_CHAINING_MODE )) { if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_ECB, size )) { alg->mode = MODE_ID_ECB; return STATUS_SUCCESS; } else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_CBC, size )) { alg->mode = MODE_ID_CBC; return STATUS_SUCCESS; } else if (!strncmpW( (WCHAR *)value, BCRYPT_CHAIN_MODE_GCM, size )) { alg->mode = MODE_ID_GCM; return STATUS_SUCCESS; } else { FIXME( "unsupported mode %s\n", debugstr_wn( (WCHAR *)value, size ) ); return STATUS_NOT_IMPLEMENTED; } } FIXME( "unsupported aes algorithm property %s\n", debugstr_w(prop) ); return STATUS_NOT_IMPLEMENTED; default: FIXME( "unsupported algorithm %u\n", alg->id ); return STATUS_NOT_IMPLEMENTED; } }
/****************************************************************************** * This function returns the HKEY associated with the data type encoded in the * value. It modifies the input parameter (key value) in order to skip this * "now useless" data type information. * * Note: Updated based on the algorithm used in 'server/registry.c' */ static DWORD getDataType(LPWSTR *lpValue, DWORD* parse_type) { struct data_type { const WCHAR *tag; int len; int type; int parse_type; }; static const WCHAR quote[] = {'"'}; static const WCHAR str[] = {'s','t','r',':','"'}; static const WCHAR str2[] = {'s','t','r','(','2',')',':','"'}; static const WCHAR hex[] = {'h','e','x',':'}; static const WCHAR dword[] = {'d','w','o','r','d',':'}; static const WCHAR hexp[] = {'h','e','x','('}; static const struct data_type data_types[] = { /* actual type */ /* type to assume for parsing */ { quote, 1, REG_SZ, REG_SZ }, { str, 5, REG_SZ, REG_SZ }, { str2, 8, REG_EXPAND_SZ, REG_SZ }, { hex, 4, REG_BINARY, REG_BINARY }, { dword, 6, REG_DWORD, REG_DWORD }, { hexp, 4, -1, REG_BINARY }, { NULL, 0, 0, 0 } }; const struct data_type *ptr; int type; for (ptr = data_types; ptr->tag; ptr++) { if (strncmpW( ptr->tag, *lpValue, ptr->len )) continue; /* Found! */ *parse_type = ptr->parse_type; type=ptr->type; *lpValue+=ptr->len; if (type == -1) { WCHAR* end; /* "hex(xx):" is special */ type = (int)strtoulW( *lpValue , &end, 16 ); if (**lpValue=='\0' || *end!=')' || *(end+1)!=':') { type=REG_NONE; } else { *lpValue = end + 2; } } return type; } *parse_type=REG_NONE; return REG_NONE; }
int wmain(int argc, WCHAR *argv[]) { if (argc > 1) { static const WCHAR slashHelpW[] = {'/','?',0}; unsigned int i; if (!strncmpW(argv[1], slashHelpW, sizeof(slashHelpW)/sizeof(WCHAR) - 1)) { hostname_message(STRING_USAGE); return 1; } for (i = 1; i < argc; i++) { if (argv[i][0] == '-') { switch (argv[i][1]) { case 's': /* Ignore the option and continue processing. */ break; case '?': hostname_message(STRING_USAGE); return 1; default: hostname_message_printfW(STRING_INVALID_OPTION, argv[i][1]); hostname_message(STRING_USAGE); return 1; } } else { hostname_message(STRING_CANNOT_SET_HOSTNAME); hostname_message(STRING_USAGE); return 1; } } } display_computer_name(); return 0; }
/*********************************************************************** * WININET_GetAuthRealm * * Determine the name of the (basic) Authentication realm */ static BOOL WININET_GetAuthRealm( HINTERNET hRequest, LPWSTR szBuf, DWORD sz, BOOL proxy ) { LPWSTR p, q; DWORD index, query; static const WCHAR szRealm[] = { 'r','e','a','l','m','=',0 }; if (proxy) query = HTTP_QUERY_PROXY_AUTHENTICATE; else query = HTTP_QUERY_WWW_AUTHENTICATE; /* extract the Realm from the response and show it */ index = 0; if( !HttpQueryInfoW( hRequest, query, szBuf, &sz, &index) ) return FALSE; /* * FIXME: maybe we should check that we're * dealing with 'Basic' Authentication */ p = strchrW( szBuf, ' ' ); if( !p || strncmpW( p+1, szRealm, strlenW(szRealm) ) ) { ERR("response wrong? (%s)\n", debugstr_w(szBuf)); return FALSE; } /* remove quotes */ p += 7; if( *p == '"' ) { p++; q = strrchrW( p, '"' ); if( q ) *q = 0; } strcpyW( szBuf, p ); return TRUE; }
/****************************************************************** * module_is_container_loaded * * checks whether the native container, for a (supposed) PE builtin is * already loaded */ static BOOL module_is_container_loaded(const struct process* pcs, const WCHAR* ImageName, DWORD64 base) { size_t len; struct module* module; PCWSTR filename, modname; static WCHAR* dll_prefix; static int dll_prefix_len; if (!dll_prefix) { dll_prefix_len = MultiByteToWideChar( CP_UNIXCP, 0, DLLPREFIX, -1, NULL, 0 ); dll_prefix = HeapAlloc( GetProcessHeap(), 0, dll_prefix_len * sizeof(WCHAR) ); MultiByteToWideChar( CP_UNIXCP, 0, DLLPREFIX, -1, dll_prefix, dll_prefix_len ); dll_prefix_len--; } if (!base) return FALSE; filename = get_filename(ImageName, NULL); len = strlenW(filename); for (module = pcs->lmodules; module; module = module->next) { if ((module->type == DMT_ELF || module->type == DMT_MACHO) && base >= module->module.BaseOfImage && base < module->module.BaseOfImage + module->module.ImageSize) { modname = get_filename(module->module.LoadedImageName, NULL); if (dll_prefix_len && !strncmpW( modname, dll_prefix, dll_prefix_len )) modname += dll_prefix_len; if (!strncmpiW(modname, filename, len) && !memcmp(modname + len, S_DotSoW, 3 * sizeof(WCHAR))) { return TRUE; } } } /* likely a native PE module */ WARN("Couldn't find container for %s\n", debugstr_w(ImageName)); return FALSE; }
static HRESULT WINAPI mxwriter_saxcontent_endElement( ISAXContentHandler *iface, const WCHAR *namespaceUri, int nnamespaceUri, const WCHAR * local_name, int nlocal_name, const WCHAR *QName, int nQName) { mxwriter *This = impl_from_ISAXContentHandler( iface ); TRACE("(%p)->(%s:%d %s:%d %s:%d)\n", This, debugstr_wn(namespaceUri, nnamespaceUri), nnamespaceUri, debugstr_wn(local_name, nlocal_name), nlocal_name, debugstr_wn(QName, nQName), nQName); if ((!namespaceUri || !local_name || !QName) && This->class_version != MSXML6) return E_INVALIDARG; if (This->element && QName && !strncmpW(This->element, QName, nQName)) { static const WCHAR closeW[] = {'/','>'}; write_output_buffer(This->buffer, closeW, 2); } else { static const WCHAR closetagW[] = {'<','/'}; static const WCHAR gtW[] = {'>'}; write_output_buffer(This->buffer, closetagW, 2); write_output_buffer(This->buffer, QName, nQName); write_output_buffer(This->buffer, gtW, 1); } set_element_name(This, NULL, 0); return S_OK; }
static HRESULT WINAPI ITS_IParseDisplayNameImpl_ParseDisplayName( IParseDisplayName *iface, IBindCtx * pbc, LPOLESTR pszDisplayName, ULONG * pchEaten, IMoniker ** ppmkOut) { static const WCHAR szPrefix[] = { '@','M','S','I','T','S','t','o','r','e',':',0 }; const DWORD prefix_len = (sizeof szPrefix/sizeof szPrefix[0])-1; DWORD n; ITS_IParseDisplayNameImpl *This = (ITS_IParseDisplayNameImpl *)iface; TRACE("%p %s %p %p\n", This, debugstr_w( pszDisplayName ), pchEaten, ppmkOut ); if( strncmpW( pszDisplayName, szPrefix, prefix_len ) ) return MK_E_SYNTAX; /* search backwards for a double colon */ for( n = strlenW( pszDisplayName ) - 3; prefix_len <= n; n-- ) if( ( pszDisplayName[n] == ':' ) && ( pszDisplayName[n+1] == ':' ) ) break; if( n < prefix_len ) return MK_E_SYNTAX; if( !pszDisplayName[n+2] ) return MK_E_SYNTAX; *pchEaten = strlenW( pszDisplayName ) - n - 3; return ITS_IMoniker_create( ppmkOut, &pszDisplayName[prefix_len], n-prefix_len ); }
HRESULT create_monodata(REFIID riid, LPVOID *ppObj ) { static const WCHAR wszAssembly[] = {'A','s','s','e','m','b','l','y',0}; static const WCHAR wszCodebase[] = {'C','o','d','e','B','a','s','e',0}; static const WCHAR wszClass[] = {'C','l','a','s','s',0}; static const WCHAR wszFileSlash[] = {'f','i','l','e',':','/','/','/',0}; static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0}; static const WCHAR wszInprocServer32[] = {'\\','I','n','p','r','o','c','S','e','r','v','e','r','3','2',0}; static const WCHAR wszDLL[] = {'.','d','l','l',0}; WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) + ARRAYSIZE(wszInprocServer32) - 1]; MonoDomain *domain; MonoAssembly *assembly; ICLRRuntimeInfo *info = NULL; RuntimeHost *host; HRESULT hr; HKEY key, subkey; LONG res; int offset = 0; DWORD numKeys, keyLength; WCHAR codebase[MAX_PATH + 8]; WCHAR classname[350], subkeyName[256]; WCHAR filename[MAX_PATH]; DWORD dwBufLen = 350; lstrcpyW(path, wszCLSIDSlash); StringFromGUID2(riid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID); lstrcatW(path, wszInprocServer32); TRACE("Registry key: %s\n", debugstr_w(path)); res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &key); if (res == ERROR_FILE_NOT_FOUND) return CLASS_E_CLASSNOTAVAILABLE; res = RegGetValueW( key, NULL, wszClass, RRF_RT_REG_SZ, NULL, classname, &dwBufLen); if(res != ERROR_SUCCESS) { WARN("Class value cannot be found.\n"); hr = CLASS_E_CLASSNOTAVAILABLE; goto cleanup; } TRACE("classname (%s)\n", debugstr_w(classname)); dwBufLen = MAX_PATH + 8; res = RegGetValueW( key, NULL, wszCodebase, RRF_RT_REG_SZ, NULL, codebase, &dwBufLen); if(res == ERROR_SUCCESS) { /* Strip file:/// */ if(strncmpW(codebase, wszFileSlash, strlenW(wszFileSlash)) == 0) offset = strlenW(wszFileSlash); strcpyW(filename, codebase + offset); } else { WCHAR assemblyname[MAX_PATH + 8]; hr = CLASS_E_CLASSNOTAVAILABLE; WARN("CodeBase value cannot be found, trying Assembly.\n"); /* get the last subkey of InprocServer32 */ res = RegQueryInfoKeyW(key, 0, 0, 0, &numKeys, 0, 0, 0, 0, 0, 0, 0); if (res != ERROR_SUCCESS || numKeys == 0) goto cleanup; numKeys--; keyLength = sizeof(subkeyName) / sizeof(WCHAR); res = RegEnumKeyExW(key, numKeys, subkeyName, &keyLength, 0, 0, 0, 0); if (res != ERROR_SUCCESS) goto cleanup; res = RegOpenKeyExW(key, subkeyName, 0, KEY_READ, &subkey); if (res != ERROR_SUCCESS) goto cleanup; dwBufLen = MAX_PATH + 8; res = RegGetValueW(subkey, NULL, wszAssembly, RRF_RT_REG_SZ, NULL, assemblyname, &dwBufLen); RegCloseKey(subkey); if (res != ERROR_SUCCESS) goto cleanup; hr = get_file_from_strongname(assemblyname, filename, MAX_PATH); if (!SUCCEEDED(hr)) { /* * The registry doesn't have a CodeBase entry and it's not in the GAC. * * Use the Assembly Key to retrieve the filename. * Assembly : REG_SZ : AssemblyName, Version=X.X.X.X, Culture=neutral, PublicKeyToken=null */ WCHAR *ns; WARN("Attempt to load from the application directory.\n"); GetModuleFileNameW(NULL, filename, MAX_PATH); ns = strrchrW(filename, '\\'); *(ns+1) = '\0'; ns = strchrW(assemblyname, ','); *(ns) = '\0'; strcatW(filename, assemblyname); *(ns) = '.'; strcatW(filename, wszDLL); } } TRACE("filename (%s)\n", debugstr_w(filename)); *ppObj = NULL; hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info); if (SUCCEEDED(hr)) { hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host); if (SUCCEEDED(hr)) hr = RuntimeHost_GetDefaultDomain(host, &domain); if (SUCCEEDED(hr)) { MonoImage *image; MonoClass *klass; MonoObject *result; IUnknown *unk = NULL; char *filenameA, *ns; char *classA; hr = CLASS_E_CLASSNOTAVAILABLE; mono_thread_attach(domain); filenameA = WtoA(filename); assembly = mono_domain_assembly_open(domain, filenameA); HeapFree(GetProcessHeap(), 0, filenameA); if (!assembly) { ERR("Cannot open assembly %s\n", filenameA); goto cleanup; } image = mono_assembly_get_image(assembly); if (!image) { ERR("Couldn't get assembly image\n"); goto cleanup; } classA = WtoA(classname); ns = strrchr(classA, '.'); *ns = '\0'; klass = mono_class_from_name(image, classA, ns+1); HeapFree(GetProcessHeap(), 0, classA); if (!klass) { ERR("Couldn't get class from image\n"); goto cleanup; } /* * Use the default constructor for the .NET class. */ result = mono_object_new(domain, klass); mono_runtime_object_init(result); hr = RuntimeHost_GetIUnknownForObject(host, result, &unk); if (SUCCEEDED(hr)) { hr = IUnknown_QueryInterface(unk, &IID_IUnknown, ppObj); IUnknown_Release(unk); } else hr = CLASS_E_CLASSNOTAVAILABLE; } else hr = CLASS_E_CLASSNOTAVAILABLE; } else hr = CLASS_E_CLASSNOTAVAILABLE; cleanup: if(info) ICLRRuntimeInfo_Release(info); RegCloseKey(key); return hr; }
static BOOL CALLBACK register_manifest( HMODULE module, const WCHAR *type, WCHAR *res_name, LONG_PTR arg ) { #ifdef __i386__ static const char current_arch[] = "x86"; #elif defined __x86_64__ static const char current_arch[] = "amd64"; #else static const char current_arch[] = "none"; #endif static const WCHAR manifestW[] = {'W','I','N','E','_','M','A','N','I','F','E','S','T'}; const struct dll_data *dll_data = (const struct dll_data*)arg; xmlbuf_t buffer; xmlstr_t elem, attr_name, attr_value; xmlstr_t name, version, arch, key, lang; BOOL end = FALSE, error; const char *manifest; SIZE_T len; HRSRC rsrc; if (IS_INTRESOURCE(res_name) || strncmpW( res_name, manifestW, sizeof(manifestW)/sizeof(WCHAR) )) return TRUE; rsrc = FindResourceW( module, res_name, type ); manifest = LoadResource( module, rsrc ); len = SizeofResource( module, rsrc ); buffer.ptr = manifest; buffer.end = manifest + len; name.ptr = version.ptr = arch.ptr = key.ptr = lang.ptr = NULL; name.len = version.len = arch.len = key.len = lang.len = 0; while (next_xml_elem( &buffer, &elem )) { if (!xmlstr_cmp( &elem, "assemblyIdentity" )) continue; while (next_xml_attr( &buffer, &attr_name, &attr_value, &error, &end )) { if (xmlstr_cmp(&attr_name, "name")) name = attr_value; else if (xmlstr_cmp(&attr_name, "version")) version = attr_value; else if (xmlstr_cmp(&attr_name, "processorArchitecture")) arch = attr_value; else if (xmlstr_cmp(&attr_name, "publicKeyToken")) key = attr_value; else if (xmlstr_cmp(&attr_name, "language")) lang = attr_value; } if (!error && name.ptr && version.ptr && arch.ptr && key.ptr) { if (!lang.ptr) { lang.ptr = "none"; lang.len = strlen( lang.ptr ); } if (!arch.len) /* fixup the architecture */ { char *new_buffer = HeapAlloc( GetProcessHeap(), 0, len + sizeof(current_arch) ); memcpy( new_buffer, manifest, arch.ptr - manifest ); strcpy( new_buffer + (arch.ptr - manifest), current_arch ); memcpy( new_buffer + strlen(new_buffer), arch.ptr, len - (arch.ptr - manifest) ); arch.ptr = current_arch; arch.len = strlen( current_arch ); if (create_winsxs_dll( dll_data->name, &arch, &name, &key, &version, &lang, dll_data->data, dll_data->size )) create_manifest( &arch, &name, &key, &version, &lang, new_buffer, len + arch.len ); HeapFree( GetProcessHeap(), 0, new_buffer ); } else { if (create_winsxs_dll( dll_data->name, &arch, &name, &key, &version, &lang, dll_data->data, dll_data->size )) create_manifest( &arch, &name, &key, &version, &lang, manifest, len ); } } } return TRUE; }
/* ECMA-262 3rd Edition 9.3.1 */ static HRESULT str_to_number(BSTR str, VARIANT *ret) { const WCHAR *ptr = str; BOOL neg = FALSE; DOUBLE d = 0.0; static const WCHAR infinityW[] = {'I','n','f','i','n','i','t','y'}; while(isspaceW(*ptr)) ptr++; if(*ptr == '-') { neg = TRUE; ptr++; }else if(*ptr == '+') { ptr++; } if(!strncmpW(ptr, infinityW, sizeof(infinityW)/sizeof(WCHAR))) { ptr += sizeof(infinityW)/sizeof(WCHAR); while(*ptr && isspaceW(*ptr)) ptr++; if(*ptr) num_set_nan(ret); else num_set_inf(ret, !neg); return S_OK; } if(*ptr == '0' && ptr[1] == 'x') { DWORD l = 0; ptr += 2; while((l = hex_to_int(*ptr)) != -1) { d = d*16 + l; ptr++; } num_set_val(ret, d); return S_OK; } while(isdigitW(*ptr)) d = d*10 + (*ptr++ - '0'); if(*ptr == 'e' || *ptr == 'E') { BOOL eneg = FALSE; LONG l = 0; ptr++; if(*ptr == '-') { ptr++; eneg = TRUE; }else if(*ptr == '+') { ptr++; } while(isdigitW(*ptr)) l = l*10 + (*ptr++ - '0'); if(eneg) l = -l; d *= pow(10, l); }else if(*ptr == '.') { DOUBLE dec = 0.1; ptr++; while(isdigitW(*ptr)) { d += dec * (*ptr++ - '0'); dec *= 0.1; } } while(isspaceW(*ptr)) ptr++; if(*ptr) { num_set_nan(ret); return S_OK; } if(neg) d = -d; num_set_val(ret, d); return S_OK; }
UBOOL afoLbrCR (LPAFOLOCALVARS lpafoLocalVars) // Ptr to AfoDetect local vars { LPAFODETECT_STR lpafoDetectStr = lpafoLocalVars->lpafoDetectStr; // If we're at the top level, ... if (lpafoLocalVars->lbrCount EQ 1) // Make room for one more entry if (!AfoDetectResize (lpafoDetectStr)) goto WSFULL_EXIT; // Save the line length and offset lpafoDetectStr->lpafoLineStr[lpafoDetectStr->uLineStrNxt].uLineOff = lpafoDetectStr->uLastLineOff; lpafoDetectStr->lpafoLineStr[lpafoDetectStr->uLineStrNxt].uLineLen = lpafoLocalVars->uChar - lpafoDetectStr->uLastLineOff; // If it's a CR/LF, ... if (strncmpW (&lpafoLocalVars->lpwszOrig[lpafoLocalVars->uChar], WS_CRLF, strcountof (WS_CRLF)) EQ 0) { // Skip over it (less one as the loop increments uChar) lpafoLocalVars->uChar += strcountof (WS_CRLF) - 1; // If we're not at the top level, ... if (lpafoLocalVars->lbrCount NE 1) // Ignore this CR return TRUE; // Count it in lpafoDetectStr->numPhyLines++; lpafoDetectStr->numLogLines++; // Mark as NOT continued onto the next physical line lpafoDetectStr->lpafoLineStr[lpafoDetectStr->uLineStrNxt].bLineCont = FALSE; } else // If it's a CR/CR/LF, ... if (strncmpW (&lpafoLocalVars->lpwszOrig[lpafoLocalVars->uChar], WS_CRCRLF, strcountof (WS_CRCRLF)) EQ 0) { // Skip over it (less one as the loop increments uChar) lpafoLocalVars->uChar += strcountof (WS_CRCRLF) - 1; // If we're not at the top level, ... if (lpafoLocalVars->lbrCount NE 1) // Ignore this CR return TRUE; // Count it in lpafoDetectStr->numPhyLines++; // Mark as continued onto the next physical line lpafoDetectStr->lpafoLineStr[lpafoDetectStr->uLineStrNxt].bLineCont = TRUE; } // End IF/ELSE #ifdef DEBUG else DbgBrk (); #endif // Skip to the next AFOLINE_STR lpafoDetectStr->uLineStrNxt++; // Save as the last line offset ("+ 1" for the loop increment accounted for above) lpafoDetectStr->uLastLineOff = lpafoLocalVars->uChar + 1; return TRUE; WSFULL_EXIT: // Set new state (we're done) lpafoLocalVars->State = AFOROW_WSFULL; return FALSE; } // End afoLbrCR
/********************************************************************* * wcsncmp (NTDLL.@) */ INT __cdecl NTDLL_wcsncmp( LPCWSTR str1, LPCWSTR str2, INT n ) { return strncmpW( str1, str2, n ); }
static LONG RegpOpenOrCreateKey( IN HKEY hParentKey, IN PCWSTR KeyName, IN BOOL AllowCreation, OUT PHKEY Key) { PWSTR LocalKeyName; PWSTR End; UNICODE_STRING KeyString; NTSTATUS Status; MEMKEY ParentKey; MEMKEY CurrentKey; PLIST_ENTRY Ptr; PCM_KEY_NODE SubKeyCell; HCELL_INDEX BlockOffset; DPRINT("RegpCreateOpenKey('%S')\n", KeyName); if (*KeyName == L'\\') { KeyName++; ParentKey = RootKey; } else if (hParentKey == NULL) { ParentKey = RootKey; } else { ParentKey = HKEY_TO_MEMKEY(RootKey); } LocalKeyName = (PWSTR)KeyName; for (;;) { End = (PWSTR)strchrW(LocalKeyName, '\\'); if (End) { KeyString.Buffer = LocalKeyName; KeyString.Length = KeyString.MaximumLength = (USHORT)((ULONG_PTR)End - (ULONG_PTR)LocalKeyName); } else RtlInitUnicodeString(&KeyString, LocalKeyName); /* Redirect from 'CurrentControlSet' to 'ControlSet001' */ if (!strncmpW(LocalKeyName, L"CurrentControlSet", 17) && ParentKey->NameSize == 12 && !memcmp(ParentKey->Name, L"SYSTEM", 12)) RtlInitUnicodeString(&KeyString, L"ControlSet001"); /* Check subkey in memory structure */ Ptr = ParentKey->SubKeyList.Flink; while (Ptr != &ParentKey->SubKeyList) { CurrentKey = CONTAINING_RECORD(Ptr, KEY, KeyList); if (CurrentKey->NameSize == KeyString.Length && memcmp(CurrentKey->Name, KeyString.Buffer, KeyString.Length) == 0) { goto nextsubkey; } Ptr = Ptr->Flink; } Status = CmiScanForSubKey( ParentKey->RegistryHive, ParentKey->KeyCell, &KeyString, OBJ_CASE_INSENSITIVE, &SubKeyCell, &BlockOffset); if (AllowCreation && Status == STATUS_OBJECT_NAME_NOT_FOUND) { Status = CmiAddSubKey( ParentKey->RegistryHive, ParentKey->KeyCell, ParentKey->KeyCellOffset, &KeyString, 0, &SubKeyCell, &BlockOffset); } if (!NT_SUCCESS(Status)) return ERROR_UNSUCCESSFUL; /* Now, SubKeyCell/BlockOffset are valid */ CurrentKey = CreateInMemoryStructure( ParentKey->RegistryHive, BlockOffset, &KeyString); if (!CurrentKey) return ERROR_OUTOFMEMORY; /* Add CurrentKey in ParentKey */ InsertTailList(&ParentKey->SubKeyList, &CurrentKey->KeyList); ParentKey->SubKeyCount++; nextsubkey: ParentKey = CurrentKey; if (End) LocalKeyName = End + 1; else break; } *Key = MEMKEY_TO_HKEY(ParentKey); return ERROR_SUCCESS; }
HRESULT create_monodata(REFIID riid, LPVOID *ppObj ) { static const WCHAR wszCodebase[] = {'C','o','d','e','B','a','s','e',0}; static const WCHAR wszClass[] = {'C','l','a','s','s',0}; static const WCHAR wszFileSlash[] = {'f','i','l','e',':','/','/','/',0}; static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0}; static const WCHAR wszInprocServer32[] = {'\\','I','n','p','r','o','c','S','e','r','v','e','r','3','2',0}; WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) + ARRAYSIZE(wszInprocServer32) - 1]; MonoDomain *domain; MonoAssembly *assembly; ICLRRuntimeInfo *info; RuntimeHost *host; HRESULT hr; HKEY key; LONG res; int offset = 0; WCHAR codebase[MAX_PATH + 8]; WCHAR classname[350]; WCHAR filename[MAX_PATH]; DWORD dwBufLen = 350; lstrcpyW(path, wszCLSIDSlash); StringFromGUID2(riid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID); lstrcatW(path, wszInprocServer32); TRACE("Registry key: %s\n", debugstr_w(path)); res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &key); if (res == ERROR_FILE_NOT_FOUND) return CLASS_E_CLASSNOTAVAILABLE; res = RegGetValueW( key, NULL, wszClass, RRF_RT_REG_SZ, NULL, classname, &dwBufLen); if(res != ERROR_SUCCESS) { WARN("Class value cannot be found.\n"); hr = CLASS_E_CLASSNOTAVAILABLE; goto cleanup; } TRACE("classname (%s)\n", debugstr_w(classname)); dwBufLen = MAX_PATH + 8; res = RegGetValueW( key, NULL, wszCodebase, RRF_RT_REG_SZ, NULL, codebase, &dwBufLen); if(res != ERROR_SUCCESS) { WARN("CodeBase value cannot be found.\n"); hr = CLASS_E_CLASSNOTAVAILABLE; goto cleanup; } /* Strip file:/// */ if(strncmpW(codebase, wszFileSlash, strlenW(wszFileSlash)) == 0) offset = strlenW(wszFileSlash); strcpyW(filename, codebase + offset); TRACE("codebase (%s)\n", debugstr_w(filename)); *ppObj = NULL; hr = get_runtime_info(filename, NULL, NULL, 0, 0, FALSE, &info); if (SUCCEEDED(hr)) { hr = ICLRRuntimeInfo_GetRuntimeHost(info, &host); if (SUCCEEDED(hr)) hr = RuntimeHost_GetDefaultDomain(host, &domain); if (SUCCEEDED(hr)) { MonoImage *image; MonoClass *klass; MonoObject *result; IUnknown *unk = NULL; char *filenameA, *ns; char *classA; hr = CLASS_E_CLASSNOTAVAILABLE; host->mono->mono_thread_attach(domain); filenameA = WtoA(filename); assembly = host->mono->mono_domain_assembly_open(domain, filenameA); HeapFree(GetProcessHeap(), 0, filenameA); if (!assembly) { ERR("Cannot open assembly %s\n", filenameA); goto cleanup; } image = host->mono->mono_assembly_get_image(assembly); if (!image) { ERR("Couldn't get assembly image\n"); goto cleanup; } classA = WtoA(classname); ns = strrchr(classA, '.'); *ns = '\0'; klass = host->mono->mono_class_from_name(image, classA, ns+1); HeapFree(GetProcessHeap(), 0, classA); if (!klass) { ERR("Couldn't get class from image\n"); goto cleanup; } /* * Use the default constructor for the .NET class. */ result = host->mono->mono_object_new(domain, klass); host->mono->mono_runtime_object_init(result); hr = RuntimeHost_GetIUnknownForObject(host, result, &unk); if (SUCCEEDED(hr)) { hr = IUnknown_QueryInterface(unk, &IID_IUnknown, ppObj); IUnknown_Release(unk); } else hr = CLASS_E_CLASSNOTAVAILABLE; } else hr = CLASS_E_CLASSNOTAVAILABLE; } else hr = CLASS_E_CLASSNOTAVAILABLE; cleanup: if(info) ICLRRuntimeInfo_Release(info); RegCloseKey(key); return hr; }
/* ECMA-262 3rd Edition 9.3.1 */ static HRESULT str_to_number(jsstr_t *str, double *ret) { const WCHAR *ptr = str->str; BOOL neg = FALSE; DOUBLE d = 0.0; static const WCHAR infinityW[] = {'I','n','f','i','n','i','t','y'}; if(!ptr) { *ret = 0; return S_OK; } while(isspaceW(*ptr)) ptr++; if(*ptr == '-') { neg = TRUE; ptr++; }else if(*ptr == '+') { ptr++; } if(!strncmpW(ptr, infinityW, sizeof(infinityW)/sizeof(WCHAR))) { ptr += sizeof(infinityW)/sizeof(WCHAR); while(*ptr && isspaceW(*ptr)) ptr++; if(*ptr) *ret = NAN; else *ret = neg ? -INFINITY : INFINITY; return S_OK; } if(*ptr == '0' && ptr[1] == 'x') { DWORD l = 0; ptr += 2; while((l = hex_to_int(*ptr)) != -1) { d = d*16 + l; ptr++; } *ret = d; return S_OK; } while(isdigitW(*ptr)) d = d*10 + (*ptr++ - '0'); if(*ptr == 'e' || *ptr == 'E') { BOOL eneg = FALSE; LONG l = 0; ptr++; if(*ptr == '-') { ptr++; eneg = TRUE; }else if(*ptr == '+') { ptr++; } while(isdigitW(*ptr)) l = l*10 + (*ptr++ - '0'); if(eneg) l = -l; d *= pow(10, l); }else if(*ptr == '.') { DOUBLE dec = 0.1; ptr++; while(isdigitW(*ptr)) { d += dec * (*ptr++ - '0'); dec *= 0.1; } } while(isspaceW(*ptr)) ptr++; if(*ptr) { *ret = NAN; return S_OK; } if(neg) d = -d; *ret = d; return S_OK; }
/* load the .sys module for a device driver */ static BOOL load_driver(void) { static const WCHAR driversW[] = {'\\','d','r','i','v','e','r','s','\\',0}; static const WCHAR postfixW[] = {'.','s','y','s',0}; static const WCHAR ntprefixW[] = {'\\','?','?','\\',0}; static const WCHAR ImagePathW[] = {'I','m','a','g','e','P','a','t','h',0}; static const WCHAR servicesW[] = {'\\','R','e','g','i','s','t','r','y', '\\','M','a','c','h','i','n','e', '\\','S','y','s','t','e','m', '\\','C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t', '\\','S','e','r','v','i','c','e','s','\\',0}; UNICODE_STRING keypath; HMODULE module; LPWSTR path = NULL, str; DWORD type, size; str = HeapAlloc( GetProcessHeap(), 0, sizeof(servicesW) + strlenW(driver_name)*sizeof(WCHAR) ); lstrcpyW( str, servicesW ); lstrcatW( str, driver_name ); if (RegOpenKeyW( HKEY_LOCAL_MACHINE, str + 18 /* skip \registry\machine */, &driver_hkey )) { WINE_ERR( "cannot open key %s, err=%u\n", wine_dbgstr_w(str), GetLastError() ); HeapFree( GetProcessHeap(), 0, str); return FALSE; } RtlInitUnicodeString( &keypath, str ); /* read the executable path from memory */ size = 0; if (!RegQueryValueExW( driver_hkey, ImagePathW, NULL, &type, NULL, &size )) { str = HeapAlloc( GetProcessHeap(), 0, size ); if (!RegQueryValueExW( driver_hkey, ImagePathW, NULL, &type, (LPBYTE)str, &size )) { size = ExpandEnvironmentStringsW(str,NULL,0); path = HeapAlloc(GetProcessHeap(),0,size*sizeof(WCHAR)); ExpandEnvironmentStringsW(str,path,size); } HeapFree( GetProcessHeap(), 0, str ); if (!path) return FALSE; } else { /* default is to use the driver name + ".sys" */ WCHAR buffer[MAX_PATH]; GetSystemDirectoryW(buffer, MAX_PATH); path = HeapAlloc(GetProcessHeap(),0, (strlenW(buffer) + strlenW(driversW) + strlenW(driver_name) + strlenW(postfixW) + 1) *sizeof(WCHAR)); lstrcpyW(path, buffer); lstrcatW(path, driversW); lstrcatW(path, driver_name); lstrcatW(path, postfixW); } /* GameGuard uses an NT-style path name */ str = path; if (!strncmpW( path, ntprefixW, 4 )) str += 4; WINE_TRACE( "loading driver %s\n", wine_dbgstr_w(str) ); module = load_driver_module( str ); HeapFree( GetProcessHeap(), 0, path ); if (!module) return FALSE; init_driver( module, &keypath ); return TRUE; }