[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.9.2.2 and 1.29

version 1.9.2.2, 2000/11/08 08:31:55 version 1.29, 2020/10/04 03:14:08
Line 44 
Line 44 
  * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY   * OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  * $OpenXM: OpenXM_contrib2/asir2000/io/sio.c,v 1.9.2.1 2000/11/08 08:18:14 maekawa Exp $   * $OpenXM: OpenXM_contrib2/asir2000/io/sio.c,v 1.28 2018/03/29 01:32:53 noro Exp $
 */  */
 #if INET  
 #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 76  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;  
 {  {
         union {    struct sockaddr_in peer;
                 struct sockaddr sa;    struct hostent *hp;
                 char data[SOCK_MAXADDRLEN];    int peerlen;
         } dummy;  
         struct sockaddr *sa;  
         socklen_t len;  
         char host[NI_MAXHOST];  
         int rs;  
   
         rs = getremotesocket(s);    peerlen = sizeof(peer);
         len = SOCK_MAXADDRLEN;    getpeername(getremotesocket(s),(struct sockaddr *)&peer,&peerlen);
         getpeername(rs, (struct sockaddr *)dummy.data, &len);    hp = gethostbyaddr((char *)&peer.sin_addr,sizeof(struct in_addr),AF_INET);
         sa = &(dummy.sa);    if ( hp )
         getnameinfo(sa, sa->sa_len, host, sizeof(host), NULL, 0, 0);      strcpy(name,hp->h_name);
         strcpy(name, host);    else
       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 !defined(VISUAL)  #if !defined(VISUAL) && !defined(__MINGW32__)
         if ( use_unix ) {    if ( use_unix ) {
                 sprintf(port_str,"/tmp/ox%02x.XXXXXX",count);      sprintf(port_str,"/tmp/ox%02x.XXXXXX",count);
                 count++;      count++;
                 mktemp(port_str);      mktemp(port_str);
         } else    } else
 #endif  #endif
         {    {
                 port = ((unsigned int)mt_genrand()+(unsigned int)get_current_time())      port = ((unsigned int)mt_genrand()+(unsigned int)get_current_time())
                         %(65536-1024)+1024;        %(65536-1024)+1024;
                 sprintf(port_str,"%d",port);      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 addrinfo hints, *res, *ai;    struct sockaddr_in sin;
         int s, error;    struct sockaddr *saddr;
         char *errstr;    int len;
     int service;
   #if !defined(VISUAL) && !defined(__MINGW32__)
     struct sockaddr_un s_un;
   
         memset(&hints, 0, sizeof(hints));    if ( use_unix ) {
 #if defined(VISUAL)      service = socket(AF_UNIX, SOCK_STREAM, 0);
         hints.ai_family = PF_UNSPEC;      if (service < 0) {
         perror("in socket");
         return -1;
       }
       s_un.sun_family = AF_UNIX;
       strcpy(s_un.sun_path,port_str);
   #if defined(__FreeBSD__)
       len = SUN_LEN(&s_un);
       s_un.sun_len = len+1; /* XXX */
 #else  #else
         if (use_unix)      len = strlen(s_un.sun_path)+sizeof(s_un.sun_family);
                 hints.ai_family = PF_UNIX;  #endif
         else      saddr = (struct sockaddr *)&s_un;
                 hints.ai_family = PF_UNSPEC;    } else
 #endif /* VISUAL */  #endif
         hints.ai_socktype = SOCK_STREAM;    {
       service = socket(AF_INET, SOCK_STREAM, 0);
         error = getaddrinfo(NULL, port_str, &hints, &res);      if ( service < 0 ) {
         if (error) {        perror("in socket");
                 warnx("try_bind_listen(): %s", gai_strerror(error));        return -1;
                 return (-1);      }
         }      sin.sin_family = AF_INET; sin.sin_addr.s_addr = INADDR_ANY;
       sin.sin_port = htons((unsigned short)atoi(port_str));
         for (ai = res ; ai != NULL ; ai = ai->ai_next) {      len = sizeof(sin);
                 if ((s = socket(ai->ai_family, ai->ai_socktype,      saddr = (struct sockaddr *)&sin;
                                 ai->ai_protocol)) < 0 ) {    }
                         errstr = "in socket";    if (bind(service, saddr, len) < 0) {
                         continue;      perror("in bind");
                 }      closesocket(service);
       return -1;
                 if (bind(s, ai->ai_addr, ai->ai_addrlen) < 0) {    }
                         errstr = "in bind";    if (getsockname(service,saddr, &len) < 0) {
                         close(s);        perror("in getsockname");
                         s = -1;        closesocket(service);
                         continue;        return -1;
                 }    }
     if (listen(service, SOCKQUEUELENGTH) < 0) {
                 if (listen(s, SOCKQUEUELENGTH) < 0) {      perror("in listen");
                         errstr = "in listen";      closesocket(service);
                         close(s);      return -1;
                         s = -1;    }
                         continue;    return service;
                 }  
   
                 /* established connection */  
                 break;  
         }  
         freeaddrinfo(res);  
   
         if (s < 0)  
                 perror(errstr);  
         return (s);  
 }  }
   
 /*  /*
   try to accept a connection request    try to accept a connection request
   
   Input    Input
       af_unix: s is UNIX domain socket if af_unix is nonzero
     s: socket      s: socket
   
   Output    Output
Line 195  char *port_str;
Line 192  char *port_str;
   the original socket is always closed.    the original socket is always closed.
 */  */
   
 int try_accept(s)  int try_accept(int af_unix,int s)
 int s;  
 {  {
         union {    int len,c,i;
                 struct sockaddr sa;    struct sockaddr_in sin;
                 char data[SOCK_MAXADDRLEN];  
         } dummy;  
         socklen_t len;  
         int c, i;  
   
         len = SOCK_MAXADDRLEN;  #if !defined(VISUAL) && !defined(__MINGW32__)
         if (getsockname(s, (struct sockaddr *)dummy.data, &len) < 0) {    struct sockaddr_un s_un;
                 close(s);    if ( af_unix ) {
                 return (-1)      len = sizeof(s_un);
         }      for ( c = -1, i = 0; (c < 0)&&(i = 10) ; i++ )
         c = accept(s, (struct sockaddr *) &s_un, &len);
     } else
   #endif
     {
   
         for (i = 0 ; i < 10 ; i++) {      len = sizeof(sin);
                 c = accept(s, &(dummy.sa), &len);      for ( c = -1, i = 0; (c < 0)&&(i = 10) ; i++ )
                 if (c >= 0) {        c = accept(s, (struct sockaddr *) &sin, &len);
                         close(s);    }
                         return (c);    if ( i == 10 )
                 }      c = -1;
         }    closesocket(s);
     return c;
         close(s);  
         return (-1);  
 }  }
   
 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 addrinfo hints, *res, *ai;    struct sockaddr_in sin;
         int s, error, i;    struct sockaddr *saddr;
         char *errstr;    struct hostent *hp;
     int len,s,i;
   #if !defined(VISUAL) && !defined(__MINGW32__)
     struct sockaddr_un s_un;
   #endif
   
         memset(&hints, 0, sizeof(hints));    for ( i = 0; i < 10; i++ ) {
 #if defined(VISUAL)  #if !defined(VISUAL) && !defined(__MINGW32__)
         hints.ai_family = PF_UNSPEC;      if ( use_unix ) {
         if ( (s = socket(AF_UNIX,SOCK_STREAM,0)) < 0 ) {
           perror("socket");
           return -1;
         }
         bzero(&s_un,sizeof(s_un));
         s_un.sun_family = AF_UNIX;
         strcpy(s_un.sun_path,port_str);
   #if defined(__FreeBSD__)
         len = SUN_LEN(&s_un);
         s_un.sun_len = len+1; /* XXX */
 #else  #else
         if (use_unix)        len = strlen(s_un.sun_path)+sizeof(s_un.sun_family);
                 hints.ai_family = PF_UNIX;  #endif
         else        saddr = (struct sockaddr *)&s_un;
                 hints.ai_family = PF_UNSPEC;      } else
 #endif /* VISUAL */  #endif /* VISUAL */
         hints.ai_socktype = SOCK_STREAM;      {
         if ( !host )
         error = getaddrinfo(host, port_str, &hints, &res);          host = "127.0.0.1";
         if (error) {        if ( (s = socket(AF_INET,SOCK_STREAM,0)) < 0 ) {
                 warnx("try_connect: %s", gai_strerror(error));          perror("socket");
                 return (-1);          return -1;
         }        }
         for (i = 0 ; i < 10 ; i++) {        bzero(&sin,sizeof(sin));
                 for (ai = res ; ai != NULL ; ai = ai->ai_next) {        sin.sin_port = htons((unsigned short)atoi(port_str));
                         if ((s = socket(ai->ai_family, ai->ai_socktype,        sin.sin_addr.s_addr = inet_addr(host);
                                         ai->ai_protocol)) < 0 ) {        if ( sin.sin_addr.s_addr != -1 ) {
                                 errstr = "socket";          sin.sin_family = AF_INET;
                                 continue;        } else {
                         }          hp = gethostbyname(host);
                         if (connect(s, ai->ai_addr, ai->ai_addrlen) < 0) {          bcopy(hp->h_addr,&sin.sin_addr,hp->h_length);
                                 errstr = "connect";          sin.sin_family = hp->h_addrtype;
                                 close(s);        }
                                 s = -1;        len = sizeof(sin);
                                 continue;        saddr = (struct sockaddr *)&sin;
                         }      }
       if ( connect(s,saddr,len) >= 0 )
                         /* established a connection */        break;
                         break;      else {
                 }        closesocket(s);
   #if defined(VISUAL) || defined(__MINGW32__)
                 if (s >= 0) {        Sleep(100);
                         freeaddrinfo(res);  
                         return (s);  
                 }  
   
 #if defined(VISUAL)  
                 Sleep(100);  
 #else  #else
                 usleep(100000);        usleep(100000);
 #endif  #endif
         }      }
         freeaddrinfo(res);    }
     if ( i == 10 ) {
         perror(errstr);      perror("connect");
         return (-1);      return -1;
     } else
       return s;
 }  }
   
 #if 0  #if 0
 close_allconnections()  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  #else
 close_allconnections()  void close_allconnections()
 {  {
         shutdown_all();    shutdown_all();
 }  }
 #endif  #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;    extern int mpi_myid;
   
 #if MPI  #if defined(MPI)
         iofp[s1].s = s1;    iofp[s1].s = s1;
         if ( mpi_myid == s1 ) {    if ( mpi_myid == s1 ) {
                 iofp[s1].in = 0;      iofp[s1].in = 0;
                 iofp[s1].out = 0;      iofp[s1].out = 0;
         } else {    } else {
                 iofp[s1].in = WSIO_open(s1,"r");      iofp[s1].in = WSIO_open(s1,"r");
                 iofp[s1].out = WSIO_open(s1,"w");      iofp[s1].out = WSIO_open(s1,"w");
         }    }
         iofp[s1].conv = 0;    iofp[s1].conv = 0;
         iofp[s1].socket = 0;    iofp[s1].socket = 0;
   
         return s1;    return s1;
 #else  #else
         for ( i = 0; i < MAXIOFP; i++ )    for ( i = 0; i < MAXIOFP; i++ )
                 if ( !iofp[i].in )      if ( !iofp[i].in )
                         break;        break;
         iofp[i].s = s1;    iofp[i].s = s1;
 #if defined(VISUAL)  #if defined(VISUAL) || defined(__MINGW32__)
         iofp[i].in = WSIO_open(s1,"r");    iofp[i].in = WSIO_open(s1,"r");
         iofp[i].out = WSIO_open(s1,"w");    iofp[i].out = WSIO_open(s1,"w");
 #else  #else
         iofp[i].in = fdopen(s1,"r");    iofp[i].in = fdopen(s1,"r");
         iofp[i].out = fdopen(s1,"w");    iofp[i].out = fdopen(s1,"w");
         setbuffer(iofp[i].in,(char *)malloc(LBUFSIZ),LBUFSIZ);  #if !defined(__CYGWIN__)
         setbuffer(iofp[i].out,(char *)malloc(LBUFSIZ),LBUFSIZ);    setbuffer(iofp[i].in,iofp[i].inbuf = (char *)MALLOC_ATOMIC(LBUFSIZ),LBUFSIZ);
     setbuffer(iofp[i].out,iofp[i].outbuf = (char *)MALLOC_ATOMIC(LBUFSIZ),LBUFSIZ);
 #endif  #endif
         if ( little_endian )  
                 c = 1;  
         else  
                 c = 0xff;  
         if ( is_server ) {  
                 /* 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);  
                 /* special care for a failure of spawing a server */  
                 if ( rc !=0 && rc != 1 && rc != 0xff )  
                         return -1;  
                 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;  
         return i;  
 #endif  #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.9.2.2  
changed lines
  Added in v.1.29
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>