#include <winpr/crt.h>
#include <winpr/stream.h>
-#include <freerdp/utils/event.h>
-#include <freerdp/client/cliprdr.h>
#include <freerdp/log.h>
#include <freerdp/utils/event.h>
-#include <winpr/stream.h>
#include <freerdp/client/cliprdr.h>
#include <Strsafe.h>
*(_p + 2) = ((_v) >> 16) & 0xFF; \
*(_p + 3) = ((_v) >> 24) & 0xFF; } while (0)
-BOOL wf_create_file_obj(cliprdrContext *cliprdr, IDataObject **ppDataObject);
-void wf_destroy_file_obj(IDataObject *instance);
+BOOL wf_create_file_obj(cliprdrContext* cliprdr, IDataObject** ppDataObject);
+void wf_destroy_file_obj(IDataObject* instance);
-static UINT32 get_local_format_id_by_name(cliprdrContext *cliprdr, void *format_name)
+static UINT32 get_local_format_id_by_name(cliprdrContext* cliprdr, void *format_name)
{
- formatMapping *map;
int i;
+ formatMapping* map;
for (i = 0; i < cliprdr->map_size; i++)
{
map = &cliprdr->format_mappings[i];
+
if ((cliprdr->capabilities & CB_USE_LONG_FORMAT_NAMES) != 0)
{
if (map->name)
return 0;
}
-static INLINE BOOL file_transferring(cliprdrContext *cliprdr)
+static INLINE BOOL file_transferring(cliprdrContext* cliprdr)
{
return !!get_local_format_id_by_name(cliprdr, L"FileGroupDescriptorW");
}
-static UINT32 get_remote_format_id(cliprdrContext *cliprdr, UINT32 local_format)
+static UINT32 get_remote_format_id(cliprdrContext* cliprdr, UINT32 local_format)
{
- formatMapping *map;
int i;
+ formatMapping* map;
for (i = 0; i < cliprdr->map_size; i++)
{
map = &cliprdr->format_mappings[i];
+
if (map->local_format_id == local_format)
{
return map->remote_format_id;
return local_format;
}
-static void map_ensure_capacity(cliprdrContext *cliprdr)
+static void map_ensure_capacity(cliprdrContext* cliprdr)
{
if (cliprdr->map_size >= cliprdr->map_capacity)
{
}
}
-static void clear_format_map(cliprdrContext *cliprdr)
+static void clear_format_map(cliprdrContext* cliprdr)
{
- formatMapping *map;
int i;
+ formatMapping* map;
if (cliprdr->format_mappings)
{
}
}
- cliprdr->map_size= 0;
+ cliprdr->map_size = 0;
}
/*
2.2.2.3 Client Temporary Directory PDU (CLIPRDR_TEMP_DIRECTORY)
by the server to be useful. Section 3.1.1.3 specifies how direct file access
impacts file copy and paste.
*/
-int cliprdr_send_tempdir(cliprdrContext *cliprdr)
+int cliprdr_send_tempdir(cliprdrContext* cliprdr)
{
- RDP_CB_TEMPDIR_EVENT *cliprdr_event;
+ RDP_CB_TEMPDIR_EVENT* cliprdr_event;
- cliprdr_event = (RDP_CB_TEMPDIR_EVENT *)freerdp_event_new(CliprdrChannel_Class,
+ cliprdr_event = (RDP_CB_TEMPDIR_EVENT*) freerdp_event_new(CliprdrChannel_Class,
CliprdrChannel_TemporaryDirectory, NULL, NULL);
if (!cliprdr_event)
/* Sending the TEMP path would only be valid iff the path is accessible from the server.
This should perhaps to change to a command line parameter value
*/
- GetEnvironmentVariableW(L"TEMP", (LPWSTR)cliprdr_event->dirname, 260);
+ GetEnvironmentVariableW(L"TEMP", (LPWSTR) cliprdr_event->dirname, 260);
- return freerdp_channels_send_event(cliprdr->channels, (wMessage *)cliprdr_event);
+ return freerdp_channels_send_event(cliprdr->channels, (wMessage*) cliprdr_event);
}
-static void cliprdr_send_format_list(cliprdrContext *cliprdr)
+static void cliprdr_send_format_list(cliprdrContext* cliprdr)
{
- RDP_CB_FORMAT_LIST_EVENT *cliprdr_event;
- BYTE *format_data;
+ BYTE* format_data;
int format = 0;
int data_size;
int format_count;
int len = 0;
int namelen;
int stream_file_transferring = FALSE;
+ RDP_CB_FORMAT_LIST_EVENT* cliprdr_event;
if (!OpenClipboard(cliprdr->hwndClipboard))
{
{
if (format >= CF_MAX)
{
- static WCHAR wName[MAX_PATH] = {0};
int wLen;
+ static WCHAR wName[MAX_PATH] = { 0 };
+
+ ZeroMemory(wName, MAX_PATH * 2);
- ZeroMemory(wName, MAX_PATH*2);
wLen = GetClipboardFormatNameW(format, wName, MAX_PATH);
+
if (wLen < 16)
{
memcpy(format_data + len, wName, wLen * sizeof(WCHAR));
freerdp_channels_send_event(cliprdr->channels, (wMessage*) cliprdr_event);
}
-int cliprdr_send_data_request(cliprdrContext *cliprdr, UINT32 format)
+int cliprdr_send_data_request(cliprdrContext* cliprdr, UINT32 format)
{
- RDP_CB_DATA_REQUEST_EVENT *cliprdr_event;
int ret;
+ RDP_CB_DATA_REQUEST_EVENT* cliprdr_event;
- cliprdr_event = (RDP_CB_DATA_REQUEST_EVENT *)freerdp_event_new(CliprdrChannel_Class,
+ cliprdr_event = (RDP_CB_DATA_REQUEST_EVENT*) freerdp_event_new(CliprdrChannel_Class,
CliprdrChannel_DataRequest, NULL, NULL);
if (!cliprdr_event)
cliprdr_event->format = get_remote_format_id(cliprdr, format);
- ret = freerdp_channels_send_event(cliprdr->channels, (wMessage *)cliprdr_event);
+ ret = freerdp_channels_send_event(cliprdr->channels, (wMessage*) cliprdr_event);
if (ret != 0)
return -1;
return 0;
}
-int cliprdr_send_lock(cliprdrContext *cliprdr)
+int cliprdr_send_lock(cliprdrContext* cliprdr)
{
- RDP_CB_LOCK_CLIPDATA_EVENT *cliprdr_event;
int ret;
+ RDP_CB_LOCK_CLIPDATA_EVENT* cliprdr_event;
- if ((cliprdr->capabilities & CB_CAN_LOCK_CLIPDATA) == 1) {
- cliprdr_event = (RDP_CB_LOCK_CLIPDATA_EVENT *)freerdp_event_new(CliprdrChannel_Class,
+ if ((cliprdr->capabilities & CB_CAN_LOCK_CLIPDATA) == 1)
+ {
+ cliprdr_event = (RDP_CB_LOCK_CLIPDATA_EVENT*) freerdp_event_new(CliprdrChannel_Class,
CliprdrChannel_LockClipdata, NULL, NULL);
if (!cliprdr_event)
cliprdr_event->clipDataId = 0;
- ret = freerdp_channels_send_event(cliprdr->channels, (wMessage *)cliprdr_event);
+ ret = freerdp_channels_send_event(cliprdr->channels, (wMessage*) cliprdr_event);
if (ret != 0)
return -1;
return 0;
}
-int cliprdr_send_unlock(cliprdrContext *cliprdr)
+int cliprdr_send_unlock(cliprdrContext* cliprdr)
{
- RDP_CB_UNLOCK_CLIPDATA_EVENT *cliprdr_event;
int ret;
+ RDP_CB_UNLOCK_CLIPDATA_EVENT* cliprdr_event;
- if ((cliprdr->capabilities & CB_CAN_LOCK_CLIPDATA) == 1) {
- cliprdr_event = (RDP_CB_UNLOCK_CLIPDATA_EVENT *)freerdp_event_new(CliprdrChannel_Class,
+ if ((cliprdr->capabilities & CB_CAN_LOCK_CLIPDATA) == 1)
+ {
+ cliprdr_event = (RDP_CB_UNLOCK_CLIPDATA_EVENT*) freerdp_event_new(CliprdrChannel_Class,
CliprdrChannel_UnLockClipdata, NULL, NULL);
if (!cliprdr_event)
cliprdr_event->clipDataId = 0;
- ret = freerdp_channels_send_event(cliprdr->channels, (wMessage *)cliprdr_event);
+ ret = freerdp_channels_send_event(cliprdr->channels, (wMessage*) cliprdr_event);
if (ret != 0)
return -1;
return 0;
}
-int cliprdr_send_request_filecontents(cliprdrContext *cliprdr, void *streamid,
+int cliprdr_send_request_filecontents(cliprdrContext* cliprdr, void* streamid,
int index, int flag, DWORD positionhigh, DWORD positionlow, ULONG nreq)
{
- RDP_CB_FILECONTENTS_REQUEST_EVENT *cliprdr_event;
int ret;
+ RDP_CB_FILECONTENTS_REQUEST_EVENT* cliprdr_event;
- cliprdr_event = (RDP_CB_FILECONTENTS_REQUEST_EVENT *)freerdp_event_new(CliprdrChannel_Class,
+ cliprdr_event = (RDP_CB_FILECONTENTS_REQUEST_EVENT*) freerdp_event_new(CliprdrChannel_Class,
CliprdrChannel_FilecontentsRequest, NULL, NULL);
if (!cliprdr_event)
return -1;
- cliprdr_event->streamId = (UINT32)streamid;
- cliprdr_event->lindex = index;
- cliprdr_event->dwFlags = flag;
- cliprdr_event->nPositionLow = positionlow;
+ cliprdr_event->streamId = (UINT32)streamid;
+ cliprdr_event->lindex = index;
+ cliprdr_event->dwFlags = flag;
+ cliprdr_event->nPositionLow = positionlow;
cliprdr_event->nPositionHigh = positionhigh;
- cliprdr_event->cbRequested = nreq;
- cliprdr_event->clipDataId = 0;
+ cliprdr_event->cbRequested = nreq;
+ cliprdr_event->clipDataId = 0;
- ret = freerdp_channels_send_event(cliprdr->channels, (wMessage *)cliprdr_event);
+ ret = freerdp_channels_send_event(cliprdr->channels, (wMessage*) cliprdr_event);
if (ret != 0)
return -1;
return 0;
}
-int cliprdr_send_response_filecontents(cliprdrContext *cliprdr, UINT32 streamid, UINT32 size, BYTE *data)
+int cliprdr_send_response_filecontents(cliprdrContext* cliprdr, UINT32 streamid, UINT32 size, BYTE* data)
{
- RDP_CB_FILECONTENTS_RESPONSE_EVENT *cliprdr_event;
int ret;
+ RDP_CB_FILECONTENTS_RESPONSE_EVENT* cliprdr_event;
- cliprdr_event = (RDP_CB_FILECONTENTS_RESPONSE_EVENT *)freerdp_event_new(CliprdrChannel_Class,
+ cliprdr_event = (RDP_CB_FILECONTENTS_RESPONSE_EVENT*) freerdp_event_new(CliprdrChannel_Class,
CliprdrChannel_FilecontentsResponse, NULL, NULL);
if (!cliprdr_event)
static LRESULT CALLBACK cliprdr_proc(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam)
{
- static cliprdrContext *cliprdr = NULL;
+ static cliprdrContext* cliprdr = NULL;
switch (Msg)
{
return 0;
}
-static int create_cliprdr_window(cliprdrContext *cliprdr)
+static int create_cliprdr_window(cliprdrContext* cliprdr)
{
WNDCLASSEX wnd_cls;
return 0;
}
-static void *cliprdr_thread_func(void *arg)
+static void* cliprdr_thread_func(void* arg)
{
int ret;
MSG msg;
return NULL;
}
-static void clear_file_array(cliprdrContext *cliprdr)
+static void clear_file_array(cliprdrContext* cliprdr)
{
int i;
void wf_cliprdr_init(wfContext* wfc, rdpChannels* channels)
{
- cliprdrContext *cliprdr;
+ cliprdrContext* cliprdr;
if (!wfc->instance->settings->RedirectClipboard)
{
return;
}
- wfc->cliprdr_context = (cliprdrContext *) calloc(1, sizeof(cliprdrContext));
- cliprdr = (cliprdrContext *) wfc->cliprdr_context;
+ wfc->cliprdr_context = (cliprdrContext*) calloc(1, sizeof(cliprdrContext));
+ cliprdr = (cliprdrContext*) wfc->cliprdr_context;
assert(cliprdr != NULL);
cliprdr->channels = channels;
cliprdr->map_capacity = 32;
cliprdr->map_size = 0;
- cliprdr->format_mappings = (formatMapping *)calloc(1, sizeof(formatMapping) * cliprdr->map_capacity);
+ cliprdr->format_mappings = (formatMapping*) calloc(1, sizeof(formatMapping) * cliprdr->map_capacity);
assert(cliprdr->format_mappings != NULL);
cliprdr->file_array_size = 32;
- cliprdr->file_names = (wchar_t **)calloc(1, cliprdr->file_array_size * sizeof(wchar_t *));
- cliprdr->fileDescriptor = (FILEDESCRIPTORW **)calloc(1, cliprdr->file_array_size * sizeof(FILEDESCRIPTORW *));
+ cliprdr->file_names = (WCHAR**) calloc(1, cliprdr->file_array_size * sizeof(WCHAR*));
+ cliprdr->fileDescriptor = (FILEDESCRIPTORW**) calloc(1, cliprdr->file_array_size * sizeof(FILEDESCRIPTORW*));
cliprdr->response_data_event = CreateEvent(NULL, TRUE, FALSE, L"response_data_event");
assert(cliprdr->response_data_event != NULL);
void wf_cliprdr_uninit(wfContext* wfc)
{
- cliprdrContext *cliprdr = (cliprdrContext *) wfc->cliprdr_context;
+ cliprdrContext* cliprdr = (cliprdrContext*) wfc->cliprdr_context;
if (!cliprdr)
return;
free(cliprdr);
}
-static void wf_cliprdr_process_cb_clip_caps_event(wfContext *wfc, RDP_CB_CLIP_CAPS *caps_event)
+static void wf_cliprdr_process_cb_clip_caps_event(wfContext* wfc, RDP_CB_CLIP_CAPS* caps_event)
{
- cliprdrContext *cliprdr = (cliprdrContext *)wfc->cliprdr_context;
+ cliprdrContext* cliprdr = (cliprdrContext*) wfc->cliprdr_context;
cliprdr->capabilities = caps_event->capabilities;
}
-static void wf_cliprdr_process_cb_monitor_ready_event(wfContext *wfc, RDP_CB_MONITOR_READY_EVENT *ready_event)
+static void wf_cliprdr_process_cb_monitor_ready_event(wfContext* wfc, RDP_CB_MONITOR_READY_EVENT* ready_event)
{
- cliprdrContext *cliprdr = (cliprdrContext *)wfc->cliprdr_context;
+ cliprdrContext* cliprdr = (cliprdrContext*) wfc->cliprdr_context;
#if 0
/*Disabled since the current function only sends the temp directory which is not
guaranteed to be accessible to the server
cliprdr_send_format_list(wfc->cliprdr_context);
}
-static BOOL wf_cliprdr_get_file_contents(wchar_t *file_name, BYTE *buffer, int positionLow, int positionHigh, int nRequested, unsigned int *puSize)
+static BOOL wf_cliprdr_get_file_contents(WCHAR* file_name, BYTE* buffer,
+ int positionLow, int positionHigh, int nRequested, unsigned int* puSize)
{
HANDLE hFile;
DWORD nGet;
- if (file_name == NULL || buffer == NULL || puSize == NULL)
+ if (!file_name || !buffer || !puSize)
{
WLog_ERR(TAG, "get file contents Invalid Arguments.");
return FALSE;
}
- hFile = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL);
+
+ hFile = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
+ FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL);
+
if (hFile == INVALID_HANDLE_VALUE)
{
return FALSE;
}
- SetFilePointer(hFile, positionLow, (PLONG)&positionHigh, FILE_BEGIN);
+ SetFilePointer(hFile, positionLow, (PLONG) &positionHigh, FILE_BEGIN);
if (!ReadFile(hFile, buffer, nRequested, &nGet, NULL))
{
DWORD err = GetLastError();
DEBUG_CLIPRDR("ReadFile failed with 0x%x.", err);
}
+
CloseHandle(hFile);
*puSize = nGet;
}
/* path_name has a '\' at the end. e.g. c:\newfolder\, file_name is c:\newfolder\new.txt */
-static FILEDESCRIPTORW *wf_cliprdr_get_file_descriptor(WCHAR* file_name, int pathLen)
+static FILEDESCRIPTORW* wf_cliprdr_get_file_descriptor(WCHAR* file_name, int pathLen)
{
- FILEDESCRIPTORW *fd;
HANDLE hFile;
+ FILEDESCRIPTORW* fd;
- fd = (FILEDESCRIPTORW*) malloc(sizeof(FILEDESCRIPTORW));
+ fd = (FILEDESCRIPTORW*) calloc(1, sizeof(FILEDESCRIPTORW));
if (!fd)
return NULL;
- ZeroMemory(fd, sizeof(FILEDESCRIPTORW));
-
hFile = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_BACKUP_SEMANTICS, NULL);
return fd;
}
-static void wf_cliprdr_array_ensure_capacity(cliprdrContext *cliprdr)
+static void wf_cliprdr_array_ensure_capacity(cliprdrContext* cliprdr)
{
if (cliprdr->nFiles == cliprdr->file_array_size)
{
cliprdr->file_array_size *= 2;
- cliprdr->fileDescriptor = (FILEDESCRIPTORW **)realloc(cliprdr->fileDescriptor, cliprdr->file_array_size * sizeof(FILEDESCRIPTORW *));
- cliprdr->file_names = (wchar_t **)realloc(cliprdr->file_names, cliprdr->file_array_size * sizeof(wchar_t *));
+ cliprdr->fileDescriptor = (FILEDESCRIPTORW**) realloc(cliprdr->fileDescriptor, cliprdr->file_array_size * sizeof(FILEDESCRIPTORW*));
+ cliprdr->file_names = (WCHAR**) realloc(cliprdr->file_names, cliprdr->file_array_size * sizeof(WCHAR*));
}
}
-static void wf_cliprdr_add_to_file_arrays(cliprdrContext *cliprdr, WCHAR *full_file_name, int pathLen)
+static void wf_cliprdr_add_to_file_arrays(cliprdrContext* cliprdr, WCHAR *full_file_name, int pathLen)
{
/* add to name array */
cliprdr->file_names[cliprdr->nFiles] = (LPWSTR) malloc(MAX_PATH);
wf_cliprdr_array_ensure_capacity(cliprdr);
}
-static void wf_cliprdr_traverse_directory(cliprdrContext *cliprdr, wchar_t *Dir, int pathLen)
+static void wf_cliprdr_traverse_directory(cliprdrContext* cliprdr, WCHAR* Dir, int pathLen)
{
- WIN32_FIND_DATA FindFileData;
HANDLE hFind;
- wchar_t DirSpec[MAX_PATH];
+ WCHAR DirSpec[MAX_PATH];
+ WIN32_FIND_DATA FindFileData;
StringCchCopy(DirSpec,MAX_PATH,Dir);
StringCchCat(DirSpec,MAX_PATH,TEXT("\\*"));
- hFind = FindFirstFile(DirSpec,&FindFileData);
+ hFind = FindFirstFile(DirSpec, &FindFileData);
- if(hFind == INVALID_HANDLE_VALUE)
+ if (hFind == INVALID_HANDLE_VALUE)
{
DEBUG_CLIPRDR("FindFirstFile failed with 0x%x.", GetLastError());
return;
}
- while(FindNextFile(hFind, &FindFileData))
+ while (FindNextFile(hFind, &FindFileData))
{
if((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0
&& wcscmp(FindFileData.cFileName,L".") == 0
continue;
}
-
if((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) !=0 )
{
- wchar_t DirAdd[MAX_PATH];
+ WCHAR DirAdd[MAX_PATH];
StringCchCopy(DirAdd,MAX_PATH,Dir);
StringCchCat(DirAdd,MAX_PATH,TEXT("\\"));
}
else if (local_format == RegisterClipboardFormatW(L"FileGroupDescriptorW"))
{
+ int len;
+ int i;
+ WCHAR* wFileName;
+ unsigned int uSize;
HRESULT result;
LPDATAOBJECT dataObj;
FORMATETC format_etc;
STGMEDIUM stg_medium;
- DROPFILES *dropFiles;
-
- int len;
- int i;
- wchar_t *wFileName;
- unsigned int uSize;
+ DROPFILES* dropFiles;
DEBUG_CLIPRDR("file descriptors request.");
+
result = OleGetClipboard(&dataObj);
+
if (!SUCCEEDED(result))
{
DEBUG_CLIPRDR("OleGetClipboard failed.");
if (SUCCEEDED(result))
{
DEBUG_CLIPRDR("Got FileGroupDescriptorW.");
- globlemem = (char *)GlobalLock(stg_medium.hGlobal);
+ globlemem = (char*) GlobalLock(stg_medium.hGlobal);
uSize = GlobalSize(stg_medium.hGlobal);
size = uSize;
buff = (char*) malloc(uSize);
if (dropFiles->fWide)
{
- wchar_t *p;
+ WCHAR* p;
int str_len;
int offset;
int pathLen;
/* dropFiles contains file names */
- for (wFileName = (wchar_t *)((char *)dropFiles + dropFiles->pFiles); (len = wcslen(wFileName)) > 0; wFileName += len + 1)
+ for (wFileName = (WCHAR*)((char *)dropFiles + dropFiles->pFiles); (len = wcslen(wFileName)) > 0; wFileName += len + 1)
{
/* get path name */
str_len = wcslen(wFileName);
int cchWideChar;
cchWideChar = MultiByteToWideChar(CP_ACP, MB_COMPOSITE, p, len, NULL, 0);
- cliprdr->file_names[cliprdr->nFiles] = (LPWSTR)malloc(cchWideChar);
+ cliprdr->file_names[cliprdr->nFiles] = (LPWSTR) malloc(cchWideChar);
MultiByteToWideChar(CP_ACP, MB_COMPOSITE, p, len, cliprdr->file_names[cliprdr->nFiles], cchWideChar);
if (cliprdr->nFiles == cliprdr->file_array_size)
{
cliprdr->file_array_size *= 2;
- cliprdr->fileDescriptor = (FILEDESCRIPTORW **)realloc(cliprdr->fileDescriptor, cliprdr->file_array_size * sizeof(FILEDESCRIPTORW *));
- cliprdr->file_names = (wchar_t **)realloc(cliprdr->file_names, cliprdr->file_array_size * sizeof(wchar_t *));
+ cliprdr->fileDescriptor = (FILEDESCRIPTORW**) realloc(cliprdr->fileDescriptor, cliprdr->file_array_size * sizeof(FILEDESCRIPTORW*));
+ cliprdr->file_names = (WCHAR**) realloc(cliprdr->file_names, cliprdr->file_array_size * sizeof(WCHAR*));
}
}
}
exit:
size = 4 + cliprdr->nFiles * sizeof(FILEDESCRIPTORW);
- buff = (char *)malloc(size);
+ buff = (char*) malloc(size);
Write_UINT32(buff, cliprdr->nFiles);
response_event = (RDP_CB_DATA_RESPONSE_EVENT*) freerdp_event_new(CliprdrChannel_Class,
CliprdrChannel_DataResponse, NULL, NULL);
- response_event->data = (BYTE *)buff;
+ response_event->data = (BYTE*) buff;
response_event->size = size;
freerdp_channels_send_event(cliprdr->channels, (wMessage*) response_event);
/* Note: don't free buffer here. */
}
-static void wf_cliprdr_process_cb_format_list_event(wfContext *wfc, RDP_CB_FORMAT_LIST_EVENT *event)
+static void wf_cliprdr_process_cb_format_list_event(wfContext* wfc, RDP_CB_FORMAT_LIST_EVENT* event)
{
- cliprdrContext *cliprdr = (cliprdrContext *)wfc->cliprdr_context;
+ cliprdrContext* cliprdr = (cliprdrContext *)wfc->cliprdr_context;
UINT32 left_size = event->raw_format_data_size;
int i = 0;
BYTE *p;
return;
if (EmptyClipboard())
+ {
for (i = 0; i < cliprdr->map_size; i++)
+ {
SetClipboardData(cliprdr->format_mappings[i].local_format_id, NULL);
+ }
+ }
CloseClipboard();
}
}
-static void wf_cliprdr_process_cb_data_response_event(wfContext *wfc, RDP_CB_DATA_RESPONSE_EVENT *event)
+static void wf_cliprdr_process_cb_data_response_event(wfContext* wfc, RDP_CB_DATA_RESPONSE_EVENT* event)
{
- cliprdrContext *cliprdr = (cliprdrContext *)wfc->cliprdr_context;
+ char* buff;
HANDLE hMem;
- char *buff;
+ cliprdrContext* cliprdr = (cliprdrContext*) wfc->cliprdr_context;
hMem = GlobalAlloc(GMEM_FIXED, event->size);
- buff = (char *) GlobalLock(hMem);
+ buff = (char*) GlobalLock(hMem);
memcpy(buff, event->data, event->size);
GlobalUnlock(hMem);
SetEvent(cliprdr->response_data_event);
}
-static void wf_cliprdr_process_cb_filecontents_request_event(wfContext *wfc, RDP_CB_FILECONTENTS_REQUEST_EVENT *event)
+static void wf_cliprdr_process_cb_filecontents_request_event(wfContext* wfc, RDP_CB_FILECONTENTS_REQUEST_EVENT* event)
{
- cliprdrContext *cliprdr = (cliprdrContext *)wfc->cliprdr_context;
- UINT32 uSize = 0;
- BYTE *pData = NULL;
- HRESULT hRet = S_OK;
- FORMATETC vFormatEtc;
- LPDATAOBJECT pDataObj = NULL;
- STGMEDIUM vStgMedium;
- LPSTREAM pStream = NULL;
- BOOL bIsStreamFile = TRUE;
- static LPSTREAM pStreamStc = NULL;
- static UINT32 uStreamIdStc = 0;
-
- pData = (BYTE *)calloc(1, event->cbRequested);
+ cliprdrContext* cliprdr = (cliprdrContext*) wfc->cliprdr_context;
+ UINT32 uSize = 0;
+ BYTE* pData = NULL;
+ HRESULT hRet = S_OK;
+ FORMATETC vFormatEtc;
+ LPDATAOBJECT pDataObj = NULL;
+ STGMEDIUM vStgMedium;
+ LPSTREAM pStream = NULL;
+ BOOL bIsStreamFile = TRUE;
+ static LPSTREAM pStreamStc = NULL;
+ static UINT32 uStreamIdStc = 0;
+
+ pData = (BYTE*) calloc(1, event->cbRequested);
+
if (!pData)
goto error;
hRet = OleGetClipboard(&pDataObj);
+
if (!SUCCEEDED(hRet))
{
WLog_ERR(TAG, "filecontents: get ole clipboard failed.");
return;
}
-static void wf_cliprdr_process_cb_filecontents_response_event(wfContext *wfc, RDP_CB_FILECONTENTS_RESPONSE_EVENT *event)
+static void wf_cliprdr_process_cb_filecontents_response_event(wfContext* wfc, RDP_CB_FILECONTENTS_RESPONSE_EVENT* event)
{
- cliprdrContext *cliprdr = (cliprdrContext *)wfc->cliprdr_context;
+ cliprdrContext* cliprdr = (cliprdrContext*) wfc->cliprdr_context;
cliprdr->req_fsize = event->size;
- cliprdr->req_fdata = (char *)malloc(event->size);
+ cliprdr->req_fdata = (char*) malloc(event->size);
memcpy(cliprdr->req_fdata, event->data, event->size);
SetEvent(cliprdr->req_fevent);
}
-static void wf_cliprdr_process_cb_lock_clipdata_event(wfContext *wfc, RDP_CB_LOCK_CLIPDATA_EVENT *event)
+static void wf_cliprdr_process_cb_lock_clipdata_event(wfContext* wfc, RDP_CB_LOCK_CLIPDATA_EVENT* event)
{
}
-static void wf_cliprdr_process_cb_unlock_clipdata_event(wfContext *wfc, RDP_CB_UNLOCK_CLIPDATA_EVENT *event)
+static void wf_cliprdr_process_cb_unlock_clipdata_event(wfContext* wfc, RDP_CB_UNLOCK_CLIPDATA_EVENT* event)
{
}
-void wf_process_cliprdr_event(wfContext *wfc, wMessage *event)
+void wf_process_cliprdr_event(wfContext* wfc, wMessage* event)
{
switch (GetMessageType(event->id))
{
case CliprdrChannel_ClipCaps:
- wf_cliprdr_process_cb_clip_caps_event(wfc, (RDP_CB_CLIP_CAPS *)event);
+ wf_cliprdr_process_cb_clip_caps_event(wfc, (RDP_CB_CLIP_CAPS*) event);
break;
case CliprdrChannel_MonitorReady:
- wf_cliprdr_process_cb_monitor_ready_event(wfc, (RDP_CB_MONITOR_READY_EVENT *)event);
+ wf_cliprdr_process_cb_monitor_ready_event(wfc, (RDP_CB_MONITOR_READY_EVENT*) event);
break;
case CliprdrChannel_FormatList:
- wf_cliprdr_process_cb_format_list_event(wfc, (RDP_CB_FORMAT_LIST_EVENT *) event);
+ wf_cliprdr_process_cb_format_list_event(wfc, (RDP_CB_FORMAT_LIST_EVENT*) event);
break;
case CliprdrChannel_DataRequest:
- wf_cliprdr_process_cb_data_request_event(wfc, (RDP_CB_DATA_REQUEST_EVENT *) event);
+ wf_cliprdr_process_cb_data_request_event(wfc, (RDP_CB_DATA_REQUEST_EVENT*) event);
break;
case CliprdrChannel_DataResponse:
- wf_cliprdr_process_cb_data_response_event(wfc, (RDP_CB_DATA_RESPONSE_EVENT *) event);
+ wf_cliprdr_process_cb_data_response_event(wfc, (RDP_CB_DATA_RESPONSE_EVENT*) event);
break;
case CliprdrChannel_FilecontentsRequest:
- wf_cliprdr_process_cb_filecontents_request_event(wfc, (RDP_CB_FILECONTENTS_REQUEST_EVENT *) event);
+ wf_cliprdr_process_cb_filecontents_request_event(wfc, (RDP_CB_FILECONTENTS_REQUEST_EVENT*) event);
break;
case CliprdrChannel_FilecontentsResponse:
- wf_cliprdr_process_cb_filecontents_response_event(wfc, (RDP_CB_FILECONTENTS_RESPONSE_EVENT *) event);
+ wf_cliprdr_process_cb_filecontents_response_event(wfc, (RDP_CB_FILECONTENTS_RESPONSE_EVENT*) event);
break;
case CliprdrChannel_LockClipdata:
- wf_cliprdr_process_cb_lock_clipdata_event(wfc, (RDP_CB_LOCK_CLIPDATA_EVENT *) event);
+ wf_cliprdr_process_cb_lock_clipdata_event(wfc, (RDP_CB_LOCK_CLIPDATA_EVENT*) event);
break;
case CliprdrChannel_UnLockClipdata:
- wf_cliprdr_process_cb_unlock_clipdata_event(wfc, (RDP_CB_UNLOCK_CLIPDATA_EVENT *) event);
+ wf_cliprdr_process_cb_unlock_clipdata_event(wfc, (RDP_CB_UNLOCK_CLIPDATA_EVENT*) event);
break;
default:
#define DEBUG_CLIPRDR(fmt, ...) do { } while (0)
#endif
-typedef struct format_mapping formatMapping;
-struct format_mapping {
+struct format_mapping
+{
UINT32 remote_format_id;
UINT32 local_format_id;
- void *name; /* Unicode or ASCII characters with NULL terminate */
+ void *name; /* Unicode or ASCII characters with NULL terminator */
};
+typedef struct format_mapping formatMapping;
typedef struct cliprdr_context cliprdrContext;
-struct cliprdr_context {
- rdpChannels *channels;
+struct cliprdr_context
+{
+ rdpChannels* channels;
UINT32 capabilities;
- formatMapping *format_mappings;
- int map_capacity;
int map_size;
+ int map_capacity;
+ formatMapping* format_mappings;
UINT32 request_format;
BOOL channel_initialized;
LPDATAOBJECT data_obj;
ULONG req_fsize;
- char *req_fdata;
+ char* req_fdata;
HANDLE req_fevent;
int nFiles;
int file_array_size;
- wchar_t **file_names;
- FILEDESCRIPTORW **fileDescriptor;
+ WCHAR** file_names;
+ FILEDESCRIPTORW** fileDescriptor;
};
void wf_cliprdr_init(wfContext* wfc, rdpChannels* channels);
BOOL wf_cliprdr_process_property_notify(wfContext* wfc, HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam);
void wf_cliprdr_check_owner(wfContext* wfc);
-int cliprdr_send_data_request(cliprdrContext *cliprdr, UINT32 format);
-int cliprdr_send_lock(cliprdrContext *cliprdr);
-int cliprdr_send_unlock(cliprdrContext *cliprdr);
-int cliprdr_send_request_filecontents(cliprdrContext *cliprdr, void *streamid,
- int index, int flag, DWORD positionhigh,
- DWORD positionlow, ULONG request);
+int cliprdr_send_data_request(cliprdrContext* cliprdr, UINT32 format);
+int cliprdr_send_lock(cliprdrContext* cliprdr);
+int cliprdr_send_unlock(cliprdrContext* cliprdr);
+int cliprdr_send_request_filecontents(cliprdrContext* cliprdr, void* streamid,
+ int index, int flag, DWORD positionhigh, DWORD positionlow, ULONG request);
#endif /* __WF_CLIPRDR_H */
#include "wf_cliprdr_DataObject.h"
#include "wf_cliprdr_EnumFORMATETC.h"
-static int cliprdr_lookup_format(CliprdrDataObject *instance, FORMATETC *pFormatEtc)
+static int cliprdr_lookup_format(CliprdrDataObject* instance, FORMATETC* pFormatEtc)
{
int i;
+
for (i = 0; i < instance->m_nNumFormats; i++)
{
- if((pFormatEtc->tymed & instance->m_pFormatEtc[i].tymed) &&
+ if ((pFormatEtc->tymed & instance->m_pFormatEtc[i].tymed) &&
pFormatEtc->cfFormat == instance->m_pFormatEtc[i].cfFormat &&
pFormatEtc->dwAspect == instance->m_pFormatEtc[i].dwAspect)
{
return -1;
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_QueryInterface(IDataObject *This, REFIID riid, void **ppvObject)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_QueryInterface(IDataObject* This, REFIID riid, void** ppvObject)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
if (IsEqualIID(riid, &IID_IDataObject) || IsEqualIID(riid, &IID_IUnknown))
{
}
}
-ULONG STDMETHODCALLTYPE CliprdrDataObject_AddRef(IDataObject *This)
+ULONG STDMETHODCALLTYPE CliprdrDataObject_AddRef(IDataObject* This)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
return InterlockedIncrement(&instance->m_lRefCount);
}
-ULONG STDMETHODCALLTYPE CliprdrDataObject_Release(IDataObject *This)
+ULONG STDMETHODCALLTYPE CliprdrDataObject_Release(IDataObject* This)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
LONG count;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
count = InterlockedDecrement(&instance->m_lRefCount);
- if(count == 0)
+ if (count == 0)
{
CliprdrDataObject_Delete(instance);
return 0;
}
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetData(IDataObject *This, FORMATETC *pFormatEtc, STGMEDIUM *pMedium)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetData(IDataObject* This, FORMATETC* pFormatEtc, STGMEDIUM* pMedium)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
- cliprdrContext *cliprdr = (cliprdrContext *)instance->m_pData;
- int idx;
- int i;
+ int i, idx;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
+ cliprdrContext* cliprdr = (cliprdrContext*) instance->m_pData;
if (pFormatEtc == NULL || pMedium == NULL)
{
return E_INVALIDARG;
}
- if((idx = cliprdr_lookup_format(instance, pFormatEtc)) == -1)
+ if ((idx = cliprdr_lookup_format(instance, pFormatEtc)) == -1)
{
return DV_E_FORMATETC;
}
{
if (!instance->m_pStream)
{
- instance->m_pStream = (LPSTREAM *)calloc(instance->m_nStreams, sizeof(LPSTREAM));
+ instance->m_pStream = (LPSTREAM*) calloc(instance->m_nStreams, sizeof(LPSTREAM));
+
if (instance->m_pStream)
- for(i = 0; i < instance->m_nStreams; i++)
- instance->m_pStream[i] = (IStream *)CliprdrStream_New(i, cliprdr);
+ {
+ for (i = 0; i < instance->m_nStreams; i++)
+ {
+ instance->m_pStream[i] = (IStream*) CliprdrStream_New(i, cliprdr);
+ }
+ }
}
}
return S_OK;
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetDataHere(IDataObject *This, FORMATETC *pformatetc, STGMEDIUM *pmedium)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetDataHere(IDataObject* This, FORMATETC *pformatetc, STGMEDIUM *pmedium)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
return DATA_E_FORMATETC;
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_QueryGetData(IDataObject *This, FORMATETC *pformatetc)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_QueryGetData(IDataObject* This, FORMATETC *pformatetc)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
if (!pformatetc)
return E_INVALIDARG;
return (cliprdr_lookup_format(instance, pformatetc) == -1) ? DV_E_FORMATETC : S_OK;
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetCanonicalFormatEtc(IDataObject *This, FORMATETC *pformatectIn, FORMATETC *pformatetcOut)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_GetCanonicalFormatEtc(IDataObject* This, FORMATETC *pformatectIn, FORMATETC *pformatetcOut)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
if (!pformatetcOut)
return E_INVALIDARG;
return E_NOTIMPL;
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_SetData(IDataObject *This, FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_SetData(IDataObject* This, FORMATETC *pformatetc, STGMEDIUM *pmedium, BOOL fRelease)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
return E_NOTIMPL;
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_EnumFormatEtc(IDataObject *This, DWORD dwDirection, IEnumFORMATETC **ppenumFormatEtc)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_EnumFormatEtc(IDataObject* This, DWORD dwDirection, IEnumFORMATETC **ppenumFormatEtc)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
if (!ppenumFormatEtc)
return E_INVALIDARG;
if(dwDirection == DATADIR_GET)
{
- *ppenumFormatEtc = (IEnumFORMATETC *)CliprdrEnumFORMATETC_New(instance->m_nNumFormats, instance->m_pFormatEtc);
+ *ppenumFormatEtc = (IEnumFORMATETC*) CliprdrEnumFORMATETC_New(instance->m_nNumFormats, instance->m_pFormatEtc);
return (*ppenumFormatEtc) ? S_OK : E_OUTOFMEMORY;
}
else
}
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_DAdvise(IDataObject *This, FORMATETC *pformatetc, DWORD advf, IAdviseSink *pAdvSink, DWORD *pdwConnection)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_DAdvise(IDataObject* This, FORMATETC *pformatetc, DWORD advf, IAdviseSink* pAdvSink, DWORD *pdwConnection)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
return OLE_E_ADVISENOTSUPPORTED;
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_DUnadvise(IDataObject *This, DWORD dwConnection)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_DUnadvise(IDataObject* This, DWORD dwConnection)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
return OLE_E_ADVISENOTSUPPORTED;
}
-HRESULT STDMETHODCALLTYPE CliprdrDataObject_EnumDAdvise(IDataObject *This, IEnumSTATDATA **ppenumAdvise)
+HRESULT STDMETHODCALLTYPE CliprdrDataObject_EnumDAdvise(IDataObject* This, IEnumSTATDATA** ppenumAdvise)
{
- CliprdrDataObject *instance = (CliprdrDataObject *)This;
+ CliprdrDataObject* instance = (CliprdrDataObject*) This;
return OLE_E_ADVISENOTSUPPORTED;
}
-CliprdrDataObject *CliprdrDataObject_New(FORMATETC *fmtetc, STGMEDIUM *stgmed, int count, void *data)
+CliprdrDataObject* CliprdrDataObject_New(FORMATETC* fmtetc, STGMEDIUM* stgmed, int count, void* data)
{
- CliprdrDataObject *instance;
- IDataObject *iDataObject;
int i;
+ CliprdrDataObject* instance;
+ IDataObject* iDataObject;
- instance = (CliprdrDataObject *)calloc(1, sizeof(CliprdrDataObject));
+ instance = (CliprdrDataObject*) calloc(1, sizeof(CliprdrDataObject));
if (instance)
{
iDataObject = &instance->iDataObject;
- iDataObject->lpVtbl = (IDataObjectVtbl *)calloc(1, sizeof(IDataObjectVtbl));
+ iDataObject->lpVtbl = (IDataObjectVtbl*) calloc(1, sizeof(IDataObjectVtbl));
+
if (iDataObject->lpVtbl)
{
- iDataObject->lpVtbl->QueryInterface = CliprdrDataObject_QueryInterface;
- iDataObject->lpVtbl->AddRef = CliprdrDataObject_AddRef;
- iDataObject->lpVtbl->Release = CliprdrDataObject_Release;
- iDataObject->lpVtbl->GetData = CliprdrDataObject_GetData;
- iDataObject->lpVtbl->GetDataHere = CliprdrDataObject_GetDataHere;
- iDataObject->lpVtbl->QueryGetData = CliprdrDataObject_QueryGetData;
+ iDataObject->lpVtbl->QueryInterface = CliprdrDataObject_QueryInterface;
+ iDataObject->lpVtbl->AddRef = CliprdrDataObject_AddRef;
+ iDataObject->lpVtbl->Release = CliprdrDataObject_Release;
+ iDataObject->lpVtbl->GetData = CliprdrDataObject_GetData;
+ iDataObject->lpVtbl->GetDataHere = CliprdrDataObject_GetDataHere;
+ iDataObject->lpVtbl->QueryGetData = CliprdrDataObject_QueryGetData;
iDataObject->lpVtbl->GetCanonicalFormatEtc = CliprdrDataObject_GetCanonicalFormatEtc;
- iDataObject->lpVtbl->SetData = CliprdrDataObject_SetData;
- iDataObject->lpVtbl->EnumFormatEtc = CliprdrDataObject_EnumFormatEtc;
- iDataObject->lpVtbl->DAdvise = CliprdrDataObject_DAdvise;
- iDataObject->lpVtbl->DUnadvise = CliprdrDataObject_DUnadvise;
- iDataObject->lpVtbl->EnumDAdvise = CliprdrDataObject_EnumDAdvise;
+ iDataObject->lpVtbl->SetData = CliprdrDataObject_SetData;
+ iDataObject->lpVtbl->EnumFormatEtc = CliprdrDataObject_EnumFormatEtc;
+ iDataObject->lpVtbl->DAdvise = CliprdrDataObject_DAdvise;
+ iDataObject->lpVtbl->DUnadvise = CliprdrDataObject_DUnadvise;
+ iDataObject->lpVtbl->EnumDAdvise = CliprdrDataObject_EnumDAdvise;
- instance->m_lRefCount = 1;
+ instance->m_lRefCount = 1;
instance->m_nNumFormats = count;
- instance->m_pData = data;
- instance->m_nStreams = 0;
- instance->m_pStream = NULL;
+ instance->m_pData = data;
+ instance->m_nStreams = 0;
+ instance->m_pStream = NULL;
- instance->m_pFormatEtc = (FORMATETC *)calloc(count, sizeof(FORMATETC));
- instance->m_pStgMedium = (STGMEDIUM *)calloc(count, sizeof(STGMEDIUM));
+ instance->m_pFormatEtc = (FORMATETC*) calloc(count, sizeof(FORMATETC));
+ instance->m_pStgMedium = (STGMEDIUM*) calloc(count, sizeof(STGMEDIUM));
- for(i = 0; i < count; i++)
+ for (i = 0; i < count; i++)
{
instance->m_pFormatEtc[i] = fmtetc[i];
instance->m_pStgMedium[i] = stgmed[i];
return instance;
}
-void CliprdrDataObject_Delete(CliprdrDataObject *instance)
+void CliprdrDataObject_Delete(CliprdrDataObject* instance)
{
if (instance)
{
int i;
for (i = 0; i < instance->m_nStreams; i++)
+ {
CliprdrStream_Release(instance->m_pStream[i]);
+ }
free(instance->m_pStream);
}
}
-BOOL wf_create_file_obj(cliprdrContext *cliprdr, IDataObject **ppDataObject)
+BOOL wf_create_file_obj(cliprdrContext* cliprdr, IDataObject** ppDataObject)
{
FORMATETC fmtetc[3];
STGMEDIUM stgmeds[3];
- if(!ppDataObject)
+ if (!ppDataObject)
return FALSE;
- fmtetc[0].cfFormat = RegisterClipboardFormatW(CFSTR_FILEDESCRIPTORW);
- fmtetc[0].dwAspect = DVASPECT_CONTENT;
- fmtetc[0].lindex = 0;
- fmtetc[0].ptd = NULL;
- fmtetc[0].tymed = TYMED_HGLOBAL;
- stgmeds[0].tymed = TYMED_HGLOBAL;
- stgmeds[0].hGlobal = NULL;
+ fmtetc[0].cfFormat = RegisterClipboardFormatW(CFSTR_FILEDESCRIPTORW);
+ fmtetc[0].dwAspect = DVASPECT_CONTENT;
+ fmtetc[0].lindex = 0;
+ fmtetc[0].ptd = NULL;
+ fmtetc[0].tymed = TYMED_HGLOBAL;
+
+ stgmeds[0].tymed = TYMED_HGLOBAL;
+ stgmeds[0].hGlobal = NULL;
stgmeds[0].pUnkForRelease = NULL;
- fmtetc[1].cfFormat = RegisterClipboardFormatW(CFSTR_FILECONTENTS);
- fmtetc[1].dwAspect = DVASPECT_CONTENT;
- fmtetc[1].lindex = 0;
- fmtetc[1].ptd = NULL;
- fmtetc[1].tymed = TYMED_ISTREAM;
- stgmeds[1].tymed = TYMED_ISTREAM;
- stgmeds[1].pstm = NULL;
+ fmtetc[1].cfFormat = RegisterClipboardFormatW(CFSTR_FILECONTENTS);
+ fmtetc[1].dwAspect = DVASPECT_CONTENT;
+ fmtetc[1].lindex = 0;
+ fmtetc[1].ptd = NULL;
+ fmtetc[1].tymed = TYMED_ISTREAM;
+
+ stgmeds[1].tymed = TYMED_ISTREAM;
+ stgmeds[1].pstm = NULL;
stgmeds[1].pUnkForRelease = NULL;
- fmtetc[2].cfFormat = RegisterClipboardFormatW(CFSTR_PREFERREDDROPEFFECT);
- fmtetc[2].dwAspect = DVASPECT_CONTENT;
- fmtetc[2].lindex = 0;
- fmtetc[2].ptd = NULL;
- fmtetc[2].tymed = TYMED_HGLOBAL;
- stgmeds[2].tymed = TYMED_HGLOBAL;
- stgmeds[2].hGlobal = NULL;
+ fmtetc[2].cfFormat = RegisterClipboardFormatW(CFSTR_PREFERREDDROPEFFECT);
+ fmtetc[2].dwAspect = DVASPECT_CONTENT;
+ fmtetc[2].lindex = 0;
+ fmtetc[2].ptd = NULL;
+ fmtetc[2].tymed = TYMED_HGLOBAL;
+
+ stgmeds[2].tymed = TYMED_HGLOBAL;
+ stgmeds[2].hGlobal = NULL;
stgmeds[2].pUnkForRelease = NULL;
- *ppDataObject = (IDataObject *)CliprdrDataObject_New(fmtetc, stgmeds, 3, cliprdr);
+ *ppDataObject = (IDataObject*) CliprdrDataObject_New(fmtetc, stgmeds, 3, cliprdr);
return (*ppDataObject) ? TRUE : FALSE;
}
-void wf_destroy_file_obj(IDataObject *instance)
+void wf_destroy_file_obj(IDataObject* instance)
{
- if(instance)
+ if (instance)
IDataObject_Release(instance);
}
#include "wf_cliprdr_EnumFORMATETC.h"
-static void cliprdr_format_deep_copy(FORMATETC *dest, FORMATETC *source)
+static void cliprdr_format_deep_copy(FORMATETC* dest, FORMATETC* source)
{
*dest = *source;
if (source->ptd)
{
- dest->ptd = (DVTARGETDEVICE *)CoTaskMemAlloc(sizeof(DVTARGETDEVICE));
+ dest->ptd = (DVTARGETDEVICE*) CoTaskMemAlloc(sizeof(DVTARGETDEVICE));
*(dest->ptd) = *(source->ptd);
}
}
-HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_QueryInterface(IEnumFORMATETC *This, REFIID riid, void **ppvObject)
+HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_QueryInterface(IEnumFORMATETC* This, REFIID riid, void** ppvObject)
{
- CliprdrEnumFORMATETC *instance = (CliprdrEnumFORMATETC *)This;
+ CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*) This;
if (IsEqualIID(riid, &IID_IEnumFORMATETC) || IsEqualIID(riid, &IID_IUnknown))
{
}
}
-ULONG STDMETHODCALLTYPE CliprdrEnumFORMATETC_AddRef(IEnumFORMATETC *This)
+ULONG STDMETHODCALLTYPE CliprdrEnumFORMATETC_AddRef(IEnumFORMATETC* This)
{
- CliprdrEnumFORMATETC *instance = (CliprdrEnumFORMATETC *)This;
+ CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*) This;
return InterlockedIncrement(&instance->m_lRefCount);
}
-ULONG STDMETHODCALLTYPE CliprdrEnumFORMATETC_Release(IEnumFORMATETC *This)
+ULONG STDMETHODCALLTYPE CliprdrEnumFORMATETC_Release(IEnumFORMATETC* This)
{
- CliprdrEnumFORMATETC *instance = (CliprdrEnumFORMATETC *)This;
LONG count;
+ CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*) This;
count = InterlockedDecrement(&instance->m_lRefCount);
}
}
-HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Next(IEnumFORMATETC *This, ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched)
+HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Next(IEnumFORMATETC* This, ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched)
{
- CliprdrEnumFORMATETC *instance = (CliprdrEnumFORMATETC *)This;
ULONG copied = 0;
+ CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*) This;
if (celt == 0 || !rgelt)
return E_INVALIDARG;
while (instance->m_nIndex < instance->m_nNumFormats && copied < celt)
+ {
cliprdr_format_deep_copy(&rgelt[copied++], &instance->m_pFormatEtc[instance->m_nIndex++]);
+ }
if (pceltFetched != 0)
*pceltFetched = copied;
return (copied == celt) ? S_OK : S_FALSE;
}
-HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Skip(IEnumFORMATETC *This, ULONG celt)
+HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Skip(IEnumFORMATETC* This, ULONG celt)
{
- CliprdrEnumFORMATETC *instance = (CliprdrEnumFORMATETC *)This;
+ CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*) This;
if (instance->m_nIndex + (LONG) celt > instance->m_nNumFormats)
return S_FALSE;
return S_OK;
}
-HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Reset(IEnumFORMATETC *This)
+HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Reset(IEnumFORMATETC* This)
{
- CliprdrEnumFORMATETC *instance = (CliprdrEnumFORMATETC *)This;
+ CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*) This;
instance->m_nIndex = 0;
return S_OK;
}
-HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Clone(IEnumFORMATETC *This, IEnumFORMATETC **ppEnum)
+HRESULT STDMETHODCALLTYPE CliprdrEnumFORMATETC_Clone(IEnumFORMATETC* This, IEnumFORMATETC **ppEnum)
{
- CliprdrEnumFORMATETC *instance = (CliprdrEnumFORMATETC *)This;
+ CliprdrEnumFORMATETC* instance = (CliprdrEnumFORMATETC*) This;
if (!ppEnum)
return E_INVALIDARG;
#include "wf_cliprdr.h"
#include "wf_cliprdr_Stream.h"
-HRESULT STDMETHODCALLTYPE CliprdrStream_QueryInterface(IStream *This, REFIID riid, void **ppvObject)
+HRESULT STDMETHODCALLTYPE CliprdrStream_QueryInterface(IStream* This, REFIID riid, void** ppvObject)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
if (IsEqualIID(riid, &IID_IStream) || IsEqualIID(riid, &IID_IUnknown))
{
}
}
-ULONG STDMETHODCALLTYPE CliprdrStream_AddRef(IStream *This)
+ULONG STDMETHODCALLTYPE CliprdrStream_AddRef(IStream* This)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
return InterlockedIncrement(&instance->m_lRefCount);
}
-ULONG STDMETHODCALLTYPE CliprdrStream_Release(IStream * This)
+ULONG STDMETHODCALLTYPE CliprdrStream_Release(IStream* This)
{
- CliprdrStream *instance = (CliprdrStream *)This;
LONG count;
+ CliprdrStream* instance = (CliprdrStream*) This;
count = InterlockedDecrement(&instance->m_lRefCount);
#define FILECONTENTS_SIZE 0x00000001
#define FILECONTENTS_RANGE 0x00000002
-HRESULT STDMETHODCALLTYPE CliprdrStream_Read(IStream *This, void *pv, ULONG cb, ULONG *pcbRead)
+HRESULT STDMETHODCALLTYPE CliprdrStream_Read(IStream* This, void *pv, ULONG cb, ULONG *pcbRead)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
cliprdrContext *cliprdr = (cliprdrContext *)instance->m_pData;
int ret;
return S_OK;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_Write(IStream *This, const void *pv, ULONG cb, ULONG *pcbWritten)
+HRESULT STDMETHODCALLTYPE CliprdrStream_Write(IStream* This, const void *pv, ULONG cb, ULONG *pcbWritten)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
return STG_E_ACCESSDENIED;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_Seek(IStream *This, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
+HRESULT STDMETHODCALLTYPE CliprdrStream_Seek(IStream* This, LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
ULONGLONG newoffset;
newoffset = instance->m_lOffset.QuadPart;
return S_OK;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_SetSize(IStream *This, ULARGE_INTEGER libNewSize)
+HRESULT STDMETHODCALLTYPE CliprdrStream_SetSize(IStream* This, ULARGE_INTEGER libNewSize)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
return STG_E_INSUFFICIENTMEMORY;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_CopyTo(IStream *This, IStream *pstm, ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
+HRESULT STDMETHODCALLTYPE CliprdrStream_CopyTo(IStream* This, IStream* pstm, ULARGE_INTEGER cb, ULARGE_INTEGER* pcbRead, ULARGE_INTEGER *pcbWritten)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
return S_OK;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_Commit(IStream *This, DWORD grfCommitFlags)
+HRESULT STDMETHODCALLTYPE CliprdrStream_Commit(IStream* This, DWORD grfCommitFlags)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
return STG_E_MEDIUMFULL;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_Revert(IStream *This)
+HRESULT STDMETHODCALLTYPE CliprdrStream_Revert(IStream* This)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
return STG_E_INSUFFICIENTMEMORY;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_LockRegion(IStream *This, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
+HRESULT STDMETHODCALLTYPE CliprdrStream_LockRegion(IStream* This, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
return STG_E_INSUFFICIENTMEMORY;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_UnlockRegion(IStream *This, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
+HRESULT STDMETHODCALLTYPE CliprdrStream_UnlockRegion(IStream* This, ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
return STG_E_INSUFFICIENTMEMORY;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_Stat(IStream *This, STATSTG *pstatstg, DWORD grfStatFlag)
+HRESULT STDMETHODCALLTYPE CliprdrStream_Stat(IStream* This, STATSTG* pstatstg, DWORD grfStatFlag)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
if (pstatstg == NULL)
return STG_E_INVALIDPOINTER;
return STG_E_INSUFFICIENTMEMORY;
case STATFLAG_NONAME:
- pstatstg->cbSize.QuadPart = instance->m_lSize.QuadPart;
+ pstatstg->cbSize.QuadPart = instance->m_lSize.QuadPart;
pstatstg->grfLocksSupported = LOCK_EXCLUSIVE;
- pstatstg->grfMode = GENERIC_READ;
- pstatstg->grfStateBits = 0;
- pstatstg->type = STGTY_STREAM;
+ pstatstg->grfMode = GENERIC_READ;
+ pstatstg->grfStateBits = 0;
+ pstatstg->type = STGTY_STREAM;
break;
case STATFLAG_NOOPEN:
return S_OK;
}
-HRESULT STDMETHODCALLTYPE CliprdrStream_Clone(IStream *This, IStream **ppstm)
+HRESULT STDMETHODCALLTYPE CliprdrStream_Clone(IStream* This, IStream** ppstm)
{
- CliprdrStream *instance = (CliprdrStream *)This;
+ CliprdrStream* instance = (CliprdrStream*) This;
return STG_E_INSUFFICIENTMEMORY;
}
-CliprdrStream *CliprdrStream_New(LONG index, void *pData)
+CliprdrStream *CliprdrStream_New(LONG index, void* pData)
{
- cliprdrContext *cliprdr = (cliprdrContext *)pData;
- CliprdrStream *instance;
- IStream *iStream;
+ cliprdrContext* cliprdr = (cliprdrContext*) pData;
+ CliprdrStream* instance;
+ IStream* iStream;
- instance = (CliprdrStream *)calloc(1, sizeof(CliprdrStream));
+ instance = (CliprdrStream*) calloc(1, sizeof(CliprdrStream));
if (instance)
{
iStream = &instance->iStream;
- iStream->lpVtbl = (IStreamVtbl *)calloc(1, sizeof(IStreamVtbl));
+ iStream->lpVtbl = (IStreamVtbl*) calloc(1, sizeof(IStreamVtbl));
+
if (iStream->lpVtbl)
{
iStream->lpVtbl->QueryInterface = CliprdrStream_QueryInterface;
- iStream->lpVtbl->AddRef = CliprdrStream_AddRef;
- iStream->lpVtbl->Release = CliprdrStream_Release;
- iStream->lpVtbl->Read = CliprdrStream_Read;
- iStream->lpVtbl->Write = CliprdrStream_Write;
- iStream->lpVtbl->Seek = CliprdrStream_Seek;
- iStream->lpVtbl->SetSize = CliprdrStream_SetSize;
- iStream->lpVtbl->CopyTo = CliprdrStream_CopyTo;
- iStream->lpVtbl->Commit = CliprdrStream_Commit;
- iStream->lpVtbl->Revert = CliprdrStream_Revert;
- iStream->lpVtbl->LockRegion = CliprdrStream_LockRegion;
- iStream->lpVtbl->UnlockRegion = CliprdrStream_UnlockRegion;
- iStream->lpVtbl->Stat = CliprdrStream_Stat;
- iStream->lpVtbl->Clone = CliprdrStream_Clone;
-
- instance->m_lRefCount = 1;
- instance->m_lIndex = index;
- instance->m_pData = pData;
+ iStream->lpVtbl->AddRef = CliprdrStream_AddRef;
+ iStream->lpVtbl->Release = CliprdrStream_Release;
+ iStream->lpVtbl->Read = CliprdrStream_Read;
+ iStream->lpVtbl->Write = CliprdrStream_Write;
+ iStream->lpVtbl->Seek = CliprdrStream_Seek;
+ iStream->lpVtbl->SetSize = CliprdrStream_SetSize;
+ iStream->lpVtbl->CopyTo = CliprdrStream_CopyTo;
+ iStream->lpVtbl->Commit = CliprdrStream_Commit;
+ iStream->lpVtbl->Revert = CliprdrStream_Revert;
+ iStream->lpVtbl->LockRegion = CliprdrStream_LockRegion;
+ iStream->lpVtbl->UnlockRegion = CliprdrStream_UnlockRegion;
+ iStream->lpVtbl->Stat = CliprdrStream_Stat;
+ iStream->lpVtbl->Clone = CliprdrStream_Clone;
+
+ instance->m_lRefCount = 1;
+ instance->m_lIndex = index;
+ instance->m_pData = pData;
instance->m_lOffset.QuadPart = 0;
/* get content size of this stream */
- cliprdr_send_request_filecontents(cliprdr, (void *)instance, instance->m_lIndex, FILECONTENTS_SIZE, 0, 0, 8);
- instance->m_lSize.QuadPart = *(LONGLONG *)cliprdr->req_fdata;
+ cliprdr_send_request_filecontents(cliprdr, (void*) instance, instance->m_lIndex, FILECONTENTS_SIZE, 0, 0, 8);
+ instance->m_lSize.QuadPart = *(LONGLONG*)cliprdr->req_fdata;
free(cliprdr->req_fdata);
}
else
return instance;
}
-void CliprdrStream_Delete(CliprdrStream *instance)
+void CliprdrStream_Delete(CliprdrStream* instance)
{
if (instance)
{
if (instance->iStream.lpVtbl)
free(instance->iStream.lpVtbl);
+
free(instance);
}
}
${${MODULE_PREFIX}_DRIVER}
${${MODULE_PREFIX}_TESTS})
+include_directories(${OPENSSL_INCLUDE_DIR})
+
add_executable(${MODULE_NAME} ${${MODULE_PREFIX}_SRCS})
target_link_libraries(${MODULE_NAME} freerdp)
char* body;
BYTE bom[2];
char num[11];
+ WCHAR* wstr;
if (SrcSize > 2)
{
if ((bom[0] == 0xFF) && (bom[1] == 0xFE))
{
- ConvertFromUnicode(CP_UTF8, 0, (WCHAR*) (data + 2),
+ wstr = (WCHAR*) &((BYTE*) data)[2];
+
+ ConvertFromUnicode(CP_UTF8, 0, wstr,
(SrcSize - 2) / 2, &pSrcData, 0, NULL, NULL);
}
}
projects / platform / upstream / freerdp.git / commitdiff