[BACK]Return to sio.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / io

Diff for /OpenXM_contrib2/asir2000/io/sio.c between version 1.3 and 1.29

version 1.3, 2000/02/08 04:47:11 version 1.29, 2020/10/04 03:14:08
Line 1 
Line 1 
 /* $OpenXM: OpenXM_contrib2/asir2000/io/sio.c,v 1.2 1999/12/24 06:57:22 noro Exp $ */  /*
 #if INET   * Copyright (c) 1994-2000 FUJITSU LABORATORIES LIMITED
    * All rights reserved.
    *
    * FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,
    * non-exclusive and royalty-free license to use, copy, modify and
    * redistribute, solely for non-commercial and non-profit purposes, the
    * computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and
    * conditions of this Agreement. For the avoidance of doubt, you acquire
    * only a limited right to use the SOFTWARE hereunder, and FLL or any
    * third party developer retains all rights, including but not limited to
    * copyrights, in and to the SOFTWARE.
    *
    * (1) FLL does not grant you a license in any way for commercial
    * purposes. You may use the SOFTWARE only for non-commercial and
    * non-profit purposes only, such as academic, research and internal
    * business use.
    * (2) The SOFTWARE is protected by the Copyright Law of Japan and
    * international copyright treaties. If you make copies of the SOFTWARE,
    * with or without modification, as permitted hereunder, you shall affix
    * to all such copies of the SOFTWARE the above copyright notice.
    * (3) An explicit reference to this SOFTWARE and its copyright owner
    * shall be made on your publication or presentation in any form of the
    * results obtained by use of the SOFTWARE.
    * (4) In the event that you modify the SOFTWARE, you shall notify FLL by
    * e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification
    * for such modification or the source code of the modified part of the
    * SOFTWARE.
    *
    * THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL
    * MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND
    * EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS
    * FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'
    * RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY
    * MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.
    * UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,
    * OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY
    * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL
    * DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES
    * ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES
    * FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY
    * DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF
    * SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART
    * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
    * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
    * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
    * $OpenXM: OpenXM_contrib2/asir2000/io/sio.c,v 1.28 2018/03/29 01:32:53 noro Exp $
   */
 #include "ca.h"  #include "ca.h"
 #include "setjmp.h"  #include <setjmp.h>
 #include "ox.h"  #include "ox.h"
 #if defined(VISUAL)  #if defined(VISUAL) || defined(__MINGW32__)
 #include <winsock.h>  #include <winsock2.h>
   #include <io.h>
 #else  #else
 #include <sys/time.h>  #include <sys/time.h>
 #include <sys/uio.h>  #include <sys/uio.h>
 #include <sys/ioctl.h>  #include <sys/ioctl.h>
 #include <sys/un.h>  #include <sys/un.h>
   #include <netinet/in.h>
   #include <arpa/inet.h>
 #endif  #endif
 #include<signal.h>  #include<signal.h>
   
Line 18 
Line 67 
   
 extern int little_endian;  extern int little_endian;
   
   int I_am_server;
 struct IOFP iofp[MAXIOFP];  struct IOFP iofp[MAXIOFP];
   
 #if !defined(_PA_RISC1_1)  #if !defined(_PA_RISC1_1)
