Esempio n. 1
0
/*! 
  Sets the Tcl stderr and stdout channels to be the same as the C stderr and
  stdout streams.

  \author  jfpatry
*/
void setup_tcl_std_channels()
{
    /* Only need to do this under Win32 */
#if defined( NATIVE_WIN32_COMPILER )
    Tcl_Channel stdout_chnl, stderr_chnl;

    /* I'm not sure why the _dup is necessary under Windows.  

       See the Tcl_SetStdChannel manpage for more info.
    */
    
    /* Create new stdout channel */
    Tcl_SetStdChannel( NULL, TCL_STDOUT );
    
    stdout_chnl = Tcl_MakeFileChannel( 
	(ClientData) _get_osfhandle( _dup( _fileno(stdout) ) ),
	TCL_WRITABLE );
    
    check_assertion( stdout_chnl, "Couldn't create new stdout channel" );
    
    
    /* Create a new stderr channel */
    Tcl_SetStdChannel( NULL, TCL_STDERR );
    
    stderr_chnl = Tcl_MakeFileChannel( 
	(ClientData) _get_osfhandle( _dup( _fileno(stderr) ) ),
	TCL_WRITABLE );
    
    check_assertion( stderr_chnl, "Couldn't create new stderr channel" );
#endif
}
Esempio n. 2
0
	ShellWrapper()
	{
		int iReturn;
		iReturn = _pipe(iPipeIn_, 512, _O_TEXT | O_NOINHERIT);
		assert(iReturn != -1);
		iReturn = _pipe(iPipeOut_, 512, _O_TEXT | O_NOINHERIT);
		assert(iReturn != -1);

		//save old handle
		int iStdin = _dup(_fileno(stdin));
		int iStdout = _dup(_fileno(stdout));
		int iStderr = _dup(_fileno(stderr));

		iReturn = _dup2(iPipeOut_[0], _fileno(stdin));
		assert(iReturn == 0);
		iReturn = _dup2(iPipeIn_[1], _fileno(stdout));
		assert(iReturn == 0);
		iReturn = _dup2(iPipeIn_[1], _fileno(stderr));
		assert(iReturn == 0);

		char *arg[] = {"cmd.exe", "/Q", "/A", NULL};
		iSubProcess_ = spawnvp(P_NOWAIT, arg[0], arg);

		//restore old handle
		iReturn = _dup2(iStdin, _fileno(stdin));
		iReturn = _dup2(iStdout, _fileno(stdout));
		iReturn = _dup2(iStderr, _fileno(stderr));
	}
