return strW;
}
+static UNICODE_STRING xmlstr2unicode(const xmlstr_t *xmlstr)
+{
+ UNICODE_STRING res;
+
+ res.Buffer = (PWSTR)xmlstr->ptr;
+ res.Length = res.MaximumLength = xmlstr->len;
+
+ return res;
+}
+
static inline BOOL xmlstr_cmp(const xmlstr_t* xmlstr, const WCHAR *str)
{
return !strncmpW(xmlstr->ptr, str, xmlstr->len) && !str[xmlstr->len];
for (i = 0; i < acl->actctx->num_assemblies; i++)
if (is_matching_identity( ai, &acl->actctx->assemblies[i].id ))
{
- DPRINT( "reusing existing assembly for %s arch %s version %u.%u.%u.%u\n",
+ DPRINT( "reusing existing assembly for %S arch %S version %u.%u.%u.%u\n",
ai->name, ai->arch, ai->version.major, ai->version.minor,
ai->version.build, ai->version.revision );
return TRUE;
for (i = 0; i < acl->num_dependencies; i++)
if (is_matching_identity( ai, &acl->dependencies[i] ))
{
- DPRINT( "reusing existing dependency for %s arch %s version %u.%u.%u.%u\n",
+ DPRINT( "reusing existing dependency for %S arch %S version %u.%u.%u.%u\n",
ai->name, ai->arch, ai->version.major, ai->version.minor,
ai->version.build, ai->version.revision );
return TRUE;
ACTIVATION_CONTEXT *ret = NULL, *actctx = h;
if (!h || h == INVALID_HANDLE_VALUE) return NULL;
- //__TRY
+ _SEH2_TRY
{
if (actctx && actctx->magic == ACTCTX_MAGIC) ret = actctx;
}
- //__EXCEPT_PAGE_FAULT
+ _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
{
+ DPRINT1("Invalid activation context handle!\n");
}
- //__ENDTRY
+ _SEH2_END;
return ret;
}
static inline void actctx_addref( ACTIVATION_CONTEXT *actctx )
{
- _InterlockedExchangeAdd( &actctx->ref_count, 1 );
+ InterlockedExchangeAdd( &actctx->ref_count, 1 );
}
static void actctx_release( ACTIVATION_CONTEXT *actctx )
{
- if (_InterlockedExchangeAdd( &actctx->ref_count, -1 ) == 1)
+ if (InterlockedExchangeAdd( &actctx->ref_count, -1 ) == 1)
{
unsigned int i, j;
unsigned int ver[4];
unsigned int pos;
const WCHAR *curr;
+ UNICODE_STRING strU;
/* major.minor.build.revision */
ver[0] = ver[1] = ver[2] = ver[3] = pos = 0;
return TRUE;
error:
- DPRINT1( "Wrong version definition in manifest file (%s)\n", str->ptr );
+ strU = xmlstr2unicode(str);
+ DPRINT1( "Wrong version definition in manifest file (%wZ)\n", &strU );
return FALSE;
}
static BOOL parse_expect_elem(xmlbuf_t* xmlbuf, const WCHAR* name)
{
xmlstr_t elem;
+ UNICODE_STRING elemU;
if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
if (xmlstr_cmp(&elem, name)) return TRUE;
- DPRINT1( "unexpected element %s\n", elem.ptr );
+ elemU = xmlstr2unicode(&elem);
+ DPRINT1( "unexpected element %wZ\n", &elemU );
return FALSE;
}
static BOOL parse_expect_no_attr(xmlbuf_t* xmlbuf, BOOL* end)
{
xmlstr_t attr_name, attr_value;
+ UNICODE_STRING attr_nameU, attr_valueU;
BOOL error;
while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, end))
{
- DPRINT1( "unexpected attr %s=%s\n", attr_name.ptr,
- attr_value.ptr);
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_name);
+ DPRINT1( "unexpected attr %S=%S\n", &attr_nameU,
+ &attr_valueU);
}
return !error;
}
static BOOL parse_expect_end_elem(xmlbuf_t *xmlbuf, const WCHAR *name)
{
xmlstr_t elem;
+ UNICODE_STRING elemU;
if (!next_xml_elem(xmlbuf, &elem)) return FALSE;
if (!xmlstr_cmp_end(&elem, name))
{
- DPRINT1( "unexpected element %s\n", elem.ptr );
+ elemU = xmlstr2unicode(&elem);
+ DPRINT1( "unexpected element %wZ\n", &elemU );
return FALSE;
}
return parse_end_element(xmlbuf);
{
xmlstr_t attr_name, attr_value;
BOOL end = FALSE, error;
+ UNICODE_STRING attr_valueU, attr_nameU;
while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
{
}
else if (xmlstr_cmp(&attr_name, languageW))
{
- DPRINT1("Unsupported yet language attribute (%s)\n",
- attr_value.ptr);
if (!(ai->language = xmlstrdupW(&attr_value))) return FALSE;
+ DPRINT1("Unsupported yet language attribute (%S)\n",
+ ai->language);
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr,
- attr_value.ptr);
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
xmlstr_t elem, attr_name, attr_value;
BOOL ret, end = FALSE, error;
struct entity* entity;
+ UNICODE_STRING attr_valueU, attr_nameU;
if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION)))
return FALSE;
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr, attr_value.ptr);
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
}
else
{
- DPRINT1("unknown elem %s\n", elem.ptr);
+ attr_nameU = xmlstr2unicode(&elem);
+ DPRINT1("unknown elem %wZ\n", &attr_nameU);
ret = parse_unknown_elem(xmlbuf, &elem);
}
}
xmlstr_t attr_name, attr_value;
BOOL end = FALSE, error;
struct entity* entity;
+ UNICODE_STRING attr_valueU, attr_nameU;
if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION)))
return FALSE;
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr, attr_value.ptr);
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
xmlstr_t attr_name, attr_value;
BOOL end = FALSE, error;
struct entity* entity;
+ UNICODE_STRING attr_valueU, attr_nameU;
if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_COM_TYPE_LIBRARY_REDIRECTION)))
return FALSE;
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr , attr_value.ptr);
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
xmlstr_t elem, content;
BOOL end = FALSE, ret = TRUE;
struct entity* entity;
+ UNICODE_STRING elemU;
if (!(entity = add_entity(&dll->entities, ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION)))
return FALSE;
}
else
{
- DPRINT1("unknown elem %s\n", elem.ptr);
+ elemU = xmlstr2unicode(&elem);
+ DPRINT1("unknown elem %wZ\n", &elemU);
ret = parse_unknown_elem(xmlbuf, &elem);
}
}
static BOOL parse_binding_redirect_elem(xmlbuf_t* xmlbuf)
{
xmlstr_t attr_name, attr_value;
+ UNICODE_STRING attr_valueU, attr_nameU;
BOOL end = FALSE, error;
while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
{
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+
if (xmlstr_cmp(&attr_name, oldVersionW))
{
- DPRINT1("Not stored yet oldVersion=%s\n", attr_value.ptr);
+ DPRINT1("Not stored yet oldVersion=%wZ\n", &attr_valueU);
}
else if (xmlstr_cmp(&attr_name, newVersionW))
{
- DPRINT1("Not stored yet newVersion=%s\n", attr_value.ptr);
+ DPRINT1("Not stored yet newVersion=%wZ\n", &attr_valueU);
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr, attr_value.ptr);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
static BOOL parse_description_elem(xmlbuf_t* xmlbuf)
{
xmlstr_t elem, content;
+ UNICODE_STRING elemU;
BOOL end = FALSE, ret = TRUE;
if (!parse_expect_no_attr(xmlbuf, &end) || end ||
!parse_text_content(xmlbuf, &content))
return FALSE;
- DPRINT("Got description %s\n", content.ptr);
+ elemU = xmlstr2unicode(&content);
+ DPRINT("Got description %wZ\n", &elemU);
while (ret && (ret = next_xml_elem(xmlbuf, &elem)))
{
}
else
{
- DPRINT1("unknown elem %s\n", elem.ptr);
+ elemU = xmlstr2unicode(&elem);
+ DPRINT1("unknown elem %wZ\n", &elemU);
ret = parse_unknown_elem(xmlbuf, &elem);
}
}
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr, attr_value.ptr);
+ DPRINT1("unknown attr %S=%S\n", attr_name.ptr, attr_value.ptr);
}
}
static BOOL parse_clr_class_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
{
xmlstr_t attr_name, attr_value;
+ UNICODE_STRING attr_nameU, attr_valueU;
BOOL end = FALSE, error;
struct entity* entity;
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr, attr_value.ptr);
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
static BOOL parse_clr_surrogate_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
{
xmlstr_t attr_name, attr_value;
+ UNICODE_STRING attr_nameU, attr_valueU;
BOOL end = FALSE, error;
struct entity* entity;
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr, attr_value.ptr);
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
}
else
{
- DPRINT1("unknown elem %s\n", elem.ptr);
+ DPRINT1("unknown elem %S\n", elem.ptr);
ret = parse_unknown_elem(xmlbuf, &elem);
}
}
static BOOL parse_dependency_elem(xmlbuf_t* xmlbuf, struct actctx_loader* acl)
{
xmlstr_t attr_name, attr_value, elem;
+ UNICODE_STRING attr_nameU, attr_valueU;
BOOL end = FALSE, ret = TRUE, error, optional = FALSE;
while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
{
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+
if (xmlstr_cmp(&attr_name, optionalW))
{
static const WCHAR yesW[] = {'y','e','s',0};
optional = xmlstr_cmpi( &attr_value, yesW );
- DPRINT1("optional=%s\n", attr_value.ptr);
+ DPRINT1("optional=%wZ\n", &attr_valueU);
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr, attr_value.ptr);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
}
else
{
- DPRINT1("unknown element %s\n", elem.ptr);
+ attr_nameU = xmlstr2unicode(&elem);
+ DPRINT1("unknown element %wZ\n", &attr_nameU);
ret = parse_unknown_elem(xmlbuf, &elem);
}
}
static BOOL parse_file_elem(xmlbuf_t* xmlbuf, struct assembly* assembly)
{
xmlstr_t attr_name, attr_value, elem;
+ UNICODE_STRING attr_nameU, attr_valueU;
BOOL end = FALSE, error, ret = TRUE;
struct dll_redirect* dll;
while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
{
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+
if (xmlstr_cmp(&attr_name, nameW))
{
if (!(dll->name = xmlstrdupW(&attr_value))) return FALSE;
- DPRINT("name=%s\n", attr_value.ptr);
+ DPRINT("name=%wZ\n", &attr_valueU);
}
else if (xmlstr_cmp(&attr_name, hashW))
{
{
static const WCHAR sha1W[] = {'S','H','A','1',0};
if (!xmlstr_cmpi(&attr_value, sha1W))
- DPRINT1("hashalg should be SHA1, got %s\n", attr_value.ptr);
+ DPRINT1("hashalg should be SHA1, got %wZ\n", &attr_valueU);
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr, attr_value.ptr);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
}
else
{
- DPRINT1("unknown elem %s\n", elem.ptr);
+ attr_nameU = xmlstr2unicode(&elem);
+ DPRINT1("unknown elem %wZ\n", &attr_nameU);
ret = parse_unknown_elem( xmlbuf, &elem );
}
}
struct assembly_identity* expected_ai)
{
xmlstr_t attr_name, attr_value, elem;
+ UNICODE_STRING attr_nameU, attr_valueU;
BOOL end = FALSE, error, version = FALSE, xmlns = FALSE, ret = TRUE;
while (next_xml_attr(xmlbuf, &attr_name, &attr_value, &error, &end))
{
+ attr_nameU = xmlstr2unicode(&attr_name);
+ attr_valueU = xmlstr2unicode(&attr_value);
+
if (xmlstr_cmp(&attr_name, manifestVersionW))
{
static const WCHAR v10W[] = {'1','.','0',0};
if (!xmlstr_cmp(&attr_value, v10W))
{
- DPRINT1("wrong version %s\n", attr_value.ptr);
+ DPRINT1("wrong version %wZ\n", &attr_valueU);
return FALSE;
}
version = TRUE;
{
if (!xmlstr_cmp(&attr_value, manifestv1W) && !xmlstr_cmp(&attr_value, manifestv3W))
{
- DPRINT1("wrong namespace %s\n", attr_value.ptr);
+ DPRINT1("wrong namespace %wZ\n", &attr_valueU);
return FALSE;
}
xmlns = TRUE;
}
else
{
- DPRINT1("unknown attr %s=%s\n", attr_name.ptr, attr_value.ptr);
+ DPRINT1("unknown attr %wZ=%wZ\n", &attr_nameU, &attr_valueU);
}
}
}
else
{
- DPRINT1("unknown element %s\n", elem.ptr);
+ attr_nameU = xmlstr2unicode(&elem);
+ DPRINT1("unknown element %wZ\n", &attr_nameU);
ret = parse_unknown_elem(xmlbuf, &elem);
}
if (ret) ret = next_xml_elem(xmlbuf, &elem);
struct assembly_identity* ai, xmlbuf_t *xmlbuf )
{
xmlstr_t elem;
+ UNICODE_STRING elemU;
if (!next_xml_elem(xmlbuf, &elem)) return STATUS_SXS_CANT_GEN_ACTCTX;
if (!xmlstr_cmp(&elem, assemblyW))
{
- DPRINT1("root element is %s, not <assembly>\n", elem.ptr);
+ elemU = xmlstr2unicode(&elem);
+ DPRINT1("root element is %wZ, not <assembly>\n", &elemU);
return STATUS_SXS_CANT_GEN_ACTCTX;
}
if (!parse_assembly_elem(xmlbuf, acl, assembly, ai))
{
- DPRINT1("failed to parse manifest %s\n", assembly->manifest.info );
+ DPRINT1("failed to parse manifest %S\n", assembly->manifest.info );
return STATUS_SXS_CANT_GEN_ACTCTX;
}
if (next_xml_elem(xmlbuf, &elem))
{
- DPRINT1("unexpected element %s\n", elem.ptr);
+ elemU = xmlstr2unicode(&elem);
+ DPRINT1("unexpected element %wZ\n", &elemU);
return STATUS_SXS_CANT_GEN_ACTCTX;
}
struct assembly *assembly;
int unicode_tests;
- DPRINT( "parsing manifest loaded from %s base dir %s\n", filename, directory );
+ DPRINT( "parsing manifest loaded from %S base dir %S\n", filename, directory );
if (!(assembly = add_assembly(acl->actctx, shared ? ASSEMBLY_SHARED_MANIFEST : ASSEMBLY_MANIFEST)))
return STATUS_SXS_CANT_GEN_ACTCTX;
{
/* let's assume utf-8 for now */
int len;
+ WCHAR *new_buff;
_SEH2_TRY
{
_SEH2_END;
DPRINT("len = %x\n", len);
- WCHAR *new_buff;
if (len == -1)
{
DPRINT1( "utf-8 conversion failed\n" );
return STATUS_SXS_CANT_GEN_ACTCTX;
}
- if (!(new_buff = RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR) )))
+ if (!(new_buff = RtlAllocateHeap( RtlGetProcessHeap(), HEAP_ZERO_MEMORY, len)))
return STATUS_NO_MEMORY;
- mbstowcs( new_buff, buffer, len);
+ mbstowcs( new_buff, buffer, size);
xmlbuf.ptr = new_buff;
- DPRINT("Buffer %S\n", new_buff);
- xmlbuf.end = xmlbuf.ptr + len;
+
+ xmlbuf.end = xmlbuf.ptr + len / sizeof(WCHAR);
status = parse_manifest_buffer( acl, assembly, ai, &xmlbuf );
RtlFreeHeap( RtlGetProcessHeap(), 0, new_buff );
SIZE_T count;
void *base;
- DPRINT( "looking for res %s in %s\n", resname, filename );
+ DPRINT( "looking for res %S in %S\n", resname, filename );
attr.Length = sizeof(attr);
attr.RootDirectory = 0;
if (!((ULONG_PTR)resname >> 16)) resid = (ULONG_PTR)resname & 0xffff;
- DPRINT( "looking for manifest associated with %s id %lu\n", filename, resid );
+ DPRINT( "looking for manifest associated with %S id %lu\n", filename, resid );
if (module) /* use the module filename */
{
break;
}
}
- else DPRINT1("no matching file for %s\n", lookup);
+ else DPRINT1("no matching file for %S\n", lookup);
RtlFreeHeap( RtlGetProcessHeap(), 0, lookup );
return ret;
}
if (flags & QUERY_ACTCTX_FLAG_USE_ACTIVE_ACTCTX)
{
+ if (*handle) return STATUS_INVALID_PARAMETER;
+
if (NtCurrentTeb()->ActivationContextStackPointer->ActiveFrame)
*handle = NtCurrentTeb()->ActivationContextStackPointer->ActiveFrame->ActivationContext;
}
ULONG magic;
LDR_DATA_TABLE_ENTRY *pldr;
+ if (!*handle) return STATUS_INVALID_PARAMETER;
+
LdrLockLoaderLock( 0, NULL, &magic );
if (!LdrFindEntryForAddress( *handle, &pldr ))
{
{
UNICODE_STRING dir;
WCHAR *p;
+ HMODULE module;
- if ((status = get_module_filename( NtCurrentTeb()->ProcessEnvironmentBlock->ImageBaseAddress, &dir, 0 )))
- goto error;
+ if (pActCtx->dwFlags & ACTCTX_FLAG_HMODULE_VALID) module = pActCtx->hModule;
+ else module = NtCurrentTeb()->ProcessEnvironmentBlock->ImageBaseAddress;
+ if ((status = get_module_filename( module, &dir, 0 ))) goto error;
if ((p = strrchrW( dir.Buffer, '\\' ))) p[1] = 0;
actctx->appdir.info = dir.Buffer;
}
if (status == STATUS_SUCCESS) *handle = actctx;
else actctx_release( actctx );
-
return status;
error:
projects / reactos.git / blobdiff