自学教程：C++ CheckInterrupted函数代码示例

extern "C" intptr_t SystemNative_MksTemps(char* pathTemplate, int32_t suffixLength){    intptr_t result;#if HAVE_MKSTEMPS    while (CheckInterrupted(result = mkstemps(pathTemplate, suffixLength)));#elif HAVE_MKSTEMP    // mkstemps is not available bionic/Android, but mkstemp is    // mkstemp doesn't allow the suffix that msktemps does allow, so we'll need to    // remove that before passing pathTemplate to mkstemp    int32_t pathTemplateLength = static_cast<int32_t>(strlen(pathTemplate));    // pathTemplate must include at least XXXXXX (6 characters) which are not part of    // the suffix    if (suffixLength < 0 || suffixLength > pathTemplateLength - 6)    {        errno = EINVAL;        return -1;    }    // Make mkstemp ignore the suffix by setting the first char of the suffix to /0,    // if there is a suffix    int32_t firstSuffixIndex = 0;    char firstSuffixChar = 0;    if (suffixLength > 0)    {        firstSuffixIndex = pathTemplateLength - suffixLength;        firstSuffixChar = pathTemplate[firstSuffixIndex];        pathTemplate[firstSuffixIndex] = 0;    }    while (CheckInterrupted(result = mkstemp(pathTemplate)));    // Reset the first char of the suffix back to its original value, if there is a suffix    if (suffixLength > 0)    {        pathTemplate[firstSuffixIndex] = firstSuffixChar;    }#else#error "Cannot find mkstemps nor mkstemp on this platform"#endif    return  result;}

extern "C" int32_t SystemNative_Pipe(int32_t pipeFds[2], int32_t flags){    switch (flags)    {        case 0:            break;        case PAL_O_CLOEXEC:            flags = O_CLOEXEC;            break;        default:            assert(false && "Unknown flag.");            errno = EINVAL;            return -1;    }    int32_t result;#if HAVE_PIPE2    // If pipe2 is available, use it.  This will handle O_CLOEXEC if it was set.    while (CheckInterrupted(result = pipe2(pipeFds, flags)));#else    // Otherwise, use pipe.    while (CheckInterrupted(result = pipe(pipeFds)));    // Then, if O_CLOEXEC was specified, use fcntl to configure the file descriptors appropriately.    if ((flags & O_CLOEXEC) != 0 && result == 0)    {        while (CheckInterrupted(result = fcntl(pipeFds[0], F_SETFD, FD_CLOEXEC)));        if (result == 0)        {            while (CheckInterrupted(result = fcntl(pipeFds[1], F_SETFD, FD_CLOEXEC)));        }        if (result != 0)        {            int tmpErrno = errno;            close(pipeFds[0]);            close(pipeFds[1]);            errno = tmpErrno;        }    }#endif    return result;}

extern "C" void SystemNative_ReadEvents(int32_t sock, NetworkChangeEvent onNetworkChange){    char buffer[4096];    iovec iov = {buffer, sizeof(buffer)};    sockaddr_nl sanl;    msghdr msg = { .msg_name = reinterpret_cast<void*>(&sanl), .msg_namelen = sizeof(sockaddr_nl), .msg_iov = &iov, .msg_iovlen = 1 };    ssize_t len;    while (CheckInterrupted(len = recvmsg(sock, &msg, 0)));    if (len == -1)    {        // Probably means the socket has been closed.        return;    }    for (nlmsghdr* hdr = reinterpret_cast<nlmsghdr*>(buffer); NLMSG_OK(hdr, UnsignedCast(len)); NLMSG_NEXT(hdr, len))    {        switch (hdr->nlmsg_type)        {            case NLMSG_DONE:                return; // End of a multi-part message; stop reading.            case NLMSG_ERROR:                return;            case RTM_NEWADDR:                onNetworkChange(sock, NetworkChangeKind::AddressAdded);                break;            case RTM_DELADDR:                onNetworkChange(sock, NetworkChangeKind::AddressRemoved);                break;            case RTM_NEWLINK:                onNetworkChange(sock, ReadNewLinkMessage(hdr));                break;            case RTM_DELLINK:                onNetworkChange(sock, NetworkChangeKind::LinkRemoved);                break;            default:                break;        }    }}NetworkChangeKind ReadNewLinkMessage(nlmsghdr* hdr){    assert(hdr != nullptr);    ifinfomsg* ifimsg;    ifimsg = reinterpret_cast<ifinfomsg*>(NLMSG_DATA(hdr));    if (ifimsg->ifi_family == AF_INET)    {        if ((ifimsg->ifi_flags & IFF_UP) != 0)        {            return NetworkChangeKind::LinkAdded;        }    }    return NetworkChangeKind::None;}

static void WriteKeypadXmit(){    // If a terminfo "application mode" keypad_xmit string has been supplied,    // write it out to the terminal to enter the mode.    if (g_keypadXmit != NULL)    {        ssize_t ret;        while (CheckInterrupted(ret = write(STDOUT_FILENO, g_keypadXmit, (size_t)(sizeof(char) * strlen(g_keypadXmit)))));        assert(ret >= 0); // failure to change the mode should not prevent app from continuing    }}

extern "C" int32_t SystemNative_UTime(const char* path, UTimBuf* times){    assert(times != nullptr);    utimbuf temp;    ConvertUTimBuf(*times, temp);    int32_t result;    while (CheckInterrupted(result = utime(path, &temp)));    return result;}

extern "C" NetworkChangeKind SystemNative_ReadSingleEvent(int32_t sock){    char buffer[4096];    iovec iov = {buffer, sizeof(buffer)};    sockaddr_nl sanl;    msghdr msg = { .msg_name = reinterpret_cast<void*>(&sanl), .msg_namelen = sizeof(sockaddr_nl), .msg_iov = &iov, .msg_iovlen = 1 };    ssize_t len;    while (CheckInterrupted(len = recvmsg(sock, &msg, 0)));    if (len == -1)    {        // Probably means the socket has been closed.        // If so, the managed side will ignore the return value.        return NetworkChangeKind::None;    }    nlmsghdr* hdr = reinterpret_cast<nlmsghdr*>(buffer);    // This channel should only send a single message at a time.    // This means there should be no multi-part messages (NLM_F_MULTI).    assert((hdr->nlmsg_flags & NLM_F_MULTI) == 0);    switch (hdr->nlmsg_type)    {        case NLMSG_DONE:            return NetworkChangeKind::None;        case NLMSG_ERROR:            return NetworkChangeKind::None;        case RTM_NEWADDR:            return NetworkChangeKind::AddressAdded;        case RTM_DELADDR:            return NetworkChangeKind::AddressRemoved;        case RTM_NEWLINK:            return ReadNewLinkMessage(hdr);        case RTM_DELLINK:            return NetworkChangeKind::LinkRemoved;        default:            return NetworkChangeKind::None;    }}NetworkChangeKind ReadNewLinkMessage(nlmsghdr* hdr){    assert(hdr != nullptr);    ifinfomsg* ifimsg;    ifimsg = reinterpret_cast<ifinfomsg*>(NLMSG_DATA(hdr));    if (ifimsg->ifi_family == AF_INET)    {        if ((ifimsg->ifi_flags & IFF_UP) != 0)        {            return NetworkChangeKind::LinkAdded;        }    }    return NetworkChangeKind::None;}

extern "C" int32_t SystemNative_FcntlSetPipeSz(intptr_t fd, int32_t size){#ifdef F_SETPIPE_SZ    int32_t result;    while (CheckInterrupted(result = fcntl(ToFileDescriptor(fd), F_SETPIPE_SZ, size)));    return result;#else    (void)fd, (void)size;    errno = ENOTSUP;    return -1;#endif}

extern "C" int32_t SystemNative_FStat(intptr_t fd, FileStatus* output){    struct stat_ result;    int ret;    while (CheckInterrupted(ret = fstat_(ToFileDescriptor(fd), &result)));    if (ret == 0)    {        ConvertFileStatus(result, output);    }    return ret;}

extern "C" int32_t SystemNative_ShmUnlink(const char* name){#if HAVE_SHM_OPEN_THAT_WORKS_WELL_ENOUGH_WITH_MMAP    int32_t result;    while (CheckInterrupted(result = shm_unlink(name)));    return result;#else    // Not supported on e.g. Android. Also, prevent a compiler error because name is unused    (void)name;    errno = ENOTSUP;    return -1;#endif}

extern "C" int32_t SystemNative_Stat(const char* path, FileStatus* output){    struct stat_ result;    int ret;    while (CheckInterrupted(ret = stat_(path, &result)));    if (ret == 0)    {        ConvertFileStatus(result, output);    }    return ret;}

extern "C" intptr_t SystemNative_Open(const char* path, int32_t flags, int32_t mode){    flags = ConvertOpenFlags(flags);    if (flags == -1)    {        errno = EINVAL;        return -1;    }    int result;    while (CheckInterrupted(result = open(path, flags, static_cast<mode_t>(mode))));    return result;}

int32_t SystemNative_UTimensat(const char* path, TimeSpec* times){    int32_t result;#if HAVE_UTIMENSAT    struct timespec updatedTimes[2];    updatedTimes[0].tv_sec = (time_t)times[0].tv_sec;    updatedTimes[0].tv_nsec = (long)times[0].tv_nsec;    updatedTimes[1].tv_sec = (time_t)times[1].tv_sec;    updatedTimes[1].tv_nsec = (long)times[1].tv_nsec;        while (CheckInterrupted(result = utimensat(AT_FDCWD, path, updatedTimes, 0)));#else    struct timeval updatedTimes[2];    updatedTimes[0].tv_sec = (long)times[0].tv_sec;    updatedTimes[0].tv_usec = (int)times[0].tv_nsec / 1000;        updatedTimes[1].tv_sec = (long)times[1].tv_sec;    updatedTimes[1].tv_usec = (int)times[1].tv_nsec / 1000;    while (CheckInterrupted(result = utimes(path, updatedTimes)));#endif    return result;}

extern "C" int32_t SystemNative_FTruncate(intptr_t fd, int64_t length){    int32_t result;    while (CheckInterrupted(        result =#if HAVE_FTRUNCATE64        ftruncate64(#else        ftruncate(#endif            ToFileDescriptor(fd),            length)));    return result;}

extern "C" int32_t SystemNative_Pipe(int32_t pipeFds[2], int32_t flags){    switch (flags)    {        case 0:            break;        case PAL_O_CLOEXEC:            flags = O_CLOEXEC;            break;        default:            assert(false && "Unknown flag.");            errno = EINVAL;            return -1;    }    int32_t result;#if HAVE_PIPE2    while (CheckInterrupted(result = pipe2(pipeFds, flags)));#else    while (CheckInterrupted(result = pipe(pipeFds)));         // CLOEXEC intentionally ignored on platforms without pipe2.#endif    return result;}

extern "C" int64_t SystemNative_LSeek(intptr_t fd, int64_t offset, SeekWhence whence){    int64_t result;    while (CheckInterrupted(        result =#if HAVE_LSEEK64            lseek64(#else            lseek(#endif                 ToFileDescriptor(fd),                 offset,                 whence)));    return result;}

int32_t SystemNative_ReadStdin(void* buffer, int32_t bufferSize){    assert(buffer != NULL || bufferSize == 0);    assert(bufferSize >= 0);     if (bufferSize < 0)    {        errno = EINVAL;        return -1;    }    ssize_t count;    while (CheckInterrupted(count = read(STDIN_FILENO, buffer, Int32ToSizeT(bufferSize))));    return (int32_t)count;}

extern "C" int32_t SystemNative_ReadStdinUnbuffered(void* buffer, int32_t bufferSize){    assert(buffer != nullptr || bufferSize == 0);    assert(bufferSize >= 0);    if (bufferSize < 0)    {        errno = EINVAL;        return -1;    }    ssize_t count;    while (CheckInterrupted(count = read(STDIN_FILENO, buffer, UnsignedCast(bufferSize))));    return static_cast<int32_t>(count);}

extern "C" int32_t SystemNative_Write(intptr_t fd, const void* buffer, int32_t bufferSize){    assert(buffer != nullptr || bufferSize == 0);    assert(bufferSize >= 0);    if (bufferSize < 0)    {        errno = ERANGE;        return -1;    }    ssize_t count;    while (CheckInterrupted(count = write(ToFileDescriptor(fd), buffer, UnsignedCast(bufferSize))));    assert(count >= -1 && count <= bufferSize);    return static_cast<int32_t>(count);}

extern "C" int32_t SystemNative_LockFileRegion(intptr_t fd, int64_t offset, int64_t length, int16_t lockType){    if (offset < 0 || length < 0)     {        errno = EINVAL;        return -1;    }#if HAVE_FLOCK64    struct flock64 lockArgs;#else    struct flock lockArgs;#endif    lockArgs.l_type = lockType;    lockArgs.l_whence = SEEK_SET;    lockArgs.l_start = offset;    lockArgs.l_len = length;    int32_t ret;    while (CheckInterrupted(ret = fcntl (ToFileDescriptor(fd), F_SETLK, &lockArgs)));    return ret;}

extern "C" int32_t SystemNative_RmDir(const char* path){    int32_t result;    while (CheckInterrupted(result = rmdir(path)));    return result;}

extern "C" int32_t SystemNative_Rename(const char* oldPath, const char* newPath){    int32_t result;    while (CheckInterrupted(result = rename(oldPath, newPath)));    return result;}

extern "C" Error SystemNative_Poll(PollEvent* pollEvents, uint32_t eventCount, int32_t milliseconds, uint32_t* triggered){    if (pollEvents == nullptr || triggered == nullptr)    {        return PAL_EFAULT;    }    if (milliseconds < -1)    {        return PAL_EINVAL;    }    size_t bufferSize = sizeof(pollfd) * static_cast<size_t>(eventCount);    bool useStackBuffer = bufferSize <= 2048;    pollfd* pollfds = reinterpret_cast<pollfd*>(useStackBuffer ? alloca(bufferSize) : malloc(bufferSize));    for (uint32_t i = 0; i < eventCount; i++)    {        const PollEvent& event = pollEvents[i];        pollfds[i] = { .fd = event.FileDescriptor, .events = event.Events, .revents = 0 };    }    int rv;    while (CheckInterrupted(rv = poll(pollfds, static_cast<nfds_t>(eventCount), milliseconds)));    if (rv < 0)    {        if (!useStackBuffer)        {            free(pollfds);        }        *triggered = 0;        return SystemNative_ConvertErrorPlatformToPal(errno);    }    for (uint32_t i = 0; i < eventCount; i++)    {        const pollfd& pfd = pollfds[i];        assert(pfd.fd == pollEvents[i].FileDescriptor);        assert(pfd.events == pollEvents[i].Events);        pollEvents[i].TriggeredEvents = static_cast<PollEvents>(pfd.revents);    }    *triggered = static_cast<uint32_t>(rv);    if (!useStackBuffer)    {        free(pollfds);    }    return PAL_SUCCESS;}extern "C" int32_t SystemNative_PosixFAdvise(intptr_t fd, int64_t offset, int64_t length, FileAdvice advice){#if HAVE_POSIX_ADVISE    int32_t result;    while (CheckInterrupted(result = posix_fadvise(ToFileDescriptor(fd), offset, length, advice)));    return result;#else    // Not supported on this platform. Caller can ignore this failure since it's just a hint.    (void)fd, (void)offset, (void)length, (void)advice;    return ENOTSUP;#endif}

extern "C" int32_t SystemNative_FTruncate(intptr_t fd, int64_t length){    int32_t result;    while (CheckInterrupted(result = ftruncate(ToFileDescriptor(fd), length)));    return result;}

extern "C" intptr_t SystemNative_MksTemps(char* pathTemplate, int32_t suffixLength){    intptr_t result;    while (CheckInterrupted(result = mkstemps(pathTemplate, suffixLength)));    return  result;}

extern "C" int32_t SystemNative_Link(const char* source, const char* linkTarget){    int32_t result;    while (CheckInterrupted(result = link(source, linkTarget)));    return result;}

extern "C" int64_t SystemNative_LSeek(intptr_t fd, int64_t offset, SeekWhence whence){    int64_t result;    while (CheckInterrupted(result = lseek(ToFileDescriptor(fd), offset, whence)));    return result;}

extern "C" int32_t SystemNative_FLock(intptr_t fd, LockOperations operation){    int32_t result;    while (CheckInterrupted(result = flock(ToFileDescriptor(fd), operation)));    return result;}

extern "C" int32_t SystemNative_FSync(intptr_t fd){    int32_t result;    while (CheckInterrupted(result = fsync(ToFileDescriptor(fd))));    return result;}

extern "C" int32_t SystemNative_FChMod(intptr_t fd, int32_t mode){    int32_t result;    while (CheckInterrupted(result = fchmod(ToFileDescriptor(fd), static_cast<mode_t>(mode))));    return result;}

extern "C" int32_t SystemNative_ChMod(const char* path, int32_t mode){    int32_t result;    while (CheckInterrupted(result = chmod(path, static_cast<mode_t>(mode))));    return result;}