Esempio n. 3
0
int main(int ac, char **av)
{
  int  savo, savi;
  FILE *fnul;
  char name[256];
  char fullname[256];
  char *p;

  kpse_set_program_name(av[0], "mkocp");

  if(ac != 2) {
    fprintf(stderr,"%s : Usage %s ocpname\n", av[0], av[0]);
    return 1;
  }

  p = strrchr(av[1], '.');
  if(p)
    *p = '\0';
  strcpy(name, av[1]);
  strcpy(fullname, name);
  strcat(fullname, ".ocp");

/* save stdout and stdin */
  savo = _dup(fileno(stdout));
  savi = _dup(fileno(stdin));

/* connect stdout to stderr */
  _dup2(fileno(stderr), fileno(stdout));

/* connect stdin to nul device */
  if(!(fnul = fopen("nul", "r"))) {
    fprintf(stderr, "Cannot open nul device to read\n");
    exit(100);
  }
  _dup2(fileno(fnul), fileno(stdin));

/* COMMAND */

  _spawnlp(_P_WAIT, "otp2ocp", "otp2ocp", name, NULL);

/* END COMMAND */
  
/* return to original stdout and stdin */
  _dup2(savo, fileno(stdout));
  close(savo);
  _dup2(savi, fileno(stdin));
  close(savi);

/* close nul device */
  fclose(fnul);

  if(_access(fullname, 0) == 0)
    printf("%s\n", fullname);

  return 0;
}
Esempio n. 4
0
File: uio.c Progetto: bajdcc/MiniOS
int uio_init(){
    if (_open("/tty", O_RW) < 0){
        if (_mknod("/tty", TTY) < 0 || _open("/tty", O_RW)){
            return -1;
        }
    }
    if (_dup(0) < 0 || _dup(0) < 0){
        return -1;
    }
    return 0;
}
Esempio n. 5
0
void
vprintf_stderr(const char* aFmt, va_list aArgs)
{
  if (sStderrCallback) {
    va_list argsCpy;
    VARARGS_ASSIGN(argsCpy, aArgs);
    sStderrCallback(aFmt, aArgs);
    va_end(argsCpy);
  }

  if (IsDebuggerPresent()) {
    char buf[2048];
    va_list argsCpy;
    VARARGS_ASSIGN(argsCpy, aArgs);
    vsnprintf(buf, sizeof(buf), aFmt, argsCpy);
    buf[sizeof(buf) - 1] = '\0';
    va_end(argsCpy);
    OutputDebugStringA(buf);
  }

  FILE* fp = _fdopen(_dup(2), "a");
  if (!fp) {
    return;
  }

  vfprintf(fp, aFmt, aArgs);

  fclose(fp);
}
Esempio n. 6
0
void __stdcall jitStartup(ICorJitHost* jitHost)
{
    g_jitHost = jitHost;

    // `jitStartup` may be called multiple times
    // when pre-jitting. We should not reinitialize
    // config values each time.
    if (!JitConfig.isInitialized())
    {
        JitConfig.initialize(jitHost);
    }

#if defined(PLATFORM_UNIX)
    jitstdout = stdout;
#else
    if (jitstdout == nullptr)
    {
        int jitstdoutFd = _dup(_fileno(stdout));
        _setmode(jitstdoutFd, _O_TEXT);
        jitstdout = _fdopen(jitstdoutFd, "w");
        assert(jitstdout != nullptr);
    }
#endif

#ifdef FEATURE_TRACELOGGING
    JitTelemetry::NotifyDllProcessAttach();
#endif
    Compiler::compStartup();
}
Esempio n. 7
0
int DUP(int fd) {
  int result = _dup(fd);
  if(result < 0) {
    throwErrNoOnSysCallException(_T("dup"));
  }
  return result;
}
Esempio n. 8
0
/*!
 * \brief   pixReadStreamGif()
 *
 * \param[in]    fp file stream
 * \return  pix, or NULL on error
 */
PIX *
pixReadStreamGif(FILE  *fp)
{
l_int32          fd;
GifFileType     *gif;

    PROCNAME("pixReadStreamGif");

#if GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 1 && GIFLIB_RELEASE == 2  /* 5.1.2 */
    L_ERROR("Can't use giflib-5.1.2; suggest 5.1.1 or earlier\n", procName);
    return NULL;
#endif  /* 5.1.2 */

    if ((fd = fileno(fp)) < 0)
        return (PIX *)ERROR_PTR("invalid file descriptor", procName, NULL);
#ifdef _WIN32
    fd = _dup(fd);
#endif /* _WIN32 */

#ifndef _MSC_VER
    lseek(fd, 0, SEEK_SET);
#else
    _lseek(fd, 0, SEEK_SET);
#endif  /* _MSC_VER */

    if ((gif = DGifOpenFileHandle(fd, NULL)) == NULL)
        return (PIX *)ERROR_PTR("invalid file or file not found",
                                procName, NULL);

    return gifToPix(gif);
}
Esempio n. 9
0
int
duplicate(int fd, int newfd, Bool useDup2) {
  if (useDup2) {
    return _dup2(fd, newfd);
  }

  return _dup(fd);
}
Esempio n. 10
0
int EbrIOFile::Dup() {
    int newHandle = _dup(filefd);
    EbrIOFile* newFile = new EbrIOFile();
    newFile->filefd = newHandle;
    EbrFile* ret = EbrAllocFile(newFile);

    return ret->idx;
}
Esempio n. 11
0
    /*
     * Integer.
     */
    explicit CarlaString(const int value) noexcept
        : fBuffer(_null()),
          fBufferLen(0)
    {
        char strBuf[0xff+1];
        std::snprintf(strBuf, 0xff, "%d", value);
        strBuf[0xff] = '\0';

        _dup(strBuf);
    }