Line 28  struct IOFP iofp[MAXIOFP];
Line 78  struct IOFP iofp[MAXIOFP];
   
 void init_socket(void);  void init_socket(void);
   
 int getremotesocket(s)  #if !defined(VISUAL) && !defined(__MINGW32__)
 int s;  #define closesocket(s)   (close((s)))
   #endif
   
   int getremotesocket(int s)
 {  {
         return iofp[s].s;    return iofp[s].s;
 }  }
   
 void getremotename(s,name)  void getremotename(int s,char *name)
 int s;  
 char *name;  
 {  {
         struct sockaddr_in peer;    struct sockaddr_in peer;
         struct hostent *hp;    struct hostent *hp;
         int peerlen;    int peerlen;
   
         peerlen = sizeof(peer);    peerlen = sizeof(peer);
         getpeername(getremotesocket(s),(struct sockaddr *)&peer,&peerlen);    getpeername(getremotesocket(s),(struct sockaddr *)&peer,&peerlen);
         hp = gethostbyaddr((char *)&peer.sin_addr,sizeof(struct in_addr),AF_INET);    hp = gethostbyaddr((char *)&peer.sin_addr,sizeof(struct in_addr),AF_INET);
         if ( hp )    if ( hp )
                 strcpy(name,hp->h_name);      strcpy(name,hp->h_name);
         else    else
                 strcpy(name,(char *)inet_ntoa(peer.sin_addr));      strcpy(name,(char *)inet_ntoa(peer.sin_addr));
 }  }
   
 int generate_port(use_unix,port_str)  void generate_port(int use_unix,char *port_str)
 int use_unix;  
 char *port_str;  
 {  {
         double get_current_time();    double get_current_time();
         unsigned long mt_genrand();    unsigned long mt_genrand();
         unsigned int port;    unsigned int port;
         static int count=0;    static int count=0;
   
         if ( use_unix ) {  #if !defined(VISUAL) && !defined(__MINGW32__)
                 sprintf(port_str,"/tmp/ox%02x.XXXXXX",count);    if ( use_unix ) {
                 count++;      sprintf(port_str,"/tmp/ox%02x.XXXXXX",count);
                 mktemp(port_str);      count++;
         } else {      mktemp(port_str);
                 port = ((unsigned int)mt_genrand()+(unsigned int)get_current_time())    } else
                         %(65536-1024)+1024;  #endif
                 sprintf(port_str,"%d",port);    {
         }      port = ((unsigned int)mt_genrand()+(unsigned int)get_current_time())
         %(65536-1024)+1024;
       sprintf(port_str,"%d",port);
     }
 }  }
   
 int try_bind_listen(use_unix,port_str)  int try_bind_listen(int use_unix,char *port_str)
 int use_unix;  
 char *port_str;  
 {  {
         struct sockaddr_in sin;    struct sockaddr_in sin;
         struct sockaddr *saddr;    struct sockaddr *saddr;
         int len;    int len;
         int service;    int service;
 #if !defined(VISUAL)  #if !defined(VISUAL) && !defined(__MINGW32__)
         struct sockaddr_un s_un;    struct sockaddr_un s_un;
   
         if ( use_unix ) {    if ( use_unix ) {
                 service = socket(AF_UNIX, SOCK_STREAM, 0);      service = socket(AF_UNIX, SOCK_STREAM, 0);
                 if (service < 0) {      if (service < 0) {
                         perror("in socket");        perror("in socket");
                         return -1;        return -1;
                 }      }
                 s_un.sun_family = AF_UNIX;      s_un.sun_family = AF_UNIX;
                 strcpy(s_un.sun_path,port_str);      strcpy(s_un.sun_path,port_str);
 #if defined(__FreeBSD__)  #if defined(__FreeBSD__)
                 len = SUN_LEN(&s_un);      len = SUN_LEN(&s_un);
                 s_un.sun_len = len+1; /* XXX */      s_un.sun_len = len+1; /* XXX */
 #else  #else
                 len = strlen(s_un.sun_path)+sizeof(s_un.sun_family);      len = strlen(s_un.sun_path)+sizeof(s_un.sun_family);
 #endif  #endif
                 saddr = (struct sockaddr *)&s_un;      saddr = (struct sockaddr *)&s_un;
         } else    } else
 #endif  #endif
         {    {
                 service = socket(AF_INET, SOCK_STREAM, 0);      service = socket(AF_INET, SOCK_STREAM, 0);
                 if ( service < 0 ) {      if ( service < 0 ) {
                         perror("in socket");        perror("in socket");
                         return -1;        return -1;
                 }      }
                 sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY;      sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY;
                 sin.sin_port = htons(atoi(port_str));      sin.sin_port = htons((unsigned short)atoi(port_str));
                 len = sizeof(sin);      len = sizeof(sin);
                 saddr = (struct sockaddr *)&sin;      saddr = (struct sockaddr *)&sin;
         }    }
         if (bind(service, saddr, len) < 0) {    if (bind(service, saddr, len) < 0) {
                 perror("in bind");      perror("in bind");
                 close(service);      closesocket(service);
                 return -1;      return -1;
         }    }
         if (getsockname(service,saddr, &len) < 0) {    if (getsockname(service,saddr, &len) < 0) {
             perror("in getsockname");        perror("in getsockname");
             close(service);        closesocket(service);
             return -1;        return -1;
         }    }
         if (listen(service, SOCKQUEUELENGTH) < 0) {    if (listen(service, SOCKQUEUELENGTH) < 0) {
                 perror("in listen");      perror("in listen");
                 close(service);      closesocket(service);
                 return -1;      return -1;
         }    }
         return service;    return service;
 }  }
   
 /*  /*
Line 142  char *port_str;
Line 192  char *port_str;
   the original socket is always closed.    the original socket is always closed.
 */  */
   
 int try_accept(af_unix,s)  int try_accept(int af_unix,int s)
 int af_unix,s;  
 {  {
         int len,c,i;    int len,c,i;
         struct sockaddr_in sin;    struct sockaddr_in sin;
   
 #if !defined(VISUAL)  #if !defined(VISUAL) && !defined(__MINGW32__)
         struct sockaddr_un s_un;    struct sockaddr_un s_un;
         if ( af_unix ) {    if ( af_unix ) {
                 len = sizeof(s_un);      len = sizeof(s_un);
                 for ( c = -1, i = 0; (c < 0)&&(i = 10) ; i++ )      for ( c = -1, i = 0; (c < 0)&&(i = 10) ; i++ )
                         c = accept(s, (struct sockaddr *) &s_un, &len);        c = accept(s, (struct sockaddr *) &s_un, &len);
         } else    } else
 #endif  #endif
         {    {
   
                 len = sizeof(sin);      len = sizeof(sin);
                 for ( c = -1, i = 0; (c < 0)&&(i = 10) ; i++ )      for ( c = -1, i = 0; (c < 0)&&(i = 10) ; i++ )
                         c = accept(s, (struct sockaddr *) &sin, &len);        c = accept(s, (struct sockaddr *) &sin, &len);
         }    }
         if ( i == 10 )    if ( i == 10 )
                 c = -1;      c = -1;
         close(s);    closesocket(s);
         return c;    return c;
 }  }
   
 int try_connect(use_unix,host,port_str)  int try_connect(int use_unix,char *host,char *port_str)
 int use_unix;  
 char *host,*port_str;  
 {  {
         struct sockaddr_in sin;    struct sockaddr_in sin;
         struct sockaddr *saddr;    struct sockaddr *saddr;
         struct hostent *hp;    struct hostent *hp;
         int len,s,i;    int len,s,i;
 #if !defined(VISUAL)  #if !defined(VISUAL) && !defined(__MINGW32__)
         struct sockaddr_un s_un;    struct sockaddr_un s_un;
 #endif  #endif
   
         for ( i = 0; i < 10; i++ ) {    for ( i = 0; i < 10; i++ ) {
 #if !defined(VISUAL)  #if !defined(VISUAL) && !defined(__MINGW32__)
                 if ( use_unix ) {      if ( use_unix ) {
                         if ( (s = socket(AF_UNIX,SOCK_STREAM,0)) < 0 ) {        if ( (s = socket(AF_UNIX,SOCK_STREAM,0)) < 0 ) {
                                 perror("socket");          perror("socket");
                                 return -1;          return -1;
                         }        }
                         bzero(&s_un,sizeof(s_un));        bzero(&s_un,sizeof(s_un));
                         s_un.sun_family = AF_UNIX;        s_un.sun_family = AF_UNIX;
                         strcpy(s_un.sun_path,port_str);        strcpy(s_un.sun_path,port_str);
 #if defined(__FreeBSD__)  #if defined(__FreeBSD__)
                         len = SUN_LEN(&s_un);        len = SUN_LEN(&s_un);
                         s_un.sun_len = len+1; /* XXX */        s_un.sun_len = len+1; /* XXX */
 #else  #else
                         len = strlen(s_un.sun_path)+sizeof(s_un.sun_family);        len = strlen(s_un.sun_path)+sizeof(s_un.sun_family);
 #endif  #endif
                         saddr = (struct sockaddr *)&s_un;        saddr = (struct sockaddr *)&s_un;
                 } else      } else
 #endif /* VISUAL */  #endif /* VISUAL */
                 {      {
                         if ( (s = socket(AF_INET,SOCK_STREAM,0)) < 0 ) {        if ( !host )
                                 perror("socket");          host = "127.0.0.1";
                                 return -1;        if ( (s = socket(AF_INET,SOCK_STREAM,0)) < 0 ) {
                         }          perror("socket");
                         bzero(&sin,sizeof(sin));          return -1;
                         sin.sin_port = htons(atoi(port_str));        }
                         sin.sin_addr.s_addr = inet_addr(host);        bzero(&sin,sizeof(sin));
                         if ( sin.sin_addr.s_addr != -1 ) {        sin.sin_port = htons((unsigned short)atoi(port_str));
                                 sin.sin_family = AF_INET;        sin.sin_addr.s_addr = inet_addr(host);
                         } else {        if ( sin.sin_addr.s_addr != -1 ) {
                                 hp = gethostbyname(host);          sin.sin_family = AF_INET;
                                 bcopy(hp->h_addr,&sin.sin_addr,hp->h_length);        } else {
                                 sin.sin_family = hp->h_addrtype;          hp = gethostbyname(host);
                         }          bcopy(hp->h_addr,&sin.sin_addr,hp->h_length);
                         len = sizeof(sin);          sin.sin_family = hp->h_addrtype;
                         saddr = (struct sockaddr *)&sin;        }
                 }        len = sizeof(sin);
                 if ( connect(s,saddr,len) >= 0 )        saddr = (struct sockaddr *)&sin;
                         break;      }
                 else {      if ( connect(s,saddr,len) >= 0 )
                         close(s);        break;
 #if defined(VISUAL)      else {
                         Sleep(100);        closesocket(s);
   #if defined(VISUAL) || defined(__MINGW32__)
         Sleep(100);
 #else  #else
                         usleep(100000);        usleep(100000);
 #endif  #endif
                 }      }
         }    }
         if ( i == 10 ) {    if ( i == 10 ) {
                 perror("connect");      perror("connect");
                 return -1;      return -1;
         } else    } else
                 return s;      return s;
 }  }
   
 close_allconnections()  #if 0
   void close_allconnections()
 {  {
         int s;    int s;
   
 #if defined(SIGPIPE)  #if defined(SIGPIPE)
         signal(SIGPIPE,SIG_IGN);    signal(SIGPIPE,SIG_IGN);
 #endif  #endif
         for ( s = 0; s < MAXIOFP; s++ )    for ( s = 0; s < MAXIOFP; s++ )
                 close_connection(s);      close_connection(s);
 }  }
   
 close_connection(s)  void close_connection(int s)
 int s;  
 {  {
         struct IOFP *r;    struct IOFP *r;
   
         r = &iofp[s];    r = &iofp[s];
         if ( r->in && r->out ) {    if ( r->in && r->out ) {
                 if ( check_sm_by_mc(s,SM_shutdown) )      if ( check_sm_by_mc(s,SM_shutdown) )
                         ox_send_cmd(s,SM_shutdown);        ox_send_cmd(s,SM_shutdown);
                 free_iofp(s);      free_iofp(s);
         }    }
 }  }
   #else
   void close_allconnections()
   {
     shutdown_all();
   }
   #endif
   
 free_iofp(s)  void free_iofp(int s)
 int s;  
 {  {
         struct IOFP *r;    struct IOFP *r;
   
         r = &iofp[s];    r = &iofp[s];
         r->in = r->out = 0; r->s = 0;  #if defined(VISUAL) || defined(__MINGW32__)
 #if !defined(VISUAL)    if ( r->s ) closesocket(r->s);
         if ( r->socket )  #elif !defined(MPI)
                 unlink(r->socket);    if ( r->in ) fclose(r->in);
     if ( r->out ) fclose(r->out);
     if ( r->socket ) unlink(r->socket);
 #endif  #endif
     r->inbuf = r->outbuf = 0;
     r->in = r->out = 0; r->s = 0;
 }  }
   
 #define LBUFSIZ BUFSIZ*10  int get_iofp(int s1,char *af_sock,int is_server)
   
 int get_iofp(s1,af_sock,is_server)  
 int s1;  
 char *af_sock;  
 int is_server;  
 {  {
         int i;    int i;
         unsigned char c,rc;    unsigned char c,rc;
     extern int mpi_myid;
   
         for ( i = 0; i < MAXIOFP; i++ )  #if defined(MPI)
                 if ( !iofp[i].in )    iofp[s1].s = s1;
                         break;    if ( mpi_myid == s1 ) {
         iofp[i].s = s1;      iofp[s1].in = 0;
 #if defined(VISUAL) || MPI      iofp[s1].out = 0;
         iofp[i].in = WSIO_open(s1,"r");    } else {
         iofp[i].out = WSIO_open(s1,"w");      iofp[s1].in = WSIO_open(s1,"r");
       iofp[s1].out = WSIO_open(s1,"w");
     }
     iofp[s1].conv = 0;
     iofp[s1].socket = 0;
   
     return s1;
 #else  #else
         iofp[i].in = fdopen(s1,"r");    for ( i = 0; i < MAXIOFP; i++ )
         iofp[i].out = fdopen(s1,"w");      if ( !iofp[i].in )
         setbuffer(iofp[i].in,(char *)malloc(LBUFSIZ),LBUFSIZ);        break;
         setbuffer(iofp[i].out,(char *)malloc(LBUFSIZ),LBUFSIZ);    iofp[i].s = s1;
 #endif  #if defined(VISUAL) || defined(__MINGW32__)
 #if MPI    iofp[i].in = WSIO_open(s1,"r");
         iofp[i].conv = 0;    iofp[i].out = WSIO_open(s1,"w");
         iofp[i].socket = 0;  
 #else  #else
         if ( little_endian )    iofp[i].in = fdopen(s1,"r");
                 c = 1;    iofp[i].out = fdopen(s1,"w");
         else  #if !defined(__CYGWIN__)
                 c = 0xff;    setbuffer(iofp[i].in,iofp[i].inbuf = (char *)MALLOC_ATOMIC(LBUFSIZ),LBUFSIZ);
         if ( is_server ) {    setbuffer(iofp[i].out,iofp[i].outbuf = (char *)MALLOC_ATOMIC(LBUFSIZ),LBUFSIZ);
                 /* server : write -> read */  
                 write_char(iofp[i].out,&c); ox_flush_stream_force(i);  
                 read_char(iofp[i].in,&rc);  
         } else {  
                 /* client : read -> write */  
                 read_char(iofp[i].in,&rc);  
                 write_char(iofp[i].out,&c); ox_flush_stream_force(i);  
         }  
         iofp[i].conv = c == rc ? 0 : 1;  
         if ( af_sock && af_sock[0] ) {  
                 iofp[i].socket = (char *)malloc(strlen(af_sock)+1);  
                 strcpy(iofp[i].socket,af_sock);  
         } else  
                 iofp[i].socket = 0;  
 #endif  #endif
         return i;  #endif
     if ( little_endian )
       c = 1;
     else
       c = 0xff;
     if ( is_server ) {
       /* server : write -> read */
       write_char((FILE *)iofp[i].out,&c); ox_flush_stream_force(i);
       read_char((FILE *)iofp[i].in,&rc);
     } else {
       /* client : read -> write */
       read_char((FILE *)iofp[i].in,&rc);
       /* special care for a failure of spawing a server */
       if ( rc !=0 && rc != 1 && rc != 0xff )
         return -1;
       write_char((FILE *)iofp[i].out,&c); ox_flush_stream_force(i);
     }
     iofp[i].conv = c == rc ? 0 : 1;
     if ( af_sock && af_sock[0] ) {
       iofp[i].socket = (char *)malloc(strlen(af_sock)+1);
       strcpy(iofp[i].socket,af_sock);
     } else
       iofp[i].socket = 0;
     return i;
   #endif
 }  }
   
 #if defined(VISUAL)  #if defined(VISUAL) || defined(__MINGW32__)
 void init_socket()  void init_socket()
 {  {
         static int socket_is_initialized;    static int socket_is_initialized;
         WORD wVersionRequested;    WORD wVersionRequested;
         WSADATA wsaData;    WSADATA wsaData;
         int err;    int err;
         wVersionRequested = MAKEWORD(2,0);    wVersionRequested = MAKEWORD(2,0);
   
         if ( socket_is_initialized )    if ( socket_is_initialized )
                 return;      return;
         err = WSAStartup(wVersionRequested,&wsaData);    err = WSAStartup(wVersionRequested,&wsaData);
         if ( err )    if ( err )
                 return;      return;
 }  }
 #endif  #endif
   
 get_fd(index)  int get_fd(int index)
 int index;  
 {  {
         return iofp[index].s;    return iofp[index].s;
 }  }
   
 get_index(fd)  int get_index(int fd)
 int fd;  
 {  {
         int i;    int i;
   
         for ( i = 0; i < MAXIOFP; i++ )    for ( i = 0; i < MAXIOFP; i++ )
                 if ( iofp[i].s == fd )      if ( iofp[i].s == fd )
                         return i;        return i;
         return -1;    return -1;
 }  }
 #endif /* INET */  
Legend:
Removed from v.1.3  
changed lines
  Added in v.1.29
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>