===================================================================
RCS file: /home/cvs/OpenXM/src/kan96xx/plugin/file2.c,v
retrieving revision 1.6
retrieving revision 1.18
diff -u -p -r1.6 -r1.18
--- OpenXM/src/kan96xx/plugin/file2.c	2003/11/18 11:08:27	1.6
+++ OpenXM/src/kan96xx/plugin/file2.c	2020/10/07 10:45:45	1.18
@@ -1,14 +1,33 @@
-/*$OpenXM: OpenXM/src/kan96xx/plugin/file2.c,v 1.5 2003/11/17 05:45:47 takayama Exp $ */
+/*$OpenXM: OpenXM/src/kan96xx/plugin/file2.c,v 1.17 2020/10/06 11:33:47 takayama Exp $ */
 #include <stdio.h>
+#include <string.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
+#include <signal.h>
+#include <errno.h>
+#include <stdlib.h>
 #include "file2.h"
+#include "mysig.h"
+#include "sm1Socket.h"
 
+/* If you use file2 standalone to output string,  
+    make the following dummy definition;
+int KsocketSelect0(int a,int b) { return(0); }
+int oxSocketSelect0(int a,int b) { return(0); }
+or define FORSTRING
+Real oxSocketSelect0 is defined in kan96xx/plugin/mytcpio.c
+*/
+#ifdef  FORSTRING
+#define KsocketSelect0(a,b) 0
+#define oxSocketSelect0(a,b) 0
+#endif
+
 #ifdef KXX
-#define GC_malloc(n) malloc(n)
+#define sGC_malloc(n) malloc(n)
+int oxSocketSelect0(int fd,int t);
 #else
