newlib-cygwin/winsup/cygwin/fhandler_clipboard.cc

341 lines
7.6 KiB
C++

/* fhandler_dev_clipboard: code to access /dev/clipboard
Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009, 2011,
2012 Red Hat, Inc
Written by Charles Wilson (cwilson@ece.gatech.edu)
This file is part of Cygwin.
This software is a copyrighted work licensed under the terms of the
Cygwin license. Please consult the file "CYGWIN_LICENSE" for
details. */
#include "winsup.h"
#include <wchar.h>
#include <wingdi.h>
#include <winuser.h>
#include "cygerrno.h"
#include "path.h"
#include "fhandler.h"
#include "sync.h"
#include "dtable.h"
#include "cygheap.h"
#include "child_info.h"
/*
* Robert Collins:
* FIXME: should we use GetClipboardSequenceNumber to tell if the clipboard has
* changed? How does /dev/clipboard operate under (say) linux?
*/
static const NO_COPY WCHAR *CYGWIN_NATIVE = L"CYGWIN_NATIVE_CLIPBOARD";
/* this is MT safe because windows format id's are atomic */
static int cygnativeformat;
typedef struct
{
timestruc_t timestamp;
size_t len;
char data[1];
} cygcb_t;
fhandler_dev_clipboard::fhandler_dev_clipboard ()
: fhandler_base (), pos (0), membuffer (NULL), msize (0),
eof (true)
{
/* FIXME: check for errors and loop until we can open the clipboard */
OpenClipboard (NULL);
cygnativeformat = RegisterClipboardFormatW (CYGWIN_NATIVE);
CloseClipboard ();
}
/*
* Special clipboard dup to duplicate input and output
* handles.
*/
int
fhandler_dev_clipboard::dup (fhandler_base * child, int)
{
fhandler_dev_clipboard *fhc = (fhandler_dev_clipboard *) child;
if (!fhc->open (get_flags (), 0))
system_printf ("error opening clipboard, %E");
return 0;
}
int
fhandler_dev_clipboard::open (int flags, mode_t)
{
set_flags (flags | O_TEXT);
eof = false;
pos = 0;
if (membuffer)
free (membuffer);
membuffer = NULL;
if (!cygnativeformat)
cygnativeformat = RegisterClipboardFormatW (CYGWIN_NATIVE);
nohandle (true);
set_open_status ();
return 1;
}
static int
set_clipboard (const void *buf, size_t len)
{
HGLOBAL hmem;
/* Native CYGWIN format */
if (OpenClipboard (NULL))
{
cygcb_t *clipbuf;
hmem = GlobalAlloc (GMEM_MOVEABLE, sizeof (cygcb_t) + len);
if (!hmem)
{
__seterrno ();
CloseClipboard ();
return -1;
}
clipbuf = (cygcb_t *) GlobalLock (hmem);
clock_gettime (CLOCK_REALTIME, &clipbuf->timestamp);
clipbuf->len = len;
memcpy (clipbuf->data, buf, len);
GlobalUnlock (hmem);
EmptyClipboard ();
if (!cygnativeformat)
cygnativeformat = RegisterClipboardFormatW (CYGWIN_NATIVE);
HANDLE ret = SetClipboardData (cygnativeformat, hmem);
CloseClipboard ();
/* According to MSDN, hmem must not be free'd after transferring the
data to the clipboard via SetClipboardData. */
/* GlobalFree (hmem); */
if (!ret)
{
__seterrno ();
return -1;
}
}
/* CF_TEXT/CF_OEMTEXT for copying to wordpad and the like */
len = sys_mbstowcs (NULL, 0, (const char *) buf, len);
if (!len)
{
set_errno (EILSEQ);
return -1;
}
if (OpenClipboard (NULL))
{
PWCHAR clipbuf;
hmem = GlobalAlloc (GMEM_MOVEABLE, (len + 1) * sizeof (WCHAR));
if (!hmem)
{
__seterrno ();
CloseClipboard ();
return -1;
}
clipbuf = (PWCHAR) GlobalLock (hmem);
sys_mbstowcs (clipbuf, len + 1, (const char *) buf);
GlobalUnlock (hmem);
HANDLE ret = SetClipboardData (CF_UNICODETEXT, hmem);
CloseClipboard ();
/* According to MSDN, hmem must not be free'd after transferring the
data to the clipboard via SetClipboardData. */
/* GlobalFree (hmem); */
if (!ret)
{
__seterrno ();
return -1;
}
}
return 0;
}
/* FIXME: arbitrary seeking is not handled */
ssize_t __stdcall
fhandler_dev_clipboard::write (const void *buf, size_t len)
{
if (!eof)
{
/* write to our membuffer */
size_t cursize = msize;
void *tempbuffer = realloc (membuffer, cursize + len);
if (!tempbuffer)
{
debug_printf ("Couldn't realloc() clipboard buffer for write");
return -1;
}
membuffer = tempbuffer;
msize = cursize + len;
memcpy ((unsigned char *) membuffer + cursize, buf, len);
/* now pass to windows */
if (set_clipboard (membuffer, msize))
{
/* FIXME: membuffer is now out of sync with pos, but msize
is used above */
return -1;
}
pos = msize;
eof = false;
return len;
}
else
{
/* FIXME: return 0 bytes written, file not open */
return 0;
}
}
int __stdcall
fhandler_dev_clipboard::fstat (struct __stat64 *buf)
{
buf->st_mode = S_IFCHR | STD_RBITS | STD_WBITS | S_IWGRP | S_IWOTH;
buf->st_uid = geteuid32 ();
buf->st_gid = getegid32 ();
buf->st_nlink = 1;
buf->st_blksize = PREFERRED_IO_BLKSIZE;
buf->st_ctim.tv_sec = 1164931200L; /* Arbitrary value: 2006-12-01 */
buf->st_ctim.tv_nsec = 0L;
buf->st_birthtim = buf->st_atim = buf->st_mtim = buf->st_ctim;
if (OpenClipboard (NULL))
{
UINT formatlist[1] = { cygnativeformat };
int format;
HGLOBAL hglb;
cygcb_t *clipbuf;
if ((format = GetPriorityClipboardFormat (formatlist, 1)) > 0
&& (hglb = GetClipboardData (format))
&& (clipbuf = (cygcb_t *) GlobalLock (hglb)))
{
buf->st_atim = buf->st_mtim = clipbuf->timestamp;
buf->st_size = clipbuf->len;
GlobalUnlock (hglb);
}
CloseClipboard ();
}
return 0;
}
void __stdcall
fhandler_dev_clipboard::read (void *ptr, size_t& len)
{
HGLOBAL hglb;
size_t ret;
UINT formatlist[2];
int format;
size_t plen = len;
len = 0;
if (eof)
return;
if (!OpenClipboard (NULL))
return;
formatlist[0] = cygnativeformat;
formatlist[1] = CF_UNICODETEXT;
if ((format = GetPriorityClipboardFormat (formatlist, 2)) <= 0)
{
CloseClipboard ();
return;
}
if (!(hglb = GetClipboardData (format)))
{
CloseClipboard ();
return;
}
if (format == cygnativeformat)
{
cygcb_t *clipbuf;
if (!(clipbuf = (cygcb_t *) GlobalLock (hglb)))
{
CloseClipboard ();
return;
}
ret = ((plen > (clipbuf->len - pos)) ? (clipbuf->len - pos) : plen);
memcpy (ptr, clipbuf->data + pos , ret);
pos += ret;
if (pos + plen - ret >= clipbuf->len)
eof = true;
}
else
{
int wret;
PWCHAR buf;
if (!(buf = (PWCHAR) GlobalLock (hglb)))
{
CloseClipboard ();
return;
}
size_t glen = GlobalSize (hglb) / sizeof (WCHAR) - 1;
/* This loop is necessary because the number of bytes returned by
sys_wcstombs does not indicate the number of wide chars used for
it, so we could potentially drop wide chars. */
if (glen - pos > plen)
glen = pos + plen;
while ((wret = sys_wcstombs (NULL, 0, buf + pos, glen - pos)) != -1
&& (size_t) wret > plen)
--glen;
ret = sys_wcstombs ((char *) ptr, plen, buf + pos, glen - pos);
pos += ret;
if (pos + plen - ret >= wcslen (buf))
eof = true;
}
GlobalUnlock (hglb);
CloseClipboard ();
len = ret;
}
_off64_t
fhandler_dev_clipboard::lseek (_off64_t offset, int whence)
{
/* On reads we check this at read time, not seek time.
* On writes we use this to decide how to write - empty and write, or open, copy, empty
* and write
*/
pos = offset;
/* treat seek like rewind */
if (membuffer)
free (membuffer);
msize = 0;
return 0;
}
int
fhandler_dev_clipboard::close ()
{
if (!have_execed)
{
eof = true;
pos = 0;
if (membuffer)
{
free (membuffer);
membuffer = NULL;
}
msize = 0;
}
return 0;
}
void
fhandler_dev_clipboard::fixup_after_exec ()
{
if (!close_on_exec ())
{
eof = false;
pos = msize = 0;
membuffer = NULL;
}
}