/***********************************************************************
* WININET_SetAuthorization
*/
static BOOL WININET_SetAuthorization( HINTERNET hRequest, LPWSTR username,
LPWSTR password, BOOL proxy )
{
http_request_t *lpwhr;
http_session_t *lpwhs;
BOOL ret = FALSE;
LPWSTR p, q;
lpwhr = (http_request_t*) WININET_GetObject( hRequest );
if( !lpwhr )
return FALSE;
lpwhs = lpwhr->lpHttpSession;
if (NULL == lpwhs || lpwhs->hdr.htype != WH_HHTTPSESSION)
{
INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
goto done;
}
p = heap_strdupW(username);
if( !p )
goto done;
q = heap_strdupW(password);
if( !q )
{
HeapFree(GetProcessHeap(), 0, username);
goto done;
}
if (proxy)
{
appinfo_t *hIC = lpwhs->lpAppInfo;
HeapFree(GetProcessHeap(), 0, hIC->lpszProxyUsername);
hIC->lpszProxyUsername = p;
HeapFree(GetProcessHeap(), 0, hIC->lpszProxyPassword);
hIC->lpszProxyPassword = q;
}
else
{
HeapFree(GetProcessHeap(), 0, lpwhs->lpszUserName);
lpwhs->lpszUserName = p;
HeapFree(GetProcessHeap(), 0, lpwhs->lpszPassword);
lpwhs->lpszPassword = q;
}
ret = TRUE;
done:
WININET_Release( &lpwhr->hdr );
return ret;
}
/***********************************************************************
* WININET_SetAuthorization
*/
static BOOL WININET_SetAuthorization( HINTERNET hRequest, LPWSTR username,
LPWSTR password, BOOL proxy )
{
http_request_t *request;
http_session_t *session;
BOOL ret = FALSE;
LPWSTR p, q;
request = (http_request_t*) get_handle_object( hRequest );
if( !request )
return FALSE;
session = request->session;
if (NULL == session || session->hdr.htype != WH_HHTTPSESSION)
{
INTERNET_SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
goto done;
}
p = heap_strdupW(username);
if( !p )
goto done;
q = heap_strdupW(password);
if( !q )
{
heap_free(username);
goto done;
}
if (proxy)
{
appinfo_t *hIC = session->appInfo;
heap_free(hIC->proxyUsername);
hIC->proxyUsername = p;
heap_free(hIC->proxyPassword);
hIC->proxyPassword = q;
}
else
{
heap_free(session->userName);
session->userName = p;
heap_free(session->password);
session->password = q;
}
ret = TRUE;
done:
WININET_Release( &request->hdr );
return ret;
}
HRESULT TaskFolderCollection_create(const WCHAR *path, ITaskFolderCollection **obj)
{
TaskFolderCollection *folders;
HRESULT hr;
TASK_NAMES list;
DWORD start_index, count;
start_index = 0;
list = NULL;
hr = SchRpcEnumFolders(path, 0, &start_index, 0, &count, &list);
if (hr != S_OK) return hr;
folders = heap_alloc(sizeof(*folders));
if (!folders)
{
free_list(list, count);
return E_OUTOFMEMORY;
}
folders->ITaskFolderCollection_iface.lpVtbl = &TaskFolderCollection_vtbl;
folders->ref = 1;
if (!(folders->path = heap_strdupW(path)))
{
heap_free(folders);
return E_OUTOFMEMORY;
}
folders->count = count;
folders->list = list;
*obj = &folders->ITaskFolderCollection_iface;
TRACE("created %p\n", *obj);
return S_OK;
}
static HRESULT WINAPI BPInternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
{
BindProtocol *This = impl_from_IInternetProtocolSink(iface);
TRACE("(%p)->(%08x %d %s)\n", This, hrResult, dwError, debugstr_w(szResult));
if(!This->protocol_sink)
return E_FAIL;
This->reported_result = TRUE;
if(!do_direct_notif(This)) {
report_result_task_t *task;
task = heap_alloc(sizeof(report_result_task_t));
if(!task)
return E_OUTOFMEMORY;
task->hres = hrResult;
task->err = dwError;
task->str = heap_strdupW(szResult);
push_task(This, &task->header, report_result_proc);
return S_OK;
}
return IInternetProtocolSink_ReportResult(This->protocol_sink_handler, hrResult, dwError, szResult);
}
static BindStatusCallback *create_callback(DocHost *doc_host, LPCWSTR url, PBYTE post_data,
ULONG post_data_len, LPCWSTR headers)
{
BindStatusCallback *ret = heap_alloc(sizeof(BindStatusCallback));
ret->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
ret->IHttpNegotiate_iface.lpVtbl = &HttpNegotiateVtbl;
ret->ref = 1;
ret->url = heap_strdupW(url);
ret->post_data = NULL;
ret->post_data_len = post_data_len;
ret->headers = headers ? SysAllocString(headers) : NULL;
ret->doc_host = doc_host;
IOleClientSite_AddRef(&doc_host->IOleClientSite_iface);
ret->binding = NULL;
if(post_data) {
ret->post_data = GlobalAlloc(0, post_data_len);
memcpy(ret->post_data, post_data, post_data_len);
}
return ret;
}
static HRESULT DownloadBSC_Create(IBindStatusCallback *callback, LPCWSTR file_name, DownloadBSC **ret_callback)
{
DownloadBSC *ret;
ret = heap_alloc_zero(sizeof(*ret));
if(!ret)
return E_OUTOFMEMORY;
ret->IBindStatusCallback_iface.lpVtbl = &BindStatusCallbackVtbl;
ret->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
ret->ref = 1;
if(file_name) {
ret->file_name = heap_strdupW(file_name);
if(!ret->file_name) {
heap_free(ret);
return E_OUTOFMEMORY;
}
}
if(callback)
IBindStatusCallback_AddRef(callback);
ret->callback = callback;
*ret_callback = ret;
return S_OK;
}
static HRESULT WINAPI DownloadBSC_OnProgress(IBindStatusCallback *iface, ULONG ulProgress,
ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
{
DownloadBSC *This = STATUSCLB_THIS(iface);
HRESULT hres = S_OK;
TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
debugstr_w(szStatusText));
switch(ulStatusCode) {
case BINDSTATUS_CONNECTING:
case BINDSTATUS_BEGINDOWNLOADDATA:
case BINDSTATUS_DOWNLOADINGDATA:
case BINDSTATUS_ENDDOWNLOADDATA:
case BINDSTATUS_SENDINGREQUEST:
case BINDSTATUS_MIMETYPEAVAILABLE:
hres = on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText);
break;
case BINDSTATUS_CACHEFILENAMEAVAILABLE:
hres = on_progress(This, ulProgress, ulProgressMax, ulStatusCode, szStatusText);
This->cache_file = heap_strdupW(szStatusText);
break;
case BINDSTATUS_FINDINGRESOURCE: /* FIXME */
break;
default:
FIXME("Unsupported status %u\n", ulStatusCode);
}
return hres;
}
static HRESULT get_dynamic_prop(DispatchEx *This, const WCHAR *name, DWORD flags, dynamic_prop_t **ret)
{
const BOOL alloc = flags & fdexNameEnsure;
dispex_dynamic_data_t *data;
dynamic_prop_t *prop;
data = get_dynamic_data(This, alloc);
if(!data) {
if(alloc)
return E_OUTOFMEMORY;
TRACE("not found %s\n", debugstr_w(name));
return DISP_E_UNKNOWNNAME;
}
for(prop = data->props; prop < data->props+data->prop_cnt; prop++) {
if(flags & fdexNameCaseInsensitive ? !strcmpiW(prop->name, name) : !strcmpW(prop->name, name)) {
if(prop->flags & DYNPROP_DELETED) {
if(!alloc)
return DISP_E_UNKNOWNNAME;
prop->flags &= ~DYNPROP_DELETED;
}
*ret = prop;
return S_OK;
}
}
if(!alloc)
return DISP_E_UNKNOWNNAME;
TRACE("creating dynamic prop %s\n", debugstr_w(name));
if(!data->buf_size) {
data->props = heap_alloc(sizeof(dynamic_prop_t)*4);
if(!data->props)
return E_OUTOFMEMORY;
data->buf_size = 4;
}else if(data->buf_size == data->prop_cnt) {
dynamic_prop_t *new_props;
new_props = heap_realloc(data->props, sizeof(dynamic_prop_t)*(data->buf_size<<1));
if(!new_props)
return E_OUTOFMEMORY;
data->props = new_props;
data->buf_size <<= 1;
}
prop = data->props + data->prop_cnt;
prop->name = heap_strdupW(name);
if(!prop->name)
return E_OUTOFMEMORY;
VariantInit(&prop->var);
prop->flags = 0;
data->prop_cnt++;
*ret = prop;
return S_OK;
}
static void mime_available(BindProtocol *This, LPCWSTR mime, BOOL verified)
{
IInternetProtocol *mime_filter;
HRESULT hres;
heap_free(This->mime);
This->mime = NULL;
mime_filter = get_mime_filter(mime);
if(mime_filter) {
TRACE("Got mime filter for %s\n", debugstr_w(mime));
hres = handle_mime_filter(This, mime_filter, mime);
IInternetProtocol_Release(mime_filter);
if(FAILED(hres))
FIXME("MIME filter failed: %08x\n", hres);
}else {
This->mime = heap_strdupW(mime);
if(verified || !(This->pi & PI_MIMEVERIFICATION)) {
This->reported_mime = TRUE;
if(This->protocol_sink)
IInternetProtocolSink_ReportProgress(This->protocol_sink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
}
}
}
VOID INTERNET_SendCallback(object_header_t *hdr, DWORD_PTR dwContext,
DWORD dwInternetStatus, LPVOID lpvStatusInfo,
DWORD dwStatusInfoLength)
{
LPVOID lpvNewInfo = NULL;
if( !hdr->lpfnStatusCB )
return;
/* the IE5 version of wininet does not
send callbacks if dwContext is zero */
if( !dwContext )
return;
lpvNewInfo = lpvStatusInfo;
if(hdr->dwInternalFlags & INET_CALLBACKW) {
switch(dwInternetStatus) {
case INTERNET_STATUS_NAME_RESOLVED:
case INTERNET_STATUS_CONNECTING_TO_SERVER:
case INTERNET_STATUS_CONNECTED_TO_SERVER:
lpvNewInfo = heap_strdupAtoW(lpvStatusInfo);
dwStatusInfoLength *= sizeof(WCHAR);
break;
case INTERNET_STATUS_RESOLVING_NAME:
case INTERNET_STATUS_REDIRECT:
lpvNewInfo = heap_strdupW(lpvStatusInfo);
break;
}
}else {
switch(dwInternetStatus)
{
case INTERNET_STATUS_NAME_RESOLVED:
case INTERNET_STATUS_CONNECTING_TO_SERVER:
case INTERNET_STATUS_CONNECTED_TO_SERVER:
lpvNewInfo = heap_alloc(strlen(lpvStatusInfo) + 1);
if (lpvNewInfo) strcpy(lpvNewInfo, lpvStatusInfo);
break;
case INTERNET_STATUS_RESOLVING_NAME:
case INTERNET_STATUS_REDIRECT:
lpvNewInfo = heap_strdupWtoA(lpvStatusInfo);
dwStatusInfoLength /= sizeof(WCHAR);
break;
}
}
TRACE(" callback(%p) (%p (%p), %08lx, %d (%s), %p, %d)\n",
hdr->lpfnStatusCB, hdr->hInternet, hdr, dwContext, dwInternetStatus, get_callback_name(dwInternetStatus),
lpvNewInfo, dwStatusInfoLength);
hdr->lpfnStatusCB(hdr->hInternet, dwContext, dwInternetStatus,
lpvNewInfo, dwStatusInfoLength);
TRACE(" end callback().\n");
if(lpvNewInfo != lpvStatusInfo)
HeapFree(GetProcessHeap(), 0, lpvNewInfo);
}
static HRESULT WINAPI JScript_AddNamedItem(IActiveScript *iface,
LPCOLESTR pstrName, DWORD dwFlags)
{
JScript *This = impl_from_IActiveScript(iface);
named_item_t *item;
IDispatch *disp = NULL;
HRESULT hres;
TRACE("(%p)->(%s %x)\n", This, debugstr_w(pstrName), dwFlags);
if(This->thread_id != GetCurrentThreadId() || !This->ctx || This->ctx->state == SCRIPTSTATE_CLOSED)
return E_UNEXPECTED;
if(dwFlags & SCRIPTITEM_GLOBALMEMBERS) {
IUnknown *unk;
hres = IActiveScriptSite_GetItemInfo(This->site, pstrName, SCRIPTINFO_IUNKNOWN, &unk, NULL);
if(FAILED(hres)) {
WARN("GetItemInfo failed: %08x\n", hres);
return hres;
}
hres = IUnknown_QueryInterface(unk, &IID_IDispatch, (void**)&disp);
IUnknown_Release(unk);
if(FAILED(hres)) {
WARN("object does not implement IDispatch\n");
return hres;
}
if(This->ctx->host_global)
IDispatch_Release(This->ctx->host_global);
IDispatch_AddRef(disp);
This->ctx->host_global = disp;
}
item = heap_alloc(sizeof(*item));
if(!item) {
if(disp)
IDispatch_Release(disp);
return E_OUTOFMEMORY;
}
item->disp = disp;
item->flags = dwFlags;
item->name = heap_strdupW(pstrName);
if(!item->name) {
if(disp)
IDispatch_Release(disp);
heap_free(item);
return E_OUTOFMEMORY;
}
item->next = This->ctx->named_items;
This->ctx->named_items = item;
return S_OK;
}
static HRESULT WINAPI InstallCallback_OnDataAvailable(IBindStatusCallback *iface, DWORD grfBSCF,
DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
{
if(!msi_file) {
msi_file = heap_strdupW(pstgmed->u.lpszFileName);
TRACE("got file name %s\n", debugstr_w(msi_file));
}
return S_OK;
}
static HRESULT WINAPI ICreateErrorInfoImpl_SetHelpFile(
ICreateErrorInfo* iface,
LPOLESTR szHelpFile)
{
ErrorInfoImpl *This = impl_from_ICreateErrorInfo(iface);
TRACE("(%p,%s)\n",This,debugstr_w(szHelpFile));
heap_free(This->help_file);
This->help_file = heap_strdupW(szHelpFile);
return S_OK;
}
HRESULT __cdecl SchRpcRegisterTask(const WCHAR *path, const WCHAR *xml, DWORD flags, const WCHAR *sddl,
DWORD task_logon_type, DWORD n_creds, const TASK_USER_CRED *creds,
WCHAR **actual_path, TASK_XML_ERROR_INFO **xml_error_info)
{
WCHAR *full_name, *relative_path;
DWORD disposition;
HRESULT hr;
WINE_TRACE("%s,%s,%#x,%s,%u,%u,%p,%p,%p\n", wine_dbgstr_w(path), wine_dbgstr_w(xml), flags,
wine_dbgstr_w(sddl), task_logon_type, n_creds, creds, actual_path, xml_error_info);
*actual_path = NULL;
*xml_error_info = NULL;
/* FIXME: assume that validation is performed on the client side */
if (flags & TASK_VALIDATE_ONLY) return S_OK;
full_name = get_full_name(path, &relative_path);
if (!full_name) return E_OUTOFMEMORY;
if (strchrW(path, '\\') || strchrW(path, '/'))
{
WCHAR *p = strrchrW(full_name, '/');
if (!p) p = strrchrW(full_name, '\\');
*p = 0;
hr = create_directory(full_name);
*p = '\\';
}
switch (flags & (TASK_CREATE | TASK_UPDATE))
{
default:
case TASK_CREATE:
disposition = CREATE_NEW;
break;
case TASK_UPDATE:
disposition = OPEN_EXISTING;
break;
case (TASK_CREATE | TASK_UPDATE):
disposition = OPEN_ALWAYS;
break;
}
hr = write_xml_utf8(full_name, disposition, xml);
if (hr == S_OK)
{
*actual_path = heap_strdupW(relative_path);
schedsvc_auto_start();
}
heap_free(full_name);
return hr;
}
static HRESULT WINAPI ICreateErrorInfoImpl_SetDescription(
ICreateErrorInfo* iface,
LPOLESTR szDescription)
{
ErrorInfoImpl *This = impl_from_ICreateErrorInfo(iface);
TRACE("(%p): %s\n",This, debugstr_w(szDescription));
heap_free(This->description);
This->description = heap_strdupW(szDescription);
return S_OK;
}
static void cache_file_available(Binding *This, const WCHAR *file_name)
{
heap_free(This->stgmed_buf->cache_file);
This->stgmed_buf->cache_file = heap_strdupW(file_name);
if(This->use_cache_file) {
This->stgmed_buf->file = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if(This->stgmed_buf->file == INVALID_HANDLE_VALUE)
WARN("CreateFile failed: %u\n", GetLastError());
}
}
LPWSTR get_useragent(void)
{
LPWSTR ret;
ensure_useragent();
EnterCriticalSection(&session_cs);
ret = heap_strdupW(user_agent);
LeaveCriticalSection(&session_cs);
return ret;
}
static void mime_available(Binding *This, LPCWSTR mime)
{
heap_free(This->mime);
This->mime = heap_strdupW(mime);
if(!This->mime || !This->report_mime)
return;
IBindStatusCallback_OnProgress(This->callback, 0, 0, BINDSTATUS_MIMETYPEAVAILABLE, This->mime);
This->clipboard_format = RegisterClipboardFormatW(This->mime);
}
static HRESULT WINAPI ICreateErrorInfoImpl_SetSource(
ICreateErrorInfo* iface,
LPOLESTR szSource)
{
ErrorInfoImpl *This = impl_from_ICreateErrorInfo(iface);
TRACE("(%p): %s\n",This, debugstr_w(szSource));
heap_free(This->source);
This->source = heap_strdupW(szSource);
return S_OK;
}
static HRESULT WINAPI InternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
ULONG ulStatusCode, LPCWSTR szStatusText)
{
Binding *This = PROTSINK_THIS(iface);
TRACE("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
switch(ulStatusCode) {
case BINDSTATUS_FINDINGRESOURCE:
on_progress(This, 0, 0, BINDSTATUS_FINDINGRESOURCE, szStatusText);
break;
case BINDSTATUS_CONNECTING:
on_progress(This, 0, 0, BINDSTATUS_CONNECTING, szStatusText);
break;
case BINDSTATUS_REDIRECTING:
heap_free(This->redirect_url);
This->redirect_url = heap_strdupW(szStatusText);
on_progress(This, 0, 0, BINDSTATUS_REDIRECTING, szStatusText);
break;
case BINDSTATUS_BEGINDOWNLOADDATA:
fill_stgmed_buffer(This->stgmed_buf);
break;
case BINDSTATUS_SENDINGREQUEST:
on_progress(This, 0, 0, BINDSTATUS_SENDINGREQUEST, szStatusText);
break;
case BINDSTATUS_PROTOCOLCLASSID:
break;
case BINDSTATUS_MIMETYPEAVAILABLE:
case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
mime_available(This, szStatusText);
break;
case BINDSTATUS_CACHEFILENAMEAVAILABLE:
cache_file_available(This, szStatusText);
break;
case BINDSTATUS_DECODING:
IBindStatusCallback_OnProgress(This->callback, 0, 0, BINDSTATUS_DECODING, szStatusText);
break;
case BINDSTATUS_LOADINGMIMEHANDLER:
on_progress(This, 0, 0, BINDSTATUS_LOADINGMIMEHANDLER, szStatusText);
break;
case BINDSTATUS_DIRECTBIND: /* FIXME: Handle BINDSTATUS_DIRECTBIND in BindProtocol */
This->report_mime = FALSE;
break;
case BINDSTATUS_ACCEPTRANGES:
break;
default:
FIXME("Unhandled status code %d\n", ulStatusCode);
return E_NOTIMPL;
};
return S_OK;
}
/***********************************************************************
* WININET_SetAuthorization
*/
static BOOL WININET_SetAuthorization( http_request_t *request, LPWSTR username,
LPWSTR password, BOOL proxy )
{
http_session_t *session = request->session;
LPWSTR p, q;
p = heap_strdupW(username);
if( !p )
return FALSE;
q = heap_strdupW(password);
if( !q )
{
heap_free(p);
return FALSE;
}
if (proxy)
{
appinfo_t *hIC = session->appInfo;
heap_free(hIC->proxyUsername);
hIC->proxyUsername = p;
heap_free(hIC->proxyPassword);
hIC->proxyPassword = q;
}
else
{
heap_free(session->userName);
session->userName = p;
heap_free(session->password);
session->password = q;
}
return TRUE;
}
HRESULT create_textformat(const WCHAR *family_name, IDWriteFontCollection *collection, DWRITE_FONT_WEIGHT weight, DWRITE_FONT_STYLE style,
DWRITE_FONT_STRETCH stretch, FLOAT size, const WCHAR *locale, IDWriteTextFormat **format)
{
struct dwrite_textformat *This;
*format = NULL;
This = heap_alloc(sizeof(struct dwrite_textformat));
if (!This) return E_OUTOFMEMORY;
This->IDWriteTextFormat_iface.lpVtbl = &dwritetextformatvtbl;
This->ref = 1;
This->format.family_name = heap_strdupW(family_name);
This->format.locale = heap_strdupW(locale);
This->format.locale_len = strlenW(locale);
This->format.weight = weight;
This->format.style = style;
This->format.size = size;
if (collection)
{
This->format.collection = collection;
IDWriteFontCollection_AddRef(collection);
}
else
{
HRESULT hr = get_system_fontcollection(&This->format.collection);
if (hr != S_OK)
{
IDWriteTextFormat_Release(&This->IDWriteTextFormat_iface);
return hr;
}
}
*format = &This->IDWriteTextFormat_iface;
return S_OK;
}
static HRESULT get_dynamic_prop(DispatchEx *This, const WCHAR *name, BOOL alloc, dynamic_prop_t **ret)
{
dispex_dynamic_data_t *data = This->dynamic_data;
if(data) {
unsigned i;
for(i=0; i < data->prop_cnt; i++) {
if(!strcmpW(data->props[i].name, name)) {
*ret = data->props+i;
return S_OK;
}
}
}
if(alloc) {
TRACE("creating dynamic prop %s\n", debugstr_w(name));
if(!data) {
data = This->dynamic_data = heap_alloc_zero(sizeof(dispex_dynamic_data_t));
if(!data)
return E_OUTOFMEMORY;
}
if(!data->buf_size) {
data->props = heap_alloc(sizeof(dynamic_prop_t)*4);
if(!data->props)
return E_OUTOFMEMORY;
data->buf_size = 4;
}else if(data->buf_size == data->prop_cnt) {
dynamic_prop_t *new_props;
new_props = heap_realloc(data->props, sizeof(dynamic_prop_t)*(data->buf_size<<1));
if(!new_props)
return E_OUTOFMEMORY;
data->props = new_props;
data->buf_size <<= 1;
}
data->props[data->prop_cnt].name = heap_strdupW(name);
VariantInit(&data->props[data->prop_cnt].var);
*ret = data->props + data->prop_cnt++;
return S_OK;
}
TRACE("not found %s\n", debugstr_w(name));
return DISP_E_UNKNOWNNAME;
}
static HRESULT WINAPI IDirectPlay8ClientImpl_SetClientInfo(IDirectPlay8Client *iface,
const DPN_PLAYER_INFO * const pdpnPlayerInfo, void * const pvAsyncContext,
DPNHANDLE * const phAsyncHandle, const DWORD dwFlags)
{
IDirectPlay8ClientImpl *This = impl_from_IDirectPlay8Client(iface);
FIXME("(%p):(%p,%p,%x): Semi-stub.\n", This, pvAsyncContext, phAsyncHandle, dwFlags);
if(!pdpnPlayerInfo)
return E_POINTER;
if(phAsyncHandle)
FIXME("Async handle currently not supported.\n");
if (pdpnPlayerInfo->dwInfoFlags & DPNINFO_NAME)
{
heap_free(This->username);
This->username = NULL;
if(pdpnPlayerInfo->pwszName)
{
This->username = heap_strdupW(pdpnPlayerInfo->pwszName);
if (!This->username)
return E_OUTOFMEMORY;
}
}
if (pdpnPlayerInfo->dwInfoFlags & DPNINFO_DATA)
{
heap_free(This->data);
This->data = NULL;
This->datasize = 0;
if(!pdpnPlayerInfo->pvData && pdpnPlayerInfo->dwDataSize)
return E_POINTER;
if(pdpnPlayerInfo->dwDataSize && pdpnPlayerInfo->pvData)
{
This->data = heap_alloc(pdpnPlayerInfo->dwDataSize);
if (!This->data)
return E_OUTOFMEMORY;
This->datasize = pdpnPlayerInfo->dwDataSize;
memcpy(This->data, pdpnPlayerInfo->pvData, pdpnPlayerInfo->dwDataSize);
}
}
return DPN_OK;
}
HRESULT RegisteredTask_create(const WCHAR *path, IRegisteredTask **obj)
{
RegisteredTask *regtask;
regtask = heap_alloc(sizeof(*regtask));
if (!regtask) return E_OUTOFMEMORY;
regtask->IRegisteredTask_iface.lpVtbl = &RegisteredTask_vtbl;
regtask->path = heap_strdupW(path);
regtask->ref = 1;
*obj = ®task->IRegisteredTask_iface;
TRACE("created %p\n", *obj);
return S_OK;
}
HRESULT RegisteredTaskCollection_create(const WCHAR *path, IRegisteredTaskCollection **obj)
{
RegisteredTaskCollection *regtasks;
regtasks = heap_alloc(sizeof(*regtasks));
if (!regtasks) return E_OUTOFMEMORY;
regtasks->IRegisteredTaskCollection_iface.lpVtbl = &RegisteredTaskCollection_vtbl;
regtasks->ref = 1;
regtasks->path = heap_strdupW(path);
*obj = ®tasks->IRegisteredTaskCollection_iface;
TRACE("created %p\n", *obj);
return S_OK;
}
static HRESULT DownloadBSC_Create(IBindStatusCallback *callback, LPCWSTR file_name, IBindStatusCallback **ret_callback)
{
DownloadBSC *ret = heap_alloc(sizeof(*ret));
ret->lpBindStatusCallbackVtbl = &BindStatusCallbackVtbl;
ret->lpServiceProviderVtbl = &ServiceProviderVtbl;
ret->ref = 1;
ret->file_name = heap_strdupW(file_name);
ret->cache_file = NULL;
if(callback)
IBindStatusCallback_AddRef(callback);
ret->callback = callback;
*ret_callback = STATUSCLB(ret);
return S_OK;
}
static HRESULT set_dochost_url(DocHost *This, const WCHAR *url)
{
WCHAR *new_url;
if(url) {
new_url = heap_strdupW(url);
if(!new_url)
return E_OUTOFMEMORY;
}else {
new_url = NULL;
}
heap_free(This->url);
This->url = new_url;
This->container_vtbl->SetURL(This, This->url);
return S_OK;
}
void INTERNET_SendCallback(object_header_t *hdr, DWORD_PTR context, DWORD status, void *info, DWORD info_len)
{
void *new_info = info;
if( !hdr->lpfnStatusCB )
return;
/* the IE5 version of wininet does not
send callbacks if dwContext is zero */
if(!context)
return;
switch(status) {
case INTERNET_STATUS_NAME_RESOLVED:
case INTERNET_STATUS_CONNECTING_TO_SERVER:
case INTERNET_STATUS_CONNECTED_TO_SERVER:
new_info = heap_alloc(info_len);
if(new_info)
memcpy(new_info, info, info_len);
break;
case INTERNET_STATUS_RESOLVING_NAME:
case INTERNET_STATUS_REDIRECT:
if(hdr->dwInternalFlags & INET_CALLBACKW) {
new_info = heap_strdupW(info);
break;
}else {
new_info = heap_strdupWtoA(info);
info_len = strlen(new_info)+1;
break;
}
}
TRACE(" callback(%p) (%p (%p), %08lx, %d (%s), %s, %d)\n",
hdr->lpfnStatusCB, hdr->hInternet, hdr, context, status, get_callback_name(status),
debugstr_status_info(status, new_info), info_len);
hdr->lpfnStatusCB(hdr->hInternet, context, status, new_info, info_len);
TRACE(" end callback().\n");
if(new_info != info)
heap_free(new_info);
}
struct table *create_table( const WCHAR *name, UINT num_cols, const struct column *columns,
UINT num_rows, UINT num_allocated, BYTE *data,
enum fill_status (*fill)(struct table *, const struct expr *cond) )
{
struct table *table;
if (!(table = heap_alloc( sizeof(*table) ))) return NULL;
table->name = heap_strdupW( name );
table->num_cols = num_cols;
table->columns = columns;
table->num_rows = num_rows;
table->num_rows_allocated = num_allocated;
table->data = data;
table->fill = fill;
table->flags = TABLE_FLAG_DYNAMIC;
table->refs = 0;
list_init( &table->entry );
return table;
}