-void *GC_malloc(int size);
+void *sGC_malloc(int size);
 #endif
 int WatchStream = 0;
 /*  Note:  1997, 12/6   cf. SS475/kxx/openxxx.tex, SS475/memo1.txt
@@ -19,6 +38,7 @@ int WatchStream = 0;
 
 static int debug1 = 0;
 static int checkfp2(FILE2 *fp2,char *s);
+static int fp2fputcString(int c,FILE2 *fp2);
 static int checkfp2(FILE2 *fp2,char *s)
 {
   if (fp2 == NULL) {
@@ -37,11 +57,12 @@ FILE2 *fp2open(int fd) {
   if (debug1) {
     printf("fp2open is called. \n");
   }
-  fp2 = (FILE2 *) GC_malloc(sizeof(FILE2));
-  if (fd < 0) {
+  fp2 = (FILE2 *) sGC_malloc(sizeof(FILE2));
+  if (fd < -1) {
     fprintf(stderr,"fp2open  Invalid file descriptor %d\n",fd);
     return(NULL);
   }
+  /* fd == -1 ==> store in string. */
   if (fp2 == NULL) {
     fprintf(stderr,"fp2open.  No memory.\n");
     return(NULL);
@@ -53,28 +74,48 @@ FILE2 *fp2open(int fd) {
   fp2->readsize = 0;
   fp2->writepos = 0;
   fp2->limit = FILE2BSIZE;
+  fp2->readBuf = (char *) sGC_malloc(FILE2BSIZE);
+  fp2->writeBuf = (char *) sGC_malloc(FILE2BSIZE);
+  if ((fp2->readBuf == NULL) || (fp2->writeBuf == NULL)) {
+	fprintf(stderr,"fp2open. No more memory.\n");
+	return(NULL);
+  }
   fp2->watch = 0;
   fp2->watchFile = NULL;
   fp2->mathcapList = NULL;
   fp2->log_incomming = NULL;
   fp2->log_outgoing = NULL;
+  fp2->popened = 0;
+  fp2->pfp = NULL;
   return(fp2);
 }
 
+void fp2setfp(FILE2 *fp2,FILE *fp,int popened) {
+  fp2->pfp = fp;
+  fp2->popened = popened;
+}
     
 int fp2fflush(FILE2 *fp2) {
   int r;
   if (debug1) {
-    printf("fp2fflush is called with FILE2 *%x.\n", (int )fp2);
+    printf("fp2fflush is called with FILE2 *%lx.\n", (long)fp2);
     fp2dumpBuffer(fp2);
     printf("--------------------------\n");
   }
   if (checkfp2(fp2,"fp2fflush ") == -1) return(-1);
+  if (fp2->fd == -1) return(0);
   if (fp2->writepos > 0) {
+	mysignal(SIGPIPE,SIG_IGN);
     r = write(fp2->fd,fp2->writeBuf,fp2->writepos);
+	mysignal(SIGPIPE,SIG_DFL);
     fp2->writepos = 0;
     if (r <= 0) {
       fprintf(stderr,"fp2fflush(): write failed on %d.\n",fp2->fd);
+	  if (errno == EPIPE) {
+		fprintf(stderr,"Your peer is closed --- SIGPIPE. Closing this fp2.\n");
+		fp2fclose(fp2);
+		return r;
+	  }
     }
     return(r);
   }else{
@@ -85,19 +126,25 @@ int fp2fflush(FILE2 *fp2) {
 int fp2fclose(FILE2 *fp2) {
   int r;
   if (checkfp2(fp2," fp2fclose ") == -1) return(-1);
+  if (fp2->fd == -1) return(0);
   r = fp2fflush(fp2);
   if (r < 0) {
     fprintf(stderr,"fp2fclose: flush error.\n");
     return(-1);
   }
-  return(close(fp2->fd));
+  if (fp2->pfp != NULL) {
+	if (fp2->popened) {
+      return pclose(fp2->pfp);
+	} else return fclose(fp2->pfp);
+  }
+  else return(close(fp2->fd));
 }
 
 int fp2fputc(int c,FILE2 *fp2) {
   FILE *fp;
   if (debug1) {
     printf("fp2fputc is called with %2x, fp2->writepos=%d, ",c,fp2->writepos);
-    printf("fp2 = %x.\n",(int) fp2);
+    printf("fp2 = %lx.\n",(long) fp2);
   }
   if (fp2->watch || WatchStream) {
     if (fp2->watch) fp = fp2->watchFile;
@@ -114,6 +161,7 @@ int fp2fputc(int c,FILE2 *fp2) {
   if (checkfp2(fp2," fp2fputc ") == -1) return(-1);
   (fp2->writeBuf)[fp2->writepos] = c;
   (fp2->writepos)++;
+  if (fp2->fd == -1) return(fp2fputcString(c,fp2));
   if (fp2->writepos < fp2->limit) {
     return(c);
   }else{
@@ -144,6 +192,7 @@ int fp2fgetc(FILE2 *fp2) {
     if (fp2->log_incomming != NULL) fputc(c,fp2->log_incomming);
     return(c); 
   }else{
+	if (fp2->fd == -1) return(-1);
     fp2->readpos = 0;
     fp2 ->readsize =
       read(fp2->fd, fp2->readBuf, fp2->limit);
@@ -154,7 +203,6 @@ int fp2fgetc(FILE2 *fp2) {
         fprintf(fp," <%2x ",c);
         fflush(NULL);
       }
-      if (fp2->log_incomming != NULL) fputc(c,fp2->log_incomming);
       return(-1);
     }
     else {
@@ -164,6 +212,10 @@ int fp2fgetc(FILE2 *fp2) {
 }
 
 int fp2select(FILE2 *fp2, int t) {
+  if (fp2->fd == -1) {
+	if (fp2->readpos < fp2->readsize) return(1);
+	else return(0);
+  }
   if (fp2->readpos < fp2->readsize) return(1);
   else {
 #ifdef KXX
@@ -198,7 +250,6 @@ int fp2dumpBuffer(FILE2 *fp2) {
 int fp2clearReadBuf(FILE2 *fp2) {
   fd_set readfds;
   struct timeval timeout;
-  extern int errno;
   int fd;
 #define TMP00SIZE  2000
   char tmp00[TMP00SIZE];
@@ -207,6 +258,7 @@ int fp2clearReadBuf(FILE2 *fp2) {
   if (checkfp2(fp2," fp2clearReadBuf ") == -1) {
     return(-1);
   }
+  if (fp2->fd == -1) return(0);  
 
   fp2->readsize=0; fp2->readpos = 0;  /* Clear the buffer. */
   
@@ -238,7 +290,7 @@ int fp2clearReadBuf(FILE2 *fp2) {
 int fp2write(FILE2 *os, char *data, int size) {
   int i,r;
   for (i=0; i<size; i++) {
-    r = fp2fputc(data[i],os);
+    r = fp2fputc((unsigned char)(data[i]),os);
   }
   return(r);
 }
@@ -289,3 +341,72 @@ int fp2stopLog(FILE2 *fp) {
   fp->log_incomming = fp->log_outgoing = NULL;
   return 0;
 }
+
+static int fp2fputcString(int c,FILE2 *fp2) {
+  unsigned char *newwrite,*newread;
+  int newsize;
+  int i;
+  (fp2->readBuf)[fp2->readsize] = c;
+  (fp2->readsize)++;
+  if ((fp2->writepos < fp2->limit) && (fp2->readsize < fp2->limit)) return(c);
+  if ((fp2->limit)*2 >=0x3000000) {
+	fprintf(stderr,"Too big output string.\n");
+	return(-1);
+  }
+  newsize = (fp2->limit)*2;
+  newwrite = (char *)sGC_malloc(newsize);
+  newread = (char *)sGC_malloc(newsize);
+  if ((newwrite == NULL) || (newread == NULL)) {
+	fprintf(stderr,"fp2fputcString: No more memory.\n");
+	return(-1);
+  }
+  for (i=0; i<fp2->writepos; i++) {
+	newwrite[i] = fp2->writeBuf[i];
+  }
+  for (i=0; i<fp2->readsize; i++) {
+	newread[i] = fp2->readBuf[i];
+  }
+  fp2->writeBuf = newwrite;
+  fp2->readBuf = newread;
+  fp2->limit = newsize;
+  return(c);
+}
+
+char *fp2fcloseInString(FILE2 *fp2, int *sizep)
+{
+  if (fp2->fd == -1) {
+	fp2fputc(0,fp2);
+	*sizep = fp2->writepos-1;
+	return(fp2->writeBuf);
+  }else{
+	fprintf(stderr,"fp2fcloseInString is called for a file stream that is not associated to a string.\n");
+  }
+}
+
+int fp2fputs(char *s,FILE2 *fp) {
+  int i,n;
+  n = strlen(s);
+  for (i=0; i<n; i++) {
+	if (fp2fputc((unsigned char)(s[i]),fp) < 0) return(-1);
+  }
+  return(0);
+}
+
+/* Sample program  FORSTRING
+ FILE2 *fp2;
+ int c;
+ char *s;
+ int size;
+ fp2 = fp2fopen(-1);
+ while ((c = getchar()) != EOF) {
+   fp2fputc(c,fp2);
+ }
+ s = fp2fcloseInString(fp2,&size);
+
+ or
+
+ while ((c = fp2fgetc(fp2)) != EOF) {
+    ....
+ }
+*/
+