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