[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.1.1.1 and 1.18

version 1.1.1.1, 1999/10/08 02:12:05 version 1.18, 2020/10/07 10:45:45
Line 1 
Line 1 
   /*$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;
 /*  Note:  1997, 12/6   cf. SS475/kxx/openxxx.tex, SS475/memo1.txt  /*  Note:  1997, 12/6   cf. SS475/kxx/openxxx.tex, SS475/memo1.txt
     The functions in file2.c should not accept interruptions      The functions in file2.c should not accept interruptions
     during its critical operations.  The synchronization mechanism      during its critical operations.  The synchronization mechanism
Line 18  void *GC_malloc(int size);
Line 38  void *GC_malloc(int size);
   
 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 36  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 52  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_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 82  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;
   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) {    if (fp2->watch || WatchStream) {
       if (fp2->watch) fp = fp2->watchFile;
       else fp = stderr;
           fprintf(stderr,"put to <%x> ",fp2->fd); /* output the channel for debug */
     if (c >= ' ' && c <='z') {      if (c >= ' ' && c <='z') {
       fprintf(fp2->watchFile," %2x(%c)-> ",c,c);        fprintf(fp," %2x(%c)-> ",c& 0xff,c);
     }else{      }else{
       fprintf(fp2->watchFile," %2x( )-> ",c);        fprintf(fp," %2x( )-> ",c& 0xff);
     }      }
     fflush(NULL);      fflush(NULL);
   }    }
     if (fp2->log_outgoing != NULL) fputc(c,fp2->log_outgoing);
   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 116  int fp2fputc(int c,FILE2 *fp2) {
Line 172  int fp2fputc(int c,FILE2 *fp2) {
   
 int fp2fgetc(FILE2 *fp2) {  int fp2fgetc(FILE2 *fp2) {
   int c;    int c;
     FILE *fp;
   /* printf("fp2fgetc is called. "); fflush(NULL); */    /* printf("fp2fgetc is called. "); fflush(NULL); */
   if (checkfp2(fp2," fp2fgetc ") == -1) return(-1);    if (checkfp2(fp2," fp2fgetc ") == -1) return(-1);
   if (fp2->readpos < fp2->readsize) {    if (fp2->readpos < fp2->readsize) {
     fp2->readpos++;      fp2->readpos++;
     c = fp2->readBuf[fp2->readpos -1];      c = fp2->readBuf[fp2->readpos -1];
     if (fp2->watch) {      if (fp2->watch || WatchStream) {
         if (fp2->watch) fp = fp2->watchFile;
         else fp = stderr;
         fprintf(fp,"get from <%x> ",fp2->fd); /* output the channel for debug*/
       if (c >= ' ' && c <= 'z') {        if (c >= ' ' && c <= 'z') {
         fprintf(fp2->watchFile," %2x(%c) ",c,c);          fprintf(fp," %2x(%c) ",c,c);
       }else{        }else{
         fprintf(fp2->watchFile," %2x( ) ",c);          fprintf(fp," %2x( ) ",c);
       }        }
       fflush(NULL);        fflush(NULL);
     }      }
       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);
     if (fp2->readsize == 0) {      if (fp2->readsize == 0) {
       if (fp2->watch) {        if (fp2->watch || WatchStream) {
         fprintf(fp2->watchFile," <%2x ",c);          if (fp2->watch) fp = fp2->watchFile;
         fflush(NULL);          else fp = stderr;
           fprintf(fp," <%2x ",c);
           fflush(NULL);
       }        }
       return(-1);        return(-1);
     }      }
Line 148  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 182  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 191  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 208  int fp2clearReadBuf(FILE2 *fp2) {
Line 276  int fp2clearReadBuf(FILE2 *fp2) {
     if (FD_ISSET(fd,&readfds)) {      if (FD_ISSET(fd,&readfds)) {
       n = read(fd,tmp00, TMP00SIZE);        n = read(fd,tmp00, TMP00SIZE);
       if (n <=  0) {        if (n <=  0) {
         fprintf(stderr,"fp2clearReadBuf: File is closed or read error.\n");          fprintf(stderr,"fp2clearReadBuf: File is closed or read error.\n");
         return(-1);          return(-1);
       }        }
       if ( n < TMP00SIZE ) {        if ( n < TMP00SIZE ) {
         return(0);          return(0);
       }        }
     }else {      }else {
       return(0);        return(0);
Line 222  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 262  int fp2stopWatch(FILE2 *fp2)
Line 330  int fp2stopWatch(FILE2 *fp2)
   }    }
 }  }
   
   int fp2log(FILE2 *fp,FILE *incomming,FILE *outgoing) {
     fp->log_incomming = incomming;
     fp->log_outgoing = outgoing;
     return 0;
   }
   int fp2stopLog(FILE2 *fp) {
     if (fp->log_incomming != NULL) fclose(fp->log_incomming);
     if (fp->log_outgoing != NULL) fclose(fp->log_outgoing);
     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) {
       ....
    }
   */
   
Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.18
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>