예제 #1
0
bool
FileDescriptor::CreatePipe(FileDescriptor &r, FileDescriptor &w)
{
  int fds[2];

#ifdef __linux__
  const int flags = O_CLOEXEC;
#ifdef __BIONIC__
  /* Bionic provides the pipe2() function only since Android 2.3,
     therefore we must roll our own system call here */
  const int result = syscall(__NR_pipe2, fds, flags);
#else
  const int result = pipe2(fds, flags);
#endif
#else
  const int result = pipe(fds);
#endif

  if (result < 0)
    return false;

  r = FileDescriptor(fds[0]);
  w = FileDescriptor(fds[1]);
  return true;
}
예제 #2
0
bool
CreateTransport(ProcessHandle /*unused*/, ProcessHandle /*unused*/,
                TransportDescriptor* aOne, TransportDescriptor* aTwo)
{
  // Gecko doesn't care about this random ID, and the argument to this
  // function isn't really necessary, it can be just any random
  // pointer value
  wstring id = ChildProcessInfo::GenerateRandomChannelID(aOne);
  // Use MODE_SERVER to force creation of the socketpair
  Transport t(id, Transport::MODE_SERVER, nsnull);
  int fd1 = t.GetServerFileDescriptor();
  int fd2, dontcare;
  t.GetClientFileDescriptorMapping(&fd2, &dontcare);
  if (fd1 < 0 || fd2 < 0) {
    return false;
  }

  // The Transport closes these fds when it goes out of scope, so we
  // dup them here
  fd1 = dup(fd1);
  fd2 = dup(fd2);
  if (fd1 < 0 || fd2 < 0) {
    return false;
  }

  aOne->mFd = FileDescriptor(fd1, true/*close after sending*/);
  aTwo->mFd = FileDescriptor(fd2, true/*close after sending*/);
  return true;
}
예제 #3
0
WaylandEventQueue::WaylandEventQueue(IOLoop &_io_loop, EventQueue &_queue)
  :io_loop(_io_loop), queue(_queue),
   display(wl_display_connect(nullptr))
{
  if (display == nullptr) {
    fprintf(stderr, "wl_display_connect() failed\n");
    exit(EXIT_FAILURE);
  }

  auto registry = wl_display_get_registry(display);
  wl_registry_add_listener(registry, &registry_listener, this);

  wl_display_dispatch(display);
  wl_display_roundtrip(display);

  if (compositor == nullptr) {
    fprintf(stderr, "No Wayland compositor found\n");
    exit(EXIT_FAILURE);
  }

  if (seat == nullptr) {
    fprintf(stderr, "No Wayland seat found\n");
    exit(EXIT_FAILURE);
  }

  if (shell == nullptr) {
    fprintf(stderr, "No Wayland shell found\n");
    exit(EXIT_FAILURE);
  }

  io_loop.Add(FileDescriptor(wl_display_get_fd(display)), io_loop.READ, *this);
}
예제 #4
0
mozilla::ipc::IPCResult
TemporaryIPCBlobParent::CreateAndShareFile()
{
  MOZ_ASSERT(mActive);
  MOZ_ASSERT(!mFile);

  nsresult rv = NS_OpenAnonymousTemporaryNsIFile(getter_AddRefs(mFile));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return SendDeleteError(rv);
  }

  PRFileDesc* fd;
  rv = mFile->OpenNSPRFileDesc(PR_RDWR, PR_IRWXU, &fd);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return SendDeleteError(rv);
  }

  FileDescriptor fdd =
    FileDescriptor(FileDescriptor::PlatformHandleType(PR_FileDesc2NativeHandle(fd)));

  // The FileDescriptor object owns a duplicate of the file handle; we
  // must close the original (and clean up the NSPR descriptor).
  PR_Close(fd);

  Unused << SendFileDesc(fdd);
  return IPC_OK();
}
예제 #5
0
void CEmuFileWrapper::UnRegisterFileObjectByStream(FILE* stream)
{
    if (isValidFilePtr(stream))
    {
        return UnRegisterFileObjectByDescriptor(FileDescriptor(*stream)->_file);
    }
}
예제 #6
0
void CEmuFileWrapper::CleanUp()
{
    CSingleLock lock(m_criticalSection);
    for (int i = 0; i < MAX_EMULATED_FILES; i++)
    {
        if (m_files[i].used)
        {
            m_files[i].file_xbmc->Close();
            delete m_files[i].file_xbmc;

            if (m_files[i].file_lock)
            {
                delete m_files[i].file_lock;
                m_files[i].file_lock = nullptr;
            }
#if !defined(TARGET_WINDOWS)
            //Don't memset on Windows as it overwrites our pointer
            memset(&m_files[i], 0, sizeof(EmuFileObject));
#endif
            m_files[i].used = false;
            FileDescriptor(m_files[i].file_emu)->_file = -1;
        }
#if defined(TARGET_WINDOWS) && (_MSC_VER >= 1900)
        delete static_cast<kodi_iobuf*>(m_files[i].file_emu._Placeholder);
        m_files[i].file_emu._Placeholder = nullptr;
#endif
    }
}
예제 #7
0
bool CEmuFileWrapper::StreamIsEmulatedFile(FILE* stream)
{
    if (isValidFilePtr(stream))
    {
        return DescriptorIsEmulatedFile(FileDescriptor(*stream)->_file);
    }
    return false;
}
예제 #8
0
EmuFileObject* CEmuFileWrapper::GetFileObjectByStream(FILE* stream)
{
    if (isValidFilePtr(stream))
    {
        return GetFileObjectByDescriptor(FileDescriptor(*stream)->_file);
    }

    return nullptr;
}
예제 #9
0
파일: Pipe.cpp 프로젝트: niclasr/watchman
Pipe::Pipe() {
#ifdef _WIN32
  HANDLE readPipe;
  HANDLE writePipe;
  SECURITY_ATTRIBUTES sec;

  memset(&sec, 0, sizeof(sec));
  sec.nLength = sizeof(sec);
  sec.bInheritHandle = FALSE; // O_CLOEXEC equivalent
  constexpr DWORD kPipeSize = 64 * 1024;

  if (!CreatePipe(&readPipe, &writePipe, &sec, kPipeSize)) {
    throw std::system_error(
        GetLastError(), std::system_category(), "CreatePipe failed");
  }
  read = FileDescriptor(intptr_t(readPipe));
  write = FileDescriptor(intptr_t(writePipe));

#else
  int fds[2];
  int res;
#if HAVE_PIPE2
  res = pipe2(fds, O_NONBLOCK | O_CLOEXEC);
#else
  res = pipe(fds);
#endif

  if (res) {
    throw std::system_error(
        errno,
        std::system_category(),
        std::string("pipe error: ") + strerror(errno));
  }
  read = FileDescriptor(fds[0]);
  write = FileDescriptor(fds[1]);

#if !HAVE_PIPE2
  read.setCloExec();
  read.setNonBlock();
  write.setCloExec();
  write.setNonBlock();
#endif
#endif
}
예제 #10
0
int CEmuFileWrapper::GetDescriptorByStream(FILE* stream)
{
    if (isValidFilePtr(stream))
    {
        int i = FileDescriptor(*stream)->_file - FILE_WRAPPER_OFFSET;
        if (i >= 0 && i < MAX_EMULATED_FILES)
        {
            return i + FILE_WRAPPER_OFFSET;
        }
    }
    return -1;
}
예제 #11
0
XFILE::CFile* CEmuFileWrapper::GetFileXbmcByStream(FILE* stream)
{
    if (isValidFilePtr(stream))
    {
        auto object = GetFileObjectByDescriptor(FileDescriptor(*stream)->_file);
        if (object != nullptr && object->used)
        {
            return object->file_xbmc;
        }
    }
    return nullptr;
}
예제 #12
0
Result<Ok, nsresult> MemMapSnapshot::Freeze(AutoMemMap& aMem) {
  auto orig = mFile.ref().ClonePlatformHandle();
  mFile.reset();

  HANDLE handle;
  if (!::DuplicateHandle(
          GetCurrentProcess(), orig.release(), GetCurrentProcess(), &handle,
          GENERIC_READ | FILE_MAP_READ, false, DUPLICATE_CLOSE_SOURCE)) {
    return Err(NS_ERROR_FAILURE);
  }

  return aMem.initWithHandle(FileDescriptor(handle), mMem.size());
}
예제 #13
0
X11EventQueue::X11EventQueue(IOLoop &_io_loop, EventQueue &_queue)
  :io_loop(_io_loop), queue(_queue),
   display(XOpenDisplay(nullptr))
{
  if (display == nullptr) {
    fprintf(stderr, "XOpenDisplay() failed\n");
    exit(EXIT_FAILURE);
  }

  wm_delete_window = XInternAtom(display, "WM_DELETE_WINDOW", false);

  io_loop.Add(FileDescriptor(ConnectionNumber(display)), io_loop.READ, *this);
}
예제 #14
0
CEmuFileWrapper::CEmuFileWrapper()
{
    // since we always use dlls we might just initialize it directly
    for (int i = 0; i < MAX_EMULATED_FILES; i++)
    {
        memset(&m_files[i], 0, sizeof(EmuFileObject));
        m_files[i].used = false;
#if defined(TARGET_WINDOWS) && (_MSC_VER >= 1900)
        m_files[i].file_emu._Placeholder = new kodi_iobuf();
#endif
        FileDescriptor(m_files[i].file_emu)->_file = -1;
    }
}
예제 #15
0
void
ParamTraits<MagicGrallocBufferHandle>::Write(Message* aMsg,
                                             const paramType& aParam)
{
#if ANDROID_VERSION >= 19
  sp<GraphicBuffer> flattenable = aParam.mGraphicBuffer;
#else
  Flattenable *flattenable = aParam.mGraphicBuffer.get();
#endif
  size_t nbytes = flattenable->getFlattenedSize();
  size_t nfds = flattenable->getFdCount();

  char data[nbytes];
  int fds[nfds];

#if ANDROID_VERSION >= 19
  // Make a copy of "data" and "fds" for flatten() to avoid casting problem
  void *pdata = (void *)data;
  int *pfds = fds;

  flattenable->flatten(pdata, nbytes, pfds, nfds);

  // In Kitkat, flatten() will change the value of nbytes and nfds, which dues
  // to multiple parcelable object consumption. The actual size and fd count
  // which returned by getFlattenedSize() and getFdCount() are not changed.
  // So we change nbytes and nfds back by call corresponding calls.
  nbytes = flattenable->getFlattenedSize();
  nfds = flattenable->getFdCount();
#else
  flattenable->flatten(data, nbytes, fds, nfds);
#endif
  aMsg->WriteInt(aParam.mRef.mOwner);
  aMsg->WriteInt64(aParam.mRef.mKey);
  aMsg->WriteSize(nbytes);
  aMsg->WriteSize(nfds);

  aMsg->WriteBytes(data, nbytes);
  for (size_t n = 0; n < nfds; ++n) {
    // These buffers can't die in transit because they're created
    // synchonously and the parent-side buffer can only be dropped if
    // there's a crash.
    aMsg->WriteFileDescriptor(FileDescriptor(fds[n], false));
  }
}
예제 #16
0
EmuFileObject* CEmuFileWrapper::RegisterFileObject(XFILE::CFile* pFile)
{
    EmuFileObject* object = nullptr;

    CSingleLock lock(m_criticalSection);

    for (int i = 0; i < MAX_EMULATED_FILES; i++)
    {
        if (!m_files[i].used)
        {
            // found a free location
            object = &m_files[i];
            object->used = true;
            object->file_xbmc = pFile;
            FileDescriptor(object->file_emu)->_file = (i + FILE_WRAPPER_OFFSET);
            object->file_lock = new CCriticalSection();
            break;
        }
    }

    return object;
}
void
ParamTraits<MagicGrallocBufferHandle>::Write(Message* aMsg,
                                             const paramType& aParam)
{
  Flattenable *flattenable = aParam.mGraphicBuffer.get();
  size_t nbytes = flattenable->getFlattenedSize();
  size_t nfds = flattenable->getFdCount();

  char data[nbytes];
  int fds[nfds];
  flattenable->flatten(data, nbytes, fds, nfds);

  aMsg->WriteSize(nbytes);
  aMsg->WriteSize(nfds);

  aMsg->WriteBytes(data, nbytes);
  for (size_t n = 0; n < nfds; ++n) {
    // These buffers can't die in transit because they're created
    // synchonously and the parent-side buffer can only be dropped if
    // there's a crash.
    aMsg->WriteFileDescriptor(FileDescriptor(fds[n], false));
  }
}
예제 #18
0
void CEmuFileWrapper::UnRegisterFileObjectByDescriptor(int fd)
{
    int i = fd - FILE_WRAPPER_OFFSET;
    if (! (i >= 0 && i < MAX_EMULATED_FILES))
        return;

    if (!m_files[i].used)
        return;

    CSingleLock lock(m_criticalSection);

    // we assume the emulated function already deleted the CFile object
    if (m_files[i].file_lock)
    {
        delete m_files[i].file_lock;
        m_files[i].file_lock = nullptr;
    }
#if !defined(TARGET_WINDOWS)
    //Don't memset on Windows as it overwrites our pointer
    memset(&m_files[i], 0, sizeof(EmuFileObject));
#endif
    m_files[i].used = false;
    FileDescriptor(m_files[i].file_emu)->_file = -1;
}
예제 #19
0
WaylandEventQueue::~WaylandEventQueue()
{
  io_loop.Remove(FileDescriptor(wl_display_get_fd(display)));
  wl_display_disconnect(display);
}
예제 #20
0
 static constexpr FileDescriptor Undefined() {
   return FileDescriptor(-1);
 }
예제 #21
0
X11EventQueue::~X11EventQueue()
{
  io_loop.Remove(FileDescriptor(ConnectionNumber(display)));
  XCloseDisplay(display);
}
예제 #22
0
MumuFile::MumuFile(QByteArray fdBlock)
{
	this->descriptor = FileDescriptor(fdBlock);	
}