On 25/04/2025 2:04 AM, Andy Valencia wrote:
> This has been touched upon way back in forum history, but I thought it was worth a fresh mention.  When writing to a socket--especially as a server--you can receive SIGPIPE.  Phobos appears to try and inhibit this on some BSD systems, but on Linux if the recipient has closed the socket and you write--SIGPIPE.

This was not a nice post to read first thing in the morning!
I haven't handled this for my eventloop, oops.

Some interesting articles on the subject:

https://www.doof.me.uk/2020/09/23/sigpipe-and-how-to-ignore-it/

https://makedist.com/posts/2014/01/16/porting-msg_more-and-msg_nosigpipe-to-os-x/

https://riptutorial.com/posix/example/17424/handle-sigpipe-generated-by-write---in-a-thread-safe-manner

Anyway, here is the solution I put together (although untested), it should cover pretty much all Posix systems:

```d
module sidero.base.internal.posix;
import core.stdc.stdio;

version(Posix) {
    import core.sys.posix.sys.types;
} else {
    alias ssize_t = size_t;
    alias off_t = ulong;
}

export nothrow @nogc:

/**
Apply any socket options required for the write abstraction here.

Returns: if it succeded in applying the required options.
*/
void applyPerSocketFlag(FILE* socket) {
    applyPerSocketFlag(fileno(socket));
}

/// Ditto
bool applyPerSocketFlag(int s) {
    version(Posix) {
        import core.sys.posix.sys.socket;

        static if(__traits(compiles, SO_NOSIGPIPE)) {
            int enable = 1;
            if (setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, &enable, int.sizeof) != 0)
                return false;
        }
    }

    return true;
}

/**
Write to a socket, handling SIGPIPE error via blocking and consuming the signal.

If a pending SIGPIPE is queued due to blocking, it will not be consumed, and should be left unaffected (max should be one queued).

May call ``writeAppend``, instead.

You must call ``applyPerSocketFlag`` prior to calling this.
*/
ssize_t writeOnSocket(FILE* socket, const scope void* buffer, size_t length, int flags = 0) {
    return writeOnSocket(fileno(socket), buffer, length, flags);
}

/// Ditto
ssize_t writeOnSocket(int socket, const scope void* buffer, size_t length, int flags = 0) {
    version(Posix) {
        import core.sys.posix.sys.socket;

        static if(__traits(compiles, SO_NOSIGPIPE)) {
            return send(socket, buffer, length, flags);
        } else static if(__traits(compiles, MSG_NOSIGNAL)) {
            return send(socket, buffer, length, flags | MSG_NOSIGNAL);
        } else {
            return writeAppend(socket, buffer, length);
        }
    } else
        assert(0, "Unimplemented, use platform specific functions for writing on a socket");
}

/**
Write to a file, handling SIGPIPE error via blocking and consuming the signal.

If a pending SIGPIPE is queued due to blocking, it will not be consumed, and should be left unaffected (max should be one queued).
*/
ssize_t writeAppend(FILE* file, const scope void* buffer, size_t length) {
    return writeAppend(fileno(file), buffer, length);
}

/// Ditto
ssize_t writeAppend(int file, const scope void* buffer, size_t length) {
    version(Posix) {
        import core.sys.posix.signal;
        import core.sys.posix.unistd;
        import core.sys.posix.time;
        import core.stdc.errno;

        sigset_t block, old, pending;

        sigemptyset(&block);
        sigaddset(&block, SIGPIPE);

        if(pthread_sigmask(SIG_BLOCK, &block, &old) != 0)
            return -1;

        int pendingtype = -1;
        if(sigpending(&block) != -1)
            pendingtype = sigismember(&pending, SIGPIPE);

        ssize_t ret;
        while((ret = write(file, buffer, length)) == -1 && errno == EINTR) {
        }

        if(ret == -1 && errno == EPIPE && pendingtype == 0) {
            static if(__traits(compiles, sigtimedwait)) {
                timespec ts;
                int sig;

                while((sig = sigtimedwait(&block, null, &ts)) == -1 && errno == EINTR) {
                }
            } else {
                pendingtype = -1;
                if(sigpending(&block) != -1)
                    pendingtype = sigismember(&pending, SIGPIPE);
                if(pendingtype == 1)
                    sigwait(&block, null);
            }
        }

        pthread_sigmask(SIG_SETMASK, &old, null);
        return ret;
    } else
        assert(0, "Unimplemented, use platform specific functions for writing to a fd");
}

/**
Write to a file at offset, handling SIGPIPE error via blocking and consuming the signal.

If a pending SIGPIPE is queued due to blocking, it will not be consumed, and should be left unaffected (max should be one queued).
*/
ssize_t writeToOffset(FILE* file, const scope void* buffer, size_t length, off_t offset) {
    return writeToOffset(fileno(file), buffer, length, offset);
}

/// Ditto
ssize_t writeToOffset(int file, const scope void* buffer, size_t length, off_t offset) {
    version(Posix) {
        import core.sys.posix.signal;
        import core.sys.posix.unistd;
        import core.sys.posix.time;
        import core.stdc.errno;

        sigset_t block, old, pending;

        sigemptyset(&block);
        sigaddset(&block, SIGPIPE);

        if(pthread_sigmask(SIG_BLOCK, &block, &old) != 0)
            return -1;

        int pendingtype = -1;
        if(sigpending(&block) != -1)
            pendingtype = sigismember(&pending, SIGPIPE);

        ssize_t ret;
        while((ret = pwrite(file, buffer, length, offset)) == -1 && errno == EINTR) {
        }

        if(ret == -1 && errno == EPIPE && pendingtype == 0) {
            static if(__traits(compiles, sigtimedwait)) {
                timespec ts;
                int sig;

                while((sig = sigtimedwait(&block, null, &ts)) == -1 && errno == EINTR) {
                }
            } else {
                pendingtype = -1;
                if(sigpending(&block) != -1)
                    pendingtype = sigismember(&pending, SIGPIPE);
                if(pendingtype == 1)
                    sigwait(&block, null);
            }
        }

        pthread_sigmask(SIG_SETMASK, &old, null);
        return ret;
    } else
        assert(0, "Unimplemented, use platform specific functions for writing to a fd");
}
```