[BACK]Return to file2.c CVS log [TXT][DIR] Up to [local] / OpenXM / src / kan96xx / plugin

Diff for /OpenXM/src/kan96xx/plugin/file2.c between version 1.5 and 1.18

version 1.5, 2003/11/17 05:45:47 version 1.18, 2020/10/07 10:45:45
Line 1 
Line 1 
 /*$OpenXM: OpenXM/src/kan96xx/plugin/file2.c,v 1.4 2001/05/04 01:06:30 takayama Exp $ */  /*$OpenXM: OpenXM/src/kan96xx/plugin/file2.c,v 1.17 2020/10/06 11:33:47 takayama Exp $ */
 #include <stdio.h>  #include <stdio.h>
   #include <string.h>
 #include <sys/time.h>  #include <sys/time.h>
 #include <sys/types.h>  #include <sys/types.h>
 #include <unistd.h>  #include <unistd.h>
   #include <signal.h>
   #include <errno.h>
   #include <stdlib.h>
 #include "file2.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  #ifdef KXX
 #define GC_malloc(n) malloc(n)  #define sGC_malloc(n) malloc(n)
   int oxSocketSelect0(int fd,int t);
 #else  #else
 void *GC_malloc(int size);  void *sGC_malloc(int size);
 #endif  #endif
 int WatchStream = 0;  int WatchStream = 0;
 /*  Note:  1997, 12/6   cf. SS475/kxx/openxxx.tex, SS475/memo1.txt  /*  Note:  1997, 12/6   cf. SS475/kxx/openxxx.tex, SS475/memo1.txt
Line 19  int WatchStream = 0;
Line 38  int WatchStream = 0;
   
 static int debug1 = 0;  static int debug1 = 0;
 static int checkfp2(FILE2 *fp2,char *s);  static int checkfp2(FILE2 *fp2,char *s);
   static int fp2fputcString(int c,FILE2 *fp2);
 static int checkfp2(FILE2 *fp2,char *s)  static int checkfp2(FILE2 *fp2,char *s)
 {  {
   if (fp2 == NULL) {    if (fp2 == NULL) {
Line 37  FILE2 *fp2open(int fd) {
Line 57  FILE2 *fp2open(int fd) {
   if (debug1) {    if (debug1) {
     printf("fp2open is called. \n");      printf("fp2open is called. \n");
   }    }
   fp2 = (FILE2 *) GC_malloc(sizeof(FILE2));    fp2 = (FILE2 *) sGC_malloc(sizeof(FILE2));
   if (fd < 0) {    if (fd < -1) {
     fprintf(stderr,"fp2open  Invalid file descriptor %d\n",fd);      fprintf(stderr,"fp2open  Invalid file descriptor %d\n",fd);
     return(NULL);      return(NULL);
   }    }
     /* fd == -1 ==> store in string. */
   if (fp2 == NULL) {    if (fp2 == NULL) {
     fprintf(stderr,"fp2open.  No memory.\n");      fprintf(stderr,"fp2open.  No memory.\n");
     return(NULL);      return(NULL);
Line 53  FILE2 *fp2open(int fd) {
Line 74  FILE2 *fp2open(int fd) {
   fp2->readsize = 0;    fp2->readsize = 0;
   fp2->writepos = 0;    fp2->writepos = 0;
   fp2->limit = FILE2BSIZE;    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->watch = 0;
   fp2->watchFile = NULL;    fp2->watchFile = NULL;
   fp2->mathcapList = NULL;    fp2->mathcapList = NULL;
   fp2->log_incomming = NULL;    fp2->log_incomming = NULL;
   fp2->log_outgoing = NULL;    fp2->log_outgoing = NULL;
     fp2->popened = 0;
     fp2->pfp = NULL;
   return(fp2);    return(fp2);
 }  }
   
   void fp2setfp(FILE2 *fp2,FILE *fp,int popened) {
     fp2->pfp = fp;
     fp2->popened = popened;
   }
   
 int fp2fflush(FILE2 *fp2) {  int fp2fflush(FILE2 *fp2) {
   int r;    int r;
   if (debug1) {    if (debug1) {
     printf("fp2fflush is called with FILE2 *%x.\n", (int )fp2);      printf("fp2fflush is called with FILE2 *%lx.\n", (long)fp2);
     fp2dumpBuffer(fp2);      fp2dumpBuffer(fp2);
     printf("--------------------------\n");      printf("--------------------------\n");
   }    }
   if (checkfp2(fp2,"fp2fflush ") == -1) return(-1);    if (checkfp2(fp2,"fp2fflush ") == -1) return(-1);
     if (fp2->fd == -1) return(0);
   if (fp2->writepos > 0) {    if (fp2->writepos > 0) {
           mysignal(SIGPIPE,SIG_IGN);
     r = write(fp2->fd,fp2->writeBuf,fp2->writepos);      r = write(fp2->fd,fp2->writeBuf,fp2->writepos);
           mysignal(SIGPIPE,SIG_DFL);
     fp2->writepos = 0;      fp2->writepos = 0;
     if (r <= 0) {      if (r <= 0) {
       fprintf(stderr,"fp2fflush(): write failed on %d.\n",fp2->fd);        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);      return(r);
   }else{    }else{
Line 85  int fp2fflush(FILE2 *fp2) {
Line 126  int fp2fflush(FILE2 *fp2) {
 int fp2fclose(FILE2 *fp2) {  int fp2fclose(FILE2 *fp2) {
   int r;    int r;
   if (checkfp2(fp2," fp2fclose ") == -1) return(-1);    if (checkfp2(fp2," fp2fclose ") == -1) return(-1);
     if (fp2->fd == -1) return(0);
   r = fp2fflush(fp2);    r = fp2fflush(fp2);
   if (r < 0) {    if (r < 0) {
     fprintf(stderr,"fp2fclose: flush error.\n");      fprintf(stderr,"fp2fclose: flush error.\n");
     return(-1);      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) {  int fp2fputc(int c,FILE2 *fp2) {
   FILE *fp;    FILE *fp;
   if (debug1) {    if (debug1) {
     printf("fp2fputc is called with %2x, fp2->writepos=%d, ",c,fp2->writepos);      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 || WatchStream) {
     if (fp2->watch) fp = fp2->watchFile;      if (fp2->watch) fp = fp2->watchFile;
     else fp = stderr;      else fp = stderr;
           fprintf(stderr,"put to <%x> ",fp2->fd); /* output the channel for debug */
     if (c >= ' ' && c <='z') {      if (c >= ' ' && c <='z') {
       fprintf(fp," %2x(%c)-> ",c& 0xff,c);        fprintf(fp," %2x(%c)-> ",c& 0xff,c);
     }else{      }else{
Line 113  int fp2fputc(int c,FILE2 *fp2) {
Line 161  int fp2fputc(int c,FILE2 *fp2) {
   if (checkfp2(fp2," fp2fputc ") == -1) return(-1);    if (checkfp2(fp2," fp2fputc ") == -1) return(-1);
   (fp2->writeBuf)[fp2->writepos] = c;    (fp2->writeBuf)[fp2->writepos] = c;
   (fp2->writepos)++;    (fp2->writepos)++;
     if (fp2->fd == -1) return(fp2fputcString(c,fp2));
   if (fp2->writepos < fp2->limit) {    if (fp2->writepos < fp2->limit) {
     return(c);      return(c);
   }else{    }else{
Line 132  int fp2fgetc(FILE2 *fp2) {
Line 181  int fp2fgetc(FILE2 *fp2) {
     if (fp2->watch || WatchStream) {      if (fp2->watch || WatchStream) {
       if (fp2->watch) fp = fp2->watchFile;        if (fp2->watch) fp = fp2->watchFile;
       else fp = stderr;        else fp = stderr;
         fprintf(fp,"get from <%x> ",fp2->fd); /* output the channel for debug*/
       if (c >= ' ' && c <= 'z') {        if (c >= ' ' && c <= 'z') {
         fprintf(fp," %2x(%c) ",c,c);          fprintf(fp," %2x(%c) ",c,c);
       }else{        }else{
Line 142  int fp2fgetc(FILE2 *fp2) {
Line 192  int fp2fgetc(FILE2 *fp2) {
     if (fp2->log_incomming != NULL) fputc(c,fp2->log_incomming);      if (fp2->log_incomming != NULL) fputc(c,fp2->log_incomming);
     return(c);      return(c);
   }else{    }else{
           if (fp2->fd == -1) return(-1);
     fp2->readpos = 0;      fp2->readpos = 0;
     fp2 ->readsize =      fp2 ->readsize =
       read(fp2->fd, fp2->readBuf, fp2->limit);        read(fp2->fd, fp2->readBuf, fp2->limit);
Line 152  int fp2fgetc(FILE2 *fp2) {
Line 203  int fp2fgetc(FILE2 *fp2) {
         fprintf(fp," <%2x ",c);          fprintf(fp," <%2x ",c);
         fflush(NULL);          fflush(NULL);
       }        }
       if (fp2->log_incomming != NULL) fputc(c,fp2->log_incomming);  
       return(-1);        return(-1);
     }      }
     else {      else {
Line 162  int fp2fgetc(FILE2 *fp2) {
Line 212  int fp2fgetc(FILE2 *fp2) {
 }  }
   
 int fp2select(FILE2 *fp2, int t) {  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);    if (fp2->readpos < fp2->readsize) return(1);
   else {    else {
 #ifdef KXX  #ifdef KXX
Line 196  int fp2dumpBuffer(FILE2 *fp2) {
Line 250  int fp2dumpBuffer(FILE2 *fp2) {
 int fp2clearReadBuf(FILE2 *fp2) {  int fp2clearReadBuf(FILE2 *fp2) {
   fd_set readfds;    fd_set readfds;
   struct timeval timeout;    struct timeval timeout;
   extern int errno;  
   int fd;    int fd;
 #define TMP00SIZE  2000  #define TMP00SIZE  2000
   char tmp00[TMP00SIZE];    char tmp00[TMP00SIZE];
Line 205  int fp2clearReadBuf(FILE2 *fp2) {
Line 258  int fp2clearReadBuf(FILE2 *fp2) {
   if (checkfp2(fp2," fp2clearReadBuf ") == -1) {    if (checkfp2(fp2," fp2clearReadBuf ") == -1) {
     return(-1);      return(-1);
   }    }
     if (fp2->fd == -1) return(0);
   
   fp2->readsize=0; fp2->readpos = 0;  /* Clear the buffer. */    fp2->readsize=0; fp2->readpos = 0;  /* Clear the buffer. */
   
Line 236  int fp2clearReadBuf(FILE2 *fp2) {
Line 290  int fp2clearReadBuf(FILE2 *fp2) {
 int fp2write(FILE2 *os, char *data, int size) {  int fp2write(FILE2 *os, char *data, int size) {
   int i,r;    int i,r;
   for (i=0; i<size; i++) {    for (i=0; i<size; i++) {
     r = fp2fputc(data[i],os);      r = fp2fputc((unsigned char)(data[i]),os);
   }    }
   return(r);    return(r);
 }  }
Line 287  int fp2stopLog(FILE2 *fp) {
Line 341  int fp2stopLog(FILE2 *fp) {
   fp->log_incomming = fp->log_outgoing = NULL;    fp->log_incomming = fp->log_outgoing = NULL;
   return 0;    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) {
       ....
    }
   */
   
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.18
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>