How to capture the contents of stderr in a C function call from golang?

Here is a golang program that calls a C function which outputs to stderr. In the real program, the function call is inside a library that I cannot change:

package main

// #include <stdio.h>
// #include <stdlib.h>
//
// // assume that we cannot change this function
// static void library_call(char* s) {
//   fprintf(stderr, "%s\n", s);
// }
import "C"

import (
	"fmt"
	"io"
	"os"
	"unsafe"
)

func main() {
	// attempt to redirect os.Stderr to write to a pipe; it does prevent
	// writing to stderr, but does not successfully capture the output
	r, w, _ := os.Pipe()
	_ = os.Stderr.Close()
	os.Stderr = w

	// call a C function that writes to stderr; I would like to capture this
	// output in a buffer
	cs := C.CString("This should be the contents of the buffer")
	C.library_call(cs)
	C.free(unsafe.Pointer(cs))

	// the pipe will capture this output if you uncomment it
	// fmt.Fprintf(os.Stderr, "testing")

	// close the pipe writer, so we can read from it
	w.Close()

	// Question: how would I restore os.Stderr here to its normal value?

	out, _ := io.ReadAll(r)

	// I'd like this to output
	// "got output: This should be the contents of the buffer",
	// but it's empty instead
	fmt.Printf("got output: %s\n", string(out))
}

(You can save this to test.go and compile and run it with: go build test.go && ./test)

What I would like to do is to capture the output of C.library_call, which writes to stderr, in a buffer, and then restore os.Stderr to its normal function after the call is complete.

I can't figure out how to do so, can you help?

(For bonus points, this should work on windows too!)

I found code from Eli Bendersky on github and an accompanying article that helped me figure out a solution, at least on unix. I'm pretty sure this won't work on windows:

package main

// #include <stdio.h>
// #include <stdlib.h>
//
// // assume that we cannot change this function
// static void library_call(char* s) {
//   fprintf(stderr, "%s\n", s);
// }
import "C"

import (
	"fmt"
	"io"
	"os"
	"syscall"
	"unsafe"
)

// Solution based on eli's work at:
// https://github.com/eliben/code-for-blog/blob/9920db50ab8e61718943e6ea355944b393b20772/2020/go-fake-stdio/snippets/redirect-cgo-stdout.go
func main() {
	// use syscall.Dup to get a copy of stderr
	origStderr, err := syscall.Dup(syscall.Stderr)
	if err != nil {
		panic(err)
	}

	r, w, _ := os.Pipe()

	// Clone the pipe's writer to the actual Stderr descriptor; from this point
	// on, writes to Stderr will go to w.
	if err = syscall.Dup2(int(w.Fd()), syscall.Stderr); err != nil {
		panic(err)
	}

	// call the C function, and flush the output
	cs := C.CString("This should be the contents of the buffer")
	C.library_call(cs)
	C.free(unsafe.Pointer(cs))
	C.fflush(nil)

	// close the pipe, restore original stderr, and close our dup'ed handle
	w.Close()
	syscall.Dup2(origStderr, syscall.Stderr)
	syscall.Close(origStderr)

	// read the data that was written to the pipe; Eli does this with a
	// goroutine in the background but this is simpler and seems to work here
	// for my purposes. Pipes have limited capacity and this will fail if
    // the output is longer than what we see here; see Eli's code and blog
    // for details
	b, _ := io.ReadAll(r)

	fmt.Printf("got output: %s\n", string(b))
	fmt.Fprintf(os.Stderr, "stderr works normally\n")
}

This gets me farther, but if you know of how to solve this on Windows too (or that this would work on windows?) that would be great!