int get_inheritable(int fd) {
#ifdef MS_WINDOWS
HANDLE handle;
DWORD flags = 0;
handle = (HANDLE)_get_osfhandle(fd);
if (handle == INVALID_HANDLE_VALUE) {
return -1;
}
if (!GetHandleInformation(handle, &flags)) {
return -1;
}
return (flags & HANDLE_FLAG_INHERIT);
#else
int flags = 0;
flags = fcntl(fd, F_GETFD, 0);
if (flags == -1) {
return -1;
}
return !(flags & FD_CLOEXEC);
#endif
}
/*
* Class: org_eclipse_cdt_utils_pty_PTY
* Method: waitFor
* Signature: (II)I
*/
JNIEXPORT jint JNICALL Java_org_eclipse_cdt_utils_pty_PTY_waitFor
(JNIEnv *env, jobject jobj, jint masterFD, jint pid)
{
int status = -1;
DWORD flags;
int fd;
std::map<int, winpty_t*> :: iterator fd2pty_Iter;
std::map<int, int> :: iterator fd2rc_Iter;
fd = masterFD;
fd2pty_Iter = fd2pty.find(fd);
if (fd2pty_Iter != fd2pty.end()) {
winpty_t* winpty = fd2pty_Iter -> second;
if (winpty != NULL) {
HANDLE handle = winpty_get_data_pipe(winpty);
BOOL success;
do {
success = GetHandleInformation(handle, &flags);
if (success) Sleep(500);
} while (success);
fd2rc_Iter = fd2rc.find(fd);
if (fd2rc_Iter != fd2rc.end()) {
status = fd2rc_Iter -> second;
fd2rc.erase(fd2rc_Iter);
}
}
}
return status;
}
static int
get_inheritable(int fd, int raise)
{
#ifdef MS_WINDOWS
HANDLE handle;
DWORD flags;
_Py_BEGIN_SUPPRESS_IPH
handle = (HANDLE)_get_osfhandle(fd);
_Py_END_SUPPRESS_IPH
if (handle == INVALID_HANDLE_VALUE) {
if (raise)
PyErr_SetFromErrno(PyExc_OSError);
return -1;
}
if (!GetHandleInformation(handle, &flags)) {
if (raise)
PyErr_SetFromWindowsErr(0);
return -1;
}
return (flags & HANDLE_FLAG_INHERIT);
#else
int flags;
flags = fcntl(fd, F_GETFD, 0);
if (flags == -1) {
if (raise)
PyErr_SetFromErrno(PyExc_OSError);
return -1;
}
return !(flags & FD_CLOEXEC);
#endif
}
bool StdHandleOk(DWORD std_handle) {
// GetStdHandle sometimes returns an invalid handle instead of INVALID_HANDLE_VALUE
// check with GetHandleInformation
HANDLE h = GetStdHandle(std_handle);
DWORD flags;
return GetHandleInformation(h,&flags);
}
BOOL WINAPI ResilientCloseHandle(
HANDLE hObject)
{
BOOL Success;
DWORD LastError;
DWORD HandleFlags = 0, FileNameLen;
WCHAR FileNameBuf[sizeof "\\\\?\\GLOBALROOT" - 1 + 1024] = L"\\\\?\\GLOBALROOT";
if (GetHandleInformation(hObject, &HandleFlags) &&
(HANDLE_FLAG_PROTECT_FROM_CLOSE & HandleFlags))
{
SetHandleInformation(hObject,
HANDLE_FLAG_PROTECT_FROM_CLOSE, 0);
FileNameLen = GetFinalPathNameByHandle(hObject,
FileNameBuf + sizeof "\\\\?\\GLOBALROOT" - 1, 1023,
FILE_NAME_OPENED | VOLUME_NAME_NT);
if (0 == FileNameLen || FileNameLen >= 1024)
HandleFlags = 0;
}
Success = CloseHandle(
hObject);
LastError = GetLastError();
if (Success)
{
if (HANDLE_FLAG_PROTECT_FROM_CLOSE & HandleFlags)
WaitDeletePending(FileNameBuf);
}
SetLastError(LastError);
return Success;
}
static BOOL hasInheritFlag(HANDLE handle)
{
DWORD mask;
if (GetHandleInformation(handle, &mask)) {
return mask & HANDLE_FLAG_INHERIT;
}
return FALSE;
}
BOOL nb_close1(HANDLE fd)
{
int dwFlags = 0;
int rc = 1;
if (fd != INVALID_HANDLE_VALUE)
{
if (rc = GetHandleInformation(fd, &dwFlags))
CloseHandle(fd);
}
return(rc);
}
void
_PR_MD_QUERY_FD_INHERITABLE(PRFileDesc *fd)
{
DWORD flags;
PR_ASSERT(_PR_TRI_UNKNOWN == fd->secret->inheritable);
if (GetHandleInformation((HANDLE)fd->secret->md.osfd, &flags)) {
if (flags & HANDLE_FLAG_INHERIT) {
fd->secret->inheritable = _PR_TRI_TRUE;
} else {
fd->secret->inheritable = _PR_TRI_FALSE;
}
}
}
/* Return true if FD is not inherited to child processes. */
static bool
is_cloexec (int fd)
{
#if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
HANDLE h = (HANDLE) _get_osfhandle (fd);
DWORD flags;
ASSERT (GetHandleInformation (h, &flags));
return (flags & HANDLE_FLAG_INHERIT) == 0;
#else
int flags;
ASSERT ((flags = fcntl (fd, F_GETFD)) >= 0);
return (flags & FD_CLOEXEC) != 0;
#endif
}
/**
* Detach a thread.
*
* @param t The thread to be detached.
* @return If the function succeeds, the return value is 0.
* If the function fails, the return value is -1,
* with errno set to indicate the error.
* @bug The main thread do not support detach.
*/
int pthread_detach (pthread_t t)
{
DWORD dwFlags;
arch_thread_info *pv = (arch_thread_info *) t;
if (pv != NULL) {
pv->state |= PTHREAD_CREATE_DETACHED;
if (pv == NULL || pv->handle == NULL || !GetHandleInformation(pv->handle, &dwFlags))
return ESRCH;
if (pv->handle != NULL)
CloseHandle(pv->handle);
}
return 0;
}
FileError File::close(const FileHandle fh )
{
FileError err =FILE_CLOSE_FAIL;
BOOL info;
DWORD lpdwFlags[100];
info= GetHandleInformation(fh,lpdwFlags);
if(fh!=INVALID_HANDLE_VALUE && fh!=0 && info!=0)
{
if(CloseHandle(fh))
{
err=FILE_SUCCESS;
}
}
return err;
}
static int pthread_check(pthread_t t)
{
struct _pthread_v *pv;
DWORD dwFlags;
if (!t)
return ESRCH;
pv = __pth_gpointer_locked (t);
if (!(pv->h) || pv->h == INVALID_HANDLE_VALUE)
{
if (pv->ended == 0)
return 0;
return ESRCH;
}
else if ((!GetHandleInformation(pv->h, &dwFlags) && pv->ended))
return ESRCH;
return 0;
}
void
OFFile::handle( OFOS::of_handle_t handle )
{
close( );
m_handle = handle;
#if defined(OFOPSYS_LINUX) || defined(OFOPSYS_SOLARIS) || defined(OFOPSYS_FREEBSD) || defined(OFOPSYS_DARWIN)
struct stat buf;
if ( fstat( m_handle, &buf ) == 0 )
m_open = true;
#elif defined(OFOPSYS_WIN32)
oflong hi;
if ( GetHandleInformation( m_handle, &hi ) )
m_open = true;
#else
#error Undefined platform
#endif
}
static int
w32_wait_events(HANDLE *events, int count, DWORD timeout, rb_thread_t *th)
{
HANDLE *targets = events;
HANDLE intr;
DWORD ret;
thread_debug(" w32_wait_events events:%p, count:%d, timeout:%ld, th:%p\n",
events, count, timeout, th);
if (th && (intr = th->native_thread_data.interrupt_event)) {
native_mutex_lock(&th->vm->global_vm_lock);
if (intr == th->native_thread_data.interrupt_event) {
w32_reset_event(intr);
if (RUBY_VM_INTERRUPTED(th)) {
w32_set_event(intr);
}
targets = ALLOCA_N(HANDLE, count + 1);
memcpy(targets, events, sizeof(HANDLE) * count);
targets[count++] = intr;
thread_debug(" * handle: %p (count: %d, intr)\n", intr, count);
}
native_mutex_unlock(&th->vm->global_vm_lock);
}
thread_debug(" WaitForMultipleObjects start (count: %d)\n", count);
ret = WaitForMultipleObjects(count, targets, FALSE, timeout);
thread_debug(" WaitForMultipleObjects end (ret: %lu)\n", ret);
if (ret == WAIT_OBJECT_0 + count - 1 && th) {
errno = EINTR;
}
if (ret == -1 && THREAD_DEBUG) {
int i;
DWORD dmy;
for (i = 0; i < count; i++) {
thread_debug(" * error handle %d - %s\n", i,
GetHandleInformation(targets[i], &dmy) ? "OK" : "NG");
}
}
return ret;
}
/* Return non-zero if FD is open and inheritable across exec/spawn. */
static int
is_inheritable (int fd)
{
# if (defined _WIN32 || defined __WIN32__) && ! defined __CYGWIN__
/* On Win32, the initial state of unassigned standard file
descriptors is that they are open but point to an
INVALID_HANDLE_VALUE, and there is no fcntl. */
HANDLE h = (HANDLE) _get_osfhandle (fd);
DWORD flags;
if (h == INVALID_HANDLE_VALUE || GetHandleInformation (h, &flags) == 0)
return 0;
return (flags & HANDLE_FLAG_INHERIT) != 0;
# else
# ifndef F_GETFD
# error Please port fcntl to your platform
# endif
int i = fcntl (fd, F_GETFD);
return 0 <= i && (i & FD_CLOEXEC) == 0;
# endif
}
int fcntl(int fd, int cmd, ...)
{
va_list va;
int res = -1;
va_start (va, cmd);
if (cmd == F_GETFD)
{
HANDLE h;
DWORD flag;
h = (HANDLE)_get_osfhandle(fd);
if (h == INVALID_HANDLE_VALUE)
return -1;
if (!GetHandleInformation(h, &flag))
{
/* FIXME: should we close h ? MSDN seems to say that */
return -1;
}
res = 0;
}
if (cmd == F_SETFD)
{
HANDLE h;
long flag;
h = (HANDLE)_get_osfhandle(fd);
if (h == INVALID_HANDLE_VALUE)
return -1;
flag = va_arg(va, long);
if (flag == FD_CLOEXEC)
{
if (SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0))
res = 0;
}
}
/**
* Wait for thread termination.
* @param thread The target thread wait for termination.
* @param value_ptr The pointer of the target thread return value.
* @return If the function succeeds, the return value is 0.
* Otherwise an error number will be returned to indicate the error.
* @bug The main thread do not support join.
*/
int pthread_join(pthread_t thread, void **value_ptr)
{
DWORD dwFlags;
arch_thread_info *pv = (arch_thread_info *) thread;
if (pv == NULL || pv->handle == NULL || !GetHandleInformation(pv->handle, &dwFlags))
return ESRCH;
if ((pv->state & PTHREAD_CREATE_DETACHED) != 0)
return EINVAL;
if (pthread_equal(pthread_self(), thread))
return EDEADLK;
WaitForSingleObject(pv->handle, INFINITE);
CloseHandle(pv->handle);
if (value_ptr)
*value_ptr = pv->return_value;
return 0;
}
PWSSOCKET
WSAAPI
WsSockFindIfsSocket(IN SOCKET Handle)
{
INT ErrorCode;
DWORD Flags;
PWSSOCKET Socket = NULL;
PWSPROCESS Process = NULL;
PTCATALOG Catalog = NULL;
/* Validate the socket and get handle info */
if ((Handle != INVALID_SOCKET) &&
(GetHandleInformation((HANDLE)Handle, &Flags)))
{
/* Get the process */
if ((Process = WsGetProcess()))
{
/* Get the catalog */
Catalog = WsProcGetTCatalog(Process);
/* Get the IFS Provider */
ErrorCode = WsTcFindIfsProviderForSocket(Catalog, Handle);
/* Check for success */
if (ErrorCode == ERROR_SUCCESS)
{
/* Get the Socket now */
Socket = WsSockGetSocketNoExport(Handle);
/* Mark it as an API Socket */
if (Socket) Socket->ApiSocket = TRUE;
}
}
}
/* Return the socket */
return Socket;
}
bool
PdFile::IsBad( void ) const
{
DWORD dwflags = 0;
return (GetHandleInformation( fd, &dwflags ) == FALSE);
}
static void test_handles(void)
{
HWINSTA w1, w2, w3;
HDESK d1, d2, d3;
HANDLE hthread;
DWORD id, flags, le;
ATOM atom;
char buffer[20];
/* win stations */
w1 = GetProcessWindowStation();
ok( GetProcessWindowStation() == w1, "GetProcessWindowStation returned different handles\n" );
ok( !CloseWindowStation(w1), "closing process win station succeeded\n" );
SetLastError( 0xdeadbeef );
ok( !CloseHandle(w1), "closing process win station handle succeeded\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
print_object( w1 );
flags = 0;
ok( GetHandleInformation( w1, &flags ), "GetHandleInformation failed\n" );
ok( !(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE) ||
broken(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE), /* set on nt4 */
"handle %p PROTECT_FROM_CLOSE set\n", w1 );
ok( DuplicateHandle( GetCurrentProcess(), w1, GetCurrentProcess(), (PHANDLE)&w2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseWindowStation(w2), "closing dup win station failed\n" );
ok( DuplicateHandle( GetCurrentProcess(), w1, GetCurrentProcess(), (PHANDLE)&w2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseHandle(w2), "closing dup win station handle failed\n" );
w2 = CreateWindowStation("WinSta0", 0, WINSTA_ALL_ACCESS, NULL );
le = GetLastError();
ok( w2 != 0 || le == ERROR_ACCESS_DENIED, "CreateWindowStation failed (%u)\n", le );
if (w2 != 0)
{
ok( w2 != w1, "CreateWindowStation returned default handle\n" );
SetLastError( 0xdeadbeef );
ok( !CloseDesktop( (HDESK)w2 ), "CloseDesktop succeeded on win station\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
w2 = CreateWindowStation("WinSta0", 0, WINSTA_ALL_ACCESS, NULL );
ok( CloseHandle( w2 ), "CloseHandle failed\n" );
}
else if (le == ERROR_ACCESS_DENIED)
win_skip( "Not enough privileges for CreateWindowStation\n" );
w2 = OpenWindowStation("winsta0", TRUE, WINSTA_ALL_ACCESS );
ok( w2 != 0, "OpenWindowStation failed\n" );
ok( w2 != w1, "OpenWindowStation returned default handle\n" );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
w2 = OpenWindowStation("dummy name", TRUE, WINSTA_ALL_ACCESS );
ok( !w2, "open dummy win station succeeded\n" );
CreateMutexA( NULL, 0, "foobar" );
w2 = CreateWindowStation("foobar", 0, WINSTA_ALL_ACCESS, NULL );
le = GetLastError();
ok( w2 != 0 || le == ERROR_ACCESS_DENIED, "create foobar station failed (%u)\n", le );
if (w2 != 0)
{
w3 = OpenWindowStation("foobar", TRUE, WINSTA_ALL_ACCESS );
ok( w3 != 0, "open foobar station failed\n" );
ok( w3 != w2, "open foobar station returned same handle\n" );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
ok( CloseWindowStation( w3 ), "CloseWindowStation failed\n" );
w3 = OpenWindowStation("foobar", TRUE, WINSTA_ALL_ACCESS );
ok( !w3, "open foobar station succeeded\n" );
w2 = CreateWindowStation("foobar1", 0, WINSTA_ALL_ACCESS, NULL );
ok( w2 != 0, "create foobar station failed\n" );
w3 = CreateWindowStation("foobar2", 0, WINSTA_ALL_ACCESS, NULL );
ok( w3 != 0, "create foobar station failed\n" );
ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
ok( GetHandleInformation( w3, &flags ), "GetHandleInformation failed\n" );
SetProcessWindowStation( w2 );
atom = GlobalAddAtomA("foo");
ok( GlobalGetAtomNameA( atom, buffer, sizeof(buffer) ) == 3, "GlobalGetAtomName failed\n" );
ok( !lstrcmpiA( buffer, "foo" ), "bad atom value %s\n", buffer );
ok( !CloseWindowStation( w2 ), "CloseWindowStation succeeded\n" );
ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
SetProcessWindowStation( w3 );
ok( GetHandleInformation( w2, &flags ), "GetHandleInformation failed\n" );
ok( CloseWindowStation( w2 ), "CloseWindowStation failed\n" );
ok( GlobalGetAtomNameA( atom, buffer, sizeof(buffer) ) == 3, "GlobalGetAtomName failed\n" );
ok( !lstrcmpiA( buffer, "foo" ), "bad atom value %s\n", buffer );
}
else if (le == ERROR_ACCESS_DENIED)
win_skip( "Not enough privileges for CreateWindowStation\n" );
/* desktops */
d1 = GetThreadDesktop(GetCurrentThreadId());
initial_desktop = d1;
ok( GetThreadDesktop(GetCurrentThreadId()) == d1,
"GetThreadDesktop returned different handles\n" );
flags = 0;
ok( GetHandleInformation( d1, &flags ), "GetHandleInformation failed\n" );
ok( !(flags & HANDLE_FLAG_PROTECT_FROM_CLOSE), "handle %p PROTECT_FROM_CLOSE set\n", d1 );
SetLastError( 0xdeadbeef );
ok( !CloseDesktop(d1), "closing thread desktop succeeded\n" );
ok( GetLastError() == ERROR_BUSY || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
SetLastError( 0xdeadbeef );
if (CloseHandle( d1 )) /* succeeds on nt4 */
{
win_skip( "NT4 desktop handle management is completely different\n" );
return;
}
ok( GetLastError() == ERROR_INVALID_HANDLE, "bad last error %d\n", GetLastError() );
ok( DuplicateHandle( GetCurrentProcess(), d1, GetCurrentProcess(), (PHANDLE)&d2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseDesktop(d2), "closing dup desktop failed\n" );
ok( DuplicateHandle( GetCurrentProcess(), d1, GetCurrentProcess(), (PHANDLE)&d2, 0,
TRUE, DUPLICATE_SAME_ACCESS ), "DuplicateHandle failed\n" );
ok( CloseHandle(d2), "closing dup desktop handle failed\n" );
d2 = OpenDesktop( "dummy name", 0, TRUE, DESKTOP_ALL_ACCESS );
ok( !d2, "open dummy desktop succeeded\n" );
d2 = CreateDesktop( "foobar", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
ok( d2 != 0, "create foobar desktop failed\n" );
SetLastError( 0xdeadbeef );
ok( !CloseWindowStation( (HWINSTA)d2 ), "CloseWindowStation succeeded on desktop\n" );
ok( GetLastError() == ERROR_INVALID_HANDLE || broken(GetLastError() == 0xdeadbeef), /* wow64 */
"bad last error %d\n", GetLastError() );
SetLastError( 0xdeadbeef );
d3 = CreateDesktop( "foobar", NULL, NULL, 0, DESKTOP_ALL_ACCESS, NULL );
ok( d3 != 0, "create foobar desktop again failed\n" );
ok( GetLastError() == 0xdeadbeef, "bad last error %d\n", GetLastError() );
ok( CloseDesktop( d3 ), "CloseDesktop failed\n" );
d3 = OpenDesktop( "foobar", 0, TRUE, DESKTOP_ALL_ACCESS );
ok( d3 != 0, "open foobar desktop failed\n" );
ok( d3 != d2, "open foobar desktop returned same handle\n" );
ok( CloseDesktop( d2 ), "CloseDesktop failed\n" );
ok( CloseDesktop( d3 ), "CloseDesktop failed\n" );
d3 = OpenDesktop( "foobar", 0, TRUE, DESKTOP_ALL_ACCESS );
ok( !d3, "open foobar desktop succeeded\n" );
ok( !CloseHandle(d1), "closing thread desktop handle succeeded\n" );
d2 = GetThreadDesktop(GetCurrentThreadId());
ok( d1 == d2, "got different handles after close\n" );
register_class();
trace( "thread 1 desktop: %p\n", d1 );
print_object( d1 );
hthread = CreateThread( NULL, 0, thread, (LPVOID)2, 0, &id );
Sleep(1000);
trace( "get other thread desktop: %p\n", GetThreadDesktop(id) );
WaitForSingleObject( hthread, INFINITE );
CloseHandle( hthread );
}
RTDECL(int) RTHandleGetStandard(RTHANDLESTD enmStdHandle, PRTHANDLE ph)
{
/*
* Validate and convert input.
*/
AssertPtrReturn(ph, VERR_INVALID_POINTER);
DWORD dwStdHandle;
switch (enmStdHandle)
{
case RTHANDLESTD_INPUT: dwStdHandle = STD_INPUT_HANDLE; break;
case RTHANDLESTD_OUTPUT: dwStdHandle = STD_OUTPUT_HANDLE; break;
case RTHANDLESTD_ERROR: dwStdHandle = STD_ERROR_HANDLE; break;
default:
AssertFailedReturn(VERR_INVALID_PARAMETER);
}
/*
* Is the requested descriptor valid and which IPRT handle type does it
* best map on to?
*/
HANDLE hNative = GetStdHandle(dwStdHandle);
if (hNative == INVALID_HANDLE_VALUE)
return RTErrConvertFromWin32(GetLastError());
DWORD dwInfo;
if (!GetHandleInformation(hNative, &dwInfo))
return RTErrConvertFromWin32(GetLastError());
bool const fInherit = RT_BOOL(dwInfo & HANDLE_FLAG_INHERIT);
RTHANDLE h;
DWORD dwType = GetFileType(hNative);
switch (dwType & ~FILE_TYPE_REMOTE)
{
default:
case FILE_TYPE_UNKNOWN:
case FILE_TYPE_CHAR:
case FILE_TYPE_DISK:
h.enmType = RTHANDLETYPE_FILE;
break;
case FILE_TYPE_PIPE:
{
DWORD cMaxInstances;
DWORD fInfo;
if (!GetNamedPipeInfo(hNative, &fInfo, NULL, NULL, &cMaxInstances))
h.enmType = RTHANDLETYPE_SOCKET;
else
h.enmType = RTHANDLETYPE_PIPE;
break;
}
}
/*
* Create the IPRT handle.
*/
int rc;
switch (h.enmType)
{
case RTHANDLETYPE_FILE:
rc = RTFileFromNative(&h.u.hFile, (RTHCUINTPTR)hNative);
break;
case RTHANDLETYPE_PIPE:
rc = RTPipeFromNative(&h.u.hPipe, (RTHCUINTPTR)hNative,
(enmStdHandle == RTHANDLESTD_INPUT ? RTPIPE_N_READ : RTPIPE_N_WRITE)
| (fInherit ? RTPIPE_N_INHERIT : 0));
break;
case RTHANDLETYPE_SOCKET:
rc = rtSocketCreateForNative(&h.u.hSocket, (RTHCUINTPTR)hNative);
break;
default: /* shut up gcc */
return VERR_INTERNAL_ERROR;
}
if (RT_SUCCESS(rc))
*ph = h;
return rc;
}
bool OutFileStream::isReady(void) { return GetHandleInformation(fd(),NULL) != 0;
}
// 使进程崩溃. 跟CrashForBitmapAllocationFailure()不同, 当位图分配失败时尝试
// 检测是不是无效的共享位图句柄问题.
void CrashIfInvalidSection(HANDLE shared_section)
{
DWORD handle_info = 0;
CHECK(GetHandleInformation(shared_section, &handle_info) == TRUE);
}
LIBFREESPACE_API int freespace_openDevice(FreespaceDeviceId id) {
int idx;
struct FreespaceDeviceStruct* device = freespace_private_getDeviceById(id);
if (device == NULL) {
return FREESPACE_ERROR_NO_DEVICE;
}
if (device->isOpened_) {
// Each device can only be opened once.
return FREESPACE_ERROR_BUSY;
}
for (idx = 0; idx < device->handleCount_; idx++) {
struct FreespaceSubStruct* s = &device->handle_[idx];
if (s->handle_ != NULL) {
// Device was partially (incorrectly) opened.
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_BUSY;
}
if (s->devicePath == NULL) {
// Device was not fully enumerated.
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_NO_DEVICE;
}
DEBUG_WPRINTF(L"Open %s\n", s->devicePath);
s->handle_ = CreateFile(s->devicePath,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
NULL);
{
DWORD d;
if (!GetHandleInformation(s->handle_, &d)) {
// We do not have the correct handle.
DEBUG_PRINTF("freespace_openDevice failed with code %d\n", GetLastError());
}
}
if (s->handle_ == INVALID_HANDLE_VALUE) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_NO_DEVICE;
}
if (!BindIoCompletionCallback(s->handle_, freespace_private_overlappedCallback, 0)) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_UNEXPECTED;
}
if (!HidD_SetNumInputBuffers(s->handle_, HID_NUM_INPUT_BUFFERS)) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_NO_DEVICE;
}
// Create the read event.
s->readOverlapped_.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
if (s->readOverlapped_.hEvent == NULL) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_UNEXPECTED;
}
s->readOverlapped_.Offset = 0;
s->readOverlapped_.OffsetHigh = 0;
s->readStatus_ = FALSE;
}
device->isOpened_ = TRUE;
// Enable send by initializing all send events.
for (idx = 0; idx < FREESPACE_MAXIMUM_SEND_MESSAGE_COUNT; idx++) {
device->send_[idx].overlapped_.hEvent = NULL;
if (initializeSendStruct(&device->send_[idx]) != FREESPACE_SUCCESS) {
freespace_private_forceCloseDevice(device);
return FREESPACE_ERROR_UNEXPECTED;
}
}
// If async mode has been enabled already, then start the receive
// process going.
if (freespace_instance_->fdAddedCallback_) {
int rc;
rc = initiateAsyncReceives(device);
if (rc != FREESPACE_SUCCESS) {
freespace_private_forceCloseDevice(device);
return rc;
}
}
return FREESPACE_SUCCESS;
}
