56a1971526
Throughout rename _PROC_* to _CH_*. * child_info.h: Include "pinfo.h". (child_info_types): Rename _PROC_* -> _CH_* to avoid confusion with similarly named constants. (_PROC_*): Delete unneeded aliases. (PROC_*): Ditto. (CURR_CHILD_INFO_MAGIC): Ditto. (cchildren): Define using "pinfo_minimal". (child_info::set_saw_ctrl_c): Move to (child_info_spawn::set_saw_ctrl_c): Here. (child_info_spawn::lock): New field. (child_info_spawn::hExeced): Ditto. (child_info_spawn::ev): Ditto. (child_info_spawn::~child_info_spawn): Move to sigproc.cc. (child_info_spawn::child_info_spawn): Ditto. (child_info_spawn::cleanup): Declare new function. (child_info_spawn::set_saw_ctrl_c): Move to this class. Set flag only when execed and return true when we have set the flag. (child_info_spawn::child_info_spawn::signal_myself_exited): New function. (child_info_spawn::wait_for_myself): Ditto. (child_info_spawn::has_execed_cygwin): Ditto. (child_info_spawn::has_execed): Ditto. Replaces "hExeced" test. (child_info_spawn::operator HANDLE&): New operator. (child_info_spawn::worker): Define old "spawn_guts" as class member. (ch_spawn): Declare. (have_execed): Define. (have_execed_cygwin): Ditto. * cygheap.h: Update comment. * dcrt0.cc (get_cygwin_startup_info): Use _CH_* enums. (child_info_spawn::handle_spawn): Ditto. (dll_crt0_0): Ditto. (multiple_cygwin_problem): Ditto. * exceptions.cc (chExeced): Delete obsolete declaration. (ctrl_c_handler): Reference set_saw_ctrl_c via new ch_spawn global. * globals.cc (hExeced): Delete. * pinfo.cc (pinfo::thisproc): Refer to cygheap as ::cygheap for consistency in handle naming when -DDEBUGGING. (pinfo::init): Accommodate case where myself.h is known but h0 is passed in. (pinfo::pinfo): New constructor for setting up a pinfo passed in by previous exec'or. (pinfo::proc_waiter): Don't handle subprocess if we're in the process of exiting due to an exec of a cygwin process. Don't close rd_proc_pipe here. Close it when we actually are finished with the process. Use new ch_spawn.signal_myself_exited function to let exec stub know that subprocess has exited. (pinfo::wait): Clarify debugging output. (pinfo::release): Use "close_h" to close all handles to avoid races. (winpids::add): Assume that elements of the array do not need to be zeroed and are properly initialized or suffer problems on pinfo::release. Don't close hProcess since release does that now. * pinfo.h: Update comment. (pinfo_minimal): Move some elements from pinfo here so that child_info_spawn can use them. (pinfo): Inherit from pinfo_minimal. (pinfo::pinfo): Modify to accommodate new pinfo_minimal. (pinfo::allow_remove): New function. * sigproc.cc (proc_subproc): Use boolean values for true/false. Implement PROC_EXEC_CLEANUP. (proc_terminate): Set ppid = 1 since the procs list will only be iterated when the process has not execed. Don't do any cleanup here since it is now handled in pinfo::release. (sigproc_init): Initialize sync_proc_subproc earlier. (child_info::child_info): Assume that all important fields are properly initialized and avoid memset(). (child_info_spawn::child_info_spawn): Specifically test for execing and then set up appropriate fields in the struct. (child_info_spawn::cleanup): Define new function. (child_info_spawn::record_children): Specifically test for being execed here. Fill in pinfo_minimal part of children array. (child_info_spawn::reattach_children): Use constructor to duplicate information for previous exec'or. Add more debugging output. (remove_proc): Force deletion of thread when exiting due to exec. Rely on pinfo::cleanup in release. * sigproc.h (PROC_EXEC_CLEANUP): New enum. (PROC_DETACHED_CHILD): Delete. * spawn.cc (chExeced): Delete. (child_info_spawn::worker): Rename from spawn_guts. Use elements of child_info_spawn throughout rather than ch.whatever. Use ::cygheap to refer to global rather than element of child_info. Use wait_for_myself() rather than waitpid(). Call child_info_spawn::cleanup on function return. (spawnve): Reflect movement of spawn_guts functionality into child_info_spawn::worker. * syscalls.cc (popen): Ditto. * winsup.h (spawn_guts): Delete declaration.
294 lines
6.6 KiB
C++
294 lines
6.6 KiB
C++
/* fhandler_dev_clipboard: code to access /dev/clipboard
|
|
|
|
Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2008, 2009, 2011 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;
|
|
|
|
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;
|
|
void *clipbuf;
|
|
/* Native CYGWIN format */
|
|
if (OpenClipboard (NULL))
|
|
{
|
|
hmem = GlobalAlloc (GMEM_MOVEABLE, len + sizeof (size_t));
|
|
if (!hmem)
|
|
{
|
|
__seterrno ();
|
|
CloseClipboard ();
|
|
return -1;
|
|
}
|
|
clipbuf = GlobalLock (hmem);
|
|
memcpy ((unsigned char *) clipbuf + sizeof (size_t), buf, len);
|
|
*(size_t *) (clipbuf) = 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))
|
|
{
|
|
hmem = GlobalAlloc (GMEM_MOVEABLE, (len + 1) * sizeof (WCHAR));
|
|
if (!hmem)
|
|
{
|
|
__seterrno ();
|
|
CloseClipboard ();
|
|
return -1;
|
|
}
|
|
clipbuf = GlobalLock (hmem);
|
|
sys_mbstowcs ((PWCHAR) 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;
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
unsigned char *buf;
|
|
|
|
if (!(buf = (unsigned char *) GlobalLock (hglb)))
|
|
{
|
|
CloseClipboard ();
|
|
return;
|
|
}
|
|
size_t buflen = (*(size_t *) buf);
|
|
ret = ((plen > (buflen - pos)) ? (buflen - pos) : plen);
|
|
memcpy (ptr, buf + sizeof (size_t)+ pos , ret);
|
|
pos += ret;
|
|
if (pos + plen - ret >= buflen)
|
|
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;
|
|
}
|
|
}
|