/*********************************************************************** * 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; }