Esempio n. 12
0
    /*
     * Unsigned integer, possibly in hexadecimal.
     */
    explicit CarlaString(const unsigned int value, const bool hexadecimal = false) noexcept
        : fBuffer(_null()),
          fBufferLen(0)
    {
        char strBuf[0xff+1];
        std::snprintf(strBuf, 0xff, hexadecimal ? "0x%x" : "%u", value);
        strBuf[0xff] = '\0';

        _dup(strBuf);
    }
Esempio n. 13
0
    /*
     * Simple character.
     */
    explicit CarlaString(const char c) noexcept
        : fBuffer(_null()),
          fBufferLen(0)
    {
        char ch[2];
        ch[0] = c;
        ch[1] = '\0';

        _dup(ch);
    }
Esempio n. 14
0
static int do_dump_do(sc_card_t *card, unsigned int tag)
{
	int r;
	size_t length;
	unsigned char buffer[254];	// Private DO are specified up to 254 bytes

	memset(buffer, '\0', sizeof(buffer));

	if (tag < 0x101 || tag > 0x104) {
		util_error("illegal DO identifier %04X", tag);
		return SC_ERROR_INVALID_ARGUMENTS;
	}

	r = sc_get_data(card, tag, buffer, sizeof(buffer));
	if (r < 0) {
		util_error("failed to get data object DO %04X: %s", tag, sc_strerror(r));
		if (SC_ERROR_SECURITY_STATUS_NOT_SATISFIED == r) {
			util_error("make sure the 'verify' and 'pin' parameters are correct");
		}
		return r;
	}
	length = (size_t) r;	/* r is guaranteed to be non-negative */

	if (opt_raw) {
		int tmp;
		FILE *fp;

#ifndef _WIN32
		tmp = dup(fileno(stdout));
#else
		tmp = _dup(_fileno(stdout));
#endif
		if (tmp < 0)
			return EXIT_FAILURE;
		fp = freopen(NULL, "wb", stdout);
		if (fp) {
			r = (int) fwrite(buffer, sizeof(char), length, fp);
		}
#ifndef _WIN32
		dup2(tmp, fileno(stdout));
#else
		_dup2(tmp, _fileno(stdout));
#endif
		clearerr(stdout);
		close(tmp);

		if (length != (size_t) r)	/* fail on write errors */
			return EXIT_FAILURE;
	} else {
		util_hex_dump_asc(stdout, buffer, length, -1);
	}

	return EXIT_SUCCESS;
}
Esempio n. 15
0
extern "C" void __stdcall jitStartup(ICorJitHost* jitHost)
{
    if (g_jitInitialized)
    {
        return;
    }

    g_jitHost = jitHost;

    assert(!JitConfig.isInitialized());
    JitConfig.initialize(jitHost);

#if defined(PLATFORM_UNIX)
    jitstdout = procstdout();
#else
    if (jitstdout == nullptr)
    {
        int stdoutFd = _fileno(procstdout());
        // Check fileno error output(s) -1 may overlap with errno result
        // but is included for completness.
        // We want to detect the case where the initial handle is null
        // or bogus and avoid making further calls.
        if ((stdoutFd != -1) && (stdoutFd != -2) && (errno != EINVAL))
        {
            int jitstdoutFd = _dup(_fileno(procstdout()));
            // Check the error status returned by dup.
            if (jitstdoutFd != -1)
            {
                _setmode(jitstdoutFd, _O_TEXT);
                jitstdout = _fdopen(jitstdoutFd, "w");
                assert(jitstdout != nullptr);

                // Prevent the FILE* from buffering its output in order to avoid calls to
                // `fflush()` throughout the code.
                setvbuf(jitstdout, nullptr, _IONBF, 0);
            }
        }
    }

    // If jitstdout is still null, fallback to whatever procstdout() was
    // initially set to.
    if (jitstdout == nullptr)
    {
        jitstdout = procstdout();
    }
#endif // PLATFORM_UNIX

#ifdef FEATURE_TRACELOGGING
    JitTelemetry::NotifyDllProcessAttach();
#endif
    Compiler::compStartup();

    g_jitInitialized = true;
}
Esempio n. 16
0
//!
//! Nullify given open file descriptor.
//!
DevNull::DevNull(int fd)
{
    orig_ = fd;
    clone_ = _dup(orig_);

#pragma warning(push)
#pragma warning(disable: 4996)
    null_ = _wopen(DEV_NULL, _O_RDWR);
#pragma warning(pop)

    _dup2(null_, orig_);
}
Esempio n. 17
0
KRB5_LIB_FUNCTION krb5_storage * KRB5_LIB_CALL
krb5_storage_from_fd(int fd_in)
{
    krb5_storage *sp;
    int saved_errno;
    int fd;

#ifdef _MSC_VER
    /*
     * This function used to try to pass the input to
     * _get_osfhandle() to test if the value is a HANDLE
     * but this doesn't work because doing so throws an
     * exception that will result in Watson being triggered
     * to file a Windows Error Report.
     */
    fd = _dup(fd_in);
#else
    fd = dup(fd_in);
#endif

    if (fd < 0)
	return NULL;

    errno = ENOMEM;
    sp = malloc(sizeof(krb5_storage));
    if (sp == NULL) {
	saved_errno = errno;
	close(fd);
	errno = saved_errno;
	return NULL;
    }

    errno = ENOMEM;
    sp->data = malloc(sizeof(fd_storage));
    if (sp->data == NULL) {
	saved_errno = errno;
	close(fd);
	free(sp);
	errno = saved_errno;
	return NULL;
    }
    sp->flags = 0;
    sp->eof_code = HEIM_ERR_EOF;
    FD(sp) = fd;
    sp->fetch = fd_fetch;
    sp->store = fd_store;
    sp->seek = fd_seek;
    sp->trunc = fd_trunc;
    sp->fsync = fd_sync;
    sp->free = fd_free;
    sp->max_alloc = UINT_MAX/8;
    return sp;
}
Esempio n. 18
0
static FILE* fopenZIPped(const char* filename, const char* mode)
{
    // check mode
    if (mode[0] == 'r')
    {
        // create the pipe
        int hPipe[2];
        if (_pipe(hPipe, 2048, ((mode[1] =='b') ? _O_BINARY : _O_TEXT) | _O_NOINHERIT) == -1)
        {
            fprintf(stderr, "could not create pipe\n");
            return NULL;
        }

        // duplicate stdin/stdout handle so we can restore them later
        int hStdOut = _dup(_fileno(stdout));

        // make the write end of pipe go to stdout
        if (_dup2(hPipe[WRITE_HANDLE], _fileno(stdout)) != 0)
        {
            fprintf(stderr, "could not set pipe output\n");
            return NULL;
        }

        // redirect read end of pipe to input file
        if (_dup2(hPipe[READ_HANDLE], _fileno(stdin)) != 0)
        {
            fprintf(stderr, "could not redirect input file\n");
            return NULL;
        }

        // close original write end of pipe
        close(hPipe[WRITE_HANDLE]);

        // Spawn process
        HANDLE hProcess = (HANDLE) spawnlp(P_NOWAIT, "unzip", "unzip", "-p", filename, NULL);

        // redirect stdout back into stdout
        if (_dup2(hStdOut, _fileno(stdout)) != 0)
        {
            fprintf(stderr, "could not reconstruct stdout\n");
            return NULL;
        }

        // return redirected stdin
        return stdin;
    }
    else
    {
        return NULL;
    }
}
Esempio n. 19
0
OutputLogger::OutputLogger(FILE *file, const std::string &filename) :
	fd(-1), fileOld(NULL), filenameLog(filename), fileLog(NULL), 	
	fdPipeRead(-1), pThread(NULL)
{
	// Get the underlying file descriptor for the FILE stream
	fd = _fileno(file);

	// Probably on windows and there is no stdout/stderr in Subsystem Windows
	if (fd < 0) {
		fileLog = freopen(filenameLog.c_str(),"w",file);
#ifdef WIN32
		DWORD stdhandle = 0;
		if (fileLog == stdout) 
			stdhandle = STD_OUTPUT_HANDLE;
		else if (fileLog == stderr) 
			stdhandle = STD_ERROR_HANDLE;
		if (stdhandle) 
			SetStdHandle(stdhandle,(HANDLE)_get_osfhandle(_fileno(fileLog)));
#endif
		return;
	}

	// Create the pipe
	int fdsPipe[2];
	if (_pipe(fdsPipe,256,_O_BINARY) != 0) {
		return;
	}
	fdPipeRead = fdsPipe[0];
	int fdPipeWrite = fdsPipe[1];

	// Make sure that buffering is turned off on the incoming file
	std::setvbuf(file,NULL,_IONBF,0);

	// Duplicate the fd and create new filestream for it
	fileOld = _fdopen(_dup(fd),"w");
	// If the file was stderr, make sure the new file doesn't have buffering
	if (fileOld && file == stderr) std::setvbuf(fileOld,NULL,_IONBF,0);

	// Create the output log file
	fileLog =  std::fopen(filenameLog.c_str(),"w");

	// Duplicate pipe write file descriptor and replace original
	_dup2(fdPipeWrite,fd);
	
	// Close the fd for the write end of the pipe
	_close(fdPipeWrite);
	fdPipeWrite = -1;

	// Create the thread
	pThread = SDL_CreateThread( (int (SDLCALL*)(void*)) &OutputLogger::sThreadMain,this);
}
Esempio n. 20
0
void WindowsHeadlessHost::LoadNativeAssets()
{
	// Native is kinda talkative, but that's annoying in our case.
	out = _fdopen(_dup(_fileno(stdout)), "wt");
	freopen("NUL", "wt", stdout);

	VFSRegister("", new DirectoryAssetReader("assets/"));
	VFSRegister("", new DirectoryAssetReader(""));
	VFSRegister("", new DirectoryAssetReader("../"));

	gl_lost_manager_init();

	// See SendDebugOutput() for how things get back on track.
}
Esempio n. 21
0
void
printf_stderr(const char *fmt, ...)
{
  FILE *fp = _fdopen(_dup(2), "a");
  if (!fp)
      return;

  va_list args;
  va_start(args, fmt);
  vfprintf(fp, fmt, args);
  va_end(args);

  fclose(fp);
}
Esempio n. 22
0
int
fd_safer (int fd)
{
  if (0 <= fd && fd <= 2)
    {
      int f = _dup (fd);
      int e = errno;
      _close (fd);
      errno = e;
      fd = f;
    }

  return fd;
}
Esempio n. 23
0
            inline void reliable_fsync(const int fd) {
#ifdef _MSC_VER
                osmium::detail::disable_invalid_parameter_handler diph;
#endif

#ifdef _WIN32
                if (_commit(fd) != 0) {
#else
                if (::fsync(fd) != 0) {
#endif
                    throw std::system_error{errno, std::system_category(), "Fsync failed"};
                }
            }

            inline void reliable_close(const int fd) {
                if (fd < 0) {
                    return;
                }
#ifdef _MSC_VER
                osmium::detail::disable_invalid_parameter_handler diph;
#endif

#ifdef _WIN32
                if (_close(fd) != 0) {
#else
                if (::close(fd) != 0) {
#endif
                    throw std::system_error{errno, std::system_category(), "Close failed"};
                }
            }

            inline int reliable_dup(const int fd) {
#ifdef _MSC_VER
                osmium::detail::disable_invalid_parameter_handler diph;
#endif

#ifdef _WIN32
                const int fd2 = _dup(fd);
#else
                const int fd2 = ::dup(fd);
#endif
                if (fd2 < 0) {
                    throw std::system_error{errno, std::system_category(), "Dup failed"};
                }
                return fd2;
            }

        } // namespace detail
Esempio n. 24
0
static int do_dump_do(sc_card_t *card, unsigned int tag)
{
	int r, tmp;
	FILE *fp;

	// Private DO are specified up to 254 bytes
	unsigned char buffer[254];
	memset(buffer, '\0', sizeof(buffer));

	r = sc_get_data(card, tag, buffer, sizeof(buffer));
	if (r < 0) {
		printf("Failed to get data object: %s\n", sc_strerror(r));
		if(SC_ERROR_SECURITY_STATUS_NOT_SATISFIED == r) {
			printf("Make sure the 'verify' and 'pin' parameters are correct.\n");
		}
		return r;
	}

	if(opt_raw) {
		r = 0;
		#ifndef _WIN32
		tmp = dup(fileno(stdout));
		#else
		tmp = _dup(_fileno(stdout));
		#endif
		if (tmp < 0)
			return EXIT_FAILURE;
		fp = freopen(NULL, "wb", stdout);
		if (fp) {
			r = (int)fwrite(buffer, sizeof(char), sizeof(buffer), fp);
		}
		#ifndef _WIN32
		dup2(tmp, fileno(stdout));
		#else
		_dup2(tmp, _fileno(stdout));
		#endif
		clearerr(stdout);
		close(tmp);
		if (sizeof(buffer) != r)
			return EXIT_FAILURE;
	} else {
		util_hex_dump_asc(stdout, buffer, sizeof(buffer), -1);
	}

	return EXIT_SUCCESS;
}
Esempio n. 25
0
/**
 * Duplicates the file descriptor for an open file \c fd. This allocates a new
 * file descriptor and clones the references of the open file \c fd into it.
 *
 * @param fd An open file to operate on.
 * @returns A new file descriptor or \c -1 on error with \c errno set to an
 *      error value.
 */
int dup(int fd)
{
    posixio_fdlock();

    struct iofile *file = posixio_file_fromfd(fd);

    if (file == NULL) {
        posixio_fdunlock();
        errno = EBADF;
        return -1;
    }

    int ret = _dup(file);

    posixio_fdunlock();
    return ret;
}
Esempio n. 26
0
/*!
 * \brief   pixWriteStreamGif()
 *
 * \param[in]    fp file stream
 * \param[in]    pix 1, 2, 4, 8, 16 or 32 bpp
 * \return  0 if OK, 1 on error
 *
 * <pre>
 * Notes:
 *      (1) All output gif have colormaps.  If the pix is 32 bpp rgb,
 *          this quantizes the colors and writes out 8 bpp.
 *          If the pix is 16 bpp grayscale, it converts to 8 bpp first.
 *      (2) We can't write to memory using open_memstream() because
 *          the gif functions write through a file descriptor, not a
 *          file stream.
 * </pre>
 */
l_int32
pixWriteStreamGif(FILE  *fp,
                  PIX   *pix)
{
l_int32      result;
l_int32      fd;
GifFileType  *gif;
#if (GIFLIB_MAJOR == 5 && GIFLIB_MINOR >= 1) || GIFLIB_MAJOR > 5
int           giferr;
#endif  /* 5.1 and beyond */

    PROCNAME("pixWriteStreamGif");

        /* See version information at top of this file */
#if GIFLIB_MAJOR == 5 && GIFLIB_MINOR == 1 && GIFLIB_RELEASE == 2  /* 5.1.2 */
    return ERROR_INT("Can't use giflib-5.1.2; suggest 5.1.1 or earlier\n",
                     procName, 1);
#endif  /* 5.1.2 */

    if (!fp)
        return ERROR_INT("stream not open", procName, 1);
    if (!pix)
        return ERROR_INT("pix not defined", procName, 1);
    rewind(fp);

    if ((fd = fileno(fp)) < 0)
        return ERROR_INT("invalid file descriptor", procName, 1);
#ifdef _WIN32
    fd = _dup(fd);
#endif /* _WIN32 */

        /* Get the gif file handle */
    if ((gif = EGifOpenFileHandle(fd, NULL)) == NULL) {
        return ERROR_INT("failed to create GIF image handle", procName, 1);
    }

    result = pixToGif(pix, gif);
    EGifCloseFile(gif, &giferr);
    return result;
}
// Duplicated from xpcom glue. Ideally this should be shared.
static void
printf_stderr(const char *fmt, ...)
{
  if (IsDebuggerPresent()) {
    char buf[2048];
    va_list args;
    va_start(args, fmt);
    VsprintfLiteral(buf, fmt, args);
    va_end(args);
    OutputDebugStringA(buf);
  }

  FILE *fp = _fdopen(_dup(2), "a");
  if (!fp)
      return;

  va_list args;
  va_start(args, fmt);
  vfprintf(fp, fmt, args);
  va_end(args);

  fclose(fp);
}
Esempio n. 28
0
std::shared_ptr<SeekableByteStream> AsyncFileByteStream::Clone() const
{
	if (_file == nullptr)
		return nullptr;

#if EPUB_OS(WINDOWS)
	int fd = _dup(_fileno(_file));
#else
	int fd = dup(fileno(_file));
#endif
	if (fd == -1)
		return nullptr;

#if EPUB_OS(WINDOWS)
	FILE* newFile = _fdopen(fd, fmode_from_openmode(_mode));
#else
	FILE* newFile = fdopen(fd, fmode_from_openmode(_mode));
#endif
	if (newFile == nullptr)
	{
#if EPUB_OS(WINDOWS)
		_close(fd);
#else
		close(fd);
#endif
		return nullptr;
	}

	auto result = std::make_shared<AsyncFileByteStream>();
	if (bool(result))
	{
		result->_file = newFile;
		result->_mode = _mode;
	}

	return result;
}
Esempio n. 29
0
/**
 * Implements \c fcntl() on an open file by passing the call through to the
 * \c fcntl handler of the underlying device.
 *
 * @param fd An open file to operate on.
 * @param cmd A file control command.
 * @param arg Argument for the command.
 * @returns \c \c -1 on error with \c errno set to an
 *      error value; otherwise it may be the result of the file control
 *      command.
 */
int _fcntl(int fd, int cmd, int arg)
{
    posixio_fdlock();

    struct iofile *file = posixio_file_fromfd(fd);

    if (file == NULL) {
        posixio_fdunlock();
        errno = EBADF;
        return -1;
    }

    int ret = INT_MAX;

    // Some commands we handle locally.
    switch (cmd) {
    case F_DUPFD:
        ret = _dup(file);
        break;

    default:
        break;
    }

    if (ret == INT_MAX) {
        if (file->dev->fcntl != NULL) {
            ret = file->dev->fcntl(file->fh, cmd, arg);
        } else {
            errno = ENOENT;
            ret = -1;
        }
    }

    posixio_fdunlock();
    return ret;
}
Esempio n. 30
0
	void* _data_copy(void) const
	{
		if(_dup) return _dup(_data, _count);
		assert(!_data && !_count);
		return nullptr;
	}