_stdio.cpp

Go to the documentation of this file.

 
#include <dcl/Config.h>     
 
#ifndef __WINNT__
 
#include <errno.h>
#if defined(_AIX) || defined(__sun__)
    #include <alloca.h>
#endif
#include <stdlib.h>         // alloca
#include <sys/stat.h>       // stat
#include <fcntl.h>          // open
#include <unistd.h>         // close
#include <utime.h>          // utime
#include <dcl/_stdio.h>
 
#if __linux__
#include <sys/sendfile.h>
#endif
#include <dcl/Object.h>     // __T(str)
#include <dcl/String.h>
 
#include "__strumbs.h"
 
#if __DCL_HAVE_THIS_FILE__
#undef __THIS_FILE__
static const char_t __UNUSED__ __THIS_FILE__[] = __T("dcl/_stdio.cpp");
#endif
 
__DCL_BEGIN_NAMESPACE
 
int __remove(const String& _path)
{
    STRTOMBS_ER(_path, path);
    return remove(path);
}
 
int __rename(const char* _oldpath, const char* _newpath)
{
    if (!rename(_oldpath, _newpath))
        return 0;
 
    if (errno != EXDEV)
        return -1;
 
    // device가 달라서 실패한 경우 파일을 복사하고 이전파일을 지운다
 
    int oldfd = -1, newfd = -1;
    struct stat oldstat, newstat;
 
    if (lstat(_oldpath, &oldstat) || lstat(_newpath, &newstat))
        return -1;
#if 0
    if (S_ISLNK(oldstat.st_mode)) {
        char oldpath[1024 + 1];
        int n = readlink(_oldpath, oldpath, sizeof(oldpath) - 1);
        if (n > 0) {
            // FIXME
            // oldpath is relative path ?
            oldpath[n] = '\0';
            if (symlink(oldpath, _newpath))
                return -1;
            unlink(_oldpath);
        }
        return -1;
    }
#endif
    if (!S_ISREG(oldstat.st_mode)) {
        errno = EINVAL;
        return -1;
    }
 
    do {
        oldfd = open(_oldpath, O_RDONLY);
        newfd = open(_newpath, O_CREAT | O_WRONLY, oldstat.st_mode);
        if (oldfd == -1 || newfd == -1)
            break;
#if __linux__
        off_t offset = 0;
        ssize_t n = sendfile(newfd, oldfd, &offset, oldstat.st_size);
        if (n == -1)
            break;
#else
        char* buf = (char*)malloc(newstat.st_blksize);
        if (!buf) {
            errno = ENOMEM;
            break;
        }
        ssize_t n = 0;
        while ((n != -1) && (n = read(oldfd, buf, newstat.st_blksize)) > 0)
            n = write(newfd, buf, n);
        free(buf);
        if (n == -1)
            break;
#endif
        close(oldfd);
        close(newfd);
 
        struct utimbuf ub;
        ub.actime = oldstat.st_atime;
        ub.modtime = oldstat.st_mtime;
        utime(_newpath, &ub);
        unlink(_oldpath);
        return 0;
    } while (true);
 
    int save = errno;
    if (oldfd != -1)
        close(oldfd);
    if (newfd != -1) {
        close(newfd);
        unlink(_newpath);
    }
 
    errno = save;
    return -1;
}
 
int __rename(const String& _oldpath, const String& _newpath)
{
    STRTOMBS_ER(_oldpath, oldpath);
    STRTOMBS_ER(_newpath, newpath);
    if (noldpath == (size_t)-1 || nnewpath == (size_t)-1) {
        errno = EILSEQ;
        return -1;
    }
    return __rename(oldpath, newpath);
}
 
FILE* __fopen(const String& _path, const String& _mode)
{
    STRTOMBS(_path, path);
    STRTOMBS(_mode, mode);
    if (npath == (size_t) -1 || nmode == (size_t) -1) {
        errno = EILSEQ;
        return NULL;
    }
    return fopen(path, mode);
}
 
FILE* __fdopen(int _fd, const String& _mode)
{
    STRTOMBS(_mode, mode);
    if (nmode == (size_t) -1) {
        errno = EILSEQ;
        return NULL;
    }
    return fdopen(_fd, mode);
}
 
__DCL_END_NAMESPACE
 
#endif  // __WINNT__