root/piperespawn/piperespawn.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <poll.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

#define BUFFERSIZE BUFSIZ
//#define BLOCKINGIO 1

static FILE *out = NULL;
static char *cmd = NULL;

void respawn_pclose () {
  if (out) pclose(out);
  out=NULL;
}

void respawn_popen () {
//fprintf(stderr,"p(re)open\n");
  respawn_pclose();
  out=popen(cmd, "w");
}

int respawn_write (char *buf, int count, int retry_cnt) {
  struct pollfd pfd;
  size_t c;
  int pv;

wait:
  if (retry_cnt > 5) return 0;
  if (!out) respawn_popen();

  pfd.fd=fileno(out);
  pfd.events=POLLOUT; //|POLLERR|POLLHUP|POLLNVAL;
  pfd.revents=0;

  pv=poll(&pfd,1,5000);
  if (pv < 1) goto retry;
  if (pv==0) {retry_cnt++; if (retry_cnt > 5)goto retry; else goto wait;}
  if ((pfd.revents & ~POLLOUT) != 0 ) goto retry;

  c=fwrite(buf,sizeof(char),count,out);
  if (c==0) goto retry;
//fprintf(stderr,"out: %i/%i\n",c,count);
  fflush(out);
  return c;

retry:
//fprintf(stderr,"retry: %i\n",pfd.revents);
  respawn_pclose();
  c=respawn_write(buf, count, retry_cnt+1);
  return c;
}


int main (int argc, char **argv) {

  size_t r,w;
  char buf[BUFFERSIZE];
  if (argc<2) {
    fprintf(stderr, "usage %s <command> [arg]*\n",argv[0]);
    return 1;
  }

// parse argv
  int i,len;
  for (i=1,len=0;i<argc;i++) {
    len+=strlen(argv[i])+1;
    if (i>1) len+=2; // quotes
  }
  cmd=malloc(sizeof(char)*len);
  for (i=1,len=0;i<argc;i++) {
    if (i>1) cmd[len++]='"';
    memcpy(cmd+len,argv[i],strlen(argv[i]));
    len+=strlen(argv[i]);
    if (i>1) cmd[len++]='"';
    cmd[len++]=' ';
  }
  if (len<2) {
    fprintf(stderr,"invalid command given.\n");
    return 1;
  }
  cmd[len-1]=0; // terminate
//fprintf(stderr,"COMMAND: '%s'\n",cmd);

#ifdef BLOCKINGIO
  FILE *in =stdin;
  if (!in) return 2;
#else 
  int fin = open ("/dev/stdin", O_RDONLY|O_NONBLOCK);
  if (fin<0) return 2;
#endif

// TODO: catch signals.


  while (
#ifdef BLOCKINGIO
    !feof(in)
#else
1
#endif
        ) {

#ifndef BLOCKINGIO
    struct pollfd pfd;
    pfd.events=POLLIN;
    pfd.revents=0;
    pfd.fd=fin;
    int pv = poll(&pfd,1,1000);
    if (pv<0) break; // error
    if (pv==0) continue; // nothing to read
    if ((pfd.revents & ~POLLIN) != 0 ) break; // read eof/hup/err
#endif
  
#ifdef BLOCKINGIO
    r=fread(buf,sizeof(char),BUFFERSIZE,in);
#else
    r=read(fin, buf,sizeof(char)*BUFFERSIZE);
    if (r==-1) break;
#endif

    if (r==0) break;
    w=respawn_write(buf,r,0);
    if (w==0) {
//    fprintf(stderr,"respawning too fast.\n");
      break;
    }
    if (w!=r) {
//    fprintf(stderr,"incomplete write. some data lost.\n");
      // TODO: tx remaining:
      // w+=respawn_write(buf[r-w],r-w,0);
    }
  }
  respawn_pclose();
  free(cmd);
  return 0;
}