diff '--color=auto' -ur a/buffer/buffer_feed.c b/buffer/buffer_feed.c
--- a/buffer/buffer_feed.c	2014-03-14 20:42:55.000000000 +0100
+++ b/buffer/buffer_feed.c	2025-05-31 23:16:39.300592765 +0200
@@ -1,11 +1,12 @@
 #include "buffer.h"
 
-extern ssize_t buffer_stubborn_read(ssize_t (*op)(),int fd,const char* buf, size_t len,void* cookie);
+typedef ssize_t (*buffer_stubborn_op_fn)(int, const char*, size_t, void*);
+extern ssize_t buffer_stubborn_read(ssize_t (*op)(int, const char*, size_t, void*),int fd,const char* buf, size_t len,void* cookie);
 
 ssize_t buffer_feed(buffer* b) {
   if (b->p==b->n) {
     ssize_t w;
-    if ((w=buffer_stubborn_read(b->op,b->fd,b->x,b->a,b))<0)
+    if ((w=buffer_stubborn_read((buffer_stubborn_op_fn)b->op,b->fd,b->x,b->a,b))<0)
       return -1;
     b->n=(size_t)w;
     b->p=0;
diff '--color=auto' -ur a/buffer/buffer_flush.c b/buffer/buffer_flush.c
--- a/buffer/buffer_flush.c	2014-03-14 20:42:55.000000000 +0100
+++ b/buffer/buffer_flush.c	2025-05-31 23:16:54.916048661 +0200
@@ -1,13 +1,14 @@
 #include "buffer.h"
 
-extern ssize_t buffer_stubborn(ssize_t (*op)(),int fd,const char* buf, size_t len,void* cookie);
+typedef ssize_t (*buffer_stubborn_op_fn)(int, const char*, size_t, void*);
+extern ssize_t buffer_stubborn(ssize_t (*op)(int, const char*, size_t, void*),int fd,const char* buf, size_t len,void* cookie);
 
 extern int buffer_flush(buffer* b) {
   register size_t p;
   register ssize_t r;
   if (!(p=b->p)) return 0; /* buffer already empty */
   b->p=0;
-  r=buffer_stubborn(b->op,b->fd,b->x,p,b);
+  r=buffer_stubborn((buffer_stubborn_op_fn)b->op,b->fd,b->x,p,b);
   if (r>0) r=0;
   return (int)r;
 }
diff '--color=auto' -ur a/buffer/buffer_init.c b/buffer/buffer_init.c
--- a/buffer/buffer_init.c	2014-03-14 20:42:55.000000000 +0100
+++ b/buffer/buffer_init.c	2025-06-01 00:13:36.878507501 +0200
@@ -1,6 +1,6 @@
 #include "buffer.h"
 
-void buffer_init(buffer* b,ssize_t (*op)(),int fd,
+void buffer_init(buffer* b,void* op,int fd,
 		 char* y,size_t ylen) {
   b->op=op;
   b->fd=fd;
diff '--color=auto' -ur a/buffer/buffer_init_allocbuf.c b/buffer/buffer_init_allocbuf.c
--- a/buffer/buffer_init_allocbuf.c	2021-01-04 00:15:28.000000000 +0100
+++ b/buffer/buffer_init_allocbuf.c	2025-06-01 00:13:56.446825643 +0200
@@ -2,7 +2,7 @@
 #include <unistd.h>
 #include "buffer.h"
 
-int buffer_init_allocbuf(buffer* b, ssize_t (*op)(), int fd, size_t ylen) {
+int buffer_init_allocbuf(buffer* b, void* op, int fd, size_t ylen) {
   if (fd==-1) return -1;
   char* thebuffer;
   if (!(thebuffer=malloc(ylen)))
diff '--color=auto' -ur a/buffer/buffer_init_free.c b/buffer/buffer_init_free.c
--- a/buffer/buffer_init_free.c	2014-03-14 20:42:55.000000000 +0100
+++ b/buffer/buffer_init_free.c	2025-06-01 00:14:33.357539491 +0200
@@ -1,6 +1,6 @@
 #include "buffer.h"
 
-void buffer_init_free(buffer* b,ssize_t (*op)(),int fd,
+void buffer_init_free(buffer* b,void* op,int fd,
 		 char* y,size_t ylen) {
   buffer_init(b,op,fd,y,ylen);
   b->deinit=buffer_free;
diff '--color=auto' -ur a/buffer/buffer_put.c b/buffer/buffer_put.c
--- a/buffer/buffer_put.c	2022-04-11 10:37:51.000000000 +0200
+++ b/buffer/buffer_put.c	2025-06-01 00:15:26.906673582 +0200
@@ -5,7 +5,8 @@
 #endif
 #include "buffer.h"
 
-extern ssize_t buffer_stubborn(ssize_t (*op)(),int fd,const char* buf, size_t len,void* cookie);
+typedef ssize_t (*buffer_stubborn_op_fn)(int, const char*, size_t, void*);
+extern ssize_t buffer_stubborn(ssize_t (*op)(int, const char*, size_t, void*),int fd,const char* buf, size_t len,void* cookie);
 
 #ifndef __unlikely
 #ifdef __GNUC__
@@ -38,7 +39,7 @@
 #endif
     if (buffer_flush(b)==-1) return -1;
     if (len>b->a) {
-      if (buffer_stubborn(b->op,b->fd,buf,len,b)<0) return -1;
+      if (buffer_stubborn((buffer_stubborn_op_fn)b->op,b->fd,buf,len,b)<0) return -1;
       return 0;
     }
   }
diff '--color=auto' -ur a/buffer/buffer_putflush.c b/buffer/buffer_putflush.c
--- a/buffer/buffer_putflush.c	2020-11-10 22:51:22.000000000 +0100
+++ b/buffer/buffer_putflush.c	2025-05-31 23:18:30.135730724 +0200
@@ -14,13 +14,14 @@
 #endif
 #endif
 
-extern ssize_t buffer_stubborn(ssize_t (*op)(),int fd,const char* buf, size_t len,void* cookie);
+typedef ssize_t (*buffer_stubborn_op_fn)(int, const char*, size_t, void*);
+extern ssize_t buffer_stubborn(ssize_t (*op)(int, const char*, size_t, void*),int fd,const char* buf, size_t len,void* cookie);
 
 int buffer_putflush(buffer* b,const char* x,size_t len) {
   /* Since we know we are going to flush anyway, let's see if we can
    * optimize a bit */
   if (!b->p)	/* if the buffer is empty, just call buffer_stubborn directly */
-    return buffer_stubborn(b->op,b->fd,x,len,b);
+    return buffer_stubborn((buffer_stubborn_op_fn)b->op,b->fd,x,len,b);
 #ifndef __MINGW32__
   if (b->op==write && len>sizeof(struct iovec)*2) {
     struct iovec v[2];
@@ -37,11 +38,11 @@
     if (__unlikely((size_t)w!=cl)) {
       /* partial write. ugh. */
       if ((size_t)w<v[0].iov_len) {
-	if (buffer_stubborn(b->op,b->fd,v[0].iov_base+w,v[0].iov_len-w,b) ||
-	    buffer_stubborn(b->op,b->fd,v[1].iov_base,v[0].iov_len,b)) return -1;
+	if (buffer_stubborn((buffer_stubborn_op_fn)b->op,b->fd,v[0].iov_base+w,v[0].iov_len-w,b) ||
+	    buffer_stubborn((buffer_stubborn_op_fn)b->op,b->fd,v[1].iov_base,v[0].iov_len,b)) return -1;
       } else {
 	w-=v[0].iov_len;
-	return buffer_stubborn(b->op,b->fd,v[1].iov_base+w,v[1].iov_len-w,b);
+	return buffer_stubborn((buffer_stubborn_op_fn)b->op,b->fd,v[1].iov_base+w,v[1].iov_len-w,b);
       }
     }
     b->p=0;
diff '--color=auto' -ur a/buffer.h b/buffer.h
--- a/buffer.h	2021-01-04 00:15:28.000000000 +0100
+++ b/buffer.h	2025-06-01 00:12:45.327303798 +0200
@@ -31,7 +31,7 @@
   size_t p;		/* current position */
   size_t n;		/* current size of string in buffer */
   size_t a;		/* allocated buffer size */
-  ssize_t (*op)();	/* use read(2) or write(2) */
+  void* op;		/* use read(2) or write(2) */
   void* cookie;			/* used internally by the to-stralloc buffers, and for buffer chaining */
   void (*deinit)(void*);	/* called to munmap/free cleanup, with a pointer to the buffer as argument */
   int fd;		/* passed as first argument to op */
@@ -46,12 +46,12 @@
 /* Initialize a buffer with an existing memory area, which the buffer
  * will NOT take ownership of (i.e. won't free the memory when it's done) */
 att_writen(4,5)
-void buffer_init(buffer* b, ssize_t (*op)(), int fd, char* y, size_t ylen);
+void buffer_init(buffer* b, void *op, int fd, char* y, size_t ylen);
 
 /* Initialize a buffer with an existing memory area, which the buffer
  * WILL take ownership of (it will call free() on it when it's done) */
 att_writen(4,5)
-void buffer_init_free(buffer* b,ssize_t (*op)(),int fd,char* y,size_t ylen);
+void buffer_init_free(buffer* b,void *op,int fd,char* y,size_t ylen);
 
 /* Call buffer_init with op=read(), return 0.
  * If fd==-1, return -1 instead, leaving b untouched. */
@@ -67,7 +67,7 @@
  * buffer_init_free(b, op, fd, thebuffer, ylen) on it.
  * Returns 0 on success, -1 on error (setting errno).
  * Passing fd==-1 is treated as error (so you can pass open*() for fd). */
-int buffer_init_allocbuf(buffer* b, ssize_t (*op)(), int fd, size_t ylen);
+int buffer_init_allocbuf(buffer* b, void *op, int fd, size_t ylen);
 
 /* Call buffer_init_allocbuf with op=read */
 int buffer_init_read_allocbuf(buffer* b, int fd, size_t ylen);