wine-devel

wine-devel@winehq.org

8 participants
84486 discussions

[PATCH v2 5/5] combase: Move ORPC functionality.
by Huw Davies 01 Sep '20

01 Sep '20

From: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/combase/apartment.c | 13 +- dlls/combase/combase.c | 11 + dlls/combase/combase.spec | 10 +- dlls/combase/combase_private.h | 31 +- dlls/combase/marshal.c | 24 +- dlls/combase/rpc.c | 1615 +++++++++++++++++++++++++++++++ dlls/combase/stubmanager.c | 22 +- dlls/ole32/Makefile.in | 1 - dlls/ole32/compobj.c | 21 - dlls/ole32/compobj_private.h | 146 +-- dlls/ole32/ole32.spec | 10 +- dlls/ole32/rpc.c | 1654 -------------------------------- 12 files changed, 1676 insertions(+), 1882 deletions(-) delete mode 100644 dlls/ole32/rpc.c diff --git a/dlls/combase/apartment.c b/dlls/combase/apartment.c index bb9e9f44032..125eaff1429 100644 --- a/dlls/combase/apartment.c +++ b/dlls/combase/apartment.c @@ -443,7 +443,7 @@ void apartment_freeunusedlibraries(struct apartment *apt, DWORD delay) LeaveCriticalSection(&apt->cs); } -void WINAPI apartment_release(struct apartment *apt) +void apartment_release(struct apartment *apt) { DWORD refcount; @@ -615,7 +615,7 @@ struct apartment * apartment_get_mta(void) /* Return the current apartment if it exists, or, failing that, the MTA. Caller * must free the returned apartment in either case. */ -struct apartment * WINAPI apartment_get_current_or_mta(void) +struct apartment * apartment_get_current_or_mta(void) { struct apartment *apt = com_get_current_apt(); if (apt) @@ -1098,14 +1098,13 @@ static HRESULT apartment_hostobject(struct apartment *apt, const struct host_obj } struct dispatch_params; -extern void WINAPI Internal_RPC_ExecuteCall(struct dispatch_params *params); static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch (msg) { case DM_EXECUTERPC: - Internal_RPC_ExecuteCall((struct dispatch_params *)lParam); + rpc_execute_call((struct dispatch_params *)lParam); return 0; case DM_HOSTOBJECT: return apartment_hostobject(com_get_current_apt(), (const struct host_object_params *)lParam); @@ -1119,7 +1118,7 @@ static BOOL apartment_is_model(const struct apartment *apt, DWORD model) return (apt->multi_threaded == !(model & COINIT_APARTMENTTHREADED)); } -HRESULT WINAPI enter_apartment(struct tlsdata *data, DWORD model) +HRESULT enter_apartment(struct tlsdata *data, DWORD model) { HRESULT hr = S_OK; @@ -1143,7 +1142,7 @@ HRESULT WINAPI enter_apartment(struct tlsdata *data, DWORD model) return hr; } -void WINAPI leave_apartment(struct tlsdata *data) +void leave_apartment(struct tlsdata *data) { if (!--data->inits) { @@ -1262,7 +1261,7 @@ HRESULT apartment_createwindowifneeded(struct apartment *apt) } /* retrieves the window for the main- or apartment-threaded apartment */ -HWND WINAPI apartment_getwindow(const struct apartment *apt) +HWND apartment_getwindow(const struct apartment *apt) { assert(!apt->multi_threaded); return apt->win; diff --git a/dlls/combase/combase.c b/dlls/combase/combase.c index b3e3844a4db..d959034b57f 100644 --- a/dlls/combase/combase.c +++ b/dlls/combase/combase.c @@ -3052,6 +3052,16 @@ HRESULT WINAPI CoLockObjectExternal(IUnknown *object, BOOL lock, BOOL last_unloc return S_OK; } +/*********************************************************************** + * CoRegisterChannelHook (combase.@) + */ +HRESULT WINAPI CoRegisterChannelHook(REFGUID guidExtension, IChannelHook *channel_hook) +{ + TRACE("%s, %p\n", debugstr_guid(guidExtension), channel_hook); + + return rpc_register_channel_hook(guidExtension, channel_hook); +} + /*********************************************************************** * DllMain (combase.@) */ @@ -3068,6 +3078,7 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD reason, LPVOID reserved) if (reserved) break; apartment_global_cleanup(); DeleteCriticalSection(&registered_classes_cs); + rpc_unregister_channel_hooks(); break; case DLL_THREAD_DETACH: com_cleanup_tlsdata(); diff --git a/dlls/combase/combase.spec b/dlls/combase/combase.spec index f0429343f66..3a09ce064b0 100644 --- a/dlls/combase/combase.spec +++ b/dlls/combase/combase.spec @@ -139,6 +139,7 @@ @ stdcall CoQueryProxyBlanket(ptr ptr ptr ptr ptr ptr ptr ptr) @ stub CoReactivateObject @ stub CoRegisterActivationFilter +@ stdcall CoRegisterChannelHook(ptr ptr) @ stdcall CoRegisterClassObject(ptr ptr long long ptr) @ stdcall CoRegisterInitializeSpy(ptr ptr) @ stdcall CoRegisterMallocSpy(ptr) @@ -350,12 +351,3 @@ @ stdcall WindowsSubstringWithSpecifiedLength(ptr long long ptr) @ stdcall WindowsTrimStringEnd(ptr ptr ptr) @ stdcall WindowsTrimStringStart(ptr ptr ptr) - -@ stdcall apartment_get_current_or_mta() -@ stdcall apartment_release(ptr) -@ stdcall enter_apartment(ptr long) -@ stdcall leave_apartment(ptr) -@ stdcall apartment_getwindow(ptr) -@ stdcall stub_manager_int_release(ptr) -@ stdcall ipid_get_dispatch_params(ptr ptr ptr ptr ptr ptr ptr) -@ stdcall start_apartment_remote_unknown(ptr) diff --git a/dlls/combase/combase_private.h b/dlls/combase/combase_private.h index bcf0ad46102..703c1a26c20 100644 --- a/dlls/combase/combase_private.h +++ b/dlls/combase/combase_private.h @@ -102,7 +102,7 @@ static inline struct apartment* com_get_current_apt(void) return tlsdata->apt; } -HWND WINAPI apartment_getwindow(const struct apartment *apt) DECLSPEC_HIDDEN; +HWND apartment_getwindow(const struct apartment *apt) DECLSPEC_HIDDEN; HRESULT apartment_createwindowifneeded(struct apartment *apt) DECLSPEC_HIDDEN; void apartment_freeunusedlibraries(struct apartment *apt, DWORD unload_delay) DECLSPEC_HIDDEN; void apartment_global_cleanup(void) DECLSPEC_HIDDEN; @@ -114,6 +114,18 @@ HRESULT rpcss_get_next_seqid(DWORD *id) DECLSPEC_HIDDEN; HRESULT rpc_get_local_class_object(REFCLSID rclsid, REFIID riid, void **obj) DECLSPEC_HIDDEN; HRESULT rpc_start_local_server(REFCLSID clsid, IStream *stream, BOOL multi_use, void **registration) DECLSPEC_HIDDEN; void rpc_stop_local_server(void *registration) DECLSPEC_HIDDEN; +HRESULT rpc_create_clientchannel(const OXID *oxid, const IPID *ipid, const OXID_INFO *oxid_info, const IID *iid, + DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan, struct apartment *apt) DECLSPEC_HIDDEN; +HRESULT rpc_create_serverchannel(DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan) DECLSPEC_HIDDEN; +HRESULT rpc_register_interface(REFIID riid) DECLSPEC_HIDDEN; +void rpc_unregister_interface(REFIID riid, BOOL wait) DECLSPEC_HIDDEN; +HRESULT rpc_resolve_oxid(OXID oxid, OXID_INFO *oxid_info) DECLSPEC_HIDDEN; +void rpc_start_remoting(struct apartment *apt) DECLSPEC_HIDDEN; +HRESULT rpc_register_channel_hook(REFGUID rguid, IChannelHook *hook) DECLSPEC_HIDDEN; +void rpc_unregister_channel_hooks(void) DECLSPEC_HIDDEN; + +struct dispatch_params; +void rpc_execute_call(struct dispatch_params *params); enum class_reg_data_origin { @@ -136,10 +148,10 @@ struct class_reg_data } u; }; -HRESULT WINAPI enter_apartment(struct tlsdata *data, DWORD model); -void WINAPI leave_apartment(struct tlsdata *data); -void WINAPI apartment_release(struct apartment *apt); -struct apartment * WINAPI apartment_get_current_or_mta(void); +HRESULT enter_apartment(struct tlsdata *data, DWORD model) DECLSPEC_HIDDEN; +void leave_apartment(struct tlsdata *data) DECLSPEC_HIDDEN; +void apartment_release(struct apartment *apt) DECLSPEC_HIDDEN; +struct apartment * apartment_get_current_or_mta(void) DECLSPEC_HIDDEN; HRESULT apartment_increment_mta_usage(CO_MTA_USAGE_COOKIE *cookie) DECLSPEC_HIDDEN; void apartment_decrement_mta_usage(CO_MTA_USAGE_COOKIE cookie) DECLSPEC_HIDDEN; struct apartment * apartment_get_mta(void) DECLSPEC_HIDDEN; @@ -152,6 +164,9 @@ void apartment_revoke_all_classes(const struct apartment *apt) DECLSPEC_HIDDEN; struct apartment * apartment_findfromoxid(OXID oxid) DECLSPEC_HIDDEN; struct apartment * apartment_findfromtid(DWORD tid) DECLSPEC_HIDDEN; +HRESULT marshal_object(struct apartment *apt, STDOBJREF *stdobjref, REFIID riid, IUnknown *object, + DWORD dest_context, void *dest_context_data, MSHLFLAGS mshlflags) DECLSPEC_HIDDEN; + /* Stub Manager */ /* signal to stub manager that this is a rem unknown object */ @@ -219,7 +234,7 @@ struct stub_manager BOOL disconnected; /* CoDisconnectObject has been called (CS lock) */ }; -ULONG WINAPI stub_manager_int_release(struct stub_manager *stub_manager) DECLSPEC_HIDDEN; +ULONG stub_manager_int_release(struct stub_manager *stub_manager) DECLSPEC_HIDDEN; struct stub_manager * get_stub_manager_from_object(struct apartment *apt, IUnknown *object, BOOL alloc) DECLSPEC_HIDDEN; void stub_manager_disconnect(struct stub_manager *m) DECLSPEC_HIDDEN; ULONG stub_manager_ext_addref(struct stub_manager *m, ULONG refs, BOOL tableweak) DECLSPEC_HIDDEN; @@ -231,3 +246,7 @@ BOOL stub_manager_notify_unmarshal(struct stub_manager *m, const IPID *ipid) DEC struct ifstub * stub_manager_find_ifstub(struct stub_manager *m, REFIID iid, MSHLFLAGS flags) DECLSPEC_HIDDEN; struct ifstub * stub_manager_new_ifstub(struct stub_manager *m, IRpcStubBuffer *sb, REFIID iid, DWORD dest_context, void *dest_context_data, MSHLFLAGS flags) DECLSPEC_HIDDEN; +HRESULT ipid_get_dispatch_params(const IPID *ipid, struct apartment **stub_apt, + struct stub_manager **manager, IRpcStubBuffer **stub, IRpcChannelBuffer **chan, + IID *iid, IUnknown **iface) DECLSPEC_HIDDEN; +HRESULT start_apartment_remote_unknown(struct apartment *apt) DECLSPEC_HIDDEN; diff --git a/dlls/combase/marshal.c b/dlls/combase/marshal.c index 977945cd013..bcc78132651 100644 --- a/dlls/combase/marshal.c +++ b/dlls/combase/marshal.c @@ -36,9 +36,6 @@ HRESULT WINAPI RPC_CreateClientChannel(const OXID *oxid, const IPID *ipid, const OXID_INFO *oxid_info, const IID *iid, DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan, struct apartment *apt); -HRESULT WINAPI RPC_RegisterInterface(REFIID riid); -HRESULT WINAPI RPC_ResolveOxid(OXID oxid, OXID_INFO *oxid_info); -void WINAPI RPC_StartRemoting(struct apartment *apt); static HRESULT unmarshal_object(const STDOBJREF *stdobjref, struct apartment *apt, MSHCTX dest_context, void *dest_context_data, @@ -889,7 +886,7 @@ static inline HRESULT get_facbuf_for_iid(REFIID riid, IPSFactoryBuffer **facbuf) } /* marshals an object into a STDOBJREF structure */ -HRESULT WINAPI marshal_object(struct apartment *apt, STDOBJREF *stdobjref, REFIID riid, IUnknown *object, +HRESULT marshal_object(struct apartment *apt, STDOBJREF *stdobjref, REFIID riid, IUnknown *object, DWORD dest_context, void *dest_context_data, MSHLFLAGS mshlflags) { struct stub_manager *manager; @@ -971,7 +968,7 @@ HRESULT WINAPI marshal_object(struct apartment *apt, STDOBJREF *stdobjref, REFII } /* FIXME: check return value */ - RPC_RegisterInterface(riid); + rpc_register_interface(riid); stdobjref->ipid = ifstub->ipid; @@ -979,8 +976,6 @@ HRESULT WINAPI marshal_object(struct apartment *apt, STDOBJREF *stdobjref, REFII return S_OK; } - - /* Client-side identity of the server object */ static HRESULT proxy_manager_get_remunknown(struct proxy_manager * This, IRemUnknown **remunk); @@ -1583,7 +1578,7 @@ static HRESULT proxy_manager_construct( } else { - HRESULT hr = RPC_ResolveOxid(oxid, &This->oxid_info); + HRESULT hr = rpc_resolve_oxid(oxid, &This->oxid_info); if (FAILED(hr)) { CloseHandle(This->remoting_mutex); @@ -2081,7 +2076,7 @@ static HRESULT WINAPI StdMarshalImpl_MarshalInterface(IMarshal *iface, IStream * } /* make sure this apartment can be reached from other threads / processes */ - RPC_StartRemoting(apt); + rpc_start_remoting(apt); fill_std_objref(&objref, riid, NULL); hr = marshal_object(apt, &objref.u_objref.u_standard.std, riid, pv, dest_context, @@ -2134,14 +2129,11 @@ static HRESULT unmarshal_object(const STDOBJREF *stdobjref, struct apartment *ap if (hr == E_NOINTERFACE) { IRpcChannelBuffer *chanbuf; - hr = RPC_CreateClientChannel(&stdobjref->oxid, &stdobjref->ipid, - &proxy_manager->oxid_info, riid, - proxy_manager->dest_context, - proxy_manager->dest_context_data, - &chanbuf, apt); + hr = rpc_create_clientchannel(&stdobjref->oxid, &stdobjref->ipid, + &proxy_manager->oxid_info, riid, proxy_manager->dest_context, + proxy_manager->dest_context_data, &chanbuf, apt); if (hr == S_OK) - hr = proxy_manager_create_ifproxy(proxy_manager, stdobjref, - riid, chanbuf, &ifproxy); + hr = proxy_manager_create_ifproxy(proxy_manager, stdobjref, riid, chanbuf, &ifproxy); } else IUnknown_AddRef((IUnknown *)ifproxy->iface); diff --git a/dlls/combase/rpc.c b/dlls/combase/rpc.c index cb503e9ae7c..ebfc19329d8 100644 --- a/dlls/combase/rpc.c +++ b/dlls/combase/rpc.c @@ -1,4 +1,8 @@ /* + * Copyright 2001 Ove Kåven, TransGaming Technologies + * Copyright 2002 Marcus Meissner + * Copyright 2005 Mike Hearn, Rob Shearman for CodeWeavers + * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either @@ -33,6 +37,138 @@ WINE_DEFAULT_DEBUG_CHANNEL(ole); +static void __RPC_STUB dispatch_rpc(RPC_MESSAGE *msg); + +/* we only use one function to dispatch calls for all methods - we use the + * RPC_IF_OLE flag to tell the RPC runtime that this is the case */ +static RPC_DISPATCH_FUNCTION rpc_dispatch_table[1] = { dispatch_rpc }; /* (RO) */ +static RPC_DISPATCH_TABLE rpc_dispatch = { 1, rpc_dispatch_table }; /* (RO) */ + +static struct list registered_interfaces = LIST_INIT(registered_interfaces); /* (CS csRegIf) */ +static CRITICAL_SECTION csRegIf; +static CRITICAL_SECTION_DEBUG csRegIf_debug = +{ + 0, 0, &csRegIf, + { &csRegIf_debug.ProcessLocksList, &csRegIf_debug.ProcessLocksList }, + 0, 0, { (DWORD_PTR)(__FILE__ ": dcom registered server interfaces") } +}; +static CRITICAL_SECTION csRegIf = { &csRegIf_debug, -1, 0, 0, 0, 0 }; + +static struct list channel_hooks = LIST_INIT(channel_hooks); /* (CS csChannelHook) */ +static CRITICAL_SECTION csChannelHook; +static CRITICAL_SECTION_DEBUG csChannelHook_debug = +{ + 0, 0, &csChannelHook, + { &csChannelHook_debug.ProcessLocksList, &csChannelHook_debug.ProcessLocksList }, + 0, 0, { (DWORD_PTR)(__FILE__ ": channel hooks") } +}; +static CRITICAL_SECTION csChannelHook = { &csChannelHook_debug, -1, 0, 0, 0, 0 }; + +static WCHAR rpctransportW[] = L"ncalrpc"; + +struct registered_if +{ + struct list entry; + DWORD refs; /* ref count */ + RPC_SERVER_INTERFACE If; /* interface registered with the RPC runtime */ +}; + +/* get the pipe endpoint specified of the specified apartment */ +static inline void get_rpc_endpoint(LPWSTR endpoint, const OXID *oxid) +{ + /* FIXME: should get endpoint from rpcss */ + static const WCHAR wszEndpointFormat[] = {'\\','p','i','p','e','\\','O','L','E','_','%','0','8','l','x','%','0','8','l','x',0}; + wsprintfW(endpoint, wszEndpointFormat, (DWORD)(*oxid >> 32),(DWORD)*oxid); +} + +typedef struct +{ + IRpcChannelBuffer IRpcChannelBuffer_iface; + LONG refs; + + DWORD dest_context; /* returned from GetDestCtx */ + void *dest_context_data; /* returned from GetDestCtx */ +} RpcChannelBuffer; + +typedef struct +{ + RpcChannelBuffer super; /* superclass */ + + RPC_BINDING_HANDLE bind; /* handle to the remote server */ + OXID oxid; /* apartment in which the channel is valid */ + DWORD server_pid; /* id of server process */ + HANDLE event; /* cached event handle */ + IID iid; /* IID of the proxy this belongs to */ +} ClientRpcChannelBuffer; + +struct dispatch_params +{ + RPCOLEMESSAGE *msg; /* message */ + IRpcStubBuffer *stub; /* stub buffer, if applicable */ + IRpcChannelBuffer *chan; /* server channel buffer, if applicable */ + IID iid; /* ID of interface being called */ + IUnknown *iface; /* interface being called */ + HANDLE handle; /* handle that will become signaled when call finishes */ + BOOL bypass_rpcrt; /* bypass RPC runtime? */ + RPC_STATUS status; /* status (out) */ + HRESULT hr; /* hresult (out) */ +}; + +struct message_state +{ + RPC_BINDING_HANDLE binding_handle; + ULONG prefix_data_len; + SChannelHookCallInfo channel_hook_info; + BOOL bypass_rpcrt; + + /* client only */ + HWND target_hwnd; + DWORD target_tid; + struct dispatch_params params; +}; + +typedef struct +{ + ULONG conformance; /* NDR */ + GUID id; + ULONG size; + /* [size_is((size+7)&~7)] */ unsigned char data[1]; +} WIRE_ORPC_EXTENT; + +typedef struct +{ + ULONG size; + ULONG reserved; + unsigned char extent[1]; +} WIRE_ORPC_EXTENT_ARRAY; + +typedef struct +{ + ULONG version; + ULONG flags; + ULONG reserved1; + GUID cid; + unsigned char extensions[1]; +} WIRE_ORPCTHIS; + +typedef struct +{ + ULONG flags; + unsigned char extensions[1]; +} WIRE_ORPCTHAT; + +struct channel_hook_entry +{ + struct list entry; + GUID id; + IChannelHook *hook; +}; + +struct channel_hook_buffer_data +{ + GUID id; + ULONG extension_size; +}; void * __RPC_USER MIDL_user_allocate(SIZE_T size) { return heap_alloc(size); @@ -629,3 +765,1482 @@ void rpc_stop_local_server(void *registration) CloseHandle(lsp->thread); HeapFree(GetProcessHeap(), 0, lsp); } + +static HRESULT unmarshal_ORPCTHAT(RPC_MESSAGE *msg, ORPCTHAT *orpcthat, ORPC_EXTENT_ARRAY *orpc_ext_array, + WIRE_ORPC_EXTENT **first_wire_orpc_extent); + +/* Channel Hook Functions */ + +static ULONG ChannelHooks_ClientGetSize(SChannelHookCallInfo *info, struct channel_hook_buffer_data **data, + unsigned int *hook_count, ULONG *extension_count) +{ + struct channel_hook_entry *entry; + ULONG total_size = 0; + unsigned int hook_index = 0; + + *hook_count = 0; + *extension_count = 0; + + EnterCriticalSection(&csChannelHook); + + LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) + (*hook_count)++; + + if (*hook_count) + *data = HeapAlloc(GetProcessHeap(), 0, *hook_count * sizeof(struct channel_hook_buffer_data)); + else + *data = NULL; + + LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) + { + ULONG extension_size = 0; + + IChannelHook_ClientGetSize(entry->hook, &entry->id, &info->iid, &extension_size); + + TRACE("%s: extension_size = %u\n", debugstr_guid(&entry->id), extension_size); + + extension_size = (extension_size+7)&~7; + (*data)[hook_index].id = entry->id; + (*data)[hook_index].extension_size = extension_size; + + /* an extension is only put onto the wire if it has data to write */ + if (extension_size) + { + total_size += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[extension_size]); + (*extension_count)++; + } + + hook_index++; + } + + LeaveCriticalSection(&csChannelHook); + + return total_size; +} + +static unsigned char * ChannelHooks_ClientFillBuffer(SChannelHookCallInfo *info, + unsigned char *buffer, struct channel_hook_buffer_data *data, + unsigned int hook_count) +{ + struct channel_hook_entry *entry; + + EnterCriticalSection(&csChannelHook); + + LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) + { + unsigned int i; + ULONG extension_size = 0; + WIRE_ORPC_EXTENT *wire_orpc_extent = (WIRE_ORPC_EXTENT *)buffer; + + for (i = 0; i < hook_count; i++) + if (IsEqualGUID(&entry->id, &data[i].id)) + extension_size = data[i].extension_size; + + /* an extension is only put onto the wire if it has data to write */ + if (!extension_size) + continue; + + IChannelHook_ClientFillBuffer(entry->hook, &entry->id, &info->iid, + &extension_size, buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0])); + + TRACE("%s: extension_size = %u\n", debugstr_guid(&entry->id), extension_size); + + /* FIXME: set unused portion of wire_orpc_extent->data to 0? */ + + wire_orpc_extent->conformance = (extension_size+7)&~7; + wire_orpc_extent->size = extension_size; + wire_orpc_extent->id = entry->id; + buffer += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[wire_orpc_extent->conformance]); + } + + LeaveCriticalSection(&csChannelHook); + + return buffer; +} + +static void ChannelHooks_ServerNotify(SChannelHookCallInfo *info, + DWORD lDataRep, WIRE_ORPC_EXTENT *first_wire_orpc_extent, + ULONG extension_count) +{ + struct channel_hook_entry *entry; + ULONG i; + + EnterCriticalSection(&csChannelHook); + + LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) + { + WIRE_ORPC_EXTENT *wire_orpc_extent; + for (i = 0, wire_orpc_extent = first_wire_orpc_extent; + i < extension_count; + i++, wire_orpc_extent = (WIRE_ORPC_EXTENT *)&wire_orpc_extent->data[wire_orpc_extent->conformance]) + { + if (IsEqualGUID(&entry->id, &wire_orpc_extent->id)) + break; + } + if (i == extension_count) wire_orpc_extent = NULL; + + IChannelHook_ServerNotify(entry->hook, &entry->id, &info->iid, + wire_orpc_extent ? wire_orpc_extent->size : 0, + wire_orpc_extent ? wire_orpc_extent->data : NULL, + lDataRep); + } + + LeaveCriticalSection(&csChannelHook); +} + +static ULONG ChannelHooks_ServerGetSize(SChannelHookCallInfo *info, + struct channel_hook_buffer_data **data, unsigned int *hook_count, + ULONG *extension_count) +{ + struct channel_hook_entry *entry; + ULONG total_size = 0; + unsigned int hook_index = 0; + + *hook_count = 0; + *extension_count = 0; + + EnterCriticalSection(&csChannelHook); + + LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) + (*hook_count)++; + + if (*hook_count) + *data = HeapAlloc(GetProcessHeap(), 0, *hook_count * sizeof(struct channel_hook_buffer_data)); + else + *data = NULL; + + LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) + { + ULONG extension_size = 0; + + IChannelHook_ServerGetSize(entry->hook, &entry->id, &info->iid, S_OK, + &extension_size); + + TRACE("%s: extension_size = %u\n", debugstr_guid(&entry->id), extension_size); + + extension_size = (extension_size+7)&~7; + (*data)[hook_index].id = entry->id; + (*data)[hook_index].extension_size = extension_size; + + /* an extension is only put onto the wire if it has data to write */ + if (extension_size) + { + total_size += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[extension_size]); + (*extension_count)++; + } + + hook_index++; + } + + LeaveCriticalSection(&csChannelHook); + + return total_size; +} + +static unsigned char * ChannelHooks_ServerFillBuffer(SChannelHookCallInfo *info, + unsigned char *buffer, struct channel_hook_buffer_data *data, + unsigned int hook_count) +{ + struct channel_hook_entry *entry; + + EnterCriticalSection(&csChannelHook); + + LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) + { + unsigned int i; + ULONG extension_size = 0; + WIRE_ORPC_EXTENT *wire_orpc_extent = (WIRE_ORPC_EXTENT *)buffer; + + for (i = 0; i < hook_count; i++) + if (IsEqualGUID(&entry->id, &data[i].id)) + extension_size = data[i].extension_size; + + /* an extension is only put onto the wire if it has data to write */ + if (!extension_size) + continue; + + IChannelHook_ServerFillBuffer(entry->hook, &entry->id, &info->iid, + &extension_size, buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]), + S_OK); + + TRACE("%s: extension_size = %u\n", debugstr_guid(&entry->id), extension_size); + + /* FIXME: set unused portion of wire_orpc_extent->data to 0? */ + + wire_orpc_extent->conformance = (extension_size+7)&~7; + wire_orpc_extent->size = extension_size; + wire_orpc_extent->id = entry->id; + buffer += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[wire_orpc_extent->conformance]); + } + + LeaveCriticalSection(&csChannelHook); + + return buffer; +} + +static void ChannelHooks_ClientNotify(SChannelHookCallInfo *info, + DWORD lDataRep, WIRE_ORPC_EXTENT *first_wire_orpc_extent, + ULONG extension_count, HRESULT hrFault) +{ + struct channel_hook_entry *entry; + ULONG i; + + EnterCriticalSection(&csChannelHook); + + LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) + { + WIRE_ORPC_EXTENT *wire_orpc_extent; + for (i = 0, wire_orpc_extent = first_wire_orpc_extent; + i < extension_count; + i++, wire_orpc_extent = (WIRE_ORPC_EXTENT *)&wire_orpc_extent->data[wire_orpc_extent->conformance]) + { + if (IsEqualGUID(&entry->id, &wire_orpc_extent->id)) + break; + } + if (i == extension_count) wire_orpc_extent = NULL; + + IChannelHook_ClientNotify(entry->hook, &entry->id, &info->iid, + wire_orpc_extent ? wire_orpc_extent->size : 0, + wire_orpc_extent ? wire_orpc_extent->data : NULL, + lDataRep, hrFault); + } + + LeaveCriticalSection(&csChannelHook); +} + +HRESULT rpc_register_channel_hook(REFGUID rguid, IChannelHook *hook) +{ + struct channel_hook_entry *entry; + + entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry)); + if (!entry) + return E_OUTOFMEMORY; + + entry->id = *rguid; + entry->hook = hook; + IChannelHook_AddRef(hook); + + EnterCriticalSection(&csChannelHook); + list_add_tail(&channel_hooks, &entry->entry); + LeaveCriticalSection(&csChannelHook); + + return S_OK; +} + +void rpc_unregister_channel_hooks(void) +{ + struct channel_hook_entry *cursor; + struct channel_hook_entry *cursor2; + + EnterCriticalSection(&csChannelHook); + LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &channel_hooks, struct channel_hook_entry, entry) + HeapFree(GetProcessHeap(), 0, cursor); + LeaveCriticalSection(&csChannelHook); + DeleteCriticalSection(&csChannelHook); + DeleteCriticalSection(&csRegIf); +} + +/* RPC Channel Buffer Functions */ + +static HRESULT WINAPI RpcChannelBuffer_QueryInterface(IRpcChannelBuffer *iface, REFIID riid, LPVOID *ppv) +{ + *ppv = NULL; + if (IsEqualIID(riid,&IID_IRpcChannelBuffer) || IsEqualIID(riid,&IID_IUnknown)) + { + *ppv = iface; + IRpcChannelBuffer_AddRef(iface); + return S_OK; + } + return E_NOINTERFACE; +} + +static ULONG WINAPI RpcChannelBuffer_AddRef(LPRPCCHANNELBUFFER iface) +{ + RpcChannelBuffer *This = (RpcChannelBuffer *)iface; + return InterlockedIncrement(&This->refs); +} + +static ULONG WINAPI ServerRpcChannelBuffer_Release(LPRPCCHANNELBUFFER iface) +{ + RpcChannelBuffer *This = (RpcChannelBuffer *)iface; + ULONG ref; + + ref = InterlockedDecrement(&This->refs); + if (ref) + return ref; + + HeapFree(GetProcessHeap(), 0, This); + return 0; +} + +static ULONG WINAPI ClientRpcChannelBuffer_Release(LPRPCCHANNELBUFFER iface) +{ + ClientRpcChannelBuffer *This = (ClientRpcChannelBuffer *)iface; + ULONG ref; + + ref = InterlockedDecrement(&This->super.refs); + if (ref) + return ref; + + if (This->event) CloseHandle(This->event); + RpcBindingFree(&This->bind); + HeapFree(GetProcessHeap(), 0, This); + return 0; +} + +static HRESULT WINAPI ServerRpcChannelBuffer_GetBuffer(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE* olemsg, REFIID riid) +{ + RpcChannelBuffer *This = (RpcChannelBuffer *)iface; + RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; + RPC_STATUS status; + ORPCTHAT *orpcthat; + struct message_state *message_state; + ULONG extensions_size; + struct channel_hook_buffer_data *channel_hook_data; + unsigned int channel_hook_count; + ULONG extension_count; + + TRACE("(%p)->(%p,%s)\n", This, olemsg, debugstr_guid(riid)); + + message_state = msg->Handle; + /* restore the binding handle and the real start of data */ + msg->Handle = message_state->binding_handle; + msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; + + extensions_size = ChannelHooks_ServerGetSize(&message_state->channel_hook_info, + &channel_hook_data, &channel_hook_count, &extension_count); + + msg->BufferLength += FIELD_OFFSET(WIRE_ORPCTHAT, extensions) + sizeof(DWORD); + if (extensions_size) + { + msg->BufferLength += FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent[2*sizeof(DWORD) + extensions_size]); + if (extension_count & 1) + msg->BufferLength += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]); + } + + if (message_state->bypass_rpcrt) + { + msg->Buffer = HeapAlloc(GetProcessHeap(), 0, msg->BufferLength); + if (msg->Buffer) + status = RPC_S_OK; + else + { + HeapFree(GetProcessHeap(), 0, channel_hook_data); + return E_OUTOFMEMORY; + } + } + else + status = I_RpcGetBuffer(msg); + + orpcthat = msg->Buffer; + msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPCTHAT, extensions); + + orpcthat->flags = ORPCF_NULL /* FIXME? */; + + /* NDR representation of orpcthat->extensions */ + *(DWORD *)msg->Buffer = extensions_size ? 1 : 0; + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + + if (extensions_size) + { + WIRE_ORPC_EXTENT_ARRAY *orpc_extent_array = msg->Buffer; + orpc_extent_array->size = extension_count; + orpc_extent_array->reserved = 0; + msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent); + /* NDR representation of orpc_extent_array->extent */ + *(DWORD *)msg->Buffer = 1; + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + /* NDR representation of [size_is] attribute of orpc_extent_array->extent */ + *(DWORD *)msg->Buffer = (extension_count + 1) & ~1; + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + + msg->Buffer = ChannelHooks_ServerFillBuffer(&message_state->channel_hook_info, + msg->Buffer, channel_hook_data, channel_hook_count); + + /* we must add a dummy extension if there is an odd extension + * count to meet the contract specified by the size_is attribute */ + if (extension_count & 1) + { + WIRE_ORPC_EXTENT *wire_orpc_extent = msg->Buffer; + wire_orpc_extent->conformance = 0; + wire_orpc_extent->id = GUID_NULL; + wire_orpc_extent->size = 0; + msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]); + } + } + + HeapFree(GetProcessHeap(), 0, channel_hook_data); + + /* store the prefixed data length so that we can restore the real buffer + * later */ + message_state->prefix_data_len = (char *)msg->Buffer - (char *)orpcthat; + msg->BufferLength -= message_state->prefix_data_len; + /* save away the message state again */ + msg->Handle = message_state; + + TRACE("-- %d\n", status); + + return HRESULT_FROM_WIN32(status); +} + +static HANDLE ClientRpcChannelBuffer_GetEventHandle(ClientRpcChannelBuffer *This) +{ + HANDLE event = InterlockedExchangePointer(&This->event, NULL); + + /* Note: must be auto-reset event so we can reuse it without a call + * to ResetEvent */ + if (!event) event = CreateEventW(NULL, FALSE, FALSE, NULL); + + return event; +} + +static void ClientRpcChannelBuffer_ReleaseEventHandle(ClientRpcChannelBuffer *This, HANDLE event) +{ + if (InterlockedCompareExchangePointer(&This->event, event, NULL)) + /* already a handle cached in This */ + CloseHandle(event); +} + +static HRESULT WINAPI ClientRpcChannelBuffer_GetBuffer(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE* olemsg, REFIID riid) +{ + ClientRpcChannelBuffer *This = (ClientRpcChannelBuffer *)iface; + RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; + RPC_CLIENT_INTERFACE *cif; + RPC_STATUS status; + ORPCTHIS *orpcthis; + struct message_state *message_state; + ULONG extensions_size; + struct channel_hook_buffer_data *channel_hook_data; + unsigned int channel_hook_count; + ULONG extension_count; + IPID ipid; + HRESULT hr; + struct apartment *apt = NULL; + + TRACE("(%p)->(%p,%s)\n", This, olemsg, debugstr_guid(riid)); + + cif = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RPC_CLIENT_INTERFACE)); + if (!cif) + return E_OUTOFMEMORY; + + message_state = HeapAlloc(GetProcessHeap(), 0, sizeof(*message_state)); + if (!message_state) + { + HeapFree(GetProcessHeap(), 0, cif); + return E_OUTOFMEMORY; + } + + cif->Length = sizeof(RPC_CLIENT_INTERFACE); + /* RPC interface ID = COM interface ID */ + cif->InterfaceId.SyntaxGUID = This->iid; + /* COM objects always have a version of 0.0 */ + cif->InterfaceId.SyntaxVersion.MajorVersion = 0; + cif->InterfaceId.SyntaxVersion.MinorVersion = 0; + msg->Handle = This->bind; + msg->RpcInterfaceInformation = cif; + + message_state->prefix_data_len = 0; + message_state->binding_handle = This->bind; + + message_state->channel_hook_info.iid = *riid; + message_state->channel_hook_info.cbSize = sizeof(message_state->channel_hook_info); + CoGetCurrentLogicalThreadId(&message_state->channel_hook_info.uCausality); + message_state->channel_hook_info.dwServerPid = This->server_pid; + message_state->channel_hook_info.iMethod = msg->ProcNum & ~RPC_FLAGS_VALID_BIT; + message_state->channel_hook_info.pObject = NULL; /* only present on server-side */ + message_state->target_hwnd = NULL; + message_state->target_tid = 0; + memset(&message_state->params, 0, sizeof(message_state->params)); + + extensions_size = ChannelHooks_ClientGetSize(&message_state->channel_hook_info, + &channel_hook_data, &channel_hook_count, &extension_count); + + msg->BufferLength += FIELD_OFFSET(WIRE_ORPCTHIS, extensions) + sizeof(DWORD); + if (extensions_size) + { + msg->BufferLength += FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent[2*sizeof(DWORD) + extensions_size]); + if (extension_count & 1) + msg->BufferLength += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]); + } + + RpcBindingInqObject(message_state->binding_handle, &ipid); + hr = ipid_get_dispatch_params(&ipid, &apt, NULL, &message_state->params.stub, + &message_state->params.chan, + &message_state->params.iid, + &message_state->params.iface); + if (hr == S_OK) + { + /* stub, chan, iface and iid are unneeded in multi-threaded case as we go + * via the RPC runtime */ + if (apt->multi_threaded) + { + IRpcStubBuffer_Release(message_state->params.stub); + message_state->params.stub = NULL; + IRpcChannelBuffer_Release(message_state->params.chan); + message_state->params.chan = NULL; + message_state->params.iface = NULL; + } + else + { + message_state->params.bypass_rpcrt = TRUE; + message_state->target_hwnd = apartment_getwindow(apt); + message_state->target_tid = apt->tid; + /* we assume later on that this being non-NULL is the indicator that + * means call directly instead of going through RPC runtime */ + if (!message_state->target_hwnd) + ERR("window for apartment %s is NULL\n", wine_dbgstr_longlong(apt->oxid)); + } + } + if (apt) apartment_release(apt); + message_state->params.handle = ClientRpcChannelBuffer_GetEventHandle(This); + /* Note: message_state->params.msg is initialised in + * ClientRpcChannelBuffer_SendReceive */ + + /* shortcut the RPC runtime */ + if (message_state->target_hwnd) + { + msg->Buffer = HeapAlloc(GetProcessHeap(), 0, msg->BufferLength); + if (msg->Buffer) + status = RPC_S_OK; + else + status = ERROR_OUTOFMEMORY; + } + else + status = I_RpcGetBuffer(msg); + + msg->Handle = message_state; + + if (status == RPC_S_OK) + { + orpcthis = msg->Buffer; + msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPCTHIS, extensions); + + orpcthis->version.MajorVersion = COM_MAJOR_VERSION; + orpcthis->version.MinorVersion = COM_MINOR_VERSION; + orpcthis->flags = message_state->channel_hook_info.dwServerPid ? ORPCF_LOCAL : ORPCF_NULL; + orpcthis->reserved1 = 0; + orpcthis->cid = message_state->channel_hook_info.uCausality; + + /* NDR representation of orpcthis->extensions */ + *(DWORD *)msg->Buffer = extensions_size ? 1 : 0; + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + + if (extensions_size) + { + ORPC_EXTENT_ARRAY *orpc_extent_array = msg->Buffer; + orpc_extent_array->size = extension_count; + orpc_extent_array->reserved = 0; + msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent); + /* NDR representation of orpc_extent_array->extent */ + *(DWORD *)msg->Buffer = 1; + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + /* NDR representation of [size_is] attribute of orpc_extent_array->extent */ + *(DWORD *)msg->Buffer = (extension_count + 1) & ~1; + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + + msg->Buffer = ChannelHooks_ClientFillBuffer(&message_state->channel_hook_info, + msg->Buffer, channel_hook_data, channel_hook_count); + + /* we must add a dummy extension if there is an odd extension + * count to meet the contract specified by the size_is attribute */ + if (extension_count & 1) + { + WIRE_ORPC_EXTENT *wire_orpc_extent = msg->Buffer; + wire_orpc_extent->conformance = 0; + wire_orpc_extent->id = GUID_NULL; + wire_orpc_extent->size = 0; + msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]); + } + } + + /* store the prefixed data length so that we can restore the real buffer + * pointer in ClientRpcChannelBuffer_SendReceive. */ + message_state->prefix_data_len = (char *)msg->Buffer - (char *)orpcthis; + msg->BufferLength -= message_state->prefix_data_len; + } + + HeapFree(GetProcessHeap(), 0, channel_hook_data); + + TRACE("-- %d\n", status); + + return HRESULT_FROM_WIN32(status); +} + +static HRESULT WINAPI ServerRpcChannelBuffer_SendReceive(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE *olemsg, ULONG *pstatus) +{ + FIXME("stub\n"); + return E_NOTIMPL; +} + +/* this thread runs an outgoing RPC */ +static DWORD WINAPI rpc_sendreceive_thread(LPVOID param) +{ + struct dispatch_params *data = param; + + /* Note: I_RpcSendReceive doesn't raise exceptions like the higher-level + * RPC functions do */ + data->status = I_RpcSendReceive((RPC_MESSAGE *)data->msg); + + TRACE("completed with status 0x%x\n", data->status); + + SetEvent(data->handle); + + return 0; +} + +static inline HRESULT ClientRpcChannelBuffer_IsCorrectApartment(ClientRpcChannelBuffer *This, const struct apartment *apt) +{ + if (!apt) + return S_FALSE; + if (This->oxid != apartment_getoxid(apt)) + return S_FALSE; + return S_OK; +} + +static HRESULT WINAPI ClientRpcChannelBuffer_SendReceive(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE *olemsg, ULONG *pstatus) +{ + ClientRpcChannelBuffer *This = (ClientRpcChannelBuffer *)iface; + HRESULT hr; + RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; + RPC_STATUS status; + DWORD index; + struct message_state *message_state; + ORPCTHAT orpcthat; + ORPC_EXTENT_ARRAY orpc_ext_array; + WIRE_ORPC_EXTENT *first_wire_orpc_extent = NULL; + HRESULT hrFault = S_OK; + struct apartment *apt = apartment_get_current_or_mta(); + struct tlsdata *tlsdata; + + TRACE("(%p) iMethod=%d\n", olemsg, olemsg->iMethod); + + hr = ClientRpcChannelBuffer_IsCorrectApartment(This, apt); + if (hr != S_OK) + { + ERR("called from wrong apartment, should have been 0x%s\n", + wine_dbgstr_longlong(This->oxid)); + if (apt) apartment_release(apt); + return RPC_E_WRONG_THREAD; + } + + if (FAILED(hr = com_get_tlsdata(&tlsdata))) + return hr; + + /* This situation should be impossible in multi-threaded apartments, + * because the calling thread isn't re-enterable. + * Note: doing a COM call during the processing of a sent message is + * only disallowed if a client call is already being waited for + * completion */ + if (!apt->multi_threaded && + tlsdata->pending_call_count_client && + InSendMessage()) + { + ERR("can't make an outgoing COM call in response to a sent message\n"); + apartment_release(apt); + return RPC_E_CANTCALLOUT_ININPUTSYNCCALL; + } + + message_state = msg->Handle; + /* restore the binding handle and the real start of data */ + msg->Handle = message_state->binding_handle; + msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; + msg->BufferLength += message_state->prefix_data_len; + + /* Note: this is an optimization in the Microsoft OLE runtime that we need + * to copy, as shown by the test_no_couninitialize_client test. without + * short-circuiting the RPC runtime in the case below, the test will + * deadlock on the loader lock due to the RPC runtime needing to create + * a thread to process the RPC when this function is called indirectly + * from DllMain */ + + message_state->params.msg = olemsg; + if (message_state->params.bypass_rpcrt) + { + TRACE("Calling apartment thread 0x%08x...\n", message_state->target_tid); + + msg->ProcNum &= ~RPC_FLAGS_VALID_BIT; + + if (!PostMessageW(message_state->target_hwnd, DM_EXECUTERPC, 0, + (LPARAM)&message_state->params)) + { + ERR("PostMessage failed with error %u\n", GetLastError()); + + /* Note: message_state->params.iface doesn't have a reference and + * so doesn't need to be released */ + + hr = HRESULT_FROM_WIN32(GetLastError()); + } + } + else + { + /* we use a separate thread here because we need to be able to + * pump the message loop in the application thread: if we do not, + * any windows created by this thread will hang and RPCs that try + * and re-enter this STA from an incoming server thread will + * deadlock. InstallShield is an example of that. + */ + if (!QueueUserWorkItem(rpc_sendreceive_thread, &message_state->params, WT_EXECUTEDEFAULT)) + { + ERR("QueueUserWorkItem failed with error %u\n", GetLastError()); + hr = E_UNEXPECTED; + } + else + hr = S_OK; + } + + if (hr == S_OK) + { + if (WaitForSingleObject(message_state->params.handle, 0)) + { + tlsdata->pending_call_count_client++; + hr = CoWaitForMultipleHandles(0, INFINITE, 1, &message_state->params.handle, &index); + tlsdata->pending_call_count_client--; + } + } + ClientRpcChannelBuffer_ReleaseEventHandle(This, message_state->params.handle); + + /* for WM shortcut, faults are returned in params->hr */ + if (hr == S_OK) + hrFault = message_state->params.hr; + + status = message_state->params.status; + + orpcthat.flags = ORPCF_NULL; + orpcthat.extensions = NULL; + + TRACE("RPC call status: 0x%x\n", status); + if (status != RPC_S_OK) + hr = HRESULT_FROM_WIN32(status); + + TRACE("hrFault = 0x%08x\n", hrFault); + + /* FIXME: this condition should be + * "hr == S_OK && (!hrFault || msg->BufferLength > FIELD_OFFSET(ORPCTHAT, extensions) + 4)" + * but we don't currently reset the message length for PostMessage + * dispatched calls */ + if (hr == S_OK && hrFault == S_OK) + { + HRESULT hr2; + char *original_buffer = msg->Buffer; + + /* handle ORPCTHAT and client extensions */ + + hr2 = unmarshal_ORPCTHAT(msg, &orpcthat, &orpc_ext_array, &first_wire_orpc_extent); + if (FAILED(hr2)) + hr = hr2; + + message_state->prefix_data_len = (char *)msg->Buffer - original_buffer; + msg->BufferLength -= message_state->prefix_data_len; + } + else + message_state->prefix_data_len = 0; + + if (hr == S_OK) + { + ChannelHooks_ClientNotify(&message_state->channel_hook_info, + msg->DataRepresentation, + first_wire_orpc_extent, + orpcthat.extensions && first_wire_orpc_extent ? orpcthat.extensions->size : 0, + hrFault); + } + + /* save away the message state again */ + msg->Handle = message_state; + + if (pstatus) *pstatus = status; + + if (hr == S_OK) + hr = hrFault; + + TRACE("-- 0x%08x\n", hr); + + apartment_release(apt); + return hr; +} + +static HRESULT WINAPI ServerRpcChannelBuffer_FreeBuffer(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE* olemsg) +{ + RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; + RPC_STATUS status; + struct message_state *message_state; + + TRACE("(%p)\n", msg); + + message_state = msg->Handle; + /* restore the binding handle and the real start of data */ + msg->Handle = message_state->binding_handle; + msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; + msg->BufferLength += message_state->prefix_data_len; + message_state->prefix_data_len = 0; + + if (message_state->bypass_rpcrt) + { + HeapFree(GetProcessHeap(), 0, msg->Buffer); + status = RPC_S_OK; + } + else + status = I_RpcFreeBuffer(msg); + + msg->Handle = message_state; + + TRACE("-- %d\n", status); + + return HRESULT_FROM_WIN32(status); +} + +static HRESULT WINAPI ClientRpcChannelBuffer_FreeBuffer(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE* olemsg) +{ + RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; + RPC_STATUS status; + struct message_state *message_state; + + TRACE("(%p)\n", msg); + + message_state = msg->Handle; + /* restore the binding handle and the real start of data */ + msg->Handle = message_state->binding_handle; + msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; + msg->BufferLength += message_state->prefix_data_len; + + if (message_state->params.bypass_rpcrt) + { + HeapFree(GetProcessHeap(), 0, msg->Buffer); + status = RPC_S_OK; + } + else + status = I_RpcFreeBuffer(msg); + + HeapFree(GetProcessHeap(), 0, msg->RpcInterfaceInformation); + msg->RpcInterfaceInformation = NULL; + + if (message_state->params.stub) + IRpcStubBuffer_Release(message_state->params.stub); + if (message_state->params.chan) + IRpcChannelBuffer_Release(message_state->params.chan); + HeapFree(GetProcessHeap(), 0, message_state); + + TRACE("-- %d\n", status); + + return HRESULT_FROM_WIN32(status); +} + +static HRESULT WINAPI ClientRpcChannelBuffer_GetDestCtx(LPRPCCHANNELBUFFER iface, DWORD* pdwDestContext, void** ppvDestContext) +{ + ClientRpcChannelBuffer *This = (ClientRpcChannelBuffer *)iface; + + TRACE("(%p,%p)\n", pdwDestContext, ppvDestContext); + + *pdwDestContext = This->super.dest_context; + *ppvDestContext = This->super.dest_context_data; + + return S_OK; +} + +static HRESULT WINAPI ServerRpcChannelBuffer_GetDestCtx(LPRPCCHANNELBUFFER iface, DWORD* dest_context, void** dest_context_data) +{ + RpcChannelBuffer *This = (RpcChannelBuffer *)iface; + + TRACE("(%p,%p)\n", dest_context, dest_context_data); + + *dest_context = This->dest_context; + *dest_context_data = This->dest_context_data; + return S_OK; +} + +static HRESULT WINAPI RpcChannelBuffer_IsConnected(LPRPCCHANNELBUFFER iface) +{ + TRACE("()\n"); + /* native does nothing too */ + return S_OK; +} + +static const IRpcChannelBufferVtbl ClientRpcChannelBufferVtbl = +{ + RpcChannelBuffer_QueryInterface, + RpcChannelBuffer_AddRef, + ClientRpcChannelBuffer_Release, + ClientRpcChannelBuffer_GetBuffer, + ClientRpcChannelBuffer_SendReceive, + ClientRpcChannelBuffer_FreeBuffer, + ClientRpcChannelBuffer_GetDestCtx, + RpcChannelBuffer_IsConnected +}; + +static const IRpcChannelBufferVtbl ServerRpcChannelBufferVtbl = +{ + RpcChannelBuffer_QueryInterface, + RpcChannelBuffer_AddRef, + ServerRpcChannelBuffer_Release, + ServerRpcChannelBuffer_GetBuffer, + ServerRpcChannelBuffer_SendReceive, + ServerRpcChannelBuffer_FreeBuffer, + ServerRpcChannelBuffer_GetDestCtx, + RpcChannelBuffer_IsConnected +}; + +/* returns a channel buffer for proxies */ +HRESULT rpc_create_clientchannel(const OXID *oxid, const IPID *ipid, + const OXID_INFO *oxid_info, const IID *iid, + DWORD dest_context, void *dest_context_data, + IRpcChannelBuffer **chan, struct apartment *apt) +{ + ClientRpcChannelBuffer *This; + WCHAR endpoint[200]; + RPC_BINDING_HANDLE bind; + RPC_STATUS status; + LPWSTR string_binding; + + /* FIXME: get the endpoint from oxid_info->psa instead */ + get_rpc_endpoint(endpoint, oxid); + + TRACE("proxy pipe: connecting to endpoint: %s\n", debugstr_w(endpoint)); + + status = RpcStringBindingComposeW( + NULL, + rpctransportW, + NULL, + endpoint, + NULL, + &string_binding); + + if (status == RPC_S_OK) + { + status = RpcBindingFromStringBindingW(string_binding, &bind); + + if (status == RPC_S_OK) + { + IPID ipid2 = *ipid; /* why can't RpcBindingSetObject take a const? */ + status = RpcBindingSetObject(bind, &ipid2); + if (status != RPC_S_OK) + RpcBindingFree(&bind); + } + + RpcStringFreeW(&string_binding); + } + + if (status != RPC_S_OK) + { + ERR("Couldn't get binding for endpoint %s, status = %d\n", debugstr_w(endpoint), status); + return HRESULT_FROM_WIN32(status); + } + + This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); + if (!This) + { + RpcBindingFree(&bind); + return E_OUTOFMEMORY; + } + + This->super.IRpcChannelBuffer_iface.lpVtbl = &ClientRpcChannelBufferVtbl; + This->super.refs = 1; + This->super.dest_context = dest_context; + This->super.dest_context_data = dest_context_data; + This->bind = bind; + This->oxid = apartment_getoxid(apt); + This->server_pid = oxid_info->dwPid; + This->event = NULL; + This->iid = *iid; + + *chan = &This->super.IRpcChannelBuffer_iface; + + return S_OK; +} + +HRESULT rpc_create_serverchannel(DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan) +{ + RpcChannelBuffer *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); + if (!This) + return E_OUTOFMEMORY; + + This->IRpcChannelBuffer_iface.lpVtbl = &ServerRpcChannelBufferVtbl; + This->refs = 1; + This->dest_context = dest_context; + This->dest_context_data = dest_context_data; + + *chan = &This->IRpcChannelBuffer_iface; + + return S_OK; +} + +/* unmarshals ORPC_EXTENT_ARRAY according to NDR rules, but doesn't allocate + * any memory */ +static HRESULT unmarshal_ORPC_EXTENT_ARRAY(RPC_MESSAGE *msg, const char *end, + ORPC_EXTENT_ARRAY *extensions, + WIRE_ORPC_EXTENT **first_wire_orpc_extent) +{ + DWORD pointer_id; + DWORD i; + + memcpy(extensions, msg->Buffer, FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent)); + msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent); + + if ((const char *)msg->Buffer + 2 * sizeof(DWORD) > end) + return RPC_E_INVALID_HEADER; + + pointer_id = *(DWORD *)msg->Buffer; + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + extensions->extent = NULL; + + if (pointer_id) + { + WIRE_ORPC_EXTENT *wire_orpc_extent; + + /* conformance */ + if (*(DWORD *)msg->Buffer != ((extensions->size+1)&~1)) + return RPC_S_INVALID_BOUND; + + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + + /* arbitrary limit for security (don't know what native does) */ + if (extensions->size > 256) + { + ERR("too many extensions: %d\n", extensions->size); + return RPC_S_INVALID_BOUND; + } + + *first_wire_orpc_extent = wire_orpc_extent = msg->Buffer; + for (i = 0; i < ((extensions->size+1)&~1); i++) + { + if ((const char *)&wire_orpc_extent->data[0] > end) + return RPC_S_INVALID_BOUND; + if (wire_orpc_extent->conformance != ((wire_orpc_extent->size+7)&~7)) + return RPC_S_INVALID_BOUND; + if ((const char *)&wire_orpc_extent->data[wire_orpc_extent->conformance] > end) + return RPC_S_INVALID_BOUND; + TRACE("size %u, guid %s\n", wire_orpc_extent->size, debugstr_guid(&wire_orpc_extent->id)); + wire_orpc_extent = (WIRE_ORPC_EXTENT *)&wire_orpc_extent->data[wire_orpc_extent->conformance]; + } + msg->Buffer = wire_orpc_extent; + } + + return S_OK; +} + +/* unmarshals ORPCTHIS according to NDR rules, but doesn't allocate any memory */ +static HRESULT unmarshal_ORPCTHIS(RPC_MESSAGE *msg, ORPCTHIS *orpcthis, + ORPC_EXTENT_ARRAY *orpc_ext_array, WIRE_ORPC_EXTENT **first_wire_orpc_extent) +{ + const char *end = (char *)msg->Buffer + msg->BufferLength; + + *first_wire_orpc_extent = NULL; + + if (msg->BufferLength < FIELD_OFFSET(WIRE_ORPCTHIS, extensions) + sizeof(DWORD)) + { + ERR("invalid buffer length\n"); + return RPC_E_INVALID_HEADER; + } + + memcpy(orpcthis, msg->Buffer, FIELD_OFFSET(WIRE_ORPCTHIS, extensions)); + msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPCTHIS, extensions); + + if ((const char *)msg->Buffer + sizeof(DWORD) > end) + return RPC_E_INVALID_HEADER; + + if (*(DWORD *)msg->Buffer) + orpcthis->extensions = orpc_ext_array; + else + orpcthis->extensions = NULL; + + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + + if (orpcthis->extensions) + { + HRESULT hr = unmarshal_ORPC_EXTENT_ARRAY(msg, end, orpc_ext_array, + first_wire_orpc_extent); + if (FAILED(hr)) + return hr; + } + + if ((orpcthis->version.MajorVersion != COM_MAJOR_VERSION) || + (orpcthis->version.MinorVersion > COM_MINOR_VERSION)) + { + ERR("COM version {%d, %d} not supported\n", + orpcthis->version.MajorVersion, orpcthis->version.MinorVersion); + return RPC_E_VERSION_MISMATCH; + } + + if (orpcthis->flags & ~(ORPCF_LOCAL|ORPCF_RESERVED1|ORPCF_RESERVED2|ORPCF_RESERVED3|ORPCF_RESERVED4)) + { + ERR("invalid flags 0x%x\n", orpcthis->flags & ~(ORPCF_LOCAL|ORPCF_RESERVED1|ORPCF_RESERVED2|ORPCF_RESERVED3|ORPCF_RESERVED4)); + return RPC_E_INVALID_HEADER; + } + + return S_OK; +} + +static HRESULT unmarshal_ORPCTHAT(RPC_MESSAGE *msg, ORPCTHAT *orpcthat, + ORPC_EXTENT_ARRAY *orpc_ext_array, WIRE_ORPC_EXTENT **first_wire_orpc_extent) +{ + const char *end = (char *)msg->Buffer + msg->BufferLength; + + *first_wire_orpc_extent = NULL; + + if (msg->BufferLength < FIELD_OFFSET(WIRE_ORPCTHAT, extensions) + sizeof(DWORD)) + { + ERR("invalid buffer length\n"); + return RPC_E_INVALID_HEADER; + } + + memcpy(orpcthat, msg->Buffer, FIELD_OFFSET(WIRE_ORPCTHAT, extensions)); + msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPCTHAT, extensions); + + if ((const char *)msg->Buffer + sizeof(DWORD) > end) + return RPC_E_INVALID_HEADER; + + if (*(DWORD *)msg->Buffer) + orpcthat->extensions = orpc_ext_array; + else + orpcthat->extensions = NULL; + + msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); + + if (orpcthat->extensions) + { + HRESULT hr = unmarshal_ORPC_EXTENT_ARRAY(msg, end, orpc_ext_array, + first_wire_orpc_extent); + if (FAILED(hr)) + return hr; + } + + if (orpcthat->flags & ~(ORPCF_LOCAL|ORPCF_RESERVED1|ORPCF_RESERVED2|ORPCF_RESERVED3|ORPCF_RESERVED4)) + { + ERR("invalid flags 0x%x\n", orpcthat->flags & ~(ORPCF_LOCAL|ORPCF_RESERVED1|ORPCF_RESERVED2|ORPCF_RESERVED3|ORPCF_RESERVED4)); + return RPC_E_INVALID_HEADER; + } + + return S_OK; +} + +void rpc_execute_call(struct dispatch_params *params) +{ + struct message_state *message_state = NULL; + RPC_MESSAGE *msg = (RPC_MESSAGE *)params->msg; + char *original_buffer = msg->Buffer; + ORPCTHIS orpcthis; + ORPC_EXTENT_ARRAY orpc_ext_array; + WIRE_ORPC_EXTENT *first_wire_orpc_extent; + GUID old_causality_id; + struct tlsdata *tlsdata; + struct apartment *apt; + + if (FAILED(com_get_tlsdata(&tlsdata))) + return; + + apt = com_get_current_apt(); + + /* handle ORPCTHIS and server extensions */ + + params->hr = unmarshal_ORPCTHIS(msg, &orpcthis, &orpc_ext_array, &first_wire_orpc_extent); + if (params->hr != S_OK) + { + msg->Buffer = original_buffer; + goto exit; + } + + message_state = HeapAlloc(GetProcessHeap(), 0, sizeof(*message_state)); + if (!message_state) + { + params->hr = E_OUTOFMEMORY; + msg->Buffer = original_buffer; + goto exit; + } + + message_state->prefix_data_len = (char *)msg->Buffer - original_buffer; + message_state->binding_handle = msg->Handle; + message_state->bypass_rpcrt = params->bypass_rpcrt; + + message_state->channel_hook_info.iid = params->iid; + message_state->channel_hook_info.cbSize = sizeof(message_state->channel_hook_info); + message_state->channel_hook_info.uCausality = orpcthis.cid; + message_state->channel_hook_info.dwServerPid = GetCurrentProcessId(); + message_state->channel_hook_info.iMethod = msg->ProcNum; + message_state->channel_hook_info.pObject = params->iface; + + if (orpcthis.extensions && first_wire_orpc_extent && + orpcthis.extensions->size) + ChannelHooks_ServerNotify(&message_state->channel_hook_info, msg->DataRepresentation, first_wire_orpc_extent, orpcthis.extensions->size); + + msg->Handle = message_state; + msg->BufferLength -= message_state->prefix_data_len; + + /* call message filter */ + + if (apt->filter) + { + DWORD handlecall; + INTERFACEINFO interface_info; + CALLTYPE calltype; + + interface_info.pUnk = params->iface; + interface_info.iid = params->iid; + interface_info.wMethod = msg->ProcNum; + + if (IsEqualGUID(&orpcthis.cid, &tlsdata->causality_id)) + calltype = CALLTYPE_NESTED; + else if (tlsdata->pending_call_count_server == 0) + calltype = CALLTYPE_TOPLEVEL; + else + calltype = CALLTYPE_TOPLEVEL_CALLPENDING; + + handlecall = IMessageFilter_HandleInComingCall(apt->filter, + calltype, + UlongToHandle(GetCurrentProcessId()), + 0 /* FIXME */, + &interface_info); + TRACE("IMessageFilter_HandleInComingCall returned %d\n", handlecall); + switch (handlecall) + { + case SERVERCALL_REJECTED: + params->hr = RPC_E_CALL_REJECTED; + goto exit_reset_state; + case SERVERCALL_RETRYLATER: +#if 0 /* FIXME: handle retries on the client side before enabling this code */ + params->hr = RPC_E_RETRY; + goto exit_reset_state; +#else + FIXME("retry call later not implemented\n"); + break; +#endif + case SERVERCALL_ISHANDLED: + default: + break; + } + } + + /* invoke the method */ + + /* save the old causality ID - note: any calls executed while processing + * messages received during the SendReceive will appear to originate from + * this call - this should be checked with what Windows does */ + old_causality_id = tlsdata->causality_id; + tlsdata->causality_id = orpcthis.cid; + tlsdata->pending_call_count_server++; + params->hr = IRpcStubBuffer_Invoke(params->stub, params->msg, params->chan); + tlsdata->pending_call_count_server--; + tlsdata->causality_id = old_causality_id; + + /* the invoke allocated a new buffer, so free the old one */ + if (message_state->bypass_rpcrt && original_buffer != msg->Buffer) + HeapFree(GetProcessHeap(), 0, original_buffer); + +exit_reset_state: + message_state = msg->Handle; + msg->Handle = message_state->binding_handle; + msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; + msg->BufferLength += message_state->prefix_data_len; + +exit: + HeapFree(GetProcessHeap(), 0, message_state); + if (params->handle) SetEvent(params->handle); +} + +static void __RPC_STUB dispatch_rpc(RPC_MESSAGE *msg) +{ + struct dispatch_params *params; + struct stub_manager *stub_manager; + struct apartment *apt; + IPID ipid; + HRESULT hr; + + RpcBindingInqObject(msg->Handle, &ipid); + + TRACE("ipid = %s, iMethod = %d\n", debugstr_guid(&ipid), msg->ProcNum); + + params = HeapAlloc(GetProcessHeap(), 0, sizeof(*params)); + if (!params) + { + RpcRaiseException(E_OUTOFMEMORY); + return; + } + + hr = ipid_get_dispatch_params(&ipid, &apt, &stub_manager, &params->stub, &params->chan, + &params->iid, &params->iface); + if (hr != S_OK) + { + ERR("no apartment found for ipid %s\n", debugstr_guid(&ipid)); + HeapFree(GetProcessHeap(), 0, params); + RpcRaiseException(hr); + return; + } + + params->msg = (RPCOLEMESSAGE *)msg; + params->status = RPC_S_OK; + params->hr = S_OK; + params->handle = NULL; + params->bypass_rpcrt = FALSE; + + /* Note: this is the important difference between STAs and MTAs - we + * always execute RPCs to STAs in the thread that originally created the + * apartment (i.e. the one that pumps messages to the window) */ + if (!apt->multi_threaded) + { + params->handle = CreateEventW(NULL, FALSE, FALSE, NULL); + + TRACE("Calling apartment thread 0x%08x...\n", apt->tid); + + if (PostMessageW(apartment_getwindow(apt), DM_EXECUTERPC, 0, (LPARAM)params)) + WaitForSingleObject(params->handle, INFINITE); + else + { + ERR("PostMessage failed with error %u\n", GetLastError()); + IRpcChannelBuffer_Release(params->chan); + IRpcStubBuffer_Release(params->stub); + } + CloseHandle(params->handle); + } + else + { + BOOL joined = FALSE; + struct tlsdata *tlsdata; + + com_get_tlsdata(&tlsdata); + + if (!tlsdata->apt) + { + enter_apartment(tlsdata, COINIT_MULTITHREADED); + joined = TRUE; + } + rpc_execute_call(params); + if (joined) + { + leave_apartment(tlsdata); + } + } + + hr = params->hr; + if (params->chan) + IRpcChannelBuffer_Release(params->chan); + if (params->stub) + IRpcStubBuffer_Release(params->stub); + HeapFree(GetProcessHeap(), 0, params); + + stub_manager_int_release(stub_manager); + apartment_release(apt); + + /* if IRpcStubBuffer_Invoke fails, we should raise an exception to tell + * the RPC runtime that the call failed */ + if (hr != S_OK) RpcRaiseException(hr); +} + +/* stub registration */ +HRESULT rpc_register_interface(REFIID riid) +{ + struct registered_if *rif; + BOOL found = FALSE; + HRESULT hr = S_OK; + + TRACE("(%s)\n", debugstr_guid(riid)); + + EnterCriticalSection(&csRegIf); + LIST_FOR_EACH_ENTRY(rif, &registered_interfaces, struct registered_if, entry) + { + if (IsEqualGUID(&rif->If.InterfaceId.SyntaxGUID, riid)) + { + rif->refs++; + found = TRUE; + break; + } + } + if (!found) + { + TRACE("Creating new interface\n"); + + rif = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rif)); + if (rif) + { + RPC_STATUS status; + + rif->refs = 1; + rif->If.Length = sizeof(RPC_SERVER_INTERFACE); + /* RPC interface ID = COM interface ID */ + rif->If.InterfaceId.SyntaxGUID = *riid; + rif->If.DispatchTable = &rpc_dispatch; + /* all other fields are 0, including the version asCOM objects + * always have a version of 0.0 */ + status = RpcServerRegisterIfEx( + (RPC_IF_HANDLE)&rif->If, + NULL, NULL, + RPC_IF_OLE | RPC_IF_AUTOLISTEN, + RPC_C_LISTEN_MAX_CALLS_DEFAULT, + NULL); + if (status == RPC_S_OK) + list_add_tail(&registered_interfaces, &rif->entry); + else + { + ERR("RpcServerRegisterIfEx failed with error %d\n", status); + HeapFree(GetProcessHeap(), 0, rif); + hr = HRESULT_FROM_WIN32(status); + } + } + else + hr = E_OUTOFMEMORY; + } + LeaveCriticalSection(&csRegIf); + return hr; +} + +/* stub unregistration */ +void rpc_unregister_interface(REFIID riid, BOOL wait) +{ + struct registered_if *rif; + EnterCriticalSection(&csRegIf); + LIST_FOR_EACH_ENTRY(rif, &registered_interfaces, struct registered_if, entry) + { + if (IsEqualGUID(&rif->If.InterfaceId.SyntaxGUID, riid)) + { + if (!--rif->refs) + { + RpcServerUnregisterIf((RPC_IF_HANDLE)&rif->If, NULL, wait); + list_remove(&rif->entry); + HeapFree(GetProcessHeap(), 0, rif); + } + break; + } + } + LeaveCriticalSection(&csRegIf); +} + +/* get the info for an OXID, including the IPID for the rem unknown interface + * and the string binding */ +HRESULT rpc_resolve_oxid(OXID oxid, OXID_INFO *oxid_info) +{ + TRACE("%s\n", wine_dbgstr_longlong(oxid)); + + oxid_info->dwTid = 0; + oxid_info->dwPid = 0; + oxid_info->dwAuthnHint = RPC_C_AUTHN_LEVEL_NONE; + /* FIXME: this is a hack around not having an OXID resolver yet - + * this function should contact the machine's OXID resolver and then it + * should give us the IPID of the IRemUnknown interface */ + oxid_info->ipidRemUnknown.Data1 = 0xffffffff; + oxid_info->ipidRemUnknown.Data2 = 0xffff; + oxid_info->ipidRemUnknown.Data3 = 0xffff; + memcpy(oxid_info->ipidRemUnknown.Data4, &oxid, sizeof(OXID)); + oxid_info->psa = NULL /* FIXME */; + + return S_OK; +} + +/* make the apartment reachable by other threads and processes and create the + * IRemUnknown object */ +void rpc_start_remoting(struct apartment *apt) +{ + if (!InterlockedExchange(&apt->remoting_started, TRUE)) + { + WCHAR endpoint[200]; + RPC_STATUS status; + + get_rpc_endpoint(endpoint, &apt->oxid); + + status = RpcServerUseProtseqEpW( + rpctransportW, + RPC_C_PROTSEQ_MAX_REQS_DEFAULT, + endpoint, + NULL); + if (status != RPC_S_OK) + ERR("Couldn't register endpoint %s\n", debugstr_w(endpoint)); + + /* FIXME: move remote unknown exporting into this function */ + } + start_apartment_remote_unknown(apt); +} diff --git a/dlls/combase/stubmanager.c b/dlls/combase/stubmanager.c index a800c0b4844..16b8bb35d00 100644 --- a/dlls/combase/stubmanager.c +++ b/dlls/combase/stubmanager.c @@ -44,11 +44,6 @@ WINE_DEFAULT_DEBUG_CHANNEL(ole); -extern HRESULT WINAPI marshal_object(struct apartment *apt, STDOBJREF *stdobjref, REFIID riid, IUnknown *object, - DWORD dest_context, void *dest_context_data, MSHLFLAGS mshlflags); -extern HRESULT WINAPI RPC_CreateServerChannel(DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan); -extern void WINAPI RPC_UnregisterInterface(REFIID riid, BOOL wait); - /* generates an ipid in the following format (similar to native version): * Data1 = apartment-local ipid counter * Data2 = apartment creator thread ID @@ -92,7 +87,7 @@ struct ifstub * stub_manager_new_ifstub(struct stub_manager *m, IRpcStubBuffer * return NULL; } - hr = RPC_CreateServerChannel(dest_context, dest_context_data, &stub->chan); + hr = rpc_create_serverchannel(dest_context, dest_context_data, &stub->chan); if (hr != S_OK) { IUnknown_Release(stub->iface); @@ -131,7 +126,7 @@ static void stub_manager_delete_ifstub(struct stub_manager *m, struct ifstub *if list_remove(&ifstub->entry); if (!m->disconnected) - RPC_UnregisterInterface(&ifstub->iid, TRUE); + rpc_unregister_interface(&ifstub->iid, TRUE); if (ifstub->stubbuffer) IRpcStubBuffer_Release(ifstub->stubbuffer); IUnknown_Release(ifstub->iface); @@ -255,7 +250,7 @@ void stub_manager_disconnect(struct stub_manager *m) if (!m->disconnected) { LIST_FOR_EACH_ENTRY(ifstub, &m->ifstubs, struct ifstub, entry) - RPC_UnregisterInterface(&ifstub->iid, FALSE); + rpc_unregister_interface(&ifstub->iid, FALSE); m->disconnected = TRUE; } @@ -314,7 +309,7 @@ static ULONG stub_manager_int_addref(struct stub_manager *m) } /* decrements the internal refcount */ -ULONG WINAPI stub_manager_int_release(struct stub_manager *m) +ULONG stub_manager_int_release(struct stub_manager *m) { ULONG refs; struct apartment *apt = m->apt; @@ -542,10 +537,9 @@ static HRESULT ipid_to_stub_manager(const IPID *ipid, struct apartment **stub_ap /* gets the apartment, stub and channel of an object. the caller must * release the references to all objects (except iface) if the function * returned success, otherwise no references are returned. */ -HRESULT WINAPI ipid_get_dispatch_params(const IPID *ipid, struct apartment **stub_apt, - struct stub_manager **manager, - IRpcStubBuffer **stub, IRpcChannelBuffer **chan, - IID *iid, IUnknown **iface) +HRESULT ipid_get_dispatch_params(const IPID *ipid, struct apartment **stub_apt, + struct stub_manager **manager, IRpcStubBuffer **stub, IRpcChannelBuffer **chan, + IID *iid, IUnknown **iface) { struct stub_manager *stubmgr; struct ifstub *ifstub; @@ -826,7 +820,7 @@ static const IRemUnknownVtbl RemUnknown_Vtbl = }; /* starts the IRemUnknown listener for the current apartment */ -HRESULT WINAPI start_apartment_remote_unknown(struct apartment *apt) +HRESULT start_apartment_remote_unknown(struct apartment *apt) { IRemUnknown *pRemUnknown; HRESULT hr = S_OK; diff --git a/dlls/ole32/Makefile.in b/dlls/ole32/Makefile.in index ddbdfab30de..89807b94ef0 100644 --- a/dlls/ole32/Makefile.in +++ b/dlls/ole32/Makefile.in @@ -33,7 +33,6 @@ C_SRCS = \ oleobj.c \ oleproxy.c \ pointermoniker.c \ - rpc.c \ stg_prop.c \ stg_stream.c \ storage32.c \ diff --git a/dlls/ole32/compobj.c b/dlls/ole32/compobj.c index b92dfd87267..a9a9af53108 100644 --- a/dlls/ole32/compobj.c +++ b/dlls/ole32/compobj.c @@ -930,26 +930,6 @@ HRESULT WINAPI CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions, return hr; } -/*********************************************************************** - * CoRegisterChannelHook [OLE32.@] - * - * Registers a process-wide hook that is called during ORPC calls. - * - * PARAMS - * guidExtension [I] GUID of the channel hook to register. - * pChannelHook [I] Channel hook object to register. - * - * RETURNS - * Success: S_OK. - * Failure: HRESULT code. - */ -HRESULT WINAPI CoRegisterChannelHook(REFGUID guidExtension, IChannelHook *pChannelHook) -{ - TRACE("(%s, %p)\n", debugstr_guid(guidExtension), pChannelHook); - - return RPC_RegisterChannelHook(guidExtension, pChannelHook); -} - /* Returns expanded dll path from the registry or activation context. */ static BOOL get_object_dll_path(const struct class_reg_data *regdata, WCHAR *dst, DWORD dstlen) { @@ -1176,7 +1156,6 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID reserved) case DLL_PROCESS_DETACH: if (reserved) break; release_std_git(); - RPC_UnregisterAllChannelHooks(); break; } return TRUE; diff --git a/dlls/ole32/compobj_private.h b/dlls/ole32/compobj_private.h index 12acfc0a9e5..18b39d655f0 100644 --- a/dlls/ole32/compobj_private.h +++ b/dlls/ole32/compobj_private.h @@ -39,113 +39,9 @@ #include "winreg.h" #include "winternl.h" -struct apartment; - DEFINE_OLEGUID( CLSID_DfMarshal, 0x0000030b, 0, 0 ); -/* signal to stub manager that this is a rem unknown object */ -#define MSHLFLAGSP_REMUNKNOWN 0x80000000 - -/* Thread-safety Annotation Legend: - * - * RO - The value is read only. It never changes after creation, so no - * locking is required. - * LOCK - The value is written to only using Interlocked* functions. - * CS - The value is read or written to inside a critical section. - * The identifier following "CS" is the specific critical section that - * must be used. - * MUTEX - The value is read or written to with a mutex held. - * The identifier following "MUTEX" is the specific mutex that - * must be used. - */ - -typedef enum ifstub_state -{ - STUBSTATE_NORMAL_MARSHALED, - STUBSTATE_NORMAL_UNMARSHALED, - STUBSTATE_TABLE_WEAK_MARSHALED, - STUBSTATE_TABLE_WEAK_UNMARSHALED, - STUBSTATE_TABLE_STRONG, -} STUB_STATE; - -/* an interface stub */ -struct ifstub -{ - struct list entry; /* entry in stub_manager->ifstubs list (CS stub_manager->lock) */ - IRpcStubBuffer *stubbuffer; /* RO */ - IID iid; /* RO */ - IPID ipid; /* RO */ - IUnknown *iface; /* RO */ - MSHLFLAGS flags; /* so we can enforce process-local marshalling rules (RO) */ - IRpcChannelBuffer*chan; /* channel passed to IRpcStubBuffer::Invoke (RO) */ -}; - - -/* stub managers hold refs on the object and each interface stub */ -struct stub_manager -{ - struct list entry; /* entry in apartment stubmgr list (CS apt->cs) */ - struct list ifstubs; /* list of active ifstubs for the object (CS lock) */ - CRITICAL_SECTION lock; - struct apartment *apt; /* owning apt (RO) */ - - ULONG extrefs; /* number of 'external' references (CS lock) */ - ULONG refs; /* internal reference count (CS apt->cs) */ - ULONG weakrefs; /* number of weak references (CS lock) */ - OID oid; /* apartment-scoped unique identifier (RO) */ - IUnknown *object; /* the object we are managing the stub for (RO) */ - ULONG next_ipid; /* currently unused (LOCK) */ - OXID_INFO oxid_info; /* string binding, ipid of rem unknown and other information (RO) */ - - IExternalConnection *extern_conn; - - /* We need to keep a count of the outstanding marshals, so we can enforce the - * marshalling rules (ie, you can only unmarshal normal marshals once). Note - * that these counts do NOT include unmarshalled interfaces, once a stream is - * unmarshalled and a proxy set up, this count is decremented. - */ - - ULONG norm_refs; /* refcount of normal marshals (CS lock) */ - BOOL disconnected; /* CoDisconnectObject has been called (CS lock) */ -}; - -struct apartment -{ - struct list entry; - - LONG refs; /* refcount of the apartment (LOCK) */ - BOOL multi_threaded; /* multi-threaded or single-threaded apartment? (RO) */ - DWORD tid; /* thread id (RO) */ - OXID oxid; /* object exporter ID (RO) */ - LONG ipidc; /* interface pointer ID counter, starts at 1 (LOCK) */ - CRITICAL_SECTION cs; /* thread safety */ - struct list proxies; /* imported objects (CS cs) */ - struct list stubmgrs; /* stub managers for exported objects (CS cs) */ - BOOL remunk_exported; /* has the IRemUnknown interface for this apartment been created yet? (CS cs) */ - LONG remoting_started; /* has the RPC system been started for this apartment? (LOCK) */ - struct list loaded_dlls; /* list of dlls loaded by this apartment (CS cs) */ - DWORD host_apt_tid; /* thread ID of apartment hosting objects of differing threading model (CS cs) */ - HWND host_apt_hwnd; /* handle to apartment window of host apartment (CS cs) */ - struct local_server *local_server; /* A marshallable object exposing local servers (CS cs) */ - BOOL being_destroyed; /* is currently being destroyed */ - - /* FIXME: OIDs should be given out by RPCSS */ - OID oidc; /* object ID counter, starts at 1, zero is invalid OID (CS cs) */ - - /* STA-only fields */ - HWND win; /* message window (LOCK) */ - LPMESSAGEFILTER filter; /* message filter (CS cs) */ - BOOL main; /* is this a main-threaded-apartment? (RO) */ - /* MTA-only */ - struct list usage_cookies; /* Used for refcount control with CoIncrementMTAUsage()/CoDecrementMTAUsage(). */ -}; - -struct init_spy -{ - struct list entry; - IInitializeSpy *spy; - unsigned int id; -}; +struct apartment; /* this is what is stored in TEB->ReservedForOle */ struct oletls @@ -170,7 +66,6 @@ struct oletls DWORD spies_lock; }; - /* Global Interface Table Functions */ extern void release_std_git(void) DECLSPEC_HIDDEN; extern HRESULT StdGlobalInterfaceTable_GetFactory(LPVOID *ppv) DECLSPEC_HIDDEN; @@ -179,48 +74,9 @@ HRESULT COM_OpenKeyForCLSID(REFCLSID clsid, LPCWSTR keyname, REGSAM access, HKEY HRESULT MARSHAL_GetStandardMarshalCF(LPVOID *ppv) DECLSPEC_HIDDEN; HRESULT FTMarshalCF_Create(REFIID riid, LPVOID *ppv) DECLSPEC_HIDDEN; -/* Stub Manager */ - -extern ULONG WINAPI stub_manager_int_release(struct stub_manager *This) DECLSPEC_HIDDEN; - -/* RPC Backend */ - -struct dispatch_params; - -HRESULT WINAPI RPC_CreateClientChannel(const OXID *oxid, const IPID *ipid, - const OXID_INFO *oxid_info, const IID *iid, - DWORD dest_context, void *dest_context_data, - IRpcChannelBuffer **chan, struct apartment *apt) DECLSPEC_HIDDEN; -HRESULT WINAPI RPC_RegisterInterface(REFIID riid) DECLSPEC_HIDDEN; -HRESULT RPC_RegisterChannelHook(REFGUID rguid, IChannelHook *hook) DECLSPEC_HIDDEN; -void RPC_UnregisterAllChannelHooks(void) DECLSPEC_HIDDEN; -HRESULT WINAPI RPC_ResolveOxid(OXID oxid, OXID_INFO *oxid_info) DECLSPEC_HIDDEN; - /* Drag and drop */ void OLEDD_UnInitialize(void) DECLSPEC_HIDDEN; -/* Apartment Functions */ - -extern void WINAPI apartment_release(struct apartment *apt) DECLSPEC_HIDDEN; -static inline HRESULT apartment_getoxid(const struct apartment *apt, OXID *oxid) -{ - *oxid = apt->oxid; - return S_OK; -} -extern HWND WINAPI apartment_getwindow(const struct apartment *apt) DECLSPEC_HIDDEN; -extern HRESULT WINAPI enter_apartment(struct oletls *info, DWORD model) DECLSPEC_HIDDEN; -void WINAPI leave_apartment(struct oletls *info) DECLSPEC_HIDDEN; -extern struct apartment * WINAPI apartment_get_current_or_mta(void) DECLSPEC_HIDDEN; -extern HRESULT WINAPI apartment_get_local_server_stream(struct apartment *apt, IStream **ret) DECLSPEC_HIDDEN; - -/* DCOM messages used by the apartment window (not compatible with native) */ -#define DM_EXECUTERPC (WM_USER + 0) /* WPARAM = 0, LPARAM = (struct dispatch_params *) */ -#define DM_HOSTOBJECT (WM_USER + 1) /* WPARAM = 0, LPARAM = (struct host_object_params *) */ - -/* - * Per-thread values are stored in the TEB on offset 0xF80 - */ - extern HRESULT WINAPI InternalTlsAllocData(struct oletls **tlsdata); /* will create if necessary */ diff --git a/dlls/ole32/ole32.spec b/dlls/ole32/ole32.spec index 1ea57416176..cf48d043b75 100644 --- a/dlls/ole32/ole32.spec +++ b/dlls/ole32/ole32.spec @@ -64,7 +64,7 @@ @ stdcall CoQueryClientBlanket(ptr ptr ptr ptr ptr ptr ptr) combase.CoQueryClientBlanket @ stdcall CoQueryProxyBlanket(ptr ptr ptr ptr ptr ptr ptr ptr) combase.CoQueryProxyBlanket @ stub CoQueryReleaseObject -@ stdcall CoRegisterChannelHook(ptr ptr) +@ stdcall CoRegisterChannelHook(ptr ptr) combase.CoRegisterChannelHook @ stdcall CoRegisterClassObject(ptr ptr long long ptr) combase.CoRegisterClassObject @ stdcall CoRegisterInitializeSpy(ptr ptr) combase.CoRegisterInitializeSpy @ stdcall CoRegisterMallocSpy(ptr) combase.CoRegisterMallocSpy @@ -298,11 +298,3 @@ @ stdcall WriteFmtUserTypeStg(ptr long ptr) @ stub WriteOleStg @ stub WriteStringStream - -@ stdcall Internal_RPC_ExecuteCall(ptr) -@ stdcall RPC_CreateServerChannel(long ptr ptr) -@ stdcall RPC_UnregisterInterface(ptr long) -@ stdcall RPC_RegisterInterface(ptr) -@ stdcall RPC_ResolveOxid(int64 ptr) -@ stdcall RPC_StartRemoting(ptr) -@ stdcall RPC_CreateClientChannel(ptr ptr ptr ptr long ptr ptr ptr) diff --git a/dlls/ole32/rpc.c b/dlls/ole32/rpc.c deleted file mode 100644 index a6783c45eae..00000000000 --- a/dlls/ole32/rpc.c +++ /dev/null @@ -1,1654 +0,0 @@ -/* - * RPC Manager - * - * Copyright 2001 Ove Kåven, TransGaming Technologies - * Copyright 2002 Marcus Meissner - * Copyright 2005 Mike Hearn, Rob Shearman for CodeWeavers - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2.1 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the Free Software - * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA - */ - -#include <stdarg.h> -#include <string.h> - -#define COBJMACROS -#define NONAMELESSUNION - -#include "windef.h" -#include "winbase.h" -#include "winuser.h" -#include "winsvc.h" -#include "objbase.h" -#include "ole2.h" -#include "rpc.h" -#include "winerror.h" -#include "winreg.h" -#include "servprov.h" - -#include "compobj_private.h" - -#include "wine/debug.h" - -WINE_DEFAULT_DEBUG_CHANNEL(ole); - -extern HRESULT WINAPI ipid_get_dispatch_params(const IPID *ipid, struct apartment **stub_apt, - struct stub_manager **manager, IRpcStubBuffer **stub, IRpcChannelBuffer **chan, IID *iid, IUnknown **iface); -extern HRESULT WINAPI start_apartment_remote_unknown(struct apartment *apt); - -static void __RPC_STUB dispatch_rpc(RPC_MESSAGE *msg); - -/* we only use one function to dispatch calls for all methods - we use the - * RPC_IF_OLE flag to tell the RPC runtime that this is the case */ -static RPC_DISPATCH_FUNCTION rpc_dispatch_table[1] = { dispatch_rpc }; /* (RO) */ -static RPC_DISPATCH_TABLE rpc_dispatch = { 1, rpc_dispatch_table }; /* (RO) */ - -static struct list registered_interfaces = LIST_INIT(registered_interfaces); /* (CS csRegIf) */ -static CRITICAL_SECTION csRegIf; -static CRITICAL_SECTION_DEBUG csRegIf_debug = -{ - 0, 0, &csRegIf, - { &csRegIf_debug.ProcessLocksList, &csRegIf_debug.ProcessLocksList }, - 0, 0, { (DWORD_PTR)(__FILE__ ": dcom registered server interfaces") } -}; -static CRITICAL_SECTION csRegIf = { &csRegIf_debug, -1, 0, 0, 0, 0 }; - -static struct list channel_hooks = LIST_INIT(channel_hooks); /* (CS csChannelHook) */ -static CRITICAL_SECTION csChannelHook; -static CRITICAL_SECTION_DEBUG csChannelHook_debug = -{ - 0, 0, &csChannelHook, - { &csChannelHook_debug.ProcessLocksList, &csChannelHook_debug.ProcessLocksList }, - 0, 0, { (DWORD_PTR)(__FILE__ ": channel hooks") } -}; -static CRITICAL_SECTION csChannelHook = { &csChannelHook_debug, -1, 0, 0, 0, 0 }; - -static WCHAR wszRpcTransport[] = {'n','c','a','l','r','p','c',0}; - - -struct registered_if -{ - struct list entry; - DWORD refs; /* ref count */ - RPC_SERVER_INTERFACE If; /* interface registered with the RPC runtime */ -}; - -/* get the pipe endpoint specified of the specified apartment */ -static inline void get_rpc_endpoint(LPWSTR endpoint, const OXID *oxid) -{ - /* FIXME: should get endpoint from rpcss */ - static const WCHAR wszEndpointFormat[] = {'\\','p','i','p','e','\\','O','L','E','_','%','0','8','l','x','%','0','8','l','x',0}; - wsprintfW(endpoint, wszEndpointFormat, (DWORD)(*oxid >> 32),(DWORD)*oxid); -} - -typedef struct -{ - IRpcChannelBuffer IRpcChannelBuffer_iface; - LONG refs; - - DWORD dest_context; /* returned from GetDestCtx */ - void *dest_context_data; /* returned from GetDestCtx */ -} RpcChannelBuffer; - -typedef struct -{ - RpcChannelBuffer super; /* superclass */ - - RPC_BINDING_HANDLE bind; /* handle to the remote server */ - OXID oxid; /* apartment in which the channel is valid */ - DWORD server_pid; /* id of server process */ - HANDLE event; /* cached event handle */ - IID iid; /* IID of the proxy this belongs to */ -} ClientRpcChannelBuffer; - -struct dispatch_params -{ - RPCOLEMESSAGE *msg; /* message */ - IRpcStubBuffer *stub; /* stub buffer, if applicable */ - IRpcChannelBuffer *chan; /* server channel buffer, if applicable */ - IID iid; /* ID of interface being called */ - IUnknown *iface; /* interface being called */ - HANDLE handle; /* handle that will become signaled when call finishes */ - BOOL bypass_rpcrt; /* bypass RPC runtime? */ - RPC_STATUS status; /* status (out) */ - HRESULT hr; /* hresult (out) */ -}; - -struct message_state -{ - RPC_BINDING_HANDLE binding_handle; - ULONG prefix_data_len; - SChannelHookCallInfo channel_hook_info; - BOOL bypass_rpcrt; - - /* client only */ - HWND target_hwnd; - DWORD target_tid; - struct dispatch_params params; -}; - -typedef struct -{ - ULONG conformance; /* NDR */ - GUID id; - ULONG size; - /* [size_is((size+7)&~7)] */ unsigned char data[1]; -} WIRE_ORPC_EXTENT; - -typedef struct -{ - ULONG size; - ULONG reserved; - unsigned char extent[1]; -} WIRE_ORPC_EXTENT_ARRAY; - -typedef struct -{ - ULONG version; - ULONG flags; - ULONG reserved1; - GUID cid; - unsigned char extensions[1]; -} WIRE_ORPCTHIS; - -typedef struct -{ - ULONG flags; - unsigned char extensions[1]; -} WIRE_ORPCTHAT; - -struct channel_hook_entry -{ - struct list entry; - GUID id; - IChannelHook *hook; -}; - -struct channel_hook_buffer_data -{ - GUID id; - ULONG extension_size; -}; - - -static HRESULT unmarshal_ORPCTHAT(RPC_MESSAGE *msg, ORPCTHAT *orpcthat, - ORPC_EXTENT_ARRAY *orpc_ext_array, WIRE_ORPC_EXTENT **first_wire_orpc_extent); - -/* Channel Hook Functions */ - -static ULONG ChannelHooks_ClientGetSize(SChannelHookCallInfo *info, - struct channel_hook_buffer_data **data, unsigned int *hook_count, - ULONG *extension_count) -{ - struct channel_hook_entry *entry; - ULONG total_size = 0; - unsigned int hook_index = 0; - - *hook_count = 0; - *extension_count = 0; - - EnterCriticalSection(&csChannelHook); - - LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) - (*hook_count)++; - - if (*hook_count) - *data = HeapAlloc(GetProcessHeap(), 0, *hook_count * sizeof(struct channel_hook_buffer_data)); - else - *data = NULL; - - LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) - { - ULONG extension_size = 0; - - IChannelHook_ClientGetSize(entry->hook, &entry->id, &info->iid, &extension_size); - - TRACE("%s: extension_size = %u\n", debugstr_guid(&entry->id), extension_size); - - extension_size = (extension_size+7)&~7; - (*data)[hook_index].id = entry->id; - (*data)[hook_index].extension_size = extension_size; - - /* an extension is only put onto the wire if it has data to write */ - if (extension_size) - { - total_size += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[extension_size]); - (*extension_count)++; - } - - hook_index++; - } - - LeaveCriticalSection(&csChannelHook); - - return total_size; -} - -static unsigned char * ChannelHooks_ClientFillBuffer(SChannelHookCallInfo *info, - unsigned char *buffer, struct channel_hook_buffer_data *data, - unsigned int hook_count) -{ - struct channel_hook_entry *entry; - - EnterCriticalSection(&csChannelHook); - - LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) - { - unsigned int i; - ULONG extension_size = 0; - WIRE_ORPC_EXTENT *wire_orpc_extent = (WIRE_ORPC_EXTENT *)buffer; - - for (i = 0; i < hook_count; i++) - if (IsEqualGUID(&entry->id, &data[i].id)) - extension_size = data[i].extension_size; - - /* an extension is only put onto the wire if it has data to write */ - if (!extension_size) - continue; - - IChannelHook_ClientFillBuffer(entry->hook, &entry->id, &info->iid, - &extension_size, buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0])); - - TRACE("%s: extension_size = %u\n", debugstr_guid(&entry->id), extension_size); - - /* FIXME: set unused portion of wire_orpc_extent->data to 0? */ - - wire_orpc_extent->conformance = (extension_size+7)&~7; - wire_orpc_extent->size = extension_size; - wire_orpc_extent->id = entry->id; - buffer += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[wire_orpc_extent->conformance]); - } - - LeaveCriticalSection(&csChannelHook); - - return buffer; -} - -static void ChannelHooks_ServerNotify(SChannelHookCallInfo *info, - DWORD lDataRep, WIRE_ORPC_EXTENT *first_wire_orpc_extent, - ULONG extension_count) -{ - struct channel_hook_entry *entry; - ULONG i; - - EnterCriticalSection(&csChannelHook); - - LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) - { - WIRE_ORPC_EXTENT *wire_orpc_extent; - for (i = 0, wire_orpc_extent = first_wire_orpc_extent; - i < extension_count; - i++, wire_orpc_extent = (WIRE_ORPC_EXTENT *)&wire_orpc_extent->data[wire_orpc_extent->conformance]) - { - if (IsEqualGUID(&entry->id, &wire_orpc_extent->id)) - break; - } - if (i == extension_count) wire_orpc_extent = NULL; - - IChannelHook_ServerNotify(entry->hook, &entry->id, &info->iid, - wire_orpc_extent ? wire_orpc_extent->size : 0, - wire_orpc_extent ? wire_orpc_extent->data : NULL, - lDataRep); - } - - LeaveCriticalSection(&csChannelHook); -} - -static ULONG ChannelHooks_ServerGetSize(SChannelHookCallInfo *info, - struct channel_hook_buffer_data **data, unsigned int *hook_count, - ULONG *extension_count) -{ - struct channel_hook_entry *entry; - ULONG total_size = 0; - unsigned int hook_index = 0; - - *hook_count = 0; - *extension_count = 0; - - EnterCriticalSection(&csChannelHook); - - LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) - (*hook_count)++; - - if (*hook_count) - *data = HeapAlloc(GetProcessHeap(), 0, *hook_count * sizeof(struct channel_hook_buffer_data)); - else - *data = NULL; - - LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) - { - ULONG extension_size = 0; - - IChannelHook_ServerGetSize(entry->hook, &entry->id, &info->iid, S_OK, - &extension_size); - - TRACE("%s: extension_size = %u\n", debugstr_guid(&entry->id), extension_size); - - extension_size = (extension_size+7)&~7; - (*data)[hook_index].id = entry->id; - (*data)[hook_index].extension_size = extension_size; - - /* an extension is only put onto the wire if it has data to write */ - if (extension_size) - { - total_size += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[extension_size]); - (*extension_count)++; - } - - hook_index++; - } - - LeaveCriticalSection(&csChannelHook); - - return total_size; -} - -static unsigned char * ChannelHooks_ServerFillBuffer(SChannelHookCallInfo *info, - unsigned char *buffer, struct channel_hook_buffer_data *data, - unsigned int hook_count) -{ - struct channel_hook_entry *entry; - - EnterCriticalSection(&csChannelHook); - - LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) - { - unsigned int i; - ULONG extension_size = 0; - WIRE_ORPC_EXTENT *wire_orpc_extent = (WIRE_ORPC_EXTENT *)buffer; - - for (i = 0; i < hook_count; i++) - if (IsEqualGUID(&entry->id, &data[i].id)) - extension_size = data[i].extension_size; - - /* an extension is only put onto the wire if it has data to write */ - if (!extension_size) - continue; - - IChannelHook_ServerFillBuffer(entry->hook, &entry->id, &info->iid, - &extension_size, buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]), - S_OK); - - TRACE("%s: extension_size = %u\n", debugstr_guid(&entry->id), extension_size); - - /* FIXME: set unused portion of wire_orpc_extent->data to 0? */ - - wire_orpc_extent->conformance = (extension_size+7)&~7; - wire_orpc_extent->size = extension_size; - wire_orpc_extent->id = entry->id; - buffer += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[wire_orpc_extent->conformance]); - } - - LeaveCriticalSection(&csChannelHook); - - return buffer; -} - -static void ChannelHooks_ClientNotify(SChannelHookCallInfo *info, - DWORD lDataRep, WIRE_ORPC_EXTENT *first_wire_orpc_extent, - ULONG extension_count, HRESULT hrFault) -{ - struct channel_hook_entry *entry; - ULONG i; - - EnterCriticalSection(&csChannelHook); - - LIST_FOR_EACH_ENTRY(entry, &channel_hooks, struct channel_hook_entry, entry) - { - WIRE_ORPC_EXTENT *wire_orpc_extent; - for (i = 0, wire_orpc_extent = first_wire_orpc_extent; - i < extension_count; - i++, wire_orpc_extent = (WIRE_ORPC_EXTENT *)&wire_orpc_extent->data[wire_orpc_extent->conformance]) - { - if (IsEqualGUID(&entry->id, &wire_orpc_extent->id)) - break; - } - if (i == extension_count) wire_orpc_extent = NULL; - - IChannelHook_ClientNotify(entry->hook, &entry->id, &info->iid, - wire_orpc_extent ? wire_orpc_extent->size : 0, - wire_orpc_extent ? wire_orpc_extent->data : NULL, - lDataRep, hrFault); - } - - LeaveCriticalSection(&csChannelHook); -} - -HRESULT RPC_RegisterChannelHook(REFGUID rguid, IChannelHook *hook) -{ - struct channel_hook_entry *entry; - - TRACE("(%s, %p)\n", debugstr_guid(rguid), hook); - - entry = HeapAlloc(GetProcessHeap(), 0, sizeof(*entry)); - if (!entry) - return E_OUTOFMEMORY; - - entry->id = *rguid; - entry->hook = hook; - IChannelHook_AddRef(hook); - - EnterCriticalSection(&csChannelHook); - list_add_tail(&channel_hooks, &entry->entry); - LeaveCriticalSection(&csChannelHook); - - return S_OK; -} - -void RPC_UnregisterAllChannelHooks(void) -{ - struct channel_hook_entry *cursor; - struct channel_hook_entry *cursor2; - - EnterCriticalSection(&csChannelHook); - LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &channel_hooks, struct channel_hook_entry, entry) - HeapFree(GetProcessHeap(), 0, cursor); - LeaveCriticalSection(&csChannelHook); - DeleteCriticalSection(&csChannelHook); - DeleteCriticalSection(&csRegIf); -} - -/* RPC Channel Buffer Functions */ - -static HRESULT WINAPI RpcChannelBuffer_QueryInterface(IRpcChannelBuffer *iface, REFIID riid, LPVOID *ppv) -{ - *ppv = NULL; - if (IsEqualIID(riid,&IID_IRpcChannelBuffer) || IsEqualIID(riid,&IID_IUnknown)) - { - *ppv = iface; - IRpcChannelBuffer_AddRef(iface); - return S_OK; - } - return E_NOINTERFACE; -} - -static ULONG WINAPI RpcChannelBuffer_AddRef(LPRPCCHANNELBUFFER iface) -{ - RpcChannelBuffer *This = (RpcChannelBuffer *)iface; - return InterlockedIncrement(&This->refs); -} - -static ULONG WINAPI ServerRpcChannelBuffer_Release(LPRPCCHANNELBUFFER iface) -{ - RpcChannelBuffer *This = (RpcChannelBuffer *)iface; - ULONG ref; - - ref = InterlockedDecrement(&This->refs); - if (ref) - return ref; - - HeapFree(GetProcessHeap(), 0, This); - return 0; -} - -static ULONG WINAPI ClientRpcChannelBuffer_Release(LPRPCCHANNELBUFFER iface) -{ - ClientRpcChannelBuffer *This = (ClientRpcChannelBuffer *)iface; - ULONG ref; - - ref = InterlockedDecrement(&This->super.refs); - if (ref) - return ref; - - if (This->event) CloseHandle(This->event); - RpcBindingFree(&This->bind); - HeapFree(GetProcessHeap(), 0, This); - return 0; -} - -static HRESULT WINAPI ServerRpcChannelBuffer_GetBuffer(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE* olemsg, REFIID riid) -{ - RpcChannelBuffer *This = (RpcChannelBuffer *)iface; - RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; - RPC_STATUS status; - ORPCTHAT *orpcthat; - struct message_state *message_state; - ULONG extensions_size; - struct channel_hook_buffer_data *channel_hook_data; - unsigned int channel_hook_count; - ULONG extension_count; - - TRACE("(%p)->(%p,%s)\n", This, olemsg, debugstr_guid(riid)); - - message_state = msg->Handle; - /* restore the binding handle and the real start of data */ - msg->Handle = message_state->binding_handle; - msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; - - extensions_size = ChannelHooks_ServerGetSize(&message_state->channel_hook_info, - &channel_hook_data, &channel_hook_count, &extension_count); - - msg->BufferLength += FIELD_OFFSET(WIRE_ORPCTHAT, extensions) + sizeof(DWORD); - if (extensions_size) - { - msg->BufferLength += FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent[2*sizeof(DWORD) + extensions_size]); - if (extension_count & 1) - msg->BufferLength += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]); - } - - if (message_state->bypass_rpcrt) - { - msg->Buffer = HeapAlloc(GetProcessHeap(), 0, msg->BufferLength); - if (msg->Buffer) - status = RPC_S_OK; - else - { - HeapFree(GetProcessHeap(), 0, channel_hook_data); - return E_OUTOFMEMORY; - } - } - else - status = I_RpcGetBuffer(msg); - - orpcthat = msg->Buffer; - msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPCTHAT, extensions); - - orpcthat->flags = ORPCF_NULL /* FIXME? */; - - /* NDR representation of orpcthat->extensions */ - *(DWORD *)msg->Buffer = extensions_size ? 1 : 0; - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - - if (extensions_size) - { - WIRE_ORPC_EXTENT_ARRAY *orpc_extent_array = msg->Buffer; - orpc_extent_array->size = extension_count; - orpc_extent_array->reserved = 0; - msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent); - /* NDR representation of orpc_extent_array->extent */ - *(DWORD *)msg->Buffer = 1; - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - /* NDR representation of [size_is] attribute of orpc_extent_array->extent */ - *(DWORD *)msg->Buffer = (extension_count + 1) & ~1; - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - - msg->Buffer = ChannelHooks_ServerFillBuffer(&message_state->channel_hook_info, - msg->Buffer, channel_hook_data, channel_hook_count); - - /* we must add a dummy extension if there is an odd extension - * count to meet the contract specified by the size_is attribute */ - if (extension_count & 1) - { - WIRE_ORPC_EXTENT *wire_orpc_extent = msg->Buffer; - wire_orpc_extent->conformance = 0; - wire_orpc_extent->id = GUID_NULL; - wire_orpc_extent->size = 0; - msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]); - } - } - - HeapFree(GetProcessHeap(), 0, channel_hook_data); - - /* store the prefixed data length so that we can restore the real buffer - * later */ - message_state->prefix_data_len = (char *)msg->Buffer - (char *)orpcthat; - msg->BufferLength -= message_state->prefix_data_len; - /* save away the message state again */ - msg->Handle = message_state; - - TRACE("-- %d\n", status); - - return HRESULT_FROM_WIN32(status); -} - -static HANDLE ClientRpcChannelBuffer_GetEventHandle(ClientRpcChannelBuffer *This) -{ - HANDLE event = InterlockedExchangePointer(&This->event, NULL); - - /* Note: must be auto-reset event so we can reuse it without a call - * to ResetEvent */ - if (!event) event = CreateEventW(NULL, FALSE, FALSE, NULL); - - return event; -} - -static void ClientRpcChannelBuffer_ReleaseEventHandle(ClientRpcChannelBuffer *This, HANDLE event) -{ - if (InterlockedCompareExchangePointer(&This->event, event, NULL)) - /* already a handle cached in This */ - CloseHandle(event); -} - -static HRESULT WINAPI ClientRpcChannelBuffer_GetBuffer(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE* olemsg, REFIID riid) -{ - ClientRpcChannelBuffer *This = (ClientRpcChannelBuffer *)iface; - RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; - RPC_CLIENT_INTERFACE *cif; - RPC_STATUS status; - ORPCTHIS *orpcthis; - struct message_state *message_state; - ULONG extensions_size; - struct channel_hook_buffer_data *channel_hook_data; - unsigned int channel_hook_count; - ULONG extension_count; - IPID ipid; - HRESULT hr; - struct apartment *apt = NULL; - - TRACE("(%p)->(%p,%s)\n", This, olemsg, debugstr_guid(riid)); - - cif = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RPC_CLIENT_INTERFACE)); - if (!cif) - return E_OUTOFMEMORY; - - message_state = HeapAlloc(GetProcessHeap(), 0, sizeof(*message_state)); - if (!message_state) - { - HeapFree(GetProcessHeap(), 0, cif); - return E_OUTOFMEMORY; - } - - cif->Length = sizeof(RPC_CLIENT_INTERFACE); - /* RPC interface ID = COM interface ID */ - cif->InterfaceId.SyntaxGUID = This->iid; - /* COM objects always have a version of 0.0 */ - cif->InterfaceId.SyntaxVersion.MajorVersion = 0; - cif->InterfaceId.SyntaxVersion.MinorVersion = 0; - msg->Handle = This->bind; - msg->RpcInterfaceInformation = cif; - - message_state->prefix_data_len = 0; - message_state->binding_handle = This->bind; - - message_state->channel_hook_info.iid = *riid; - message_state->channel_hook_info.cbSize = sizeof(message_state->channel_hook_info); - CoGetCurrentLogicalThreadId(&message_state->channel_hook_info.uCausality); - message_state->channel_hook_info.dwServerPid = This->server_pid; - message_state->channel_hook_info.iMethod = msg->ProcNum & ~RPC_FLAGS_VALID_BIT; - message_state->channel_hook_info.pObject = NULL; /* only present on server-side */ - message_state->target_hwnd = NULL; - message_state->target_tid = 0; - memset(&message_state->params, 0, sizeof(message_state->params)); - - extensions_size = ChannelHooks_ClientGetSize(&message_state->channel_hook_info, - &channel_hook_data, &channel_hook_count, &extension_count); - - msg->BufferLength += FIELD_OFFSET(WIRE_ORPCTHIS, extensions) + sizeof(DWORD); - if (extensions_size) - { - msg->BufferLength += FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent[2*sizeof(DWORD) + extensions_size]); - if (extension_count & 1) - msg->BufferLength += FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]); - } - - RpcBindingInqObject(message_state->binding_handle, &ipid); - hr = ipid_get_dispatch_params(&ipid, &apt, NULL, &message_state->params.stub, - &message_state->params.chan, - &message_state->params.iid, - &message_state->params.iface); - if (hr == S_OK) - { - /* stub, chan, iface and iid are unneeded in multi-threaded case as we go - * via the RPC runtime */ - if (apt->multi_threaded) - { - IRpcStubBuffer_Release(message_state->params.stub); - message_state->params.stub = NULL; - IRpcChannelBuffer_Release(message_state->params.chan); - message_state->params.chan = NULL; - message_state->params.iface = NULL; - } - else - { - message_state->params.bypass_rpcrt = TRUE; - message_state->target_hwnd = apartment_getwindow(apt); - message_state->target_tid = apt->tid; - /* we assume later on that this being non-NULL is the indicator that - * means call directly instead of going through RPC runtime */ - if (!message_state->target_hwnd) - ERR("window for apartment %s is NULL\n", wine_dbgstr_longlong(apt->oxid)); - } - } - if (apt) apartment_release(apt); - message_state->params.handle = ClientRpcChannelBuffer_GetEventHandle(This); - /* Note: message_state->params.msg is initialised in - * ClientRpcChannelBuffer_SendReceive */ - - /* shortcut the RPC runtime */ - if (message_state->target_hwnd) - { - msg->Buffer = HeapAlloc(GetProcessHeap(), 0, msg->BufferLength); - if (msg->Buffer) - status = RPC_S_OK; - else - status = ERROR_OUTOFMEMORY; - } - else - status = I_RpcGetBuffer(msg); - - msg->Handle = message_state; - - if (status == RPC_S_OK) - { - orpcthis = msg->Buffer; - msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPCTHIS, extensions); - - orpcthis->version.MajorVersion = COM_MAJOR_VERSION; - orpcthis->version.MinorVersion = COM_MINOR_VERSION; - orpcthis->flags = message_state->channel_hook_info.dwServerPid ? ORPCF_LOCAL : ORPCF_NULL; - orpcthis->reserved1 = 0; - orpcthis->cid = message_state->channel_hook_info.uCausality; - - /* NDR representation of orpcthis->extensions */ - *(DWORD *)msg->Buffer = extensions_size ? 1 : 0; - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - - if (extensions_size) - { - ORPC_EXTENT_ARRAY *orpc_extent_array = msg->Buffer; - orpc_extent_array->size = extension_count; - orpc_extent_array->reserved = 0; - msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent); - /* NDR representation of orpc_extent_array->extent */ - *(DWORD *)msg->Buffer = 1; - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - /* NDR representation of [size_is] attribute of orpc_extent_array->extent */ - *(DWORD *)msg->Buffer = (extension_count + 1) & ~1; - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - - msg->Buffer = ChannelHooks_ClientFillBuffer(&message_state->channel_hook_info, - msg->Buffer, channel_hook_data, channel_hook_count); - - /* we must add a dummy extension if there is an odd extension - * count to meet the contract specified by the size_is attribute */ - if (extension_count & 1) - { - WIRE_ORPC_EXTENT *wire_orpc_extent = msg->Buffer; - wire_orpc_extent->conformance = 0; - wire_orpc_extent->id = GUID_NULL; - wire_orpc_extent->size = 0; - msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT, data[0]); - } - } - - /* store the prefixed data length so that we can restore the real buffer - * pointer in ClientRpcChannelBuffer_SendReceive. */ - message_state->prefix_data_len = (char *)msg->Buffer - (char *)orpcthis; - msg->BufferLength -= message_state->prefix_data_len; - } - - HeapFree(GetProcessHeap(), 0, channel_hook_data); - - TRACE("-- %d\n", status); - - return HRESULT_FROM_WIN32(status); -} - -static HRESULT WINAPI ServerRpcChannelBuffer_SendReceive(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE *olemsg, ULONG *pstatus) -{ - FIXME("stub\n"); - return E_NOTIMPL; -} - -/* this thread runs an outgoing RPC */ -static DWORD WINAPI rpc_sendreceive_thread(LPVOID param) -{ - struct dispatch_params *data = param; - - /* Note: I_RpcSendReceive doesn't raise exceptions like the higher-level - * RPC functions do */ - data->status = I_RpcSendReceive((RPC_MESSAGE *)data->msg); - - TRACE("completed with status 0x%x\n", data->status); - - SetEvent(data->handle); - - return 0; -} - -static inline HRESULT ClientRpcChannelBuffer_IsCorrectApartment(ClientRpcChannelBuffer *This, struct apartment *apt) -{ - OXID oxid; - if (!apt) - return S_FALSE; - if (apartment_getoxid(apt, &oxid) != S_OK) - return S_FALSE; - if (This->oxid != oxid) - return S_FALSE; - return S_OK; -} - -static HRESULT WINAPI ClientRpcChannelBuffer_SendReceive(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE *olemsg, ULONG *pstatus) -{ - ClientRpcChannelBuffer *This = (ClientRpcChannelBuffer *)iface; - HRESULT hr; - RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; - RPC_STATUS status; - DWORD index; - struct message_state *message_state; - ORPCTHAT orpcthat; - ORPC_EXTENT_ARRAY orpc_ext_array; - WIRE_ORPC_EXTENT *first_wire_orpc_extent = NULL; - HRESULT hrFault = S_OK; - struct apartment *apt = apartment_get_current_or_mta(); - - TRACE("(%p) iMethod=%d\n", olemsg, olemsg->iMethod); - - hr = ClientRpcChannelBuffer_IsCorrectApartment(This, apt); - if (hr != S_OK) - { - ERR("called from wrong apartment, should have been 0x%s\n", - wine_dbgstr_longlong(This->oxid)); - if (apt) apartment_release(apt); - return RPC_E_WRONG_THREAD; - } - /* This situation should be impossible in multi-threaded apartments, - * because the calling thread isn't re-enterable. - * Note: doing a COM call during the processing of a sent message is - * only disallowed if a client call is already being waited for - * completion */ - if (!apt->multi_threaded && - COM_CurrentInfo()->pending_call_count_client && - InSendMessage()) - { - ERR("can't make an outgoing COM call in response to a sent message\n"); - apartment_release(apt); - return RPC_E_CANTCALLOUT_ININPUTSYNCCALL; - } - - message_state = msg->Handle; - /* restore the binding handle and the real start of data */ - msg->Handle = message_state->binding_handle; - msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; - msg->BufferLength += message_state->prefix_data_len; - - /* Note: this is an optimization in the Microsoft OLE runtime that we need - * to copy, as shown by the test_no_couninitialize_client test. without - * short-circuiting the RPC runtime in the case below, the test will - * deadlock on the loader lock due to the RPC runtime needing to create - * a thread to process the RPC when this function is called indirectly - * from DllMain */ - - message_state->params.msg = olemsg; - if (message_state->params.bypass_rpcrt) - { - TRACE("Calling apartment thread 0x%08x...\n", message_state->target_tid); - - msg->ProcNum &= ~RPC_FLAGS_VALID_BIT; - - if (!PostMessageW(message_state->target_hwnd, DM_EXECUTERPC, 0, - (LPARAM)&message_state->params)) - { - ERR("PostMessage failed with error %u\n", GetLastError()); - - /* Note: message_state->params.iface doesn't have a reference and - * so doesn't need to be released */ - - hr = HRESULT_FROM_WIN32(GetLastError()); - } - } - else - { - /* we use a separate thread here because we need to be able to - * pump the message loop in the application thread: if we do not, - * any windows created by this thread will hang and RPCs that try - * and re-enter this STA from an incoming server thread will - * deadlock. InstallShield is an example of that. - */ - if (!QueueUserWorkItem(rpc_sendreceive_thread, &message_state->params, WT_EXECUTEDEFAULT)) - { - ERR("QueueUserWorkItem failed with error %u\n", GetLastError()); - hr = E_UNEXPECTED; - } - else - hr = S_OK; - } - - if (hr == S_OK) - { - if (WaitForSingleObject(message_state->params.handle, 0)) - { - COM_CurrentInfo()->pending_call_count_client++; - hr = CoWaitForMultipleHandles(0, INFINITE, 1, &message_state->params.handle, &index); - COM_CurrentInfo()->pending_call_count_client--; - } - } - ClientRpcChannelBuffer_ReleaseEventHandle(This, message_state->params.handle); - - /* for WM shortcut, faults are returned in params->hr */ - if (hr == S_OK) - hrFault = message_state->params.hr; - - status = message_state->params.status; - - orpcthat.flags = ORPCF_NULL; - orpcthat.extensions = NULL; - - TRACE("RPC call status: 0x%x\n", status); - if (status != RPC_S_OK) - hr = HRESULT_FROM_WIN32(status); - - TRACE("hrFault = 0x%08x\n", hrFault); - - /* FIXME: this condition should be - * "hr == S_OK && (!hrFault || msg->BufferLength > FIELD_OFFSET(ORPCTHAT, extensions) + 4)" - * but we don't currently reset the message length for PostMessage - * dispatched calls */ - if (hr == S_OK && hrFault == S_OK) - { - HRESULT hr2; - char *original_buffer = msg->Buffer; - - /* handle ORPCTHAT and client extensions */ - - hr2 = unmarshal_ORPCTHAT(msg, &orpcthat, &orpc_ext_array, &first_wire_orpc_extent); - if (FAILED(hr2)) - hr = hr2; - - message_state->prefix_data_len = (char *)msg->Buffer - original_buffer; - msg->BufferLength -= message_state->prefix_data_len; - } - else - message_state->prefix_data_len = 0; - - if (hr == S_OK) - { - ChannelHooks_ClientNotify(&message_state->channel_hook_info, - msg->DataRepresentation, - first_wire_orpc_extent, - orpcthat.extensions && first_wire_orpc_extent ? orpcthat.extensions->size : 0, - hrFault); - } - - /* save away the message state again */ - msg->Handle = message_state; - - if (pstatus) *pstatus = status; - - if (hr == S_OK) - hr = hrFault; - - TRACE("-- 0x%08x\n", hr); - - apartment_release(apt); - return hr; -} - -static HRESULT WINAPI ServerRpcChannelBuffer_FreeBuffer(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE* olemsg) -{ - RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; - RPC_STATUS status; - struct message_state *message_state; - - TRACE("(%p)\n", msg); - - message_state = msg->Handle; - /* restore the binding handle and the real start of data */ - msg->Handle = message_state->binding_handle; - msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; - msg->BufferLength += message_state->prefix_data_len; - message_state->prefix_data_len = 0; - - if (message_state->bypass_rpcrt) - { - HeapFree(GetProcessHeap(), 0, msg->Buffer); - status = RPC_S_OK; - } - else - status = I_RpcFreeBuffer(msg); - - msg->Handle = message_state; - - TRACE("-- %d\n", status); - - return HRESULT_FROM_WIN32(status); -} - -static HRESULT WINAPI ClientRpcChannelBuffer_FreeBuffer(LPRPCCHANNELBUFFER iface, RPCOLEMESSAGE* olemsg) -{ - RPC_MESSAGE *msg = (RPC_MESSAGE *)olemsg; - RPC_STATUS status; - struct message_state *message_state; - - TRACE("(%p)\n", msg); - - message_state = msg->Handle; - /* restore the binding handle and the real start of data */ - msg->Handle = message_state->binding_handle; - msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; - msg->BufferLength += message_state->prefix_data_len; - - if (message_state->params.bypass_rpcrt) - { - HeapFree(GetProcessHeap(), 0, msg->Buffer); - status = RPC_S_OK; - } - else - status = I_RpcFreeBuffer(msg); - - HeapFree(GetProcessHeap(), 0, msg->RpcInterfaceInformation); - msg->RpcInterfaceInformation = NULL; - - if (message_state->params.stub) - IRpcStubBuffer_Release(message_state->params.stub); - if (message_state->params.chan) - IRpcChannelBuffer_Release(message_state->params.chan); - HeapFree(GetProcessHeap(), 0, message_state); - - TRACE("-- %d\n", status); - - return HRESULT_FROM_WIN32(status); -} - -static HRESULT WINAPI ClientRpcChannelBuffer_GetDestCtx(LPRPCCHANNELBUFFER iface, DWORD* pdwDestContext, void** ppvDestContext) -{ - ClientRpcChannelBuffer *This = (ClientRpcChannelBuffer *)iface; - - TRACE("(%p,%p)\n", pdwDestContext, ppvDestContext); - - *pdwDestContext = This->super.dest_context; - *ppvDestContext = This->super.dest_context_data; - - return S_OK; -} - -static HRESULT WINAPI ServerRpcChannelBuffer_GetDestCtx(LPRPCCHANNELBUFFER iface, DWORD* dest_context, void** dest_context_data) -{ - RpcChannelBuffer *This = (RpcChannelBuffer *)iface; - - TRACE("(%p,%p)\n", dest_context, dest_context_data); - - *dest_context = This->dest_context; - *dest_context_data = This->dest_context_data; - return S_OK; -} - -static HRESULT WINAPI RpcChannelBuffer_IsConnected(LPRPCCHANNELBUFFER iface) -{ - TRACE("()\n"); - /* native does nothing too */ - return S_OK; -} - -static const IRpcChannelBufferVtbl ClientRpcChannelBufferVtbl = -{ - RpcChannelBuffer_QueryInterface, - RpcChannelBuffer_AddRef, - ClientRpcChannelBuffer_Release, - ClientRpcChannelBuffer_GetBuffer, - ClientRpcChannelBuffer_SendReceive, - ClientRpcChannelBuffer_FreeBuffer, - ClientRpcChannelBuffer_GetDestCtx, - RpcChannelBuffer_IsConnected -}; - -static const IRpcChannelBufferVtbl ServerRpcChannelBufferVtbl = -{ - RpcChannelBuffer_QueryInterface, - RpcChannelBuffer_AddRef, - ServerRpcChannelBuffer_Release, - ServerRpcChannelBuffer_GetBuffer, - ServerRpcChannelBuffer_SendReceive, - ServerRpcChannelBuffer_FreeBuffer, - ServerRpcChannelBuffer_GetDestCtx, - RpcChannelBuffer_IsConnected -}; - -/* returns a channel buffer for proxies */ -HRESULT WINAPI RPC_CreateClientChannel(const OXID *oxid, const IPID *ipid, - const OXID_INFO *oxid_info, const IID *iid, - DWORD dest_context, void *dest_context_data, - IRpcChannelBuffer **chan, struct apartment *apt) -{ - ClientRpcChannelBuffer *This; - WCHAR endpoint[200]; - RPC_BINDING_HANDLE bind; - RPC_STATUS status; - LPWSTR string_binding; - - /* FIXME: get the endpoint from oxid_info->psa instead */ - get_rpc_endpoint(endpoint, oxid); - - TRACE("proxy pipe: connecting to endpoint: %s\n", debugstr_w(endpoint)); - - status = RpcStringBindingComposeW( - NULL, - wszRpcTransport, - NULL, - endpoint, - NULL, - &string_binding); - - if (status == RPC_S_OK) - { - status = RpcBindingFromStringBindingW(string_binding, &bind); - - if (status == RPC_S_OK) - { - IPID ipid2 = *ipid; /* why can't RpcBindingSetObject take a const? */ - status = RpcBindingSetObject(bind, &ipid2); - if (status != RPC_S_OK) - RpcBindingFree(&bind); - } - - RpcStringFreeW(&string_binding); - } - - if (status != RPC_S_OK) - { - ERR("Couldn't get binding for endpoint %s, status = %d\n", debugstr_w(endpoint), status); - return HRESULT_FROM_WIN32(status); - } - - This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); - if (!This) - { - RpcBindingFree(&bind); - return E_OUTOFMEMORY; - } - - This->super.IRpcChannelBuffer_iface.lpVtbl = &ClientRpcChannelBufferVtbl; - This->super.refs = 1; - This->super.dest_context = dest_context; - This->super.dest_context_data = dest_context_data; - This->bind = bind; - apartment_getoxid(apt, &This->oxid); - This->server_pid = oxid_info->dwPid; - This->event = NULL; - This->iid = *iid; - - *chan = &This->super.IRpcChannelBuffer_iface; - - return S_OK; -} - -HRESULT WINAPI RPC_CreateServerChannel(DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan) -{ - RpcChannelBuffer *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This)); - if (!This) - return E_OUTOFMEMORY; - - This->IRpcChannelBuffer_iface.lpVtbl = &ServerRpcChannelBufferVtbl; - This->refs = 1; - This->dest_context = dest_context; - This->dest_context_data = dest_context_data; - - *chan = &This->IRpcChannelBuffer_iface; - - return S_OK; -} - -/* unmarshals ORPC_EXTENT_ARRAY according to NDR rules, but doesn't allocate - * any memory */ -static HRESULT unmarshal_ORPC_EXTENT_ARRAY(RPC_MESSAGE *msg, const char *end, - ORPC_EXTENT_ARRAY *extensions, - WIRE_ORPC_EXTENT **first_wire_orpc_extent) -{ - DWORD pointer_id; - DWORD i; - - memcpy(extensions, msg->Buffer, FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent)); - msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPC_EXTENT_ARRAY, extent); - - if ((const char *)msg->Buffer + 2 * sizeof(DWORD) > end) - return RPC_E_INVALID_HEADER; - - pointer_id = *(DWORD *)msg->Buffer; - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - extensions->extent = NULL; - - if (pointer_id) - { - WIRE_ORPC_EXTENT *wire_orpc_extent; - - /* conformance */ - if (*(DWORD *)msg->Buffer != ((extensions->size+1)&~1)) - return RPC_S_INVALID_BOUND; - - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - - /* arbitrary limit for security (don't know what native does) */ - if (extensions->size > 256) - { - ERR("too many extensions: %d\n", extensions->size); - return RPC_S_INVALID_BOUND; - } - - *first_wire_orpc_extent = wire_orpc_extent = msg->Buffer; - for (i = 0; i < ((extensions->size+1)&~1); i++) - { - if ((const char *)&wire_orpc_extent->data[0] > end) - return RPC_S_INVALID_BOUND; - if (wire_orpc_extent->conformance != ((wire_orpc_extent->size+7)&~7)) - return RPC_S_INVALID_BOUND; - if ((const char *)&wire_orpc_extent->data[wire_orpc_extent->conformance] > end) - return RPC_S_INVALID_BOUND; - TRACE("size %u, guid %s\n", wire_orpc_extent->size, debugstr_guid(&wire_orpc_extent->id)); - wire_orpc_extent = (WIRE_ORPC_EXTENT *)&wire_orpc_extent->data[wire_orpc_extent->conformance]; - } - msg->Buffer = wire_orpc_extent; - } - - return S_OK; -} - -/* unmarshals ORPCTHIS according to NDR rules, but doesn't allocate any memory */ -static HRESULT unmarshal_ORPCTHIS(RPC_MESSAGE *msg, ORPCTHIS *orpcthis, - ORPC_EXTENT_ARRAY *orpc_ext_array, WIRE_ORPC_EXTENT **first_wire_orpc_extent) -{ - const char *end = (char *)msg->Buffer + msg->BufferLength; - - *first_wire_orpc_extent = NULL; - - if (msg->BufferLength < FIELD_OFFSET(WIRE_ORPCTHIS, extensions) + sizeof(DWORD)) - { - ERR("invalid buffer length\n"); - return RPC_E_INVALID_HEADER; - } - - memcpy(orpcthis, msg->Buffer, FIELD_OFFSET(WIRE_ORPCTHIS, extensions)); - msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPCTHIS, extensions); - - if ((const char *)msg->Buffer + sizeof(DWORD) > end) - return RPC_E_INVALID_HEADER; - - if (*(DWORD *)msg->Buffer) - orpcthis->extensions = orpc_ext_array; - else - orpcthis->extensions = NULL; - - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - - if (orpcthis->extensions) - { - HRESULT hr = unmarshal_ORPC_EXTENT_ARRAY(msg, end, orpc_ext_array, - first_wire_orpc_extent); - if (FAILED(hr)) - return hr; - } - - if ((orpcthis->version.MajorVersion != COM_MAJOR_VERSION) || - (orpcthis->version.MinorVersion > COM_MINOR_VERSION)) - { - ERR("COM version {%d, %d} not supported\n", - orpcthis->version.MajorVersion, orpcthis->version.MinorVersion); - return RPC_E_VERSION_MISMATCH; - } - - if (orpcthis->flags & ~(ORPCF_LOCAL|ORPCF_RESERVED1|ORPCF_RESERVED2|ORPCF_RESERVED3|ORPCF_RESERVED4)) - { - ERR("invalid flags 0x%x\n", orpcthis->flags & ~(ORPCF_LOCAL|ORPCF_RESERVED1|ORPCF_RESERVED2|ORPCF_RESERVED3|ORPCF_RESERVED4)); - return RPC_E_INVALID_HEADER; - } - - return S_OK; -} - -static HRESULT unmarshal_ORPCTHAT(RPC_MESSAGE *msg, ORPCTHAT *orpcthat, - ORPC_EXTENT_ARRAY *orpc_ext_array, WIRE_ORPC_EXTENT **first_wire_orpc_extent) -{ - const char *end = (char *)msg->Buffer + msg->BufferLength; - - *first_wire_orpc_extent = NULL; - - if (msg->BufferLength < FIELD_OFFSET(WIRE_ORPCTHAT, extensions) + sizeof(DWORD)) - { - ERR("invalid buffer length\n"); - return RPC_E_INVALID_HEADER; - } - - memcpy(orpcthat, msg->Buffer, FIELD_OFFSET(WIRE_ORPCTHAT, extensions)); - msg->Buffer = (char *)msg->Buffer + FIELD_OFFSET(WIRE_ORPCTHAT, extensions); - - if ((const char *)msg->Buffer + sizeof(DWORD) > end) - return RPC_E_INVALID_HEADER; - - if (*(DWORD *)msg->Buffer) - orpcthat->extensions = orpc_ext_array; - else - orpcthat->extensions = NULL; - - msg->Buffer = (char *)msg->Buffer + sizeof(DWORD); - - if (orpcthat->extensions) - { - HRESULT hr = unmarshal_ORPC_EXTENT_ARRAY(msg, end, orpc_ext_array, - first_wire_orpc_extent); - if (FAILED(hr)) - return hr; - } - - if (orpcthat->flags & ~(ORPCF_LOCAL|ORPCF_RESERVED1|ORPCF_RESERVED2|ORPCF_RESERVED3|ORPCF_RESERVED4)) - { - ERR("invalid flags 0x%x\n", orpcthat->flags & ~(ORPCF_LOCAL|ORPCF_RESERVED1|ORPCF_RESERVED2|ORPCF_RESERVED3|ORPCF_RESERVED4)); - return RPC_E_INVALID_HEADER; - } - - return S_OK; -} - -void WINAPI Internal_RPC_ExecuteCall(struct dispatch_params *params) -{ - struct message_state *message_state = NULL; - RPC_MESSAGE *msg = (RPC_MESSAGE *)params->msg; - char *original_buffer = msg->Buffer; - ORPCTHIS orpcthis; - ORPC_EXTENT_ARRAY orpc_ext_array; - WIRE_ORPC_EXTENT *first_wire_orpc_extent; - GUID old_causality_id; - - /* handle ORPCTHIS and server extensions */ - - params->hr = unmarshal_ORPCTHIS(msg, &orpcthis, &orpc_ext_array, &first_wire_orpc_extent); - if (params->hr != S_OK) - { - msg->Buffer = original_buffer; - goto exit; - } - - message_state = HeapAlloc(GetProcessHeap(), 0, sizeof(*message_state)); - if (!message_state) - { - params->hr = E_OUTOFMEMORY; - msg->Buffer = original_buffer; - goto exit; - } - - message_state->prefix_data_len = (char *)msg->Buffer - original_buffer; - message_state->binding_handle = msg->Handle; - message_state->bypass_rpcrt = params->bypass_rpcrt; - - message_state->channel_hook_info.iid = params->iid; - message_state->channel_hook_info.cbSize = sizeof(message_state->channel_hook_info); - message_state->channel_hook_info.uCausality = orpcthis.cid; - message_state->channel_hook_info.dwServerPid = GetCurrentProcessId(); - message_state->channel_hook_info.iMethod = msg->ProcNum; - message_state->channel_hook_info.pObject = params->iface; - - if (orpcthis.extensions && first_wire_orpc_extent && - orpcthis.extensions->size) - ChannelHooks_ServerNotify(&message_state->channel_hook_info, msg->DataRepresentation, first_wire_orpc_extent, orpcthis.extensions->size); - - msg->Handle = message_state; - msg->BufferLength -= message_state->prefix_data_len; - - /* call message filter */ - - if (COM_CurrentApt()->filter) - { - DWORD handlecall; - INTERFACEINFO interface_info; - CALLTYPE calltype; - - interface_info.pUnk = params->iface; - interface_info.iid = params->iid; - interface_info.wMethod = msg->ProcNum; - - if (IsEqualGUID(&orpcthis.cid, &COM_CurrentInfo()->causality_id)) - calltype = CALLTYPE_NESTED; - else if (COM_CurrentInfo()->pending_call_count_server == 0) - calltype = CALLTYPE_TOPLEVEL; - else - calltype = CALLTYPE_TOPLEVEL_CALLPENDING; - - handlecall = IMessageFilter_HandleInComingCall(COM_CurrentApt()->filter, - calltype, - UlongToHandle(GetCurrentProcessId()), - 0 /* FIXME */, - &interface_info); - TRACE("IMessageFilter_HandleInComingCall returned %d\n", handlecall); - switch (handlecall) - { - case SERVERCALL_REJECTED: - params->hr = RPC_E_CALL_REJECTED; - goto exit_reset_state; - case SERVERCALL_RETRYLATER: -#if 0 /* FIXME: handle retries on the client side before enabling this code */ - params->hr = RPC_E_RETRY; - goto exit_reset_state; -#else - FIXME("retry call later not implemented\n"); - break; -#endif - case SERVERCALL_ISHANDLED: - default: - break; - } - } - - /* invoke the method */ - - /* save the old causality ID - note: any calls executed while processing - * messages received during the SendReceive will appear to originate from - * this call - this should be checked with what Windows does */ - old_causality_id = COM_CurrentInfo()->causality_id; - COM_CurrentInfo()->causality_id = orpcthis.cid; - COM_CurrentInfo()->pending_call_count_server++; - params->hr = IRpcStubBuffer_Invoke(params->stub, params->msg, params->chan); - COM_CurrentInfo()->pending_call_count_server--; - COM_CurrentInfo()->causality_id = old_causality_id; - - /* the invoke allocated a new buffer, so free the old one */ - if (message_state->bypass_rpcrt && original_buffer != msg->Buffer) - HeapFree(GetProcessHeap(), 0, original_buffer); - -exit_reset_state: - message_state = msg->Handle; - msg->Handle = message_state->binding_handle; - msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len; - msg->BufferLength += message_state->prefix_data_len; - -exit: - HeapFree(GetProcessHeap(), 0, message_state); - if (params->handle) SetEvent(params->handle); -} - -static void __RPC_STUB dispatch_rpc(RPC_MESSAGE *msg) -{ - struct dispatch_params *params; - struct stub_manager *stub_manager; - struct apartment *apt; - IPID ipid; - HRESULT hr; - - RpcBindingInqObject(msg->Handle, &ipid); - - TRACE("ipid = %s, iMethod = %d\n", debugstr_guid(&ipid), msg->ProcNum); - - params = HeapAlloc(GetProcessHeap(), 0, sizeof(*params)); - if (!params) - { - RpcRaiseException(E_OUTOFMEMORY); - return; - } - - hr = ipid_get_dispatch_params(&ipid, &apt, &stub_manager, &params->stub, &params->chan, - &params->iid, &params->iface); - if (hr != S_OK) - { - ERR("no apartment found for ipid %s\n", debugstr_guid(&ipid)); - HeapFree(GetProcessHeap(), 0, params); - RpcRaiseException(hr); - return; - } - - params->msg = (RPCOLEMESSAGE *)msg; - params->status = RPC_S_OK; - params->hr = S_OK; - params->handle = NULL; - params->bypass_rpcrt = FALSE; - - /* Note: this is the important difference between STAs and MTAs - we - * always execute RPCs to STAs in the thread that originally created the - * apartment (i.e. the one that pumps messages to the window) */ - if (!apt->multi_threaded) - { - params->handle = CreateEventW(NULL, FALSE, FALSE, NULL); - - TRACE("Calling apartment thread 0x%08x...\n", apt->tid); - - if (PostMessageW(apartment_getwindow(apt), DM_EXECUTERPC, 0, (LPARAM)params)) - WaitForSingleObject(params->handle, INFINITE); - else - { - ERR("PostMessage failed with error %u\n", GetLastError()); - IRpcChannelBuffer_Release(params->chan); - IRpcStubBuffer_Release(params->stub); - } - CloseHandle(params->handle); - } - else - { - BOOL joined = FALSE; - struct oletls *info = COM_CurrentInfo(); - - if (!info->apt) - { - enter_apartment(info, COINIT_MULTITHREADED); - joined = TRUE; - } - Internal_RPC_ExecuteCall(params); - if (joined) - { - leave_apartment(info); - } - } - - hr = params->hr; - if (params->chan) - IRpcChannelBuffer_Release(params->chan); - if (params->stub) - IRpcStubBuffer_Release(params->stub); - HeapFree(GetProcessHeap(), 0, params); - - stub_manager_int_release(stub_manager); - apartment_release(apt); - - /* if IRpcStubBuffer_Invoke fails, we should raise an exception to tell - * the RPC runtime that the call failed */ - if (hr != S_OK) RpcRaiseException(hr); -} - -/* stub registration */ -HRESULT WINAPI RPC_RegisterInterface(REFIID riid) -{ - struct registered_if *rif; - BOOL found = FALSE; - HRESULT hr = S_OK; - - TRACE("(%s)\n", debugstr_guid(riid)); - - EnterCriticalSection(&csRegIf); - LIST_FOR_EACH_ENTRY(rif, &registered_interfaces, struct registered_if, entry) - { - if (IsEqualGUID(&rif->If.InterfaceId.SyntaxGUID, riid)) - { - rif->refs++; - found = TRUE; - break; - } - } - if (!found) - { - TRACE("Creating new interface\n"); - - rif = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rif)); - if (rif) - { - RPC_STATUS status; - - rif->refs = 1; - rif->If.Length = sizeof(RPC_SERVER_INTERFACE); - /* RPC interface ID = COM interface ID */ - rif->If.InterfaceId.SyntaxGUID = *riid; - rif->If.DispatchTable = &rpc_dispatch; - /* all other fields are 0, including the version asCOM objects - * always have a version of 0.0 */ - status = RpcServerRegisterIfEx( - (RPC_IF_HANDLE)&rif->If, - NULL, NULL, - RPC_IF_OLE | RPC_IF_AUTOLISTEN, - RPC_C_LISTEN_MAX_CALLS_DEFAULT, - NULL); - if (status == RPC_S_OK) - list_add_tail(&registered_interfaces, &rif->entry); - else - { - ERR("RpcServerRegisterIfEx failed with error %d\n", status); - HeapFree(GetProcessHeap(), 0, rif); - hr = HRESULT_FROM_WIN32(status); - } - } - else - hr = E_OUTOFMEMORY; - } - LeaveCriticalSection(&csRegIf); - return hr; -} - -/* stub unregistration */ -void WINAPI RPC_UnregisterInterface(REFIID riid, BOOL wait) -{ - struct registered_if *rif; - EnterCriticalSection(&csRegIf); - LIST_FOR_EACH_ENTRY(rif, &registered_interfaces, struct registered_if, entry) - { - if (IsEqualGUID(&rif->If.InterfaceId.SyntaxGUID, riid)) - { - if (!--rif->refs) - { - RpcServerUnregisterIf((RPC_IF_HANDLE)&rif->If, NULL, wait); - list_remove(&rif->entry); - HeapFree(GetProcessHeap(), 0, rif); - } - break; - } - } - LeaveCriticalSection(&csRegIf); -} - -/* get the info for an OXID, including the IPID for the rem unknown interface - * and the string binding */ -HRESULT WINAPI RPC_ResolveOxid(OXID oxid, OXID_INFO *oxid_info) -{ - TRACE("%s\n", wine_dbgstr_longlong(oxid)); - - oxid_info->dwTid = 0; - oxid_info->dwPid = 0; - oxid_info->dwAuthnHint = RPC_C_AUTHN_LEVEL_NONE; - /* FIXME: this is a hack around not having an OXID resolver yet - - * this function should contact the machine's OXID resolver and then it - * should give us the IPID of the IRemUnknown interface */ - oxid_info->ipidRemUnknown.Data1 = 0xffffffff; - oxid_info->ipidRemUnknown.Data2 = 0xffff; - oxid_info->ipidRemUnknown.Data3 = 0xffff; - memcpy(oxid_info->ipidRemUnknown.Data4, &oxid, sizeof(OXID)); - oxid_info->psa = NULL /* FIXME */; - - return S_OK; -} - -/* make the apartment reachable by other threads and processes and create the - * IRemUnknown object */ -void WINAPI RPC_StartRemoting(struct apartment *apt) -{ - if (!InterlockedExchange(&apt->remoting_started, TRUE)) - { - WCHAR endpoint[200]; - RPC_STATUS status; - - get_rpc_endpoint(endpoint, &apt->oxid); - - status = RpcServerUseProtseqEpW( - wszRpcTransport, - RPC_C_PROTSEQ_MAX_REQS_DEFAULT, - endpoint, - NULL); - if (status != RPC_S_OK) - ERR("Couldn't register endpoint %s\n", debugstr_w(endpoint)); - - /* FIXME: move remote unknown exporting into this function */ - } - start_apartment_remote_unknown(apt); -} -- 2.23.0

1 0

[PATCH v2 3/5] combase: Move CoUnmarshalInterface().
by Huw Davies 01 Sep '20

01 Sep '20

1 0

[PATCH v2 2/5] combase: Move CoReleaseMarshalData().
by Huw Davies 01 Sep '20

01 Sep '20

From: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Nikolay Sivov <nsivov(a)codeweavers.com> Signed-off-by: Huw Davies <huw(a)codeweavers.com> --- dlls/combase/combase.spec | 2 +- dlls/combase/combase_private.h | 2 + dlls/combase/marshal.c | 141 +++++++++++++++++++++++++++++++++ dlls/ole32/marshal.c | 50 ------------ dlls/ole32/ole32.spec | 2 +- 5 files changed, 145 insertions(+), 52 deletions(-) diff --git a/dlls/combase/combase.spec b/dlls/combase/combase.spec index 4ac93ff545d..e1ffdc82539 100644 --- a/dlls/combase/combase.spec +++ b/dlls/combase/combase.spec @@ -146,7 +146,7 @@ @ stdcall CoRegisterPSClsid(ptr ptr) @ stdcall CoRegisterSurrogate(ptr) ole32.CoRegisterSurrogate @ stdcall CoRegisterSurrogateEx(ptr ptr) ole32.CoRegisterSurrogateEx -@ stdcall CoReleaseMarshalData(ptr) ole32.CoReleaseMarshalData +@ stdcall CoReleaseMarshalData(ptr) @ stdcall CoReleaseServerProcess() @ stdcall CoResumeClassObjects() ole32.CoResumeClassObjects @ stub CoRetireServer diff --git a/dlls/combase/combase_private.h b/dlls/combase/combase_private.h index 898d42b3c7b..cc1c3d34388 100644 --- a/dlls/combase/combase_private.h +++ b/dlls/combase/combase_private.h @@ -222,3 +222,5 @@ struct stub_manager * WINAPI get_stub_manager_from_object(struct apartment *apt, void stub_manager_disconnect(struct stub_manager *m) DECLSPEC_HIDDEN; ULONG WINAPI stub_manager_ext_addref(struct stub_manager *m, ULONG refs, BOOL tableweak) DECLSPEC_HIDDEN; ULONG WINAPI stub_manager_ext_release(struct stub_manager *m, ULONG refs, BOOL tableweak, BOOL last_unlock_releases) DECLSPEC_HIDDEN; +struct stub_manager * WINAPI get_stub_manager(struct apartment *apt, OID oid); +void WINAPI stub_manager_release_marshal_data(struct stub_manager *m, ULONG refs, const IPID *ipid, BOOL tableweak); diff --git a/dlls/combase/marshal.c b/dlls/combase/marshal.c index db5089f013e..bfe31ff17dd 100644 --- a/dlls/combase/marshal.c +++ b/dlls/combase/marshal.c @@ -29,6 +29,9 @@ WINE_DEFAULT_DEBUG_CHANNEL(ole); +/* private flag indicating that the object was marshaled as table-weak */ +#define SORFP_TABLEWEAK SORF_OXRES1 + struct ftmarshaler { IUnknown IUnknown_inner; @@ -507,3 +510,141 @@ cleanup: return hr; } + +/* Creates an IMarshal* object according to the data marshaled to the stream. + * The function leaves the stream pointer at the start of the data written + * to the stream by the IMarshal* object. + */ +static HRESULT get_unmarshaler_from_stream(IStream *stream, IMarshal **marshal, IID *iid) +{ + OBJREF objref; + HRESULT hr; + ULONG res; + + /* read common OBJREF header */ + hr = IStream_Read(stream, &objref, FIELD_OFFSET(OBJREF, u_objref), &res); + if (hr != S_OK || (res != FIELD_OFFSET(OBJREF, u_objref))) + { + ERR("Failed to read common OBJREF header, 0x%08x\n", hr); + return STG_E_READFAULT; + } + + /* sanity check on header */ + if (objref.signature != OBJREF_SIGNATURE) + { + ERR("Bad OBJREF signature 0x%08x\n", objref.signature); + return RPC_E_INVALID_OBJREF; + } + + if (iid) *iid = objref.iid; + + /* FIXME: handler marshaling */ + if (objref.flags & OBJREF_STANDARD) + { + TRACE("Using standard unmarshaling\n"); + *marshal = NULL; + return S_FALSE; + } + else if (objref.flags & OBJREF_CUSTOM) + { + ULONG custom_header_size = FIELD_OFFSET(OBJREF, u_objref.u_custom.pData) - + FIELD_OFFSET(OBJREF, u_objref.u_custom); + TRACE("Using custom unmarshaling\n"); + /* read constant sized OR_CUSTOM data from stream */ + hr = IStream_Read(stream, &objref.u_objref.u_custom, + custom_header_size, &res); + if (hr != S_OK || (res != custom_header_size)) + { + ERR("Failed to read OR_CUSTOM header, 0x%08x\n", hr); + return STG_E_READFAULT; + } + /* now create the marshaler specified in the stream */ + hr = CoCreateInstance(&objref.u_objref.u_custom.clsid, NULL, + CLSCTX_INPROC_SERVER, &IID_IMarshal, + (LPVOID*)marshal); + } + else + { + FIXME("Invalid or unimplemented marshaling type specified: %x\n", + objref.flags); + return RPC_E_INVALID_OBJREF; + } + + if (hr != S_OK) + ERR("Failed to create marshal, 0x%08x\n", hr); + + return hr; +} + +static HRESULT std_release_marshal_data(IStream *stream) +{ + struct stub_manager *stubmgr; + struct OR_STANDARD obj; + struct apartment *apt; + ULONG res; + HRESULT hr; + + hr = IStream_Read(stream, &obj, FIELD_OFFSET(struct OR_STANDARD, saResAddr.aStringArray), &res); + if (hr != S_OK) return STG_E_READFAULT; + + if (obj.saResAddr.wNumEntries) + { + ERR("unsupported size of DUALSTRINGARRAY\n"); + return E_NOTIMPL; + } + + TRACE("oxid = %s, oid = %s, ipid = %s\n", wine_dbgstr_longlong(obj.std.oxid), + wine_dbgstr_longlong(obj.std.oid), wine_dbgstr_guid(&obj.std.ipid)); + + if (!(apt = apartment_findfromoxid(obj.std.oxid))) + { + WARN("Could not map OXID %s to apartment object\n", + wine_dbgstr_longlong(obj.std.oxid)); + return RPC_E_INVALID_OBJREF; + } + + if (!(stubmgr = get_stub_manager(apt, obj.std.oid))) + { + apartment_release(apt); + ERR("could not map object ID to stub manager, oxid=%s, oid=%s\n", + wine_dbgstr_longlong(obj.std.oxid), wine_dbgstr_longlong(obj.std.oid)); + return RPC_E_INVALID_OBJREF; + } + + stub_manager_release_marshal_data(stubmgr, obj.std.cPublicRefs, &obj.std.ipid, obj.std.flags & SORFP_TABLEWEAK); + + stub_manager_int_release(stubmgr); + apartment_release(apt); + + return S_OK; +} + +/*********************************************************************** + * CoReleaseMarshalData (combase.@) + */ +HRESULT WINAPI CoReleaseMarshalData(IStream *stream) +{ + IMarshal *marshal; + HRESULT hr; + + TRACE("%p\n", stream); + + hr = get_unmarshaler_from_stream(stream, &marshal, NULL); + if (hr == S_FALSE) + { + hr = std_release_marshal_data(stream); + if (hr != S_OK) + ERR("StdMarshal ReleaseMarshalData failed with error %#x\n", hr); + return hr; + } + if (hr != S_OK) + return hr; + + /* call the helper object to do the releasing of marshal data */ + hr = IMarshal_ReleaseMarshalData(marshal, stream); + if (hr != S_OK) + ERR("IMarshal::ReleaseMarshalData failed with error %#x\n", hr); + + IMarshal_Release(marshal); + return hr; +} diff --git a/dlls/ole32/marshal.c b/dlls/ole32/marshal.c index 87017dbc922..e462c9ffd48 100644 --- a/dlls/ole32/marshal.c +++ b/dlls/ole32/marshal.c @@ -1837,56 +1837,6 @@ HRESULT WINAPI CoUnmarshalInterface(IStream *pStream, REFIID riid, LPVOID *ppv) return hr; } -/*********************************************************************** - * CoReleaseMarshalData [OLE32.@] - * - * Releases resources associated with an object that has been marshaled into - * a stream. - * - * PARAMS - * - * pStream [I] The stream that the object has been marshaled into. - * - * RETURNS - * Success: S_OK. - * Failure: HRESULT error code. - * - * NOTES - * - * Call this function to release resources associated with a normal or - * table-weak marshal that will not be unmarshaled, and all table-strong - * marshals when they are no longer needed. - * - * SEE ALSO - * CoMarshalInterface(), CoUnmarshalInterface(). - */ -HRESULT WINAPI CoReleaseMarshalData(IStream *pStream) -{ - HRESULT hr; - LPMARSHAL pMarshal; - - TRACE("(%p)\n", pStream); - - hr = get_unmarshaler_from_stream(pStream, &pMarshal, NULL); - if (hr == S_FALSE) - { - hr = std_release_marshal_data(pStream); - if (hr != S_OK) - ERR("StdMarshal ReleaseMarshalData failed with error 0x%08x\n", hr); - return hr; - } - if (hr != S_OK) - return hr; - - /* call the helper object to do the releasing of marshal data */ - hr = IMarshal_ReleaseMarshalData(pMarshal, pStream); - if (hr != S_OK) - ERR("IMarshal::ReleaseMarshalData failed with error 0x%08x\n", hr); - - IMarshal_Release(pMarshal); - return hr; -} - static HRESULT WINAPI StdMarshalCF_QueryInterface(LPCLASSFACTORY iface, REFIID riid, LPVOID *ppv) { diff --git a/dlls/ole32/ole32.spec b/dlls/ole32/ole32.spec index 972629ecb70..2ecfcf6b510 100644 --- a/dlls/ole32/ole32.spec +++ b/dlls/ole32/ole32.spec @@ -72,7 +72,7 @@ @ stdcall CoRegisterPSClsid(ptr ptr) combase.CoRegisterPSClsid @ stdcall CoRegisterSurrogate(ptr) @ stdcall CoRegisterSurrogateEx(ptr ptr) -@ stdcall CoReleaseMarshalData(ptr) +@ stdcall CoReleaseMarshalData(ptr) combase.CoReleaseMarshalData @ stdcall CoReleaseServerProcess() combase.CoReleaseServerProcess @ stdcall CoResumeClassObjects() @ stdcall CoRevertToSelf() combase.CoRevertToSelf -- 2.23.0

1 0

[PATCH] msvcirt: Implement ifstream.
by Arkadiusz Hiler 01 Sep '20

01 Sep '20

Based on the semi-stubs by Gijs Vermeulen. We need to check that calls to different methods translate correctly to modifications done on the internal filebuf - not all methods call their filebuf counterparts directly (see setbuf). Tested with Power Tab Editor and GraphCalc - the crashes are gone and loading saved files seems to work correctly. Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=22616 Wine-Bug: https://bugs.winehq.org/show_bug.cgi?id=30014 Signed-off-by: Arkadiusz Hiler <ahiler(a)codeweavers.com> --- dlls/msvcirt/msvcirt.c | 185 ++++++++++++++++++++++++++ dlls/msvcirt/msvcirt.spec | 72 +++++------ dlls/msvcirt/tests/msvcirt.c | 243 +++++++++++++++++++++++++++++++++++ dlls/msvcrt20/msvcrt20.spec | 72 +++++------ dlls/msvcrt40/msvcrt40.spec | 72 +++++------ 5 files changed, 536 insertions(+), 108 deletions(-) diff --git a/dlls/msvcirt/msvcirt.c b/dlls/msvcirt/msvcirt.c index f76eaf6d7ac..a54d86f7350 100644 --- a/dlls/msvcirt/msvcirt.c +++ b/dlls/msvcirt/msvcirt.c @@ -192,6 +192,8 @@ extern const vtable_ptr MSVCP_istream_vtable; extern const vtable_ptr MSVCP_istream_withassign_vtable; /* ??_7istrstream@@6B@ */ extern const vtable_ptr MSVCP_istrstream_vtable; +/* ??_7ifstream@@6B@ */ +extern const vtable_ptr MSVCP_ifstream_vtable; /* ??_7iostream@@6B@ */ extern const vtable_ptr MSVCP_iostream_vtable; /* ??_7strstream@@6B@ */ @@ -262,6 +264,8 @@ __ASM_BLOCK_BEGIN(vtables) VTABLE_ADD_FUNC(istream_vector_dtor)); __ASM_VTABLE(istrstream, VTABLE_ADD_FUNC(istream_vector_dtor)); + __ASM_VTABLE(ifstream, + VTABLE_ADD_FUNC(istream_vector_dtor)); __ASM_VTABLE(iostream, VTABLE_ADD_FUNC(iostream_vector_dtor)); __ASM_VTABLE(strstream, @@ -280,6 +284,7 @@ const int ostream_vbtable[] = {0, VBTABLE_ENTRY(ostream, FIELD_OFFSET(ostream, v /* ??_8istream@@7B@ */ /* ??_8istream_withassign@@7B@ */ /* ??_8istrstream@@7B@ */ +/* ??_8ifstream@@7B@ */ const int istream_vbtable[] = {0, VBTABLE_ENTRY(istream, FIELD_OFFSET(istream, vbtable), ios)}; /* ??_8iostream@@7Bistream@@@ */ /* ??_8stdiostream@@7Bistream@@@ */ @@ -305,6 +310,8 @@ DEFINE_RTTI_DATA2(istream_withassign, sizeof(istream), &istream_rtti_base_descriptor, &ios_rtti_base_descriptor, ".?AVistream_withassign@@") DEFINE_RTTI_DATA2(istrstream, sizeof(istream), &istream_rtti_base_descriptor, &ios_rtti_base_descriptor, ".?AVistrstream@@") +DEFINE_RTTI_DATA2(ifstream, sizeof(istream), + &istream_rtti_base_descriptor, &ios_rtti_base_descriptor, ".?AVifstream@@") DEFINE_RTTI_DATA4(iostream, sizeof(iostream), &istream_rtti_base_descriptor, &ios_rtti_base_descriptor, &ostream_rtti_base_descriptor, &ios_rtti_base_descriptor, ".?AViostream@@") @@ -3113,6 +3120,8 @@ istream* __thiscall istream_copy_ctor(istream *this, const istream *copy, BOOL v /* ??1istream_withassign@@UEAA@XZ */ /* ??1istrstream@@UAE@XZ */ /* ??1istrstream@@UEAA@XZ */ +/* ??1ifstream@@UAE@XZ */ +/* ??1ifstream@@UEAA@XZ */ DEFINE_THISCALL_WRAPPER(istream_dtor, 4) void __thiscall istream_dtor(ios *base) { @@ -3152,6 +3161,8 @@ istream* __thiscall istream_assign_sb(istream *this, streambuf *sb) /* ??4istream_withassign@@QEAAAEAVistream@@AEBV1@@Z */ /* ??4istrstream@@QAEAAV0@ABV0@@Z */ /* ??4istrstream@@QEAAAEAV0@AEBV0@@Z */ +/* ??4ifstream@@QAEAAV0@ABV0@@Z */ +/* ??4ifstream@@QEAAAEAV0@AEBV0@@Z */ DEFINE_THISCALL_WRAPPER(istream_assign, 8) istream* __thiscall istream_assign(istream *this, const istream *rhs) { @@ -3164,6 +3175,8 @@ istream* __thiscall istream_assign(istream *this, const istream *rhs) /* ??_Distream_withassign@@QEAAXXZ */ /* ??_Distrstream@@QAEXXZ */ /* ??_Distrstream@@QEAAXXZ */ +/* ??_Difstream@@QAEXXZ */ +/* ??_Difstream@@QEAAXXZ */ DEFINE_THISCALL_WRAPPER(istream_vbase_dtor, 4) void __thiscall istream_vbase_dtor(istream *this) { @@ -3178,6 +3191,7 @@ void __thiscall istream_vbase_dtor(istream *this) /* ??_Eistream@@UAEPAXI@Z */ /* ??_Eistream_withassign@@UAEPAXI@Z */ /* ??_Eistrstream@@UAEPAXI@Z */ +/* ??_Eifstream@@UAEPAXI@Z */ DEFINE_THISCALL_WRAPPER(istream_vector_dtor, 8) istream* __thiscall istream_vector_dtor(ios *base, unsigned int flags) { @@ -3203,6 +3217,7 @@ istream* __thiscall istream_vector_dtor(ios *base, unsigned int flags) /* ??_Gistream@@UAEPAXI@Z */ /* ??_Gistream_withassign@@UAEPAXI@Z */ /* ??_Gistrstream@@UAEPAXI@Z */ +/* ??_Gifstream@@UAEPAXI@Z */ DEFINE_THISCALL_WRAPPER(istream_scalar_dtor, 8) istream* __thiscall istream_scalar_dtor(ios *base, unsigned int flags) { @@ -4089,6 +4104,175 @@ char* __thiscall istrstream_str(istream *this) return strstreambuf_str(istrstream_rdbuf(this)); } +/* ??0ifstream@@QAE@ABV0@@Z */ +/* ??0ifstream@@QEAA@AEBV0@@Z */ +DEFINE_THISCALL_WRAPPER(ifstream_copy_ctor, 12) +istream* __thiscall ifstream_copy_ctor(istream *this, const istream *copy, BOOL virt_init) +{ + TRACE("(%p %p %d)\n", this, copy, virt_init); + + istream_withassign_copy_ctor(this, copy, virt_init); + istream_get_ios(this)->vtable = &MSVCP_ifstream_vtable; + + return this; +} + +/* ??0ifstream@@QAE@HPADH@Z */ +/* ??0ifstream@@QEAA@HPEADH@Z */ +DEFINE_THISCALL_WRAPPER(ifstream_buffer_ctor, 20) +istream* __thiscall ifstream_buffer_ctor(istream *this, filedesc fd, char *buffer, int length, BOOL virt_init) +{ + ios *base; + filebuf *fb = MSVCRT_operator_new(sizeof(filebuf)); + + TRACE("(%p %d %p %d %d)\n", this, fd, buffer, length, virt_init); + + if (fb) + { + filebuf_fd_reserve_ctor(fb, fd, buffer, length); + istream_sb_ctor(this, &fb->base, virt_init); + } + else + istream_ctor(this, virt_init); + + base = istream_get_ios(this); + base->vtable = &MSVCP_ifstream_vtable; + base->delbuf = 1; + + return this; +} + +/* ??0ifstream@@QAE@H@Z */ +/* ??0ifstream@@QEAA@H@Z */ +DEFINE_THISCALL_WRAPPER(ifstream_fd_ctor, 12) +istream* __thiscall ifstream_fd_ctor(istream *this, filedesc fd, BOOL virt_init) +{ + ios *base; + filebuf *fb = MSVCRT_operator_new(sizeof(filebuf)); + + TRACE("(%p %d %d)\n", this, fd, virt_init); + + if (fb) + { + filebuf_fd_ctor(fb, fd); + istream_sb_ctor(this, &fb->base, virt_init); + } + else + istream_ctor(this, virt_init); + + base = istream_get_ios(this); + base->vtable = &MSVCP_ifstream_vtable; + base->delbuf = 1; + + return this; +} + +/* ??0ifstream@@QAE@PBDHH@Z */ +/* ??0ifstream@@QEAA@PEBDHH@Z */ +DEFINE_THISCALL_WRAPPER(ifstream_open_ctor, 20) +istream* __thiscall ifstream_open_ctor(istream *this, const char *name, ios_open_mode mode, int protection, BOOL virt_init) +{ + ios *base; + filebuf *fb = MSVCRT_operator_new(sizeof(filebuf)); + + TRACE("(%p %s %d %d %d)\n", this, name, mode, protection, virt_init); + + if (fb) + { + filebuf_ctor(fb); + istream_sb_ctor(this, &fb->base, virt_init); + filebuf_open(fb, name, mode, protection); + } + else + istream_ctor(this, virt_init); + + base = istream_get_ios(this); + base->vtable = &MSVCP_ifstream_vtable; + base->delbuf = 1; + + return this; +} + +/* ??0ifstream@@QAE@XZ */ +/* ??0ifstream@@QEAA@XZ */ +DEFINE_THISCALL_WRAPPER(ifstream_ctor, 8) +istream* __thiscall ifstream_ctor(istream *this, BOOL virt_init) +{ + return ifstream_fd_ctor(this, -1, virt_init); +} + +/* ?rdbuf@ifstream@@QBEPAVfilebuf@@XZ */ +/* ?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ */ +DEFINE_THISCALL_WRAPPER(ifstream_rdbuf, 4) +filebuf* __thiscall ifstream_rdbuf(const istream *this) +{ + TRACE("(%p)\n", this); + return (filebuf*) istream_get_ios(this)->sb; +} + +/* ?fd@ifstream@@QBEHXZ */ +/* ?fd@ifstream@@QEBAHXZ */ +DEFINE_THISCALL_WRAPPER(ifstream_fd, 4) +filedesc __thiscall ifstream_fd(istream *this) +{ + TRACE("(%p)\n", this); + return filebuf_fd(ifstream_rdbuf(this)); +} + +/* ?attach@ifstream@@QAEXH@Z */ +/* ?attach@ifstream@@QEAAXH@Z */ +DEFINE_THISCALL_WRAPPER(ifstream_attach, 8) +void __thiscall ifstream_attach(istream *this, filedesc fd) +{ + TRACE("(%p %d)\n", this, fd); + filebuf_attach(ifstream_rdbuf(this), fd); +} + +/* ?close@ifstream@@QAEXXZ */ +/* ?close@ifstream@@QEAAXXZ */ +DEFINE_THISCALL_WRAPPER(ifstream_close, 4) +void __thiscall ifstream_close(istream *this) +{ + TRACE("(%p)\n", this); + filebuf_close(ifstream_rdbuf(this)); +} + +/* ?is_open@ifstream@@QBEHXZ */ +/* ?is_open@ifstream@@QEBAHXZ */ +DEFINE_THISCALL_WRAPPER(ifstream_is_open, 4) +int __thiscall ifstream_is_open(const istream *this) +{ + TRACE("(%p)\n", this); + return filebuf_is_open(ifstream_rdbuf(this)); +} + +/* ?open@ifstream@@QAEXPBDHH@Z */ +/* ?open@ifstream@@QEAAXPEBDHH@Z */ +DEFINE_THISCALL_WRAPPER(ifstream_open, 16) +void __thiscall ifstream_open(istream *this, const char *name, ios_open_mode mode, int protection) +{ + TRACE("(%p %s %d %d)\n", this, name, mode, protection); + filebuf_open(ifstream_rdbuf(this), name, mode, protection); +} + +/* ?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z */ +/* ?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z */ +DEFINE_THISCALL_WRAPPER(ifstream_setbuf, 12) +streambuf* __thiscall ifstream_setbuf(istream *this, char *buffer, int length) +{ + TRACE("(%p %p %d)\n", this, buffer, length); + return NULL; +} + +/* ?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z */ +/* ?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z */ +DEFINE_THISCALL_WRAPPER(ifstream_setmode, 8) +int __thiscall ifstream_setmode(istream *this, int mode) +{ + TRACE("(%p %d)\n", this, mode); + return filebuf_setmode(ifstream_rdbuf(this), mode); +} + static inline ios* iostream_to_ios(const iostream *this) { return (ios*)((char*)this + iostream_vbtable_istream[1]); @@ -4522,6 +4706,7 @@ static void init_io(void *base) init_istream_rtti(base); init_istream_withassign_rtti(base); init_istrstream_rtti(base); + init_ifstream_rtti(base); init_iostream_rtti(base); init_strstream_rtti(base); init_stdiostream_rtti(base); diff --git a/dlls/msvcirt/msvcirt.spec b/dlls/msvcirt/msvcirt.spec index f2e875695ef..c2b4b9d30eb 100644 --- a/dlls/msvcirt/msvcirt.spec +++ b/dlls/msvcirt/msvcirt.spec @@ -26,16 +26,16 @@ @ stub -arch=win64 ??0fstream@@QEAA@PEBDHH@Z @ stub -arch=win32 ??0fstream@@QAE@XZ # __thiscall fstream::fstream(void) @ stub -arch=win64 ??0fstream@@QEAA@XZ -@ stub -arch=win32 ??0ifstream@@QAE@ABV0@@Z # __thiscall ifstream::ifstream(class ifstream const &) -@ stub -arch=win64 ??0ifstream@@QEAA@AEBV0@@Z -@ stub -arch=win32 ??0ifstream@@QAE@H@Z # __thiscall ifstream::ifstream(int) -@ stub -arch=win64 ??0ifstream@@QEAA@H@Z -@ stub -arch=win32 ??0ifstream@@QAE@HPADH@Z # __thiscall ifstream::ifstream(int,char *,int) -@ stub -arch=win64 ??0ifstream@@QEAA@HPEADH@Z -@ stub -arch=win32 ??0ifstream@@QAE@PBDHH@Z # __thiscall ifstream::ifstream(char const *,int,int) -@ stub -arch=win64 ??0ifstream@@QEAA@PEBDHH@Z -@ stub -arch=win32 ??0ifstream@@QAE@XZ # __thiscall ifstream::ifstream(void) -@ stub -arch=win64 ??0ifstream@@QEAA@XZ +@ thiscall -arch=win32 ??0ifstream@@QAE@ABV0@@Z(ptr ptr long) ifstream_copy_ctor +@ cdecl -arch=win64 ??0ifstream@@QEAA@AEBV0@@Z(ptr ptr long) ifstream_copy_ctor +@ thiscall -arch=win32 ??0ifstream@@QAE@H@Z(ptr long long) ifstream_fd_ctor +@ cdecl -arch=win64 ??0ifstream@@QEAA@H@Z(ptr long long) ifstream_fd_ctor +@ thiscall -arch=win32 ??0ifstream@@QAE@HPADH@Z(ptr long ptr long long) ifstream_buffer_ctor +@ cdecl -arch=win64 ??0ifstream@@QEAA@HPEADH@Z(ptr long ptr long long) ifstream_buffer_ctor +@ thiscall -arch=win32 ??0ifstream@@QAE@PBDHH@Z(ptr str long long long) ifstream_open_ctor +@ cdecl -arch=win64 ??0ifstream@@QEAA@PEBDHH@Z(ptr str long long long) ifstream_open_ctor +@ thiscall -arch=win32 ??0ifstream@@QAE@XZ(ptr long) ifstream_ctor +@ cdecl -arch=win64 ??0ifstream@@QEAA@XZ(ptr long) ifstream_ctor @ thiscall -arch=win32 ??0ios@@IAE@ABV0@@Z(ptr ptr) ios_copy_ctor @ cdecl -arch=win64 ??0ios@@IEAA@AEBV0@@Z(ptr ptr) ios_copy_ctor @ thiscall -arch=win32 ??0ios@@IAE@XZ(ptr) ios_ctor @@ -138,8 +138,8 @@ @ cdecl -arch=win64 ??1filebuf@@UEAA@XZ(ptr) filebuf_dtor @ stub -arch=win32 ??1fstream@@UAE@XZ # virtual __thiscall fstream::~fstream(void) @ stub -arch=win64 ??1fstream@@UEAA@XZ -@ stub -arch=win32 ??1ifstream@@UAE@XZ # virtual __thiscall ifstream::~ifstream(void) -@ stub -arch=win64 ??1ifstream@@UEAA@XZ +@ thiscall -arch=win32 ??1ifstream@@UAE@XZ(ptr) istream_dtor +@ cdecl -arch=win64 ??1ifstream@@UEAA@XZ(ptr) istream_dtor @ thiscall -arch=win32 ??1ios@@UAE@XZ(ptr) ios_dtor @ cdecl -arch=win64 ??1ios@@UEAA@XZ(ptr) ios_dtor @ thiscall -arch=win32 ??1iostream@@UAE@XZ(ptr) iostream_dtor @@ -178,8 +178,8 @@ @ cdecl -arch=win64 ??4filebuf@@QEAAAEAV0@AEBV0@@Z(ptr ptr) filebuf_assign @ stub -arch=win32 ??4fstream@@QAEAAV0@AAV0@@Z # class fstream & __thiscall fstream::operator=(class fstream &) @ stub -arch=win64 ??4fstream@@QEAAAEAV0@AEAV0@@Z -@ stub -arch=win32 ??4ifstream@@QAEAAV0@ABV0@@Z # class ifstream & __thiscall ifstream::operator=(class ifstream const &) -@ stub -arch=win64 ??4ifstream@@QEAAAEAV0@AEBV0@@Z +@ thiscall -arch=win32 ??4ifstream@@QAEAAV0@ABV0@@Z(ptr ptr) istream_assign +@ cdecl -arch=win64 ??4ifstream@@QEAAAEAV0@AEBV0@@Z(ptr ptr) istream_assign @ thiscall -arch=win32 ??4ios@@IAEAAV0@ABV0@@Z(ptr ptr) ios_assign @ cdecl -arch=win64 ??4ios@@IEAAAEAV0@AEBV0@@Z(ptr ptr) ios_assign @ thiscall -arch=win32 ??4iostream@@IAEAAV0@AAV0@@Z(ptr ptr) iostream_assign @@ -305,7 +305,7 @@ @ extern ??_7exception@@6B@ MSVCP_exception_vtable @ extern ??_7filebuf@@6B@ MSVCP_filebuf_vtable # @ extern ??_7fstream@@6B@ # const fstream::`vftable' -# @ extern ??_7ifstream@@6B@ # const ifstream::`vftable' +@ extern ??_7ifstream@@6B@ MSVCP_ifstream_vtable @ extern ??_7ios@@6B@ MSVCP_ios_vtable @ extern ??_7iostream@@6B@ MSVCP_iostream_vtable @ extern ??_7istream@@6B@ MSVCP_istream_vtable @@ -323,7 +323,7 @@ @ extern ??_7strstreambuf@@6B@ MSVCP_strstreambuf_vtable # @ extern ??_8fstream@@7Bistream@@@ # const fstream::`vbtable'{for `istream'} # @ extern ??_8fstream@@7Bostream@@@ # const fstream::`vbtable'{for `ostream'} -# @ extern ??_8ifstream@@7B@ # const ifstream::`vbtable' +@ extern ??_8ifstream@@7B@ istream_vbtable @ extern ??_8iostream@@7Bistream@@@ iostream_vbtable_istream @ extern ??_8iostream@@7Bostream@@@ iostream_vbtable_ostream @ extern ??_8istream@@7B@ istream_vbtable @@ -339,8 +339,8 @@ @ extern ??_8strstream@@7Bostream@@@ iostream_vbtable_ostream @ stub -arch=win32 ??_Dfstream@@QAEXXZ # void __thiscall fstream::`vbase destructor'(void) @ stub -arch=win64 ??_Dfstream@@QEAAXXZ -@ stub -arch=win32 ??_Difstream@@QAEXXZ # void __thiscall ifstream::`vbase destructor'(void) -@ stub -arch=win64 ??_Difstream@@QEAAXXZ +@ thiscall -arch=win32 ??_Difstream@@QAEXXZ(ptr) istream_vbase_dtor +@ cdecl -arch=win64 ??_Difstream@@QEAAXXZ(ptr) istream_vbase_dtor @ thiscall -arch=win32 ??_Diostream@@QAEXXZ(ptr) iostream_vbase_dtor @ cdecl -arch=win64 ??_Diostream@@QEAAXXZ(ptr) iostream_vbase_dtor @ thiscall -arch=win32 ??_Distream@@QAEXXZ(ptr) istream_vbase_dtor @@ -364,7 +364,7 @@ @ thiscall -arch=win32 ??_Eexception@@UAEPAXI@Z(ptr long) MSVCP_exception_vector_dtor @ thiscall -arch=win32 ??_Efilebuf@@UAEPAXI@Z(ptr long) filebuf_vector_dtor @ stub -arch=win32 ??_Efstream@@UAEPAXI@Z # virtual void * __thiscall fstream::`vector deleting destructor'(unsigned int) -@ stub -arch=win32 ??_Eifstream@@UAEPAXI@Z # virtual void * __thiscall ifstream::`vector deleting destructor'(unsigned int) +@ thiscall -arch=win32 ??_Eifstream@@UAEPAXI@Z(ptr long) istream_vector_dtor @ thiscall -arch=win32 ??_Eios@@UAEPAXI@Z(ptr long) ios_vector_dtor @ thiscall -arch=win32 ??_Eiostream@@UAEPAXI@Z(ptr long) iostream_vector_dtor @ thiscall -arch=win32 ??_Eistream@@UAEPAXI@Z(ptr long) istream_vector_dtor @@ -383,7 +383,7 @@ @ thiscall -arch=win32 ??_Gexception@@UAEPAXI@Z(ptr long) MSVCP_exception_scalar_dtor @ thiscall -arch=win32 ??_Gfilebuf@@UAEPAXI@Z(ptr long) filebuf_scalar_dtor @ stub -arch=win32 ??_Gfstream@@UAEPAXI@Z # virtual void * __thiscall fstream::`scalar deleting destructor'(unsigned int) -@ stub -arch=win32 ??_Gifstream@@UAEPAXI@Z # virtual void * __thiscall ifstream::`scalar deleting destructor'(unsigned int) +@ thiscall -arch=win32 ??_Gifstream@@UAEPAXI@Z(ptr long) istream_scalar_dtor @ thiscall -arch=win32 ??_Gios@@UAEPAXI@Z(ptr long) ios_scalar_dtor @ thiscall -arch=win32 ??_Giostream@@UAEPAXI@Z(ptr long) iostream_scalar_dtor @ thiscall -arch=win32 ??_Gistream@@UAEPAXI@Z(ptr long) istream_scalar_dtor @@ -406,8 +406,8 @@ @ cdecl -arch=win64 ?attach@filebuf@@QEAAPEAV1@H@Z(ptr long) filebuf_attach @ stub -arch=win32 ?attach@fstream@@QAEXH@Z # void __thiscall fstream::attach(int) @ stub -arch=win64 ?attach@fstream@@QEAAXH@Z -@ stub -arch=win32 ?attach@ifstream@@QAEXH@Z # void __thiscall ifstream::attach(int) -@ stub -arch=win64 ?attach@ifstream@@QEAAXH@Z +@ thiscall -arch=win32 ?attach@ifstream@@QAEXH@Z(ptr long) ifstream_attach +@ cdecl -arch=win64 ?attach@ifstream@@QEAAXH@Z(ptr long) ifstream_attach @ stub -arch=win32 ?attach@ofstream@@QAEXH@Z # void __thiscall ofstream::attach(int) @ stub -arch=win64 ?attach@ofstream@@QEAAXH@Z @ thiscall -arch=win32 ?bad@ios@@QBEHXZ(ptr) ios_bad @@ -428,8 +428,8 @@ @ cdecl -arch=win64 ?close@filebuf@@QEAAPEAV1@XZ(ptr) filebuf_close @ stub -arch=win32 ?close@fstream@@QAEXXZ # void __thiscall fstream::close(void) @ stub -arch=win64 ?close@fstream@@QEAAXXZ -@ stub -arch=win32 ?close@ifstream@@QAEXXZ # void __thiscall ifstream::close(void) -@ stub -arch=win64 ?close@ifstream@@QEAAXXZ +@ thiscall -arch=win32 ?close@ifstream@@QAEXXZ(ptr) ifstream_close +@ cdecl -arch=win64 ?close@ifstream@@QEAAXXZ(ptr) ifstream_close @ stub -arch=win32 ?close@ofstream@@QAEXXZ # void __thiscall ofstream::close(void) @ stub -arch=win64 ?close@ofstream@@QEAAXXZ @ cdecl -arch=win32 ?clrlock@ios@@QAAXXZ(ptr) ios_clrlock @@ -472,8 +472,8 @@ @ cdecl -arch=win64 ?fd@filebuf@@QEBAHXZ(ptr) filebuf_fd @ stub -arch=win32 ?fd@fstream@@QBEHXZ # int __thiscall fstream::fd(void)const @ stub -arch=win64 ?fd@fstream@@QEBAHXZ -@ stub -arch=win32 ?fd@ifstream@@QBEHXZ # int __thiscall ifstream::fd(void)const -@ stub -arch=win64 ?fd@ifstream@@QEBAHXZ +@ thiscall -arch=win32 ?fd@ifstream@@QBEHXZ(ptr) ifstream_fd +@ cdecl -arch=win64 ?fd@ifstream@@QEBAHXZ(ptr) ifstream_fd @ stub -arch=win32 ?fd@ofstream@@QBEHXZ # int __thiscall ofstream::fd(void)const @ stub -arch=win64 ?fd@ofstream@@QEBAHXZ @ thiscall -arch=win32 ?fill@ios@@QAEDD@Z(ptr long) ios_fill_set @@ -541,8 +541,8 @@ @ cdecl -arch=win64 ?is_open@filebuf@@QEBAHXZ(ptr) filebuf_is_open @ stub -arch=win32 ?is_open@fstream@@QBEHXZ # int __thiscall fstream::is_open(void)const @ stub -arch=win64 ?is_open@fstream@@QEBAHXZ -@ stub -arch=win32 ?is_open@ifstream@@QBEHXZ # int __thiscall ifstream::is_open(void)const -@ stub -arch=win64 ?is_open@ifstream@@QEBAHXZ +@ thiscall -arch=win32 ?is_open@ifstream@@QBEHXZ(ptr) ifstream_is_open +@ cdecl -arch=win64 ?is_open@ifstream@@QEBAHXZ(ptr) ifstream_is_open @ stub -arch=win32 ?is_open@ofstream@@QBEHXZ # int __thiscall ofstream::is_open(void)const @ stub -arch=win64 ?is_open@ofstream@@QEBAHXZ @ thiscall -arch=win32 ?isfx@istream@@QAEXXZ(ptr) istream_isfx @@ -566,8 +566,8 @@ @ cdecl -arch=win64 ?open@filebuf@@QEAAPEAV1@PEBDHH@Z(ptr str long long) filebuf_open @ stub -arch=win32 ?open@fstream@@QAEXPBDHH@Z # void __thiscall fstream::open(char const *,int,int) @ stub -arch=win64 ?open@fstream@@QEAAXPEBDHH@Z -@ stub -arch=win32 ?open@ifstream@@QAEXPBDHH@Z # void __thiscall ifstream::open(char const *,int,int) -@ stub -arch=win64 ?open@ifstream@@QEAAXPEBDHH@Z +@ thiscall -arch=win32 ?open@ifstream@@QAEXPBDHH@Z(ptr str long long) ifstream_open +@ cdecl -arch=win64 ?open@ifstream@@QEAAXPEBDHH@Z(ptr str long long) ifstream_open @ stub -arch=win32 ?open@ofstream@@QAEXPBDHH@Z # void __thiscall ofstream::open(char const *,int,int) @ stub -arch=win64 ?open@ofstream@@QEAAXPEBDHH@Z @ extern ?openprot@filebuf@@2HB filebuf_openprot @@ -615,8 +615,8 @@ @ cdecl -arch=win64 ?pword@ios@@QEBAAEAPEAXH@Z(ptr long) ios_pword @ stub -arch=win32 ?rdbuf@fstream@@QBEPAVfilebuf@@XZ # class filebuf * __thiscall fstream::rdbuf(void)const @ stub -arch=win64 ?rdbuf@fstream@@QEBAPEAVfilebuf@@XZ -@ stub -arch=win32 ?rdbuf@ifstream@@QBEPAVfilebuf@@XZ # class filebuf * __thiscall ifstream::rdbuf(void)const -@ stub -arch=win64 ?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ +@ thiscall -arch=win32 ?rdbuf@ifstream@@QBEPAVfilebuf@@XZ(ptr) ifstream_rdbuf +@ cdecl -arch=win64 ?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ(ptr) ifstream_rdbuf @ thiscall -arch=win32 ?rdbuf@ios@@QBEPAVstreambuf@@XZ(ptr) ios_rdbuf @ cdecl -arch=win64 ?rdbuf@ios@@QEBAPEAVstreambuf@@XZ(ptr) ios_rdbuf @ thiscall -arch=win32 ?rdbuf@istrstream@@QBEPAVstrstreambuf@@XZ(ptr) istrstream_rdbuf @@ -663,8 +663,8 @@ @ cdecl -arch=win64 ?setbuf@filebuf@@UEAAPEAVstreambuf@@PEADH@Z(ptr ptr long) filebuf_setbuf @ stub -arch=win32 ?setbuf@fstream@@QAEPAVstreambuf@@PADH@Z # class streambuf * __thiscall fstream::setbuf(char *,int) @ stub -arch=win64 ?setbuf@fstream@@QEAAPEAVstreambuf@@PEADH@Z -@ stub -arch=win32 ?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z # class streambuf * __thiscall ifstream::setbuf(char *,int) -@ stub -arch=win64 ?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z +@ thiscall -arch=win32 ?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z(ptr ptr long) ifstream_setbuf +@ cdecl -arch=win64 ?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z(ptr ptr long) ifstream_setbuf @ stub -arch=win32 ?setbuf@ofstream@@QAEPAVstreambuf@@PADH@Z # class streambuf * __thiscall ofstream::setbuf(char *,int) @ stub -arch=win64 ?setbuf@ofstream@@QEAAPEAVstreambuf@@PEADH@Z @ thiscall -arch=win32 ?setbuf@streambuf@@UAEPAV1@PADH@Z(ptr ptr long) streambuf_setbuf @@ -685,8 +685,8 @@ @ cdecl -arch=win64 ?setmode@filebuf@@QEAAHH@Z(ptr long) filebuf_setmode @ stub -arch=win32 ?setmode@fstream@@QAEHH@Z # int __thiscall fstream::setmode(int) @ stub -arch=win64 ?setmode@fstream@@QEAAHH@Z -@ stub -arch=win32 ?setmode@ifstream@@QAEHH@Z # int __thiscall ifstream::setmode(int) -@ stub -arch=win64 ?setmode@ifstream@@QEAAHH@Z +@ thiscall -arch=win32 ?setmode@ifstream@@QAEHH@Z(ptr long) ifstream_setmode +@ cdecl -arch=win64 ?setmode@ifstream@@QEAAHH@Z(ptr long) ifstream_setmode @ stub -arch=win32 ?setmode@ofstream@@QAEHH@Z # int __thiscall ofstream::setmode(int) @ stub -arch=win64 ?setmode@ofstream@@QEAAHH@Z @ thiscall -arch=win32 ?setp@streambuf@@IAEXPAD0@Z(ptr ptr ptr) streambuf_setp diff --git a/dlls/msvcirt/tests/msvcirt.c b/dlls/msvcirt/tests/msvcirt.c index 6440bc0dab7..06688a91c06 100644 --- a/dlls/msvcirt/tests/msvcirt.c +++ b/dlls/msvcirt/tests/msvcirt.c @@ -23,6 +23,7 @@ #include <stdio.h> #include <windef.h> #include <winbase.h> +#include <sys/stat.h> #include "wine/test.h" typedef void (*vtable_ptr)(void); @@ -403,6 +404,23 @@ static void (*__thiscall p_iostream_vbase_dtor)(iostream*); static iostream* (*__thiscall p_iostream_assign_sb)(iostream*, streambuf*); static iostream* (*__thiscall p_iostream_assign)(iostream*, const iostream*); +/* ifstream */ +static istream* (*__thiscall p_ifstream_copy_ctor)(istream*, const istream*, BOOL); +static istream* (*__thiscall p_ifstream_buffer_ctor)(istream*, filedesc, char*, int, BOOL); +static istream* (*__thiscall p_ifstream_fd_ctor)(istream*, filedesc fd, BOOL virt_init); +static istream* (*__thiscall p_ifstream_open_ctor)(istream*, const char *name, ios_open_mode, int, BOOL); +static istream* (*__thiscall p_ifstream_ctor)(istream*, BOOL); +static void (*__thiscall p_ifstream_dtor)(ios*); +static void (*__thiscall p_ifstream_vbase_dtor)(istream*); +static void (*__thiscall p_ifstream_attach)(istream*, filedesc); +static void (*__thiscall p_ifstream_close)(istream*); +static filedesc (*__thiscall p_ifstream_fd)(istream*); +static int (*__thiscall p_ifstream_is_open)(const istream*); +static void (*__thiscall p_ifstream_open)(istream*, const char*, ios_open_mode, int); +static filebuf* (*__thiscall p_ifstream_rdbuf)(const istream*); +static streambuf* (*__thiscall p_ifstream_setbuf)(istream*, char*, int); +static int (*__thiscall p_ifstream_setmode)(istream*, int); + /* strstream */ static iostream* (*__thiscall p_strstream_copy_ctor)(iostream*, const iostream*, BOOL); static iostream* (*__thiscall p_strstream_buffer_ctor)(iostream*, char*, int, int, BOOL); @@ -703,6 +721,22 @@ static BOOL init(void) SET(p_iostream_assign_sb, "??4iostream@@IEAAAEAV0@PEAVstreambuf@@@Z"); SET(p_iostream_assign, "??4iostream@@IEAAAEAV0@AEAV0@@Z"); + SET(p_ifstream_copy_ctor, "??0ifstream@@QEAA@AEBV0@@Z"); + SET(p_ifstream_buffer_ctor, "??0ifstream@@QEAA@HPEADH@Z"); + SET(p_ifstream_fd_ctor, "??0ifstream@@QEAA@H@Z"); + SET(p_ifstream_open_ctor, "??0ifstream@@QEAA@PEBDHH@Z"); + SET(p_ifstream_ctor, "??0ifstream@@QEAA@XZ"); + SET(p_ifstream_dtor, "??1ifstream@@UEAA@XZ"); + SET(p_ifstream_vbase_dtor, "??_Difstream@@QEAAXXZ"); + SET(p_ifstream_attach, "?attach@ifstream@@QEAAXH@Z"); + SET(p_ifstream_close, "?close@ifstream@@QEAAXXZ"); + SET(p_ifstream_fd, "?fd@ifstream@@QEBAHXZ"); + SET(p_ifstream_is_open, "?is_open@ifstream@@QEBAHXZ"); + SET(p_ifstream_open, "?open@ifstream@@QEAAXPEBDHH@Z"); + SET(p_ifstream_rdbuf, "?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ"); + SET(p_ifstream_setbuf, "?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z"); + SET(p_ifstream_setmode, "?setmode@ifstream@@QEAAHH@Z"); + SET(p_strstream_copy_ctor, "??0strstream@@QEAA@AEBV0@@Z"); SET(p_strstream_buffer_ctor, "??0strstream@@QEAA@PEADHH@Z"); SET(p_strstream_ctor, "??0strstream@@QEAA@XZ"); @@ -917,6 +951,22 @@ static BOOL init(void) SET(p_iostream_assign_sb, "??4iostream@@IAEAAV0@PAVstreambuf@@@Z"); SET(p_iostream_assign, "??4iostream@@IAEAAV0@AAV0@@Z"); + SET(p_ifstream_copy_ctor, "??0ifstream@@QAE@ABV0@@Z"); + SET(p_ifstream_fd_ctor, "??0ifstream@@QAE@H@Z"); + SET(p_ifstream_buffer_ctor, "??0ifstream@@QAE@HPADH@Z"); + SET(p_ifstream_open_ctor, "??0ifstream@@QAE@PBDHH@Z"); + SET(p_ifstream_ctor, "??0ifstream@@QAE@XZ"); + SET(p_istrstream_dtor, "??1ifstream@@UAE@XZ"); + SET(p_istrstream_vbase_dtor, "??_Difstream@@QAEXXZ"); + SET(p_ifstream_attach, "?attach@ifstream@@QAEXH@Z"); + SET(p_ifstream_close, "?close@ifstream@@QAEXXZ"); + SET(p_ifstream_fd, "?fd@ifstream@@QBEHXZ"); + SET(p_ifstream_is_open, "?is_open@ifstream@@QBEHXZ"); + SET(p_ifstream_open, "?open@ifstream@@QAEXPBDHH@Z"); + SET(p_ifstream_rdbuf, "?rdbuf@ifstream@@QBEPAVfilebuf@@XZ"); + SET(p_ifstream_setbuf, "?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z"); + SET(p_ifstream_setmode, "?setmode@ifstream@@QAEHH@Z"); + SET(p_strstream_copy_ctor, "??0strstream@@QAE@ABV0@@Z"); SET(p_strstream_buffer_ctor, "??0strstream@@QAE@PADHH@Z"); SET(p_strstream_ctor, "??0strstream@@QAE@XZ"); @@ -6720,6 +6770,198 @@ static void test_iostream(void) ok(ios2.base_ios.do_lock == 0xcdcdcdcd, "expected %d got %d\n", 0xcdcdcdcd, ios2.base_ios.do_lock); } +static void test_ifstream(void) +{ + const char *filename = "ifstream_test"; + istream ifs, ifs_copy, *pifs; + streambuf *psb; + filebuf *pfb; + char buffer[64]; + char st[8]; + int fd, ret, i; + + memset(&ifs, 0xab, sizeof(istream)); + + /* constructors/destructors */ + pifs = call_func2(p_ifstream_ctor, &ifs, TRUE); + pfb = (filebuf*) ifs.base_ios.sb; + ok(pifs == &ifs, "wrong return, expected %p got %p\n", &ifs, pifs); + ok(ifs.extract_delim == 0, "expected 0 got %d\n", ifs.extract_delim); + ok(ifs.count == 0, "expected 0 got %d\n", ifs.count); + ok(ifs.base_ios.sb != NULL, "expected not %p got %p\n", NULL, ifs.base_ios.sb); + ok(ifs.base_ios.state == IOSTATE_goodbit, "expected %d got %d\n", IOSTATE_goodbit, ifs.base_ios.state); + ok(ifs.base_ios.delbuf == 1, "expected 1 got %d\n", ifs.base_ios.delbuf); + ok(ifs.base_ios.tie == NULL, "expected %p got %p\n", NULL, ifs.base_ios.tie); + ok(ifs.base_ios.flags == FLAGS_skipws, "expected %x got %x\n", FLAGS_skipws, ifs.base_ios.flags); + ok(ifs.base_ios.precision == 6, "expected 6 got %d\n", ifs.base_ios.precision); + ok(ifs.base_ios.fill == ' ', "expected 32 got %d\n", ifs.base_ios.fill); + ok(ifs.base_ios.width == 0, "expected 0 got %d\n", ifs.base_ios.width); + ok(ifs.base_ios.do_lock == -1, "expected -1 got %d\n", ifs.base_ios.do_lock); + ok(pfb->fd == -1, "wrong fd, expected -1 got %d\n", pfb->fd); + ok(pfb->close == 0, "wrong value, expected 0 got %d\n", pfb->close); + ok(pfb->base.allocated == 0, "wrong allocate value, expected 0 got %d\n", pfb->base.allocated); + ok(pfb->base.unbuffered == 0, "wrong unbuffered value, expected 0 got %d\n", pfb->base.unbuffered); + ok(pfb->base.base == NULL, "wrong buffer, expected %p got %p\n", NULL, pfb->base.base); + ok(pfb->base.ebuf == NULL, "wrong ebuf, expected %p got %p\n", NULL, pfb->base.ebuf); + ok(pfb->fd == -1, "wrong fd, expected 0 got %d\n", pfb->fd); + call_func1(p_ifstream_vbase_dtor, &ifs); + + pifs = call_func3(p_ifstream_fd_ctor, &ifs, 42, TRUE); + pfb = (filebuf*) ifs.base_ios.sb; + ok(pifs == &ifs, "wrong return, expected %p got %p\n", &ifs, pifs); + ok(ifs.base_ios.delbuf == 1, "expected 1 got %d\n", ifs.base_ios.delbuf); + ok(pfb->base.allocated == 0, "wrong allocate value, expected 0 got %d\n", pfb->base.allocated); + ok(pfb->base.unbuffered == 0, "wrong unbuffered value, expected 0 got %d\n", pfb->base.unbuffered); + ok(pfb->base.base == NULL, "wrong buffer, expected %p got %p\n", NULL, pfb->base.base); + ok(pfb->base.ebuf == NULL, "wrong ebuf, expected %p got %p\n", NULL, pfb->base.ebuf); + ok(pfb->fd == 42, "wrong fd, expected 42 got %d\n", pfb->fd); + ok(pfb->close == 0, "wrong value, expected 0 got %d\n", pfb->close); + + pifs = call_func3(p_ifstream_copy_ctor, &ifs_copy, &ifs, TRUE); + pfb = (filebuf*) ifs_copy.base_ios.sb; + ok(pifs == &ifs_copy, "wrong return, expected %p got %p\n", &ifs_copy, pifs); + ok(ifs_copy.base_ios.sb == ifs.base_ios.sb, "expected shared streambuf\n"); + + call_func1(p_ifstream_vbase_dtor, &ifs_copy); + call_func1(p_ifstream_dtor, &ifs.base_ios); + + pifs = call_func5(p_ifstream_buffer_ctor, &ifs, 53, buffer, ARRAY_SIZE(buffer), TRUE); + pfb = (filebuf*) ifs.base_ios.sb; + ok(ifs.base_ios.delbuf == 1, "expected 1 got %d\n", ifs.base_ios.delbuf); + ok(pifs == &ifs, "wrong return, expected %p got %p\n", &ifs, pifs); + ok(pfb->base.allocated == 0, "wrong allocate value, expected 0 got %d\n", pfb->base.allocated); + ok(pfb->base.unbuffered == 0, "wrong unbuffered value, expected 0 got %d\n", pfb->base.unbuffered); + ok(pfb->base.base == buffer, "wrong buffer, expected %p got %p\n", buffer, pfb->base.base); + ok(pfb->base.ebuf == buffer + ARRAY_SIZE(buffer), "wrong ebuf, expected %p got %p\n", buffer + ARRAY_SIZE(buffer), pfb->base.ebuf); + ok(pfb->fd == 53, "wrong fd, expected 53 got %d\n", pfb->fd); + ok(pfb->close == 0, "wrong value, expected 0 got %d\n", pfb->close); + call_func1(p_ifstream_dtor, &ifs.base_ios); + + pifs = call_func5(p_ifstream_buffer_ctor, &ifs, 64, NULL, 0, TRUE); + pfb = (filebuf*) ifs.base_ios.sb; + ok(ifs.base_ios.delbuf == 1, "expected 1 got %d\n", ifs.base_ios.delbuf); + ok(pifs == &ifs, "wrong return, expected %p got %p\n", &ifs, pifs); + ok(pfb->base.allocated == 0, "wrong allocate value, expected 0 got %d\n", pfb->base.allocated); + ok(pfb->base.unbuffered == 1, "wrong unbuffered value, expected 1 got %d\n", pfb->base.unbuffered); + ok(pfb->base.base == NULL, "wrong buffer, expected %p got %p\n", NULL, pfb->base.base); + ok(pfb->base.ebuf == NULL, "wrong ebuf, expected %p got %p\n", NULL, pfb->base.ebuf); + ok(pfb->fd == 64, "wrong fd, expected 64 got %d\n", pfb->fd); + ok(pfb->close == 0, "wrong value, expected 0 got %d\n", pfb->close); + call_func1(p_ifstream_vbase_dtor, &ifs); + + pifs = call_func5(p_ifstream_open_ctor, &ifs, filename, OPENMODE_in, filebuf_openprot, TRUE); + pfb = (filebuf*) ifs.base_ios.sb; + ok(ifs.base_ios.delbuf == 1, "expected 1 got %d\n", ifs.base_ios.delbuf); + ok(pifs == &ifs, "wrong return, expected %p got %p\n", &ifs, pifs); + ok(pfb->base.allocated == 1, "wrong allocate value, expected 1 got %d\n", pfb->base.allocated); + ok(pfb->base.unbuffered == 0, "wrong unbuffered value, expected 0 got %d\n", pfb->base.unbuffered); + ok(pfb->base.base != NULL, "wrong buffer, expected not %p got %p\n", NULL, pfb->base.base); + ok(pfb->base.ebuf != NULL, "wrong ebuf, expected not %p got %p\n", NULL, pfb->base.ebuf); + ok(pfb->fd != -1, "wrong fd, expected not -1 got %d\n", pfb->fd); + fd = pfb->fd; + ok(pfb->close == 1, "wrong value, expected 1 got %d\n", pfb->close); + call_func1(p_ifstream_vbase_dtor, &ifs); + ok(_close(fd) == -1, "expected ifstream to close opened file\n"); + + /* setbuf - seems to be a nop and always return NULL */ + pifs = call_func5(p_ifstream_buffer_ctor, &ifs, 64, NULL, 0, TRUE); + ok(ifs.base_ios.sb->base == NULL, "wrong base value, expected NULL got %p\n", ifs.base_ios.sb->base); + ok(ifs.base_ios.sb->ebuf == NULL, "wrong ebuf value, expected NULL got %p\n", ifs.base_ios.sb->ebuf); + ok(ifs.base_ios.sb->unbuffered == 1, "wrong unbuffered value, expected 1 got %d\n", pfb->base.unbuffered); + ok(ifs.base_ios.sb->allocated == 0, "wrong allocated value, expected 0 got %d\n", ifs.base_ios.sb->allocated); + + psb = call_func3(p_ifstream_setbuf, &ifs, buffer, ARRAY_SIZE(buffer)); + ok(psb == NULL, "wrong return, expected NULL got %p\n", pfb); + ok(ifs.base_ios.sb->base == NULL, "wrong base value, expected NULL got %p\n", ifs.base_ios.sb->base); + ok(ifs.base_ios.sb->ebuf == NULL, "wrong ebuf value, expected NULL got %p\n", ifs.base_ios.sb->ebuf); + ok(ifs.base_ios.sb->unbuffered == 1, "wrong unbuffered value, expected 1 got %d\n", ifs.base_ios.sb->unbuffered); + ok(ifs.base_ios.sb->allocated == 0, "wrong allocated value, expected 0 got %d\n", ifs.base_ios.sb->allocated); + + psb = call_func3(p_ifstream_setbuf, &ifs, NULL, 0); + ok(psb == NULL, "wrong return, expected NULL got %p\n", pfb); + ok(ifs.base_ios.sb->base == NULL, "wrong base value, expected NULL got %p\n", ifs.base_ios.sb->base); + ok(ifs.base_ios.sb->ebuf == NULL, "wrong ebuf value, expected NULL got %p\n", ifs.base_ios.sb->ebuf); + ok(ifs.base_ios.sb->unbuffered == 1, "wrong unbuffered value, expected 1 got %d\n", ifs.base_ios.sb->unbuffered); + ok(ifs.base_ios.sb->allocated == 0, "wrong allocated value, expected 0 got \n", ifs.base_ios.sb->allocated); + call_func1(p_ifstream_vbase_dtor, &ifs); + + pifs = call_func5(p_ifstream_open_ctor, &ifs, filename, OPENMODE_in, filebuf_openprot, TRUE); + psb = call_func3(p_ifstream_setbuf, &ifs, NULL, 0); + ok(psb == NULL, "wrong return, expected NULL got %p\n", pfb); + ok(ifs.base_ios.sb->base != NULL, "wrong base value, expected NULL got %p\n", ifs.base_ios.sb->base); + ok(ifs.base_ios.sb->ebuf != NULL, "wrong ebuf value, expected NULL got %p\n", ifs.base_ios.sb->ebuf); + ok(ifs.base_ios.sb->unbuffered == 0, "wrong unbuffered value, expected 0 got %d\n", ifs.base_ios.sb->unbuffered); + ok(ifs.base_ios.sb->allocated == 1, "wrong allocated value, expected 1 got %d\n", ifs.base_ios.sb->allocated); + + psb = call_func3(p_ifstream_setbuf, &ifs, buffer, ARRAY_SIZE(buffer)); + ok(psb == NULL, "wrong return, expected NULL got %p\n", pfb); + ok(ifs.base_ios.sb->base != NULL, "wrong base value, expected NULL got %p\n", ifs.base_ios.sb->base); + ok(ifs.base_ios.sb->base != buffer, "wrong base value, expected not %p got %p\n", buffer, ifs.base_ios.sb->base); + ok(ifs.base_ios.sb->unbuffered == 0, "wrong unbuffered value, expected 1 got %d\n", ifs.base_ios.sb->unbuffered); + ok(ifs.base_ios.sb->allocated == 1, "wrong allocated value, expected 0 got %d\n", ifs.base_ios.sb->allocated); + call_func1(p_ifstream_vbase_dtor, &ifs); + + /* attach */ + pifs = call_func2(p_ifstream_ctor, &ifs, TRUE); + pfb = (filebuf*) ifs.base_ios.sb; + ok(pifs == &ifs, "wrong return, expected %p got %p\n", &ifs, pifs); + call_func2(p_ifstream_attach, &ifs, 42); + fd = call_func1(p_ifstream_fd, &ifs); + ok(fd == 42, "wrong fd, expected 42 got %d\n", fd); + ok(pfb->close == 0, "wrong close value, expected 0 got %d\n", pfb->close); + call_func2(p_ifstream_attach, &ifs, 53); + ok(fd == 42, "wrong fd, expected 42 got %d\n", fd); + call_func1(p_ifstream_vbase_dtor, &ifs); + + /* fd */ + pifs = call_func5(p_ifstream_open_ctor, &ifs, filename, OPENMODE_in, filebuf_openprot, TRUE); + pfb = (filebuf*) ifs.base_ios.sb; + ok(pifs == &ifs, "wrong return, expected %p got %p\n", &ifs, pifs); + fd = call_func1(p_ifstream_fd, &ifs); + ok(fd == pfb->fd, "wrong fd, expected %d but got %d\n", pfb->fd, fd); + + /* rdbuf */ + pfb = (filebuf*) call_func1(p_ifstream_rdbuf, &ifs); + ok((streambuf*) pfb == ifs.base_ios.sb, "wrong return, expected %p got %p\n", ifs.base_ios.sb, pfb); + + /* setmode */ + ret = call_func2(p_ifstream_setmode, &ifs, filebuf_binary); + ok(ret == filebuf_text, "wrong return, expected %d got %d\n", filebuf_text, ret); + ret = call_func2(p_ifstream_setmode, &ifs, filebuf_binary); + ok(ret == filebuf_binary, "wrong return, expected %d got %d\n", filebuf_binary, ret); + ret = call_func2(p_ifstream_setmode, &ifs, filebuf_text); + ok(ret == filebuf_binary, "wrong return, expected %d got %d\n", filebuf_binary, ret); + ret = call_func2(p_ifstream_setmode, &ifs, 0x9000); + ok(ret == -1, "wrong return, expected -1 got %d\n", ret); + + /* close && is_open */ + ok(call_func1(p_ifstream_is_open, &ifs) == 1, "expected ifstream to be open\n"); + call_func1(p_ifstream_close, &ifs); + ok(call_func1(p_ifstream_is_open, &ifs) == 0, "expected ifstream to not be open\n"); + ok(_close(fd) == -1, "expected close to close the opened file\n"); + + /* integration with parent istream - reading */ + fd = _open(filename, _O_TRUNC|_O_CREAT|_O_RDWR, _S_IWRITE); + ok(fd != -1, "_open failed\n"); + ok(_write(fd, "test 12", 7) == 7, "_write failed\n"); + ok(_close(fd) == 0, "_close failed\n"); + + call_func4(p_ifstream_open, &ifs, filename, OPENMODE_in, filebuf_openprot); + memset(st, 'A', sizeof(st)); + st[7] = 0; + pifs = call_func2(p_istream_read_str, &ifs, st); + ok(pifs == &ifs, "wrong return, expected %p got %p\n", &ifs, pifs); + ok(!strcmp(st, "test"), "expected 'test' got '%s'\n", st); + + i = 12345; + pifs = call_func2(p_istream_read_int, pifs, &i); + ok(pifs == &ifs, "wrong return, expected %p got %p\n", &ifs, pifs); + ok(i == 12, "expected 12 got %d\n", i); + + call_func1(p_ifstream_vbase_dtor, &ifs); + ok(_unlink(filename) == 0, "Couldn't unlink file named '%s'\n", filename); +} + static void test_strstream(void) { iostream ios1, ios2, *pios; @@ -7538,6 +7780,7 @@ START_TEST(msvcirt) test_istream_withassign(); test_istrstream(); test_iostream(); + test_ifstream(); test_strstream(); test_stdiostream(); test_Iostream_init(); diff --git a/dlls/msvcrt20/msvcrt20.spec b/dlls/msvcrt20/msvcrt20.spec index f06a53cc601..2ce72c6b13c 100644 --- a/dlls/msvcrt20/msvcrt20.spec +++ b/dlls/msvcrt20/msvcrt20.spec @@ -20,16 +20,16 @@ @ stub -arch=win64 ??0fstream@@QEAA@PEBDHH@Z @ stub -arch=win32 ??0fstream@@QAE@XZ @ stub -arch=win64 ??0fstream@@QEAA@XZ -@ stub -arch=win32 ??0ifstream@@QAE@ABV0@@Z -@ stub -arch=win64 ??0ifstream@@QEAA@AEBV0@@Z -@ stub -arch=win32 ??0ifstream@@QAE@H@Z -@ stub -arch=win64 ??0ifstream@@QEAA@H@Z -@ stub -arch=win32 ??0ifstream@@QAE@HPADH@Z -@ stub -arch=win64 ??0ifstream@@QEAA@HPEADH@Z -@ stub -arch=win32 ??0ifstream@@QAE@PBDHH@Z -@ stub -arch=win64 ??0ifstream@@QEAA@PEBDHH@Z -@ stub -arch=win32 ??0ifstream@@QAE@XZ -@ stub -arch=win64 ??0ifstream@@QEAA@XZ +@ thiscall -arch=win32 ??0ifstream@@QAE@ABV0@@Z(ptr ptr long) msvcirt.??0ifstream@@QAE@ABV0@@Z +@ cdecl -arch=win64 ??0ifstream@@QEAA@AEBV0@@Z(ptr ptr long) msvcirt.??0ifstream@@QEAA@AEBV0@@Z +@ thiscall -arch=win32 ??0ifstream@@QAE@H@Z(ptr long long) msvcirt.??0ifstream@@QAE@H@Z +@ cdecl -arch=win64 ??0ifstream@@QEAA@H@Z(ptr long long) msvcirt.??0ifstream@@QEAA@H@Z +@ thiscall -arch=win32 ??0ifstream@@QAE@HPADH@Z(ptr long ptr long long) msvcirt.??0ifstream@@QAE@HPADH@Z +@ cdecl -arch=win64 ??0ifstream@@QEAA@HPEADH@Z(ptr long ptr long long) msvcirt.??0ifstream@@QEAA@HPEADH@Z +@ thiscall -arch=win32 ??0ifstream@@QAE@PBDHH@Z(ptr str long long long) msvcirt.??0ifstream@@QAE@PBDHH@Z +@ cdecl -arch=win64 ??0ifstream@@QEAA@PEBDHH@Z(ptr str long long long) msvcirt.??0ifstream@@QEAA@PEBDHH@Z +@ thiscall -arch=win32 ??0ifstream@@QAE@XZ(ptr long) msvcirt.??0ifstream@@QAE@XZ +@ cdecl -arch=win64 ??0ifstream@@QEAA@XZ(ptr long) msvcirt.??0ifstream@@QEAA@XZ @ thiscall -arch=win32 ??0ios@@IAE@ABV0@@Z(ptr ptr) msvcirt.??0ios@@IAE@ABV0@@Z @ cdecl -arch=win64 ??0ios@@IEAA@AEBV0@@Z(ptr ptr) msvcirt.??0ios@@IEAA@AEBV0@@Z @ thiscall -arch=win32 ??0ios@@IAE@XZ(ptr) msvcirt.??0ios@@IAE@XZ @@ -124,8 +124,8 @@ @ cdecl -arch=win64 ??1filebuf@@UEAA@XZ(ptr) msvcirt.??1filebuf@@UEAA@XZ @ stub -arch=win32 ??1fstream@@UAE@XZ @ stub -arch=win64 ??1fstream@@UEAA@XZ -@ stub -arch=win32 ??1ifstream@@UAE@XZ -@ stub -arch=win64 ??1ifstream@@UEAA@XZ +@ thiscall -arch=win32 ??1ifstream@@UAE@XZ(ptr) msvcirt.??1ifstream@@UAE@XZ +@ cdecl -arch=win64 ??1ifstream@@UEAA@XZ(ptr) msvcirt.??1ifstream@@UEAA@XZ @ thiscall -arch=win32 ??1ios@@UAE@XZ(ptr) msvcirt.??1ios@@UAE@XZ @ cdecl -arch=win64 ??1ios@@UEAA@XZ(ptr) msvcirt.??1ios@@UEAA@XZ @ thiscall -arch=win32 ??1iostream@@UAE@XZ(ptr) msvcirt.??1iostream@@UAE@XZ @@ -164,8 +164,8 @@ @ cdecl -arch=win64 ??4filebuf@@QEAAAEAV0@AEBV0@@Z(ptr ptr) msvcirt.??4filebuf@@QEAAAEAV0@AEBV0@@Z @ stub -arch=win32 ??4fstream@@QAEAAV0@AAV0@@Z @ stub -arch=win64 ??4fstream@@QEAAAEAV0@AEAV0@@Z -@ stub -arch=win32 ??4ifstream@@QAEAAV0@ABV0@@Z -@ stub -arch=win64 ??4ifstream@@QEAAAEAV0@AEBV0@@Z +@ thiscall -arch=win32 ??4ifstream@@QAEAAV0@ABV0@@Z(ptr ptr) msvcirt.??4ifstream@@QAEAAV0@ABV0@@Z +@ cdecl -arch=win64 ??4ifstream@@QEAAAEAV0@AEBV0@@Z(ptr ptr) msvcirt.??4ifstream@@QEAAAEAV0@AEBV0@@Z @ thiscall -arch=win32 ??4ios@@IAEAAV0@ABV0@@Z(ptr ptr) msvcirt.??4ios@@IAEAAV0@ABV0@@Z @ cdecl -arch=win64 ??4ios@@IEAAAEAV0@AEBV0@@Z(ptr ptr) msvcirt.??4ios@@IEAAAEAV0@AEBV0@@Z @ thiscall -arch=win32 ??4iostream@@IAEAAV0@AAV0@@Z(ptr ptr) msvcirt.??4iostream@@IAEAAV0@AAV0@@Z @@ -288,7 +288,7 @@ @ cdecl -arch=win64 ??Bios@@QEBAPEAXXZ(ptr) msvcirt.??Bios@@QEBAPEAXXZ @ extern ??_7filebuf@@6B@ msvcirt.??_7filebuf@@6B@ # @ extern ??_7fstream@@6B@ -# @ extern ??_7ifstream@@6B@ +@ extern ??_7ifstream@@6B@ msvcirt.??_7ifstream@@6B@ @ extern ??_7ios@@6B@ msvcirt.??_7ios@@6B@ @ extern ??_7iostream@@6B@ msvcirt.??_7iostream@@6B@ @ extern ??_7istream@@6B@ msvcirt.??_7istream@@6B@ @@ -305,7 +305,7 @@ @ extern ??_7strstreambuf@@6B@ msvcirt.??_7strstreambuf@@6B@ # @ extern ??_8fstream@@7Bistream@@@ # @ extern ??_8fstream@@7Bostream@@@ -# @ extern ??_8ifstream@@7B@ +@ extern ??_8ifstream@@7B@ msvcirt.??_8ifstream@@7B@ @ extern ??_8iostream@@7Bistream@@@ msvcirt.??_8iostream@@7Bistream@@@ @ extern ??_8iostream@@7Bostream@@@ msvcirt.??_8iostream@@7Bostream@@@ @ extern ??_8istream@@7B@ msvcirt.??_8istream@@7B@ @@ -321,8 +321,8 @@ @ extern ??_8strstream@@7Bostream@@@ msvcirt.??_8strstream@@7Bostream@@@ @ stub -arch=win32 ??_Dfstream@@QAEXXZ @ stub -arch=win64 ??_Dfstream@@QEAAXXZ -@ stub -arch=win32 ??_Difstream@@QAEXXZ -@ stub -arch=win64 ??_Difstream@@QEAAXXZ +@ thiscall -arch=win32 ??_Difstream@@QAEXXZ(ptr) msvcirt.??_Difstream@@QAEXXZ +@ cdecl -arch=win64 ??_Difstream@@QEAAXXZ(ptr) msvcirt.??_Difstream@@QEAAXXZ @ thiscall -arch=win32 ??_Diostream@@QAEXXZ(ptr) msvcirt.??_Diostream@@QAEXXZ @ cdecl -arch=win64 ??_Diostream@@QEAAXXZ(ptr) msvcirt.??_Diostream@@QEAAXXZ @ thiscall -arch=win32 ??_Distream@@QAEXXZ(ptr) msvcirt.??_Distream@@QAEXXZ @@ -346,7 +346,7 @@ @ stub -arch=win32 ??_EIostream_init@@QAEPAXI@Z @ thiscall -arch=win32 ??_Efilebuf@@UAEPAXI@Z(ptr long) msvcirt.??_Efilebuf@@UAEPAXI@Z @ stub -arch=win32 ??_Efstream@@UAEPAXI@Z -@ stub -arch=win32 ??_Eifstream@@UAEPAXI@Z +@ thiscall -arch=win32 ??_Eifstream@@UAEPAXI@Z(ptr long) msvcirt.??_Eifstream@@UAEPAXI@Z @ thiscall -arch=win32 ??_Eios@@UAEPAXI@Z(ptr long) msvcirt.??_Eios@@UAEPAXI@Z @ thiscall -arch=win32 ??_Eiostream@@UAEPAXI@Z(ptr long) msvcirt.??_Eiostream@@UAEPAXI@Z @ thiscall -arch=win32 ??_Eistream@@UAEPAXI@Z(ptr long) msvcirt.??_Eistream@@UAEPAXI@Z @@ -364,7 +364,7 @@ @ stub -arch=win32 ??_GIostream_init@@QAEPAXI@Z @ thiscall -arch=win32 ??_Gfilebuf@@UAEPAXI@Z(ptr long) msvcirt.??_Gfilebuf@@UAEPAXI@Z @ stub -arch=win32 ??_Gfstream@@UAEPAXI@Z -@ stub -arch=win32 ??_Gifstream@@UAEPAXI@Z +@ thiscall -arch=win32 ??_Gifstream@@UAEPAXI@Z(ptr long) msvcirt.??_Gifstream@@UAEPAXI@Z @ thiscall -arch=win32 ??_Gios@@UAEPAXI@Z(ptr long) msvcirt.??_Gios@@UAEPAXI@Z @ thiscall -arch=win32 ??_Giostream@@UAEPAXI@Z(ptr long) msvcirt.??_Giostream@@UAEPAXI@Z @ thiscall -arch=win32 ??_Gistream@@UAEPAXI@Z(ptr long) msvcirt.??_Gistream@@UAEPAXI@Z @@ -394,8 +394,8 @@ @ cdecl -arch=win64 ?attach@filebuf@@QEAAPEAV1@H@Z(ptr long) msvcirt.?attach@filebuf@@QEAAPEAV1@H@Z @ stub -arch=win32 ?attach@fstream@@QAEXH@Z @ stub -arch=win64 ?attach@fstream@@QEAAXH@Z -@ stub -arch=win32 ?attach@ifstream@@QAEXH@Z -@ stub -arch=win64 ?attach@ifstream@@QEAAXH@Z +@ thiscall -arch=win32 ?attach@ifstream@@QAEXH@Z(ptr long) msvcirt.?attach@ifstream@@QAEXH@Z +@ cdecl -arch=win64 ?attach@ifstream@@QEAAXH@Z(ptr long) msvcirt.?attach@ifstream@@QEAAXH@Z @ stub -arch=win32 ?attach@ofstream@@QAEXH@Z @ stub -arch=win64 ?attach@ofstream@@QEAAXH@Z @ thiscall -arch=win32 ?bad@ios@@QBEHXZ(ptr) msvcirt.?bad@ios@@QBEHXZ @@ -416,8 +416,8 @@ @ cdecl -arch=win64 ?close@filebuf@@QEAAPEAV1@XZ(ptr) msvcirt.?close@filebuf@@QEAAPEAV1@XZ @ stub -arch=win32 ?close@fstream@@QAEXXZ @ stub -arch=win64 ?close@fstream@@QEAAXXZ -@ stub -arch=win32 ?close@ifstream@@QAEXXZ -@ stub -arch=win64 ?close@ifstream@@QEAAXXZ +@ thiscall -arch=win32 ?close@ifstream@@QAEXXZ(ptr) msvcirt.?close@ifstream@@QAEXXZ +@ cdecl -arch=win64 ?close@ifstream@@QEAAXXZ(ptr) msvcirt.?close@ifstream@@QEAAXXZ @ stub -arch=win32 ?close@ofstream@@QAEXXZ @ stub -arch=win64 ?close@ofstream@@QEAAXXZ @ cdecl -arch=win32 ?clrlock@ios@@QAAXXZ(ptr) msvcirt.?clrlock@ios@@QAAXXZ @@ -460,8 +460,8 @@ @ cdecl -arch=win64 ?fd@filebuf@@QEBAHXZ(ptr) msvcirt.?fd@filebuf@@QEBAHXZ @ stub -arch=win32 ?fd@fstream@@QBEHXZ @ stub -arch=win64 ?fd@fstream@@QEBAHXZ -@ stub -arch=win32 ?fd@ifstream@@QBEHXZ -@ stub -arch=win64 ?fd@ifstream@@QEBAHXZ +@ thiscall -arch=win32 ?fd@ifstream@@QBEHXZ(ptr) msvcirt.?fd@ifstream@@QBEHXZ +@ cdecl -arch=win64 ?fd@ifstream@@QEBAHXZ(ptr) msvcirt.?fd@ifstream@@QEBAHXZ @ stub -arch=win32 ?fd@ofstream@@QBEHXZ @ stub -arch=win64 ?fd@ofstream@@QEBAHXZ @ thiscall -arch=win32 ?fill@ios@@QAEDD@Z(ptr long) msvcirt.?fill@ios@@QAEDD@Z @@ -527,8 +527,8 @@ @ cdecl -arch=win64 ?is_open@filebuf@@QEBAHXZ(ptr) msvcirt.?is_open@filebuf@@QEBAHXZ @ stub -arch=win32 ?is_open@fstream@@QBEHXZ @ stub -arch=win64 ?is_open@fstream@@QEBAHXZ -@ stub -arch=win32 ?is_open@ifstream@@QBEHXZ -@ stub -arch=win64 ?is_open@ifstream@@QEBAHXZ +@ thiscall -arch=win32 ?is_open@ifstream@@QBEHXZ(ptr) msvcirt.?is_open@ifstream@@QBEHXZ +@ cdecl -arch=win64 ?is_open@ifstream@@QEBAHXZ(ptr) msvcirt.?is_open@ifstream@@QEBAHXZ @ stub -arch=win32 ?is_open@ofstream@@QBEHXZ @ stub -arch=win64 ?is_open@ofstream@@QEBAHXZ @ thiscall -arch=win32 ?isfx@istream@@QAEXXZ(ptr) msvcirt.?isfx@istream@@QAEXXZ @@ -552,8 +552,8 @@ @ cdecl -arch=win64 ?open@filebuf@@QEAAPEAV1@PEBDHH@Z(ptr str long long) msvcirt.?open@filebuf@@QEAAPEAV1@PEBDHH@Z @ stub -arch=win32 ?open@fstream@@QAEXPBDHH@Z @ stub -arch=win64 ?open@fstream@@QEAAXPEBDHH@Z -@ stub -arch=win32 ?open@ifstream@@QAEXPBDHH@Z -@ stub -arch=win64 ?open@ifstream@@QEAAXPEBDHH@Z +@ thiscall -arch=win32 ?open@ifstream@@QAEXPBDHH@Z(ptr str long long) msvcirt.?open@ifstream@@QAEXPBDHH@Z +@ cdecl -arch=win64 ?open@ifstream@@QEAAXPEBDHH@Z(ptr str long long) msvcirt.?open@ifstream@@QEAAXPEBDHH@Z @ stub -arch=win32 ?open@ofstream@@QAEXPBDHH@Z @ stub -arch=win64 ?open@ofstream@@QEAAXPEBDHH@Z @ extern ?openprot@filebuf@@2HB msvcirt.?openprot@filebuf@@2HB @@ -601,8 +601,8 @@ @ cdecl -arch=win64 ?pword@ios@@QEBAAEAPEAXH@Z(ptr long) msvcirt.?pword@ios@@QEBAAEAPEAXH@Z @ stub -arch=win32 ?rdbuf@fstream@@QBEPAVfilebuf@@XZ @ stub -arch=win64 ?rdbuf@fstream@@QEBAPEAVfilebuf@@XZ -@ stub -arch=win32 ?rdbuf@ifstream@@QBEPAVfilebuf@@XZ -@ stub -arch=win64 ?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ +@ thiscall -arch=win32 ?rdbuf@ifstream@@QBEPAVfilebuf@@XZ(ptr) msvcirt.?rdbuf@ifstream@@QBEPAVfilebuf@@XZ +@ cdecl -arch=win64 ?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ(ptr) msvcirt.?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ @ thiscall -arch=win32 ?rdbuf@ios@@QBEPAVstreambuf@@XZ(ptr) msvcirt.?rdbuf@ios@@QBEPAVstreambuf@@XZ @ cdecl -arch=win64 ?rdbuf@ios@@QEBAPEAVstreambuf@@XZ(ptr) msvcirt.?rdbuf@ios@@QEBAPEAVstreambuf@@XZ @ thiscall -arch=win32 ?rdbuf@istrstream@@QBEPAVstrstreambuf@@XZ(ptr) msvcirt.?rdbuf@istrstream@@QBEPAVstrstreambuf@@XZ @@ -651,8 +651,8 @@ @ cdecl -arch=win64 ?setbuf@filebuf@@UEAAPEAVstreambuf@@PEADH@Z(ptr ptr long) msvcirt.?setbuf@filebuf@@UEAAPEAVstreambuf@@PEADH@Z @ stub -arch=win32 ?setbuf@fstream@@QAEPAVstreambuf@@PADH@Z @ stub -arch=win64 ?setbuf@fstream@@QEAAPEAVstreambuf@@PEADH@Z -@ stub -arch=win32 ?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z -@ stub -arch=win64 ?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z +@ thiscall -arch=win32 ?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z(ptr ptr long) msvcirt.?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z +@ cdecl -arch=win64 ?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z(ptr ptr long) msvcirt.?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z @ stub -arch=win32 ?setbuf@ofstream@@QAEPAVstreambuf@@PADH@Z @ stub -arch=win64 ?setbuf@ofstream@@QEAAPEAVstreambuf@@PEADH@Z @ thiscall -arch=win32 ?setbuf@streambuf@@UAEPAV1@PADH@Z(ptr ptr long) msvcirt.?setbuf@streambuf@@UAEPAV1@PADH@Z @@ -673,8 +673,8 @@ @ cdecl -arch=win64 ?setmode@filebuf@@QEAAHH@Z(ptr long) msvcirt.?setmode@filebuf@@QEAAHH@Z @ stub -arch=win32 ?setmode@fstream@@QAEHH@Z @ stub -arch=win64 ?setmode@fstream@@QEAAHH@Z -@ stub -arch=win32 ?setmode@ifstream@@QAEHH@Z -@ stub -arch=win64 ?setmode@ifstream@@QEAAHH@Z +@ thiscall -arch=win32 ?setmode@ifstream@@QAEHH@Z(ptr long) msvcirt.?setmode@ifstream@@QAEHH@Z +@ cdecl -arch=win64 ?setmode@ifstream@@QEAAHH@Z(ptr long) msvcirt.?setmode@ifstream@@QEAAHH@Z @ stub -arch=win32 ?setmode@ofstream@@QAEHH@Z @ stub -arch=win64 ?setmode@ofstream@@QEAAHH@Z @ thiscall -arch=win32 ?setp@streambuf@@IAEXPAD0@Z(ptr ptr ptr) msvcirt.?setp@streambuf@@IAEXPAD0@Z diff --git a/dlls/msvcrt40/msvcrt40.spec b/dlls/msvcrt40/msvcrt40.spec index f0d966acd7c..efa3e3251d6 100644 --- a/dlls/msvcrt40/msvcrt40.spec +++ b/dlls/msvcrt40/msvcrt40.spec @@ -38,16 +38,16 @@ @ stub -arch=win64 ??0fstream@@QEAA@PEBDHH@Z @ stub -arch=win32 ??0fstream@@QAE@XZ @ stub -arch=win64 ??0fstream@@QEAA@XZ -@ stub -arch=win32 ??0ifstream@@QAE@ABV0@@Z -@ stub -arch=win64 ??0ifstream@@QEAA@AEBV0@@Z -@ stub -arch=win32 ??0ifstream@@QAE@H@Z -@ stub -arch=win64 ??0ifstream@@QEAA@H@Z -@ stub -arch=win32 ??0ifstream@@QAE@HPADH@Z -@ stub -arch=win64 ??0ifstream@@QEAA@HPEADH@Z -@ stub -arch=win32 ??0ifstream@@QAE@PBDHH@Z -@ stub -arch=win64 ??0ifstream@@QEAA@PEBDHH@Z -@ stub -arch=win32 ??0ifstream@@QAE@XZ -@ stub -arch=win64 ??0ifstream@@QEAA@XZ +@ thiscall -arch=win32 ??0ifstream@@QAE@ABV0@@Z(ptr ptr long) msvcirt.??0ifstream@@QAE@ABV0@@Z +@ cdecl -arch=win64 ??0ifstream@@QEAA@AEBV0@@Z(ptr ptr long) msvcirt.??0ifstream@@QEAA@AEBV0@@Z +@ thiscall -arch=win32 ??0ifstream@@QAE@H@Z(ptr long long) msvcirt.??0ifstream@@QAE@H@Z +@ cdecl -arch=win64 ??0ifstream@@QEAA@H@Z(ptr long long) msvcirt.??0ifstream@@QEAA@H@Z +@ thiscall -arch=win32 ??0ifstream@@QAE@HPADH@Z(ptr long ptr long long) msvcirt.??0ifstream@@QAE@HPADH@Z +@ cdecl -arch=win64 ??0ifstream@@QEAA@HPEADH@Z(ptr long ptr long long) msvcirt.??0ifstream@@QEAA@HPEADH@Z +@ thiscall -arch=win32 ??0ifstream@@QAE@PBDHH@Z(ptr str long long long) msvcirt.??0ifstream@@QAE@PBDHH@Z +@ cdecl -arch=win64 ??0ifstream@@QEAA@PEBDHH@Z(ptr str long long long) msvcirt.??0ifstream@@QEAA@PEBDHH@Z +@ thiscall -arch=win32 ??0ifstream@@QAE@XZ(ptr long) msvcirt.??0ifstream@@QAE@XZ +@ cdecl -arch=win64 ??0ifstream@@QEAA@XZ(ptr long) msvcirt.??0ifstream@@QEAA@XZ @ thiscall -arch=win32 ??0ios@@IAE@ABV0@@Z(ptr ptr) msvcirt.??0ios@@IAE@ABV0@@Z @ cdecl -arch=win64 ??0ios@@IEAA@AEBV0@@Z(ptr ptr) msvcirt.??0ios@@IEAA@AEBV0@@Z @ thiscall -arch=win32 ??0ios@@IAE@XZ(ptr) msvcirt.??0ios@@IAE@XZ @@ -154,8 +154,8 @@ @ cdecl -arch=win64 ??1filebuf@@UEAA@XZ(ptr) msvcirt.??1filebuf@@UEAA@XZ @ stub -arch=win32 ??1fstream@@UAE@XZ @ stub -arch=win64 ??1fstream@@UEAA@XZ -@ stub -arch=win32 ??1ifstream@@UAE@XZ -@ stub -arch=win64 ??1ifstream@@UEAA@XZ +@ thiscall -arch=win32 ??1ifstream@@UAE@XZ(ptr) msvcirt.??1ifstream@@UAE@XZ +@ cdecl -arch=win64 ??1ifstream@@UEAA@XZ(ptr) msvcirt.??1ifstream@@UEAA@XZ @ thiscall -arch=win32 ??1ios@@UAE@XZ(ptr) msvcirt.??1ios@@UAE@XZ @ cdecl -arch=win64 ??1ios@@UEAA@XZ(ptr) msvcirt.??1ios@@UEAA@XZ @ thiscall -arch=win32 ??1iostream@@UAE@XZ(ptr) msvcirt.??1iostream@@UAE@XZ @@ -206,8 +206,8 @@ @ cdecl -arch=win64 ??4filebuf@@QEAAAEAV0@AEBV0@@Z(ptr ptr) msvcirt.??4filebuf@@QEAAAEAV0@AEBV0@@Z @ stub -arch=win32 ??4fstream@@QAEAAV0@AAV0@@Z @ stub -arch=win64 ??4fstream@@QEAAAEAV0@AEAV0@@Z -@ stub -arch=win32 ??4ifstream@@QAEAAV0@ABV0@@Z -@ stub -arch=win64 ??4ifstream@@QEAAAEAV0@AEBV0@@Z +@ thiscall -arch=win32 ??4ifstream@@QAEAAV0@ABV0@@Z(ptr ptr) msvcirt.??4ifstream@@QAEAAV0@ABV0@@Z +@ cdecl -arch=win64 ??4ifstream@@QEAAAEAV0@AEBV0@@Z(ptr ptr) msvcirt.??4ifstream@@QEAAAEAV0@AEBV0@@Z @ thiscall -arch=win32 ??4ios@@IAEAAV0@ABV0@@Z(ptr ptr) msvcirt.??4ios@@IAEAAV0@ABV0@@Z @ cdecl -arch=win64 ??4ios@@IEAAAEAV0@AEBV0@@Z(ptr ptr) msvcirt.??4ios@@IEAAAEAV0@AEBV0@@Z @ thiscall -arch=win32 ??4iostream@@IAEAAV0@AAV0@@Z(ptr ptr) msvcirt.??4iostream@@IAEAAV0@AAV0@@Z @@ -340,7 +340,7 @@ @ extern ??_7exception@@6B@ msvcrt.??_7exception@@6B@ @ extern ??_7filebuf@@6B@ msvcirt.??_7filebuf@@6B@ # @ extern ??_7fstream@@6B@ -# @ extern ??_7ifstream@@6B@ +@ extern ??_7ifstream@@6B@ msvcirt.??_7ifstream@@6B@ @ extern ??_7ios@@6B@ msvcirt.??_7ios@@6B@ @ extern ??_7iostream@@6B@ msvcirt.??_7iostream@@6B@ @ extern ??_7istream@@6B@ msvcirt.??_7istream@@6B@ @@ -358,7 +358,7 @@ @ extern ??_7strstreambuf@@6B@ msvcirt.??_7strstreambuf@@6B@ # @ extern ??_8fstream@@7Bistream@@@ # @ extern ??_8fstream@@7Bostream@@@ -# @ extern ??_8ifstream@@7B@ +@ extern ??_8ifstream@@7B@ msvcirt.??_8ifstream@@7B@ @ extern ??_8iostream@@7Bistream@@@ msvcirt.??_8iostream@@7Bistream@@@ @ extern ??_8iostream@@7Bostream@@@ msvcirt.??_8iostream@@7Bostream@@@ @ extern ??_8istream@@7B@ msvcirt.??_8istream@@7B@ @@ -374,8 +374,8 @@ @ extern ??_8strstream@@7Bostream@@@ msvcirt.??_8strstream@@7Bostream@@@ @ stub -arch=win32 ??_Dfstream@@QAEXXZ @ stub -arch=win64 ??_Dfstream@@QEAAXXZ -@ stub -arch=win32 ??_Difstream@@QAEXXZ -@ stub -arch=win64 ??_Difstream@@QEAAXXZ +@ thiscall -arch=win32 ??_Difstream@@QAEXXZ(ptr) msvcirt.??_Difstream@@QAEXXZ +@ cdecl -arch=win64 ??_Difstream@@QEAAXXZ(ptr) msvcirt.??_Difstream@@QEAAXXZ @ thiscall -arch=win32 ??_Diostream@@QAEXXZ(ptr) msvcirt.??_Diostream@@QAEXXZ @ cdecl -arch=win64 ??_Diostream@@QEAAXXZ(ptr) msvcirt.??_Diostream@@QEAAXXZ @ thiscall -arch=win32 ??_Distream@@QAEXXZ(ptr) msvcirt.??_Distream@@QAEXXZ @@ -403,7 +403,7 @@ @ thiscall -arch=win32 ??_Eexception@@UAEPAXI@Z(ptr long) msvcrt.??_Eexception@@UAEPAXI@Z @ thiscall -arch=win32 ??_Efilebuf@@UAEPAXI@Z(ptr long) msvcirt.??_Efilebuf@@UAEPAXI@Z @ stub -arch=win32 ??_Efstream@@UAEPAXI@Z -@ stub -arch=win32 ??_Eifstream@@UAEPAXI@Z +@ thiscall -arch=win32 ??_Eifstream@@UAEPAXI@Z(ptr long) msvcirt.??_Eifstream@@UAEPAXI@Z @ thiscall -arch=win32 ??_Eios@@UAEPAXI@Z(ptr long) msvcirt.??_Eios@@UAEPAXI@Z @ thiscall -arch=win32 ??_Eiostream@@UAEPAXI@Z(ptr long) msvcirt.??_Eiostream@@UAEPAXI@Z @ thiscall -arch=win32 ??_Eistream@@UAEPAXI@Z(ptr long) msvcirt.??_Eistream@@UAEPAXI@Z @@ -426,7 +426,7 @@ @ thiscall -arch=win32 ??_Gexception@@UAEPAXI@Z(ptr long) msvcrt.??_Gexception@@UAEPAXI@Z @ thiscall -arch=win32 ??_Gfilebuf@@UAEPAXI@Z(ptr long) msvcirt.??_Gfilebuf@@UAEPAXI@Z @ stub -arch=win32 ??_Gfstream@@UAEPAXI@Z -@ stub -arch=win32 ??_Gifstream@@UAEPAXI@Z +@ thiscall -arch=win32 ??_Gifstream@@UAEPAXI@Z(ptr long) msvcirt.??_Gifstream@@UAEPAXI@Z @ thiscall -arch=win32 ??_Gios@@UAEPAXI@Z(ptr long) msvcirt.??_Gios@@UAEPAXI@Z @ thiscall -arch=win32 ??_Giostream@@UAEPAXI@Z(ptr long) msvcirt.??_Giostream@@UAEPAXI@Z @ thiscall -arch=win32 ??_Gistream@@UAEPAXI@Z(ptr long) msvcirt.??_Gistream@@UAEPAXI@Z @@ -457,8 +457,8 @@ @ cdecl -arch=win64 ?attach@filebuf@@QEAAPEAV1@H@Z(ptr long) msvcirt.?attach@filebuf@@QEAAPEAV1@H@Z @ stub -arch=win32 ?attach@fstream@@QAEXH@Z @ stub -arch=win64 ?attach@fstream@@QEAAXH@Z -@ stub -arch=win32 ?attach@ifstream@@QAEXH@Z -@ stub -arch=win64 ?attach@ifstream@@QEAAXH@Z +@ thiscall -arch=win32 ?attach@ifstream@@QAEXH@Z(ptr long) msvcirt.?attach@ifstream@@QAEXH@Z +@ cdecl -arch=win64 ?attach@ifstream@@QEAAXH@Z(ptr long) msvcirt.?attach@ifstream@@QEAAXH@Z @ stub -arch=win32 ?attach@ofstream@@QAEXH@Z @ stub -arch=win64 ?attach@ofstream@@QEAAXH@Z @ thiscall -arch=win32 ?bad@ios@@QBEHXZ(ptr) msvcirt.?bad@ios@@QBEHXZ @@ -481,8 +481,8 @@ @ cdecl -arch=win64 ?close@filebuf@@QEAAPEAV1@XZ(ptr) msvcirt.?close@filebuf@@QEAAPEAV1@XZ @ stub -arch=win32 ?close@fstream@@QAEXXZ @ stub -arch=win64 ?close@fstream@@QEAAXXZ -@ stub -arch=win32 ?close@ifstream@@QAEXXZ -@ stub -arch=win64 ?close@ifstream@@QEAAXXZ +@ thiscall -arch=win32 ?close@ifstream@@QAEXXZ(ptr) msvcirt.?close@ifstream@@QAEXXZ +@ cdecl -arch=win64 ?close@ifstream@@QEAAXXZ(ptr) msvcirt.?close@ifstream@@QEAAXXZ @ stub -arch=win32 ?close@ofstream@@QAEXXZ @ stub -arch=win64 ?close@ofstream@@QEAAXXZ @ cdecl -arch=win32 ?clrlock@ios@@QAAXXZ(ptr) msvcirt.?clrlock@ios@@QAAXXZ @@ -525,8 +525,8 @@ @ cdecl -arch=win64 ?fd@filebuf@@QEBAHXZ(ptr) msvcirt.?fd@filebuf@@QEBAHXZ @ stub -arch=win32 ?fd@fstream@@QBEHXZ @ stub -arch=win64 ?fd@fstream@@QEBAHXZ -@ stub -arch=win32 ?fd@ifstream@@QBEHXZ -@ stub -arch=win64 ?fd@ifstream@@QEBAHXZ +@ thiscall -arch=win32 ?fd@ifstream@@QBEHXZ(ptr) msvcirt.?fd@ifstream@@QBEHXZ +@ cdecl -arch=win64 ?fd@ifstream@@QEBAHXZ(ptr) msvcirt.?fd@ifstream@@QEBAHXZ @ stub -arch=win32 ?fd@ofstream@@QBEHXZ @ stub -arch=win64 ?fd@ofstream@@QEBAHXZ @ thiscall -arch=win32 ?fill@ios@@QAEDD@Z(ptr long) msvcirt.?fill@ios@@QAEDD@Z @@ -594,8 +594,8 @@ @ cdecl -arch=win64 ?is_open@filebuf@@QEBAHXZ(ptr) msvcirt.?is_open@filebuf@@QEBAHXZ @ stub -arch=win32 ?is_open@fstream@@QBEHXZ @ stub -arch=win64 ?is_open@fstream@@QEBAHXZ -@ stub -arch=win32 ?is_open@ifstream@@QBEHXZ -@ stub -arch=win64 ?is_open@ifstream@@QEBAHXZ +@ thiscall -arch=win32 ?is_open@ifstream@@QBEHXZ(ptr) msvcirt.?is_open@ifstream@@QBEHXZ +@ cdecl -arch=win64 ?is_open@ifstream@@QEBAHXZ(ptr) msvcirt.?is_open@ifstream@@QEBAHXZ @ stub -arch=win32 ?is_open@ofstream@@QBEHXZ @ stub -arch=win64 ?is_open@ofstream@@QEBAHXZ @ thiscall -arch=win32 ?isfx@istream@@QAEXXZ(ptr) msvcirt.?isfx@istream@@QAEXXZ @@ -621,8 +621,8 @@ @ cdecl -arch=win64 ?open@filebuf@@QEAAPEAV1@PEBDHH@Z(ptr str long long) msvcirt.?open@filebuf@@QEAAPEAV1@PEBDHH@Z @ stub -arch=win32 ?open@fstream@@QAEXPBDHH@Z @ stub -arch=win64 ?open@fstream@@QEAAXPEBDHH@Z -@ stub -arch=win32 ?open@ifstream@@QAEXPBDHH@Z -@ stub -arch=win64 ?open@ifstream@@QEAAXPEBDHH@Z +@ thiscall -arch=win32 ?open@ifstream@@QAEXPBDHH@Z(ptr str long long) msvcirt.?open@ifstream@@QAEXPBDHH@Z +@ cdecl -arch=win64 ?open@ifstream@@QEAAXPEBDHH@Z(ptr str long long) msvcirt.?open@ifstream@@QEAAXPEBDHH@Z @ stub -arch=win32 ?open@ofstream@@QAEXPBDHH@Z @ stub -arch=win64 ?open@ofstream@@QEAAXPEBDHH@Z @ extern ?openprot@filebuf@@2HB msvcirt.?openprot@filebuf@@2HB @@ -672,8 +672,8 @@ @ cdecl -arch=win64 ?raw_name@type_info@@QEBAPEBDXZ(ptr) msvcrt.?raw_name@type_info@@QEBAPEBDXZ @ stub -arch=win32 ?rdbuf@fstream@@QBEPAVfilebuf@@XZ @ stub -arch=win64 ?rdbuf@fstream@@QEBAPEAVfilebuf@@XZ -@ stub -arch=win32 ?rdbuf@ifstream@@QBEPAVfilebuf@@XZ -@ stub -arch=win64 ?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ +@ thiscall -arch=win32 ?rdbuf@ifstream@@QBEPAVfilebuf@@XZ(ptr) msvcirt.?rdbuf@ifstream@@QBEPAVfilebuf@@XZ +@ cdecl -arch=win64 ?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ(ptr) msvcirt.?rdbuf@ifstream@@QEBAPEAVfilebuf@@XZ @ thiscall -arch=win32 ?rdbuf@ios@@QBEPAVstreambuf@@XZ(ptr) msvcirt.?rdbuf@ios@@QBEPAVstreambuf@@XZ @ cdecl -arch=win64 ?rdbuf@ios@@QEBAPEAVstreambuf@@XZ(ptr) msvcirt.?rdbuf@ios@@QEBAPEAVstreambuf@@XZ @ thiscall -arch=win32 ?rdbuf@istrstream@@QBEPAVstrstreambuf@@XZ(ptr) msvcirt.?rdbuf@istrstream@@QBEPAVstrstreambuf@@XZ @@ -723,8 +723,8 @@ @ cdecl -arch=win64 ?setbuf@filebuf@@UEAAPEAVstreambuf@@PEADH@Z(ptr ptr long) msvcirt.?setbuf@filebuf@@UEAAPEAVstreambuf@@PEADH@Z @ stub -arch=win32 ?setbuf@fstream@@QAEPAVstreambuf@@PADH@Z @ stub -arch=win64 ?setbuf@fstream@@QEAAPEAVstreambuf@@PEADH@Z -@ stub -arch=win32 ?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z -@ stub -arch=win64 ?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z +@ thiscall -arch=win32 ?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z(ptr ptr long) msvcirt.?setbuf@ifstream@@QAEPAVstreambuf@@PADH@Z +@ cdecl -arch=win64 ?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z(ptr ptr long) msvcirt.?setbuf@ifstream@@QEAAPEAVstreambuf@@PEADH@Z @ stub -arch=win32 ?setbuf@ofstream@@QAEPAVstreambuf@@PADH@Z @ stub -arch=win64 ?setbuf@ofstream@@QEAAPEAVstreambuf@@PEADH@Z @ thiscall -arch=win32 ?setbuf@streambuf@@UAEPAV1@PADH@Z(ptr ptr long) msvcirt.?setbuf@streambuf@@UAEPAV1@PADH@Z @@ -745,8 +745,8 @@ @ cdecl -arch=win64 ?setmode@filebuf@@QEAAHH@Z(ptr long) msvcirt.?setmode@filebuf@@QEAAHH@Z @ stub -arch=win32 ?setmode@fstream@@QAEHH@Z @ stub -arch=win64 ?setmode@fstream@@QEAAHH@Z -@ stub -arch=win32 ?setmode@ifstream@@QAEHH@Z -@ stub -arch=win64 ?setmode@ifstream@@QEAAHH@Z +@ thiscall -arch=win32 ?setmode@ifstream@@QAEHH@Z(ptr long) msvcirt.?setmode@ifstream@@QAEHH@Z +@ cdecl -arch=win64 ?setmode@ifstream@@QEAAHH@Z(ptr long) msvcirt.?setmode@ifstream@@QEAAHH@Z @ stub -arch=win32 ?setmode@ofstream@@QAEHH@Z @ stub -arch=win64 ?setmode@ofstream@@QEAAHH@Z @ thiscall -arch=win32 ?setp@streambuf@@IAEXPAD0@Z(ptr ptr ptr) msvcirt.?setp@streambuf@@IAEXPAD0@Z -- 2.28.0

2 1

[PATCH 1/4] kernel32: Implement SetXStateFeaturesMask().
by Paul Gofman 01 Sep '20

01 Sep '20

Signed-off-by: Paul Gofman <pgofman(a)codeweavers.com> --- .../api-ms-win-core-xstate-l1-1-0.spec | 2 +- .../api-ms-win-core-xstate-l2-1-0.spec | 2 +- dlls/kernel32/kernel32.spec | 2 +- dlls/kernelbase/kernelbase.spec | 2 +- dlls/kernelbase/memory.c | 41 +++++++++- dlls/ntdll/exception.c | 10 +++ dlls/ntdll/ntdll.spec | 1 + dlls/ntdll/tests/exception.c | 77 ++++++++++++++++++- dlls/ntoskrnl.exe/ntoskrnl.exe.spec | 1 + include/ddk/wdm.h | 1 + include/winbase.h | 1 + 11 files changed, 131 insertions(+), 9 deletions(-) diff --git a/dlls/api-ms-win-core-xstate-l1-1-0/api-ms-win-core-xstate-l1-1-0.spec b/dlls/api-ms-win-core-xstate-l1-1-0/api-ms-win-core-xstate-l1-1-0.spec index b933eca226f..0a29d660112 100644 --- a/dlls/api-ms-win-core-xstate-l1-1-0/api-ms-win-core-xstate-l1-1-0.spec +++ b/dlls/api-ms-win-core-xstate-l1-1-0/api-ms-win-core-xstate-l1-1-0.spec @@ -5,4 +5,4 @@ @ stdcall RtlInitializeExtendedContext(ptr long ptr) ntdll.RtlInitializeExtendedContext @ stdcall RtlLocateExtendedFeature(ptr long ptr) ntdll.RtlLocateExtendedFeature @ stdcall RtlLocateLegacyContext(ptr ptr) ntdll.RtlLocateLegacyContext -@ stub RtlSetExtendedFeaturesMask +@ stdcall RtlSetExtendedFeaturesMask(ptr int64) ntdll.RtlSetExtendedFeaturesMask diff --git a/dlls/api-ms-win-core-xstate-l2-1-0/api-ms-win-core-xstate-l2-1-0.spec b/dlls/api-ms-win-core-xstate-l2-1-0/api-ms-win-core-xstate-l2-1-0.spec index 5ad2df2b405..74aafa4db1c 100644 --- a/dlls/api-ms-win-core-xstate-l2-1-0/api-ms-win-core-xstate-l2-1-0.spec +++ b/dlls/api-ms-win-core-xstate-l2-1-0/api-ms-win-core-xstate-l2-1-0.spec @@ -3,4 +3,4 @@ @ stub GetXStateFeaturesMask @ stdcall -arch=i386,x86_64 InitializeContext(ptr long ptr ptr) kernel32.InitializeContext @ stdcall -arch=i386,x86_64 LocateXStateFeature(ptr long ptr) kernel32.LocateXStateFeature -@ stub SetXStateFeaturesMask +@ stdcall -arch=i386,x86_64 SetXStateFeaturesMask(ptr int64) kernel32.SetXStateFeaturesMask diff --git a/dlls/kernel32/kernel32.spec b/dlls/kernel32/kernel32.spec index c22f3000bf0..4bcda92bf7f 100644 --- a/dlls/kernel32/kernel32.spec +++ b/dlls/kernel32/kernel32.spec @@ -895,7 +895,7 @@ @ stdcall -import GetWindowsDirectoryA(ptr long) @ stdcall -import GetWindowsDirectoryW(ptr long) @ stdcall -import GetWriteWatch(long ptr long ptr ptr ptr) -# @ stub GetXStateFeaturesMask +@ stdcall -import -arch=i386,x86_64 SetXStateFeaturesMask(ptr int64) @ stdcall GlobalAddAtomA(str) @ stdcall GlobalAddAtomW(wstr) @ stdcall -import GlobalAlloc(long long) diff --git a/dlls/kernelbase/kernelbase.spec b/dlls/kernelbase/kernelbase.spec index ef862c57a4f..d2832600091 100644 --- a/dlls/kernelbase/kernelbase.spec +++ b/dlls/kernelbase/kernelbase.spec @@ -1510,7 +1510,7 @@ @ stdcall SetUserGeoID(long) @ stdcall SetWaitableTimer(long ptr long ptr ptr long) @ stdcall SetWaitableTimerEx(long ptr long ptr ptr ptr long) -# @ stub SetXStateFeaturesMask +@ stdcall -arch=i386,x86_64 SetXStateFeaturesMask(ptr int64) @ stdcall SetupComm(long long long) # @ stub SharedLocalIsEnabled @ stdcall SignalObjectAndWait(long long long long) diff --git a/dlls/kernelbase/memory.c b/dlls/kernelbase/memory.c index ea958e1e232..f99b908494b 100644 --- a/dlls/kernelbase/memory.c +++ b/dlls/kernelbase/memory.c @@ -1236,10 +1236,10 @@ BOOL WINAPI InitializeContext( void *buffer, DWORD context_flags, CONTEXT **cont #endif +#if defined(__x86_64__) /*********************************************************************** * LocateXStateFeature (kernelbase.@) */ -#if defined(__x86_64__) void * WINAPI LocateXStateFeature( CONTEXT *context, DWORD feature_id, DWORD *length ) { if (!(context->ContextFlags & CONTEXT_AMD64)) @@ -1262,7 +1262,28 @@ void * WINAPI LocateXStateFeature( CONTEXT *context, DWORD feature_id, DWORD *le return &context->u.FltSave; } + +/*********************************************************************** + * SetXStateFeaturesMask (kernelbase.@) + */ +BOOL WINAPI SetXStateFeaturesMask( CONTEXT *context, DWORD64 feature_mask ) +{ + if (!(context->ContextFlags & CONTEXT_AMD64)) + return FALSE; + + if (feature_mask & 0x3) + context->ContextFlags |= CONTEXT_FLOATING_POINT; + + if ((context->ContextFlags & CONTEXT_XSTATE) != CONTEXT_XSTATE) + return !(feature_mask & ~(DWORD64)3); + + RtlSetExtendedFeaturesMask( (CONTEXT_EX *)(context + 1), feature_mask ); + return TRUE; +} #elif defined(__i386__) +/*********************************************************************** + * LocateXStateFeature (kernelbase.@) + */ void * WINAPI LocateXStateFeature( CONTEXT *context, DWORD feature_id, DWORD *length ) { if (!(context->ContextFlags & CONTEXT_X86)) @@ -1285,6 +1306,24 @@ void * WINAPI LocateXStateFeature( CONTEXT *context, DWORD feature_id, DWORD *le return &context->ExtendedRegisters; } + +/*********************************************************************** + * SetXStateFeaturesMask (kernelbase.@) + */ +BOOL WINAPI SetXStateFeaturesMask( CONTEXT *context, DWORD64 feature_mask ) +{ + if (!(context->ContextFlags & CONTEXT_X86)) + return FALSE; + + if (feature_mask & 0x3) + context->ContextFlags |= CONTEXT_EXTENDED_REGISTERS; + + if ((context->ContextFlags & CONTEXT_XSTATE) != CONTEXT_XSTATE) + return !(feature_mask & ~(DWORD64)3); + + RtlSetExtendedFeaturesMask( (CONTEXT_EX *)(context + 1), feature_mask ); + return TRUE; +} #endif /*********************************************************************** diff --git a/dlls/ntdll/exception.c b/dlls/ntdll/exception.c index 0e7e3b959e4..6ca22d6660f 100644 --- a/dlls/ntdll/exception.c +++ b/dlls/ntdll/exception.c @@ -861,3 +861,13 @@ void * WINAPI RtlLocateLegacyContext( CONTEXT_EX *context_ex, ULONG *length ) return (BYTE *)context_ex + context_ex->Legacy.Offset; } + +/********************************************************************** + * RtlSetExtendedFeaturesMask (NTDLL.@) + */ +void WINAPI RtlSetExtendedFeaturesMask( CONTEXT_EX *context_ex, ULONG64 feature_mask ) +{ + XSTATE *xs = (XSTATE *)((BYTE *)context_ex + context_ex->XState.Offset); + + xs->Mask = RtlGetEnabledExtendedFeatures( feature_mask ) & ~(ULONG64)3; +} diff --git a/dlls/ntdll/ntdll.spec b/dlls/ntdll/ntdll.spec index cc75aad06d1..0e17d29ed1b 100644 --- a/dlls/ntdll/ntdll.spec +++ b/dlls/ntdll/ntdll.spec @@ -946,6 +946,7 @@ @ stdcall RtlSetCurrentTransaction(ptr) @ stdcall RtlSetDaclSecurityDescriptor(ptr long ptr long) @ stdcall RtlSetEnvironmentVariable(ptr ptr ptr) +@ stdcall RtlSetExtendedFeaturesMask(ptr int64) @ stdcall RtlSetGroupSecurityDescriptor(ptr ptr long) @ stdcall RtlSetHeapInformation(long long ptr long) @ stub RtlSetInformationAcl diff --git a/dlls/ntdll/tests/exception.c b/dlls/ntdll/tests/exception.c index 4b714e4739e..7b6c65f8572 100644 --- a/dlls/ntdll/tests/exception.c +++ b/dlls/ntdll/tests/exception.c @@ -53,6 +53,7 @@ static NTSTATUS (WINAPI *pRtlInitializeExtendedContext2)(void *context, ULONG c ULONG64 compaction_mask); static void * (WINAPI *pRtlLocateExtendedFeature)(CONTEXT_EX *context_ex, ULONG feature_id, ULONG *length); static void * (WINAPI *pRtlLocateLegacyContext)(CONTEXT_EX *context_ex, ULONG *length); +static void (WINAPI *pRtlSetExtendedFeaturesMask)(CONTEXT_EX *context_ex, ULONG64 feature_mask); static NTSTATUS (WINAPI *pNtReadVirtualMemory)(HANDLE, const void*, void*, SIZE_T, SIZE_T*); static NTSTATUS (WINAPI *pNtTerminateProcess)(HANDLE handle, LONG exit_code); static NTSTATUS (WINAPI *pNtQueryInformationProcess)(HANDLE, PROCESSINFOCLASS, PVOID, ULONG, PULONG); @@ -67,6 +68,7 @@ static BOOL (WINAPI *pInitializeContext)(void *buffer, DWORD context_flags, static BOOL (WINAPI *pInitializeContext2)(void *buffer, DWORD context_flags, CONTEXT **context, DWORD *length, ULONG64 compaction_mask); static void * (WINAPI *pLocateXStateFeature)(CONTEXT *context, DWORD feature_id, DWORD *length); +static BOOL (WINAPI *pSetXStateFeaturesMask)(CONTEXT *context, DWORD64 feature_mask); #define RTL_UNLOAD_EVENT_TRACE_NUMBER 64 @@ -6224,15 +6226,15 @@ static void test_extended_context(void) }, }; ULONG expected_length, expected_length_xstate, context_flags, expected_offset; + ULONG64 enabled_features, expected_compaction; DECLSPEC_ALIGN(64) BYTE context_buffer2[2048]; DECLSPEC_ALIGN(64) BYTE context_buffer[2048]; unsigned int i, j, address_offset, test; ULONG ret, ret2, length, length2, align; - ULONG64 enabled_features; CONTEXT_EX *context_ex; + ULONG flags, flags_fpx; CONTEXT *context; unsigned data[8]; - ULONG flags; XSTATE *xs; BOOL bret; void *p; @@ -6359,6 +6361,36 @@ static void test_extended_context(void) "Got unexpected p %p, length %#x, flags %#x.\n", p, length2, flags); length2 = expected_length; + if (0) + { + /* Crashes on Windows. */ + pRtlSetExtendedFeaturesMask(context_ex, 0); + } + bret = pSetXStateFeaturesMask(context, 0); + ok(bret == !!(flags & CONTEXT_NATIVE), "Got unexpected bret %#x, flags %#x.\n", bret, flags); + context_flags = *(DWORD *)(context_buffer + context_arch[test].flags_offset); + ok(context_flags == flags, "Got unexpected ContextFlags %#x, flags %#x.\n", context_flags, flags); + + flags_fpx = flags & 0x10000 ? flags | 0x20 : flags | 0x8; + bret = pSetXStateFeaturesMask(context, 1); + ok(bret == !!(flags & CONTEXT_NATIVE), "Got unexpected bret %#x, flags %#x.\n", bret, flags); + context_flags = *(DWORD *)(context_buffer + context_arch[test].flags_offset); + ok(context_flags == (bret ? flags_fpx : flags), + "Got unexpected ContextFlags %#x, flags %#x.\n", context_flags, flags); + + bret = pSetXStateFeaturesMask(context, 2); + ok(bret == !!(flags & CONTEXT_NATIVE), "Got unexpected bret %#x, flags %#x.\n", bret, flags); + context_flags = *(DWORD *)(context_buffer + context_arch[test].flags_offset); + ok(context_flags == (bret ? flags_fpx : flags), + "Got unexpected ContextFlags %#x, flags %#x.\n", context_flags, flags); + + bret = pSetXStateFeaturesMask(context, 4); + ok(!bret, "Got unexpected bret %#x.\n", bret); + context_flags = *(DWORD *)(context_buffer + context_arch[test].flags_offset); + ok(context_flags == (flags & CONTEXT_NATIVE ? flags_fpx : flags), + "Got unexpected ContextFlags %#x, flags %#x.\n", context_flags, flags); + *(DWORD *)(context_buffer + context_arch[test].flags_offset) = flags; + for (j = 0; j < context_arch[test].flags_offset; ++j) { if (context_buffer[j] != 0xcc) @@ -6469,6 +6501,7 @@ static void test_extended_context(void) } flags = context_arch[test].flag | 0x40; + flags_fpx = flags & 0x10000 ? flags | 0x20 : flags | 0x8; length = 0xdeadbeef; ret = pRtlGetExtendedContextLength(flags, &length); @@ -6629,11 +6662,40 @@ static void test_extended_context(void) else ok(!p && length2 == 0xdeadbeef, "Got unexpected p %p, length %#x, flags %#x.\n", p, length2, flags); + expected_compaction = compaction_enabled ? ((ULONG64)1 << 63) | enabled_features : 0; ok(!xs->Mask, "Got unexpected Mask %s.\n", wine_dbgstr_longlong(xs->Mask)); - ok(xs->CompactionMask == (compaction_enabled ? ((ULONG64)1 << 63) | enabled_features : 0), + ok(xs->CompactionMask == expected_compaction, "Got unexpected CompactionMask %s.\n", wine_dbgstr_longlong(xs->CompactionMask)); ok(!xs->Reserved[0], "Got unexpected Reserved[0] %s.\n", wine_dbgstr_longlong(xs->Reserved[0])); + xs->Mask = 0xdeadbeef; + xs->CompactionMask = 0xdeadbeef; + pRtlSetExtendedFeaturesMask(context_ex, 0); + ok(!xs->Mask, "Got unexpected Mask %s.\n", wine_dbgstr_longlong(xs->Mask)); + ok(xs->CompactionMask == 0xdeadbeef, "Got unexpected CompactionMask %s.\n", wine_dbgstr_longlong(xs->CompactionMask)); + context_flags = *(DWORD *)(context_buffer + context_arch[test].flags_offset); + ok(context_flags == flags, "Got unexpected ContextFlags %#x, flags %#x.\n", context->ContextFlags, flags); + + xs->Mask = 0xdeadbeef; + xs->CompactionMask = 0; + pRtlSetExtendedFeaturesMask(context_ex, ~(ULONG64)0); + ok(xs->Mask == (enabled_features & ~(ULONG64)3), "Got unexpected Mask %s.\n", wine_dbgstr_longlong(xs->Mask)); + ok(!xs->CompactionMask, "Got unexpected CompactionMask %s.\n", + wine_dbgstr_longlong(xs->CompactionMask)); + context_flags = *(DWORD *)(context_buffer + context_arch[test].flags_offset); + ok(context_flags == flags, "Got unexpected ContextFlags %#x, flags %#x.\n", context->ContextFlags, flags); + + xs->Mask = 0xdeadbeef; + xs->CompactionMask = 0xdeadbeef; + bret = pSetXStateFeaturesMask(context, 7); + ok(bret == !!(flags & CONTEXT_NATIVE), "Got unexpected bret %#x.\n", bret); + context_flags = *(DWORD *)(context_buffer + context_arch[test].flags_offset); + ok(context_flags == (bret ? flags_fpx : flags), + "Got unexpected ContextFlags %#x, flags %#x.\n", context_flags, flags); + ok(xs->Mask == bret ? 4 : 0xdeadbeef, "Got unexpected Mask %s.\n", wine_dbgstr_longlong(xs->Mask)); + ok(xs->CompactionMask == bret ? expected_compaction : 0xdeadbeef, "Got unexpected CompactionMask %s.\n", + wine_dbgstr_longlong(xs->CompactionMask)); + if (pRtlGetExtendedContextLength2) { memset(context_buffer, 0xcc, sizeof(context_buffer)); @@ -6690,11 +6752,16 @@ static void test_extended_context(void) + context_ex->XState.Offset + context_ex->XState.Length, "Got unexpected Length %#x, flags %#x.\n", context_ex->All.Length, flags); + expected_compaction = compaction_enabled ? (ULONG64)1 << 63 : 0; xs = (XSTATE *)((BYTE *)context_ex + context_ex->XState.Offset); ok(!xs->Mask, "Got unexpected Mask %s.\n", wine_dbgstr_longlong(xs->Mask)); - ok(xs->CompactionMask == (compaction_enabled ? (ULONG64)1 << 63 : 0), + ok(xs->CompactionMask == expected_compaction, "Got unexpected CompactionMask %s.\n", wine_dbgstr_longlong(xs->CompactionMask)); ok(!xs->Reserved[0], "Got unexpected Reserved[0] %s.\n", wine_dbgstr_longlong(xs->Reserved[0])); + + pRtlSetExtendedFeaturesMask(context_ex, ~(ULONG64)0); + ok(xs->Mask == (enabled_features & ~(ULONG64)3), "Got unexpected Mask %s.\n", wine_dbgstr_longlong(xs->Mask)); + ok(xs->CompactionMask == expected_compaction, "Got unexpected CompactionMask %s.\n", wine_dbgstr_longlong(xs->CompactionMask)); } } @@ -6790,6 +6857,7 @@ START_TEST(exception) X(RtlInitializeExtendedContext2); X(RtlLocateExtendedFeature); X(RtlLocateLegacyContext); + X(RtlSetExtendedFeaturesMask); #undef X #define X(f) p##f = (void*)GetProcAddress(hkernel32, #f) @@ -6799,6 +6867,7 @@ START_TEST(exception) X(InitializeContext); X(InitializeContext2); X(LocateXStateFeature); + X(SetXStateFeaturesMask); #undef X if (pRtlAddVectoredExceptionHandler && pRtlRemoveVectoredExceptionHandler) diff --git a/dlls/ntoskrnl.exe/ntoskrnl.exe.spec b/dlls/ntoskrnl.exe/ntoskrnl.exe.spec index a900796359c..ffd8f7dcd4c 100644 --- a/dlls/ntoskrnl.exe/ntoskrnl.exe.spec +++ b/dlls/ntoskrnl.exe/ntoskrnl.exe.spec @@ -1235,6 +1235,7 @@ @ stdcall RtlSetBits(ptr long long) @ stdcall RtlSetControlSecurityDescriptor(ptr long long) @ stdcall RtlSetDaclSecurityDescriptor(ptr long ptr long) +@ stdcall RtlSetExtendedFeaturesMask(ptr int64) @ stdcall RtlSetGroupSecurityDescriptor(ptr ptr long) @ stdcall RtlSetOwnerSecurityDescriptor(ptr ptr long) @ stdcall RtlSetSaclSecurityDescriptor(ptr long ptr long) diff --git a/include/ddk/wdm.h b/include/ddk/wdm.h index 2115627d3a6..3938645da94 100644 --- a/include/ddk/wdm.h +++ b/include/ddk/wdm.h @@ -1845,6 +1845,7 @@ NTSTATUS WINAPI RtlGetExtendedContextLength2(ULONG,ULONG*,ULONG64); void * WINAPI RtlLocateLegacyContext(CONTEXT_EX*,ULONG*); void * WINAPI RtlLocateExtendedFeature(CONTEXT_EX*,ULONG,ULONG*); void * WINAPI RtlLocateExtendedFeature2(CONTEXT_EX*,ULONG,XSTATE_CONFIGURATION*,ULONG*); +void WINAPI RtlSetExtendedFeaturesMask(CONTEXT_EX*,ULONG64); #endif #ifdef __x86_64__ diff --git a/include/winbase.h b/include/winbase.h index d5ed5db8d7b..f741f0a09dc 100644 --- a/include/winbase.h +++ b/include/winbase.h @@ -2700,6 +2700,7 @@ WINBASEAPI BOOL WINAPI SetVolumeMountPointW(LPCWSTR,LPCWSTR); WINBASEAPI BOOL WINAPI SetWaitableTimer(HANDLE,const LARGE_INTEGER*,LONG,PTIMERAPCROUTINE,LPVOID,BOOL); WINBASEAPI BOOL WINAPI SetWaitableTimerEx(HANDLE,const LARGE_INTEGER*,LONG,PTIMERAPCROUTINE,LPVOID,REASON_CONTEXT*,ULONG); WINBASEAPI BOOL WINAPI SetUmsThreadInformation(PUMS_CONTEXT,UMS_THREAD_INFO_CLASS,void *,ULONG); +WINBASEAPI BOOL WINAPI SetXStateFeaturesMask(CONTEXT*, DWORD64); WINBASEAPI BOOL WINAPI SetupComm(HANDLE,DWORD,DWORD); WINBASEAPI DWORD WINAPI SignalObjectAndWait(HANDLE,HANDLE,DWORD,BOOL); WINBASEAPI DWORD WINAPI SizeofResource(HMODULE,HRSRC); -- 2.26.2

2 8

[PATCH 1/5] kernel32/tests: Skip more FreeConsole tests on win7.
by Jacek Caban 01 Sep '20

01 Sep '20

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- dlls/kernel32/tests/console.c | 17 ++++++++--------- 1 file changed, 8 insertions(+), 9 deletions(-)

2 1

[PATCH 5/5] conhost: Support CTRL_C_EVENT in write_console_input.
by Jacek Caban 01 Sep '20

01 Sep '20

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- programs/conhost/conhost.c | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-)

1 0

[PATCH 4/5] server: Support IOCTL_CONDRV_CTRL_EVENT on console server handles.
by Jacek Caban 01 Sep '20

01 Sep '20

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- server/console.c | 65 +++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 64 insertions(+), 1 deletion(-)

1 0

[PATCH 2/5] server: Introduce IOCTL_CONDRV_CTRL_EVENT ioctl.
by Jacek Caban 01 Sep '20

01 Sep '20

Signed-off-by: Jacek Caban <jacek(a)codeweavers.com> --- include/wine/condrv.h | 8 ++++++++ server/console.c | 19 +++++++++++++++++++ server/trace.c | 1 + 3 files changed, 28 insertions(+)

1 0

[PATCH v2 0/7] NDIS patchset
by Isabella Bosia 01 Sep '20

01 Sep '20

I think I've addressed all the issues that were mentioned. I've moved the test from iphlpapi to ndis.sys. I think I'm using the LoadOrderGroup correctly and it doesn't create any extra processes. I also removed the creation of the symlink with DefineDosDevice. It was inspired by some code I reversed in a third party dll, which the patches are trying to address. v1: https://www.winehq.org/pipermail/wine-devel/2020-August/172383.html Isabella Bosia (7): iphlpapi: Unify conversions to interface guid. iphlpapi: Make the interface guids more unique. wine.inf: Create NDIS service. ndis.sys: Create network card registry keys. ndis.sys: Create network card devices. ndis.sys: Implement IOCTL_NDIS_QUERY_GLOBAL_STATS on network cards. ndis.sys/tests: Add tests for ndis ioctls. configure.ac | 1 + dlls/iphlpapi/iphlpapi_main.c | 12 ++- dlls/ndis.sys/Makefile.in | 1 + dlls/ndis.sys/main.c | 159 ++++++++++++++++++++++++++++++++ dlls/ndis.sys/tests/Makefile.in | 5 + dlls/ndis.sys/tests/ndis.c | 146 +++++++++++++++++++++++++++++ loader/wine.inf.in | 14 +++ 7 files changed, 336 insertions(+), 2 deletions(-) create mode 100644 dlls/ndis.sys/tests/Makefile.in create mode 100644 dlls/ndis.sys/tests/ndis.c -- 2.25.1

1 7

Jump to page:

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

2003

2002

2001

wine-devel