Method accept

source/kernel/kunixsocket.cpp:575–620

}

U32 KUnixSocketObject::accept(KThread* thread, const KFileDescriptorPtr& fd, U32 address, U32 len, U32 flags) {
    std::shared_ptr<KUnixSocketObject> pendingConnection;
    {
        BOXEDWINE_CRITICAL_SECTION_WITH_CONDITION(this->lockCond);
        while (!this->pendingConnections.size()) {
            if (!this->blocking) {
                return -K_EWOULDBLOCK;
            }
            BOXEDWINE_CONDITION_WAIT(this->lockCond);
    #ifdef BOXEDWINE_MULTI_THREADED
            if (thread->terminating) {
                return -K_EINTR;
            }
            if (thread->startSignal) {
                thread->startSignal = false;
                return -K_CONTINUE;
            }
    #endif
        }

        pendingConnection = this->pendingConnections.front().lock();
        this->pendingConnections.pop_front();
    }
    

    BOXEDWINE_CRITICAL_SECTION_WITH_CONDITION(pendingConnection->lockCond);
    std::shared_ptr<KUnixSocketObject> resultSocket = std::make_shared<KUnixSocketObject>(domain, type, protocol);
    KFileDescriptorPtr result = thread->process->allocFileDescriptor(resultSocket, K_O_RDWR, 0, -1, 0);

    if (flags & FD_CLOEXEC) {
        result->descriptorFlags|=FD_CLOEXEC;
    }
    if (flags & K_O_NONBLOCK) {
        result->kobject->setBlocking(false);
    }

    pendingConnection->connection = resultSocket;
    //pendingConnection->connected = true; this will be handled when the connecting thread is unblocked    

    resultSocket->connected = true;
    resultSocket->connection = pendingConnection; // weak reference
    
    BOXEDWINE_CONDITION_SIGNAL_ALL(pendingConnection->lockCond);

    return result->handle;
}

U32 KUnixSocketObject::getsockname(KThread* thread, const KFileDescriptorPtr& fd, U32 address, U32 plen) {
    KMemory* memory = thread->memory;