git.sesse.net Git - rdpsrv/blob - Xserver/lib/xtrans/Xtransos2.c

   1 /* $XFree86: xc/lib/xtrans/Xtransos2.c,v 3.5 1997/01/28 10:53:32 dawes Exp $ */
   2
   3 /*
   4  * (c) Copyright 1996 by Sebastien Marineau and Holger Veit
   5  *                      <marineau@genie.uottawa.ca>
   6  *                      <Holger.Veit@gmd.de>
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the "Software"),
  10  * to deal in the Software without restriction, including without limitation
  11  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12  * and/or sell copies of the Software, and to permit persons to whom the
  13  * Software is furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21  * HOLGER VEIT  BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  23  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24  * SOFTWARE.
  25  *
  26  * Except as contained in this notice, the name of Sebastien Marineau or Holger Veit shall not be
  27  * used in advertising or otherwise to promote the sale, use or other dealings
  28  * in this Software without prior written authorization from Holger Veit or Sebastien Marineau.
  29  *
  30  */
  31
  32 /* Implementation of the OS/2 local pipe transport layer */
  33
  34 #define INCL_DOSNMPIPES
  35 #define INCL_DOSPROCESS
  36 #define INCL_DOSERRORS
  37 #define INCL_DOSFILEMGR
  38 #undef BYTE
  39 #undef BOOL
  40 #include <os2.h>
  41
  42 #ifdef XSERV_t
  43 extern HEV hPipeSem;
  44 BOOL init_server_pipes();
  45 #endif
  46
  47 /*************************************************************************
  48  * Independent Layer
  49  *************************************************************************/
  50 #ifdef TRANS_CLIENT
  51
  52 static XtransConnInfo
  53 TRANS(Os2OpenClient)(thistrans, protocol, host, port)
  54 Xtransport *thistrans;
  55 char *protocol;
  56 char *host;
  57 char *port;
  58 {
  59         APIRET rc;
  60         HFILE hfd,hServer;
  61         ULONG action,byteWritten,State;
  62         char pipename[256],clientname[256];
  63         char server_string[256];
  64         struct sockaddr *addr_name;
  65         unsigned char pipe_len;
  66         XtransConnInfo ciptr;
  67         static int unique_id=0;
  68         int i,namelen,try;
  69
  70         PRMSG(2,"Os2OpenClient(%s,%s,%s)\n",protocol,host,port);
  71
  72         /* test, whether the host is really local, i.e. either
  73          * "os2" or "local"
  74          */
  75         if (strcmp(protocol,"os2") && strcmp(protocol,"local")) {
  76                 PRMSG (1,
  77                         "Os2OpenClient: Cannot connect to non-local host %s\n",
  78                         host, 0, 0);
  79                 return NULL;
  80         }
  81
  82    /* make the pipename */
  83
  84     if (port && *port ) {
  85         if( *port == '/' ) { /* A full pathname */
  86                 (void) sprintf(pipename, "\\PIPE\\X\\%s,", port);
  87             } else {
  88                 (void) sprintf(pipename, "%s%s", "\\PIPE\\X\\xf86.", port);
  89             }
  90     } else {
  91         (void) sprintf(pipename, "\\PIPE\\X\\xfree86"); }
  92
  93     PRMSG(5, "Os2OpenClient: Creating pipe %s\n",pipename, 0,0 );
  94
  95         /* make a connection entry */
  96         if( (ciptr=(XtransConnInfo)xcalloc(1,sizeof(struct _XtransConnInfo))) == NULL ) {
  97                 PRMSG(1,"Os2OpenClient: calloc(1,%d) failed\n",
  98                         sizeof(struct _XtransConnInfo),0,0 );
  99                 return NULL;
 100         }
 101
 102         /* open the pipe. Try ten times before giving up at 500ms intervals*/
 103     try = 0;
 104     do {
 105         rc = DosOpen(pipename,&hServer, &action, 0,
 106                 FILE_NORMAL, FILE_OPEN,
 107                 OPEN_ACCESS_WRITEONLY | OPEN_SHARE_DENYWRITE,
 108                 (PEAOP2)NULL);
 109         if(rc == 0) break;
 110         if (try >=10) {
 111                 PRMSG(1,"Os2OpenClient: Open server pipe %s failed, rc=%d\n",
 112                         pipename,rc,0 );
 113                 PRMSG(1,"\tProbable causes: either the XServer is not running, or has not started properly,\n",
 114                         0,0,0 );
 115                 PRMSG(1,"\tor the DISPLAY variable is set incorrectly.\n",
 116                         0,0,0 );
 117                 xfree(ciptr);
 118                 return NULL;
 119             }
 120        try ++;
 121        DosSleep(500);
 122        } while (rc != 0);
 123
 124 /* OK, now we are talking to the server. Generate a unique pipe name and pass it to
 125  * the server. Make the pipe and wait for server to connect */
 126
 127    sprintf(clientname,"\\PIPE\\X\\%d.%d",getpid(),unique_id++);
 128
 129    rc = DosCreateNPipe (clientname, &hfd,
 130                        NP_NOINHERIT | NP_ACCESS_DUPLEX,
 131                        1 | NP_NOWAIT | NP_TYPE_BYTE | NP_READMODE_BYTE,
 132                        16384, 16384, 0);
 133    if (rc != 0){
 134         PRMSG(1, "Os2OpenClient: Unable to create pipe %s\n", pipename,0,0 );
 135         DosClose(hfd);
 136         pipe_len=0;
 137         DosWrite(hServer,&pipe_len,1,&byteWritten);
 138         DosClose(hServer);
 139         xfree(ciptr);
 140         return(NULL);
 141     }
 142
 143  /* Connect to the pipe. */
 144
 145   rc = DosConnectNPipe (hfd);
 146   if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
 147     {
 148         PRMSG(1, "Os2OpenClient: Unable to connect to pipe %s\n", pipename,0,0 );
 149         DosClose (hfd);
 150         DosClose(hServer);
 151         xfree(ciptr);
 152         return (NULL);
 153     }
 154
 155 /* Now write name to server on hServer */
 156         server_string[0]=(char) strlen(clientname)+1;
 157         strcpy(&server_string[1],clientname);
 158         rc = DosWrite(hServer,server_string,(ULONG)server_string[0]+1,&byteWritten);
 159         if(rc != 0){  /* Could not write to server pipe? */
 160            PRMSG(1, "Os2OpenClient: Error writing to server pipe, handle=%d, rc=%d, w=%d\n",
 161                 hServer,rc,byteWritten );
 162            DosClose(hServer);
 163            DosClose(hfd);
 164            xfree(ciptr);
 165            return(NULL);
 166            }
 167
 168       PRMSG (5, "Os2OpenCLient: Wrote pipename %s to server; len %d written %d \n",
 169         &server_string[1],server_string[0]+1,byteWritten);
 170
 171
 172 /* The server will respond by opening the pipe. Wait for that for 30 secs */
 173
 174         i=0;
 175         DosSleep(50);  /* Give it time to catch up but minimize race condition*/
 176         rc = DosConnectNPipe(hfd);
 177         while((rc == ERROR_PIPE_NOT_CONNECTED)&&(i++<60)) {
 178                 DosSleep(500);
 179                 rc = DosConnectNPipe(hfd);
 180                 }
 181
 182         if(rc != 0){  /* Server has not responded! */
 183            PRMSG(1, "Os2OpenClient: Timeout on wait for server response, handle=%d, rc=%d\n",hServer,rc,0 );
 184            PRMSG(1, "\tProbable cause: the XServer has exited or crashed while the connection was being established\n",0,0,0 );
 185            PRMSG(1, "\tor the XServer is too busy to respond.\n",0,0,0 );
 186            DosClose(hServer);
 187            DosClose(hfd);
 188            xfree(ciptr);
 189            return(NULL);
 190            }
 191
 192 /* OK, the server has connected! Fill-in the info and return */
 193
 194         DosClose(hServer);
 195
 196 /* Last check: make sure client is connected! */
 197
 198         rc = DosQueryNPHState(hfd,&State);
 199         if(rc != 0){  /* Client is not connected! */
 200            PRMSG(1, "Os2OpenClient: Client pipe does not appear connected. rc=%d, h=%d\n",rc,hfd,0 );
 201            PRMSG(1, "\tProbable cause: the XServer has just exited.\n",0,0,0 );
 202            DosClose(hfd);
 203            xfree(ciptr);
 204            return(NULL);
 205            }
 206
 207         namelen=sizeof(struct sockaddr);
 208         if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
 209           {
 210                 PRMSG (1, "Os2OpenClient: Can't allocate space for the addr\n",
 211                 0, 0, 0);
 212                 DosClose(hfd);
 213                 xfree(ciptr);
 214                 return(NULL);
 215            }
 216         ciptr->addrlen = namelen;
 217         ((struct sockaddr *)ciptr->addr)->sa_family = AF_UNIX;
 218         strcpy(((struct sockaddr *)ciptr->addr)->sa_data, "local");
 219
 220         if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
 221           {
 222                 PRMSG (1, "Os2OpenCLient: Can't allocate space for the addr\n",
 223                 0, 0, 0);
 224                 DosClose(hfd);
 225                 xfree(ciptr->addr);
 226                 xfree(ciptr);
 227                 return(NULL);
 228            }
 229        ciptr->peeraddrlen = namelen;
 230        ((struct sockaddr *)ciptr->peeraddr)->sa_family = AF_UNIX;
 231        strcpy (((struct sockaddr *)ciptr->peeraddr)->sa_data,"local");
 232
 233        PRMSG (5, "Os2OpenCLient: Filled in struct: len %d %d name %s\n",
 234                 ciptr->addrlen,ciptr->peeraddrlen,((struct sockaddr *)ciptr->peeraddr)->sa_data);
 235
 236
 237         ciptr->index=hfd;
 238         ciptr->family=AF_UNIX;
 239         if((ciptr->fd=_imphandle(hfd))<0){
 240            PRMSG(1, "Os2OpenClient: Could not import the pipe handle into EMX\n",0,0,0 );
 241            PRMSG(1, "\tProbable cause: EMX has run out of free file handles.\n",0,0,0 );
 242            DosClose(hfd);
 243            xfree(ciptr->addr);
 244            xfree(ciptr->peeraddr);
 245            xfree(ciptr);
 246            return(NULL);
 247            }
 248     PRMSG(5, "Os2OpenClient: pipe handle %d EMX handle %d\n",ciptr->index,ciptr->fd,0 );
 249         fcntl(ciptr->fd,F_SETFL,O_NDELAY);
 250         fcntl(ciptr->fd,F_SETFD,FD_CLOEXEC);
 251         return ciptr;
 252 }
 253 #endif /* TRANS_CLIENT */
 254
 255 #ifdef TRANS_SERVER
 256 static XtransConnInfo
 257 TRANS(Os2OpenServer)(thistrans, protocol, host, port)
 258 Xtransport *thistrans;
 259 char *protocol;
 260 char *host;
 261 char *port;
 262 {
 263    APIRET rc;
 264    HFILE hfd;
 265    ULONG action;
 266    char pipename[256];
 267    struct sockaddr *addr_name;
 268    XtransConnInfo ciptr;
 269    int namelen;
 270
 271 #ifdef XSERV_t
 272     if (! init_server_pipes()) return(NULL);
 273 #endif
 274
 275     PRMSG(2,"Os2OpenServer(%s,%s,%s)\n",protocol,host,port);
 276
 277    if( (ciptr=(XtransConnInfo)xcalloc(1,sizeof(struct _XtransConnInfo))) == NULL )
 278     {
 279         PRMSG(1,"Os2OpenServer: xcalloc(1,%d) failed\n",
 280               sizeof(struct _XtransConnInfo),0,0 );
 281         return NULL;
 282     }
 283
 284
 285     if (port && *port ) {
 286         if( *port == '/' ) { /* A full pathname */
 287                 (void) sprintf(pipename, "\\PIPE\\X\\%s", port);
 288             } else {
 289                 (void) sprintf(pipename, "%s%s", "\\PIPE\\X\\xf86.", port);
 290             }
 291     } else {
 292         (void) sprintf(pipename, "\\PIPE\\X\\xfree86");
 293     }
 294
 295     PRMSG(5, "Os2OpenServer: Creating pipe %s\n",pipename, 0,0 );
 296
 297    rc = DosCreateNPipe (pipename, &hfd,
 298                        NP_NOINHERIT | NP_ACCESS_INBOUND,
 299                        1 | NP_NOWAIT | NP_TYPE_BYTE | NP_READMODE_BYTE,
 300                        0, 8192, 0);
 301    if (rc != 0){
 302         PRMSG(1, "Os2OpenServer: Unable to create pipe %s, rc=%d\n", pipename,rc,0 );
 303         PRMSG(1, "\tProbable cause: there is already another XServer running on display :%s\n",port,0,0 );
 304         DosClose(hfd);
 305         xfree(ciptr);
 306         return(NULL);
 307     }
 308
 309  /* Connect to the pipe. */
 310
 311   rc = DosConnectNPipe (hfd);
 312   if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
 313     {
 314         PRMSG(1, "Os2OpenServer: Unable to connect to pipe %s\n", pipename,0,0 );
 315         DosClose (hfd);
 316         xfree(ciptr);
 317         return (NULL);
 318     }
 319
 320 /* Pipe is now connected and waiting for client connect */
 321
 322 /*** Put in info ***/
 323
 324         namelen=sizeof(struct sockaddr);
 325         if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
 326           {
 327                 PRMSG (1, "Os2OpenServer: Can't allocate space for the addr\n",
 328                 0, 0, 0);
 329                 DosClose(hfd);
 330                 xfree(ciptr);
 331                 return(NULL);
 332            }
 333         ciptr->addrlen = namelen;
 334         ((struct sockaddr *)ciptr->addr)->sa_family = AF_UNIX;
 335         strcpy (((struct sockaddr *)ciptr->addr)->sa_data, "local");
 336
 337         if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
 338           {
 339                 PRMSG (1, "Os2OpenServer: Can't allocate space for the addr\n",
 340                 0, 0, 0);
 341                 DosClose(hfd);
 342                 xfree(ciptr->addr);
 343                 xfree(ciptr);
 344                 return(NULL);
 345            }
 346
 347        ciptr->peeraddrlen = namelen;
 348        ((struct sockaddr *)ciptr->peeraddr)->sa_family = AF_UNIX;
 349        strcpy(((struct sockaddr *)ciptr->peeraddr)->sa_data,"local");
 350
 351       PRMSG (5, "Os2OpenServer: Filled in struct: len %d %d name %s\n",
 352                 ciptr->addrlen,ciptr->peeraddrlen,((struct sockaddr *)ciptr->peeraddr)->sa_data);
 353
 354     ciptr->index=hfd; /* Save this for later use in this unused member of struct */
 355     ciptr->flags=1;     /* Listener */
 356     ciptr->family=AF_UNIX;
 357
 358     if((ciptr->fd=_imphandle(hfd))<0){
 359        DosClose(hfd);
 360        xfree(ciptr->addr);
 361        xfree(ciptr->peeraddr);
 362        xfree(ciptr);
 363        return(NULL);
 364        }
 365     PRMSG(5, "Os2OpenServer: Pipe handle %d EMX handle %d",ciptr->index,ciptr->fd,0 );
 366
 367 #ifdef XSERV_t
 368 /* Attach the pipe sem to the pipe. Use handle index as key */
 369     rc = DosSetNPipeSem(ciptr->fd, (HSEM)hPipeSem, ciptr->fd);
 370     if (rc){
 371         PRMSG(1, "Os2OpenCOTSServer: Could not attach sem %d to pipe %d, rc=%d\n",
 372                  hPipeSem,ciptr->fd,rc);
 373         DosClose(ciptr->fd);
 374         xfree(ciptr->addr);
 375         xfree(ciptr->peeraddr);
 376         xfree(ciptr);
 377          return(NULL);
 378         }
 379 #endif
 380
 381     fcntl(ciptr->fd,F_SETFL,O_NDELAY);
 382     fcntl(ciptr->fd,F_SETFD,FD_CLOEXEC);
 383     return(ciptr);
 384 }
 385 #endif /* TRANS_SERVER */
 386
 387 #ifdef TRANS_CLIENT
 388 static XtransConnInfo
 389 TRANS(Os2OpenCLTSClient)(thistrans, protocol, host, port)
 390 Xtransport *thistrans;
 391 char *protocol;
 392 char *host;
 393 char *port;
 394 {
 395         PRMSG(2,"Os2OpenCLTSClient(%s,%s,%s)\n",protocol,host,port);
 396         return TRANS(Os2OpenClient)(thistrans, protocol, host, port);
 397 }
 398 #endif /* TRANS_CLIENT */
 399
 400 #ifdef TRANS_CLIENT
 401 static XtransConnInfo
 402 TRANS(Os2OpenCOTSClient)(thistrans, protocol, host, port)
 403 Xtransport *thistrans;
 404 char *protocol;
 405 char *host;
 406 char *port;
 407 {
 408         PRMSG(2,"Os2OpenCOTSClient(%s,%s,%s)\n",protocol,host,port);
 409         return TRANS(Os2OpenClient)(thistrans, protocol, host, port);
 410 }
 411 #endif /* TRANS_CLIENT */
 412
 413
 414 #ifdef TRANS_SERVER
 415 static XtransConnInfo
 416 TRANS(Os2OpenCLTSServer)(thistrans, protocol, host, port)
 417 Xtransport *thistrans;
 418 char *protocol;
 419 char *host;
 420 char *port;
 421 {
 422         PRMSG(2,"Os2OpenCLTSServer(%s,%s,%s)\n",protocol,host,port);
 423         return TRANS(Os2OpenServer)(thistrans, protocol, host, port);
 424 }
 425 #endif /* TRANS_SERVER */
 426
 427
 428 #ifdef TRANS_SERVER
 429 static XtransConnInfo
 430 TRANS(Os2OpenCOTSServer)(thistrans, protocol, host, port)
 431 Xtransport *thistrans;
 432 char *protocol;
 433 char *host;
 434 char *port;
 435 {
 436         PRMSG(2,"Os2OpenCOTSServer(%s,%s,%s)\n",protocol,host,port);
 437         return TRANS(Os2OpenServer)(thistrans, protocol, host, port);
 438 }
 439 #endif /* TRANS_SERVER */
 440
 441
 442 #ifdef TRANS_REOPEN
 443 static XtransConnInfo
 444 TRANS(Os2ReopenCOTSServer)(thistrans, fd, port)
 445 Xtransport *thistrans;
 446 int        fd;
 447 char       *port;
 448 {
 449
 450     XtransConnInfo ciptr;
 451     char addr_name[256];
 452     int namelen;
 453
 454     PRMSG(2,"Os2ReopenCOTSServer(%d,%s)\n", fd, port, 0);
 455
 456     if( (ciptr=(XtransConnInfo)xcalloc(1,sizeof(struct _XtransConnInfo))) == NULL )
 457     {
 458         PRMSG(1,"Os2ReopenCOTSServer: xcalloc(1,%d) failed\n",
 459               sizeof(struct _XtransConnInfo),0,0 );
 460         return NULL;
 461     }
 462
 463         strcpy(addr_name,"local");
 464         namelen=sizeof(addr_name);
 465         if ((ciptr->addr = (char *) xalloc (namelen)) == NULL)
 466           {
 467                 PRMSG (1, "Os2ReopenCOTSServer: Can't allocate space for the addr\n",
 468                 0, 0, 0);
 469                 xfree(ciptr);
 470                 return(NULL);
 471            }
 472
 473         ciptr->addrlen = namelen;
 474         memcpy (ciptr->addr, addr_name, ciptr->addrlen);
 475         if ((ciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
 476           {
 477                 PRMSG (1, "Os2ReopenCOTSServer: Can't allocate space for the addr\n",
 478                 0, 0, 0);
 479                 xfree(ciptr);
 480                 return(NULL);
 481            }
 482
 483        ciptr->peeraddrlen = namelen;
 484        memcpy (ciptr->peeraddr,addr_name, ciptr->addrlen);
 485
 486     ciptr->fd = fd;
 487     ciptr->family=AF_UNIX;
 488     ciptr->flags=1;
 489     PRMSG(1,"Os2ReopenCOTSServer: Filled-in info for handle %d on port %s.\n", fd, port, 0);
 490
 491     return(ciptr);
 492 }
 493
 494 static XtransConnInfo
 495 TRANS(Os2ReopenCLTSServer)(thistrans, fd, port)
 496 Xtransport *thistrans;
 497 int        fd;
 498 char       *port;
 499 {
 500     PRMSG(2,"Os2ReopenCLTSServer(%d,%s)\n", fd, port, 0);
 501     return TRANS(Os2ReopenCOTSServer)(thistrans, fd, port);
 502 }
 503 #endif
 504
 505 static
 506 TRANS(Os2SetOption)(ciptr, option, arg)
 507 XtransConnInfo ciptr;
 508 int option;
 509 int arg;
 510 {
 511     PRMSG(2,"Os2SetOption(%d,%d,%d)\n",ciptr->fd,option,arg);
 512     return -1;
 513 }
 514
 515 #ifdef TRANS_SERVER
 516
 517 static
 518 TRANS(Os2CreateListener)(ciptr, port)
 519 XtransConnInfo ciptr;
 520 char *port;
 521 {
 522         PRMSG(2,"Os2CreateListener(%x->%d,%s)\n",ciptr,ciptr->fd,port);
 523         return 0;
 524 }
 525
 526 static XtransConnInfo
 527 TRANS(Os2Accept)(ciptr, status)
 528 XtransConnInfo ciptr;
 529 int            *status;
 530 {
 531     XtransConnInfo      newciptr;
 532     HFILE hClient;
 533     unsigned char length;
 534     ULONG action;
 535     char clientname[256];
 536     struct sockaddr *addr_name;
 537     int in,namelen;
 538     APIRET rc;
 539
 540
 541     PRMSG(2,"Os2Accept(%x->%d)\n", ciptr, ciptr->fd,0);
 542     if( (newciptr=(XtransConnInfo)xcalloc(1,sizeof(struct _XtransConnInfo)))==NULL )
 543     {
 544         PRMSG(1,"Os2Accept: xcalloc(1,%d) failed\n",
 545               sizeof(struct _XtransConnInfo),0,0 );
 546         *status = TRANS_ACCEPT_BAD_MALLOC;
 547         return NULL;
 548     }
 549
 550 /* Read in length of client pipe name. If fails, then reset server pipe */
 551     if((in=read(ciptr->fd,&length,1))<=0){
 552         PRMSG(2,"Os2Accept: Error reading incoming connection, in=%d, error=%d\n",
 553               in,errno,0 );
 554         *status = TRANS_ACCEPT_MISC_ERROR;
 555         xfree(newciptr);
 556         rc = DosDisConnectNPipe(ciptr->fd);
 557         rc = DosConnectNPipe (ciptr->fd);
 558         if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
 559         {
 560                 PRMSG(1, "Os2Accept: Unable to reconnect server pipe %d\n", ciptr->fd,0,0 );
 561                 }
 562         return NULL;
 563         }
 564         PRMSG(5, "Os2Accept: Bytes to read for name: %d\n",length,0,0 );
 565
 566
 567 /* Check length for valid length ?? */
 568
 569 /* Now read in length bytes from pipe for client pipe name */
 570     if((in=read(ciptr->fd,clientname,length))<=0){
 571         PRMSG(2,"Os2Accept: Error reading incoming connection, in=%d, error=%d\n",
 572               in,errno,0 );
 573         *status = TRANS_ACCEPT_MISC_ERROR;
 574         xfree(newciptr);
 575         rc = DosDisConnectNPipe(ciptr->fd);
 576         rc = DosConnectNPipe (ciptr->fd);
 577         if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
 578         {
 579                 PRMSG(1, "Os2Accept: Unable to reconnect server pipe %d\n", ciptr->fd,0,0 );
 580                 }
 581         return NULL;
 582         }
 583     clientname[length]='\0';
 584     PRMSG(5, "Os2Accept: Server name %s length %d\n",clientname,length,0 );
 585
 586
 587 /* Now we have the client pipe name. Open it with DosOpen  */
 588
 589      rc = DosOpen(clientname,&hClient, &action, 0,
 590            FILE_NORMAL, FILE_OPEN,
 591            OPEN_FLAGS_NOINHERIT | OPEN_ACCESS_READWRITE | OPEN_SHARE_DENYREADWRITE,
 592            (PEAOP2)NULL);
 593
 594      PRMSG(5, "Os2Accept: Open pipe %s, handle = %d, rc=%d\n",clientname,hClient,rc );
 595
 596        if (rc) {
 597             PRMSG(1,"Os2Accept: Open pipe %s to client failed, rc=%d\n",
 598             clientname,rc,0 );
 599             PRMSG(1, "\tProbable cause: the client has exited or timed-out.\n",0,0,0 );
 600             xfree(newciptr);
 601             rc = DosDisConnectNPipe(ciptr->fd);
 602             rc = DosConnectNPipe (ciptr->fd);
 603             if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
 604                {
 605                    PRMSG(1, "Os2Accept: Unable to reconnect server pipe %d\n", ciptr->fd,0,0 );
 606                    }
 607             return NULL;
 608             }
 609
 610         rc = DosSetNPHState (hClient, NP_NOWAIT | NP_READMODE_BYTE);
 611         if (rc != 0)
 612         {
 613             PRMSG(1,"Os2Accept: Could not set pipe %s to non-blocking mode, rc=%d\n",
 614             hClient,rc,0 );
 615             xfree(newciptr);
 616             rc = DosDisConnectNPipe(ciptr->fd);
 617             rc = DosConnectNPipe (ciptr->fd);
 618             if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
 619                {
 620                    PRMSG(1, "Os2Accept: Unable to reconnect server pipe %d\n", ciptr->fd,0,0 );
 621                    }
 622             return NULL;
 623             }
 624
 625 /* OK, we seem to be well connected to client. Now disconnect server pipe and put again in listen */
 626
 627          rc = DosDisConnectNPipe(ciptr->fd);
 628          rc = DosConnectNPipe (ciptr->fd);
 629         PRMSG(5, "Os2Accept: Reconnecting server pipe %d, rc = %d\n",ciptr->fd,rc,0 );
 630
 631          if (rc != 0 && rc != ERROR_PIPE_NOT_CONNECTED)
 632          {
 633               PRMSG(1, "Os2Accept: Unable to reconnect server pipe %d\n", ciptr->fd,0,0 );
 634               }  /* Consider this non-fatal for present connection */
 635
 636 /* And finally fill-in info in newciptr */
 637
 638         namelen=sizeof(struct sockaddr);
 639         if ((newciptr->addr = (char *) xalloc (namelen)) == NULL)
 640           {
 641                 PRMSG (1, "Os2Accept: Can't allocate space for the addr\n",
 642                 0, 0, 0);
 643                 DosClose(hClient);
 644                 xfree(newciptr);
 645                 return(NULL);
 646            }
 647
 648         newciptr->addrlen = namelen;
 649         ((struct sockaddr *)newciptr->addr)->sa_family = AF_UNIX;
 650         strcpy (((struct sockaddr *)newciptr->addr)->sa_data, "local");
 651
 652         if ((newciptr->peeraddr = (char *) xalloc (namelen)) == NULL)
 653           {
 654                 PRMSG (1, "Os2Accept: Can't allocate space for the addr\n",
 655                 0, 0, 0);
 656                 DosClose(hClient);
 657                 xfree(ciptr->addr);
 658                 xfree(newciptr);
 659                 return(NULL);
 660            }
 661
 662        newciptr->peeraddrlen = namelen;
 663        ((struct sockaddr *)newciptr->peeraddr)->sa_family = AF_UNIX;
 664        strcpy (((struct sockaddr *)newciptr->peeraddr)->sa_data, "local");
 665
 666       PRMSG (5, "Os2Accept: Filled in struct: len %d %d name %s\n",
 667                 newciptr->addrlen,newciptr->peeraddrlen,newciptr->peeraddr);
 668
 669
 670         newciptr->index=hClient;
 671         newciptr->family=AF_UNIX;
 672         if((newciptr->fd=_imphandle(hClient))<0){
 673            PRMSG(1,"Os2Accept: Could not import pipe %d into EMX, errno=%d\n",
 674            hClient,errno,0 );
 675            PRMSG(1, "\tProbable cause: EMX has run out of file handles.\n",0,0,0 );
 676            DosClose(hClient);
 677            xfree(newciptr->addr);
 678            xfree(newciptr->peeraddr);
 679            xfree(newciptr);
 680            return(NULL);
 681            }
 682     PRMSG(5, "Os2Accept: Pipe handle %d EMX handle %d",newciptr->index,newciptr->fd,0 );
 683
 684 #ifdef XSERV_t
 685 /* Attach the pipe sem to the pipe. Use handle index as key */
 686     rc = DosSetNPipeSem(newciptr->fd, (HSEM)hPipeSem, newciptr->fd);
 687     if (rc){
 688         PRMSG(1, "Os2OpenCOTSServer: Could not attach sem %d to pipe %d, rc=%d\n",
 689                  hPipeSem,newciptr->fd,rc);
 690         DosClose(newciptr->fd);
 691         xfree(newciptr->addr);
 692         xfree(newciptr->peeraddr);
 693         xfree(newciptr);
 694          return(NULL);
 695         }
 696 #endif
 697
 698     fcntl(ciptr->fd,F_SETFL,O_NDELAY);
 699     fcntl(ciptr->fd,F_SETFD,FD_CLOEXEC);
 700     *status=0;
 701     return newciptr;
 702 }
 703
 704 #endif /* TRANS_SERVER */
 705
 706 #ifdef TRANS_CLIENT
 707
 708 static
 709 TRANS(Os2Connect)(ciptr, host, port)
 710 XtransConnInfo ciptr;
 711 char *host;
 712 char *port;
 713 {
 714     PRMSG(2,"Os2Connect(%x->%d,%s)\n", ciptr, ciptr->fd, port);
 715     return 0;
 716 }
 717
 718 #endif /* TRANS_CLIENT */
 719
 720 static int
 721 TRANS(Os2BytesReadable)(ciptr, pend )
 722 XtransConnInfo ciptr;
 723 BytesReadable_t *pend;
 724 {
 725    ULONG rc, state, nread;
 726   AVAILDATA avail;
 727   char buffer;
 728
 729   PRMSG(2,"Os2BytesReadable(%x->%d,%x)\n", ciptr, ciptr->fd, pend);
 730
 731   rc = DosPeekNPipe (ciptr->fd, &buffer, 0, &nread, &avail, &state);
 732   if (rc != 0)
 733     {
 734       errno = EPIPE;
 735       *pend = 0;
 736       return -1;
 737     }
 738   if (state == NP_STATE_CLOSING)
 739      {
 740         errno = EPIPE;
 741         *pend = 0;
 742         return -1;
 743       }
 744   errno = 0;
 745   *pend = avail.cbpipe;
 746   return 0;
 747 }
 748
 749 static int
 750 TRANS(Os2Read)(ciptr, buf, size)
 751 XtransConnInfo ciptr;
 752 char *buf;
 753 int size;
 754 {
 755     int ret;
 756     APIRET rc;
 757     ULONG ulRead;
 758     PRMSG(2,"Os2Read(%d,%x,%d)\n", ciptr->fd, buf, size );
 759     errno = 0;
 760     rc = DosRead(ciptr->fd, buf, size, &ulRead);
 761     if (rc == 0){
 762         ret = ulRead;
 763         }
 764     else if ((rc == 232) || (rc == 231)){
 765         errno = EAGAIN;
 766         ret = -1;
 767         }
 768     else if (rc == 6){
 769         errno = EBADF;
 770         ret = -1;
 771         }
 772      else if ((rc == 109) || (rc == 230) || (rc == 233)){
 773         errno = EPIPE;
 774        ret = -1;
 775         }
 776     else {
 777            PRMSG(2,"Os2Read: Unknown return code from DosRead, fd %d rc=%d\n", ciptr->fd,rc,0 );
 778            errno = EINVAL;
 779            ret = -1;
 780            }
 781     return (ret);
 782 }
 783
 784 static int
 785 TRANS(Os2Write)(ciptr, buf, size)
 786 XtransConnInfo ciptr;
 787 char *buf;
 788 int size;
 789 {
 790     int ret;
 791     APIRET rc;
 792     ULONG nWritten;
 793     PRMSG(2,"Os2Write(%d,%x,%d)\n", ciptr->fd, buf, size );
 794     rc = DosWrite(ciptr->fd, buf, size, &nWritten);
 795     if (rc == 0){
 796          ret = nWritten;
 797          if(nWritten == 0) {
 798                  errno=EAGAIN;
 799                  ret = -1;
 800                  }
 801          }
 802     else if ((rc == 39) || (rc == 112)){
 803         errno = EAGAIN;
 804         ret = -1;
 805         }
 806     else if ((rc == 109) || (rc == 230) || (rc == 233)){
 807         errno = EPIPE;
 808         ret = -1;
 809         }
 810     else if (rc == 6){
 811          errno=EBADF;
 812          ret = -1;
 813          }
 814     else {
 815         PRMSG(2,"(Os2Write)Unknown return code from DosWrite, fd %d rc=%d\n", ciptr->fd,rc,0 );
 816         errno = EINVAL;
 817         ret = -1;
 818         }
 819     return (ret);
 820 }
 821
 822 static int
 823 TRANS(Os2Readv)(ciptr, buf, size)
 824 XtransConnInfo  ciptr;
 825 struct iovec    *buf;
 826 int             size;
 827 {
 828     int ret;
 829     PRMSG(2,"Os2Readv(%d,%x,%d)\n", ciptr->fd, buf, size );
 830     ret = READV(ciptr,buf,size);
 831     if ((ret <0) && (errno == EINVAL)) errno = EPIPE;
 832     return (ret);
 833 }
 834
 835 static int
 836 TRANS(Os2Writev)(ciptr, buf, size)
 837 XtransConnInfo  ciptr;
 838 struct iovec    *buf;
 839 int             size;
 840 {
 841     int ret;
 842     PRMSG(2,"Os2Writev(%d,%x,%d)\n", ciptr->fd, buf, size );
 843     ret = WRITEV(ciptr,buf,size);
 844     if ((ret <0) && (errno == EINVAL)) errno = EPIPE;
 845     if ((ret <0) && (errno == ENOSPC)) errno = EAGAIN;
 846     return (ret);
 847 }
 848
 849 static int
 850 TRANS(Os2Disconnect)(ciptr)
 851 XtransConnInfo ciptr;
 852 {
 853     PRMSG(2,"Os2Disconnect(%x->%d)\n", ciptr, ciptr->fd, 0);
 854     return 0;
 855 }
 856
 857 static int
 858 TRANS(Os2Close)(ciptr)
 859 XtransConnInfo ciptr;
 860 {
 861     int ret;
 862     PRMSG(2,"Os2Close(%x->%d)\n", ciptr, ciptr->fd ,0);
 863     ret=close(ciptr->fd);
 864     return ret;
 865 }
 866
 867 static int
 868 TRANS(Os2CloseForCloning)(ciptr)
 869 XtransConnInfo ciptr;
 870 {
 871     int ret;
 872
 873     PRMSG(2,"Os2CloseForCloning(%x->%d)\n", ciptr, ciptr->fd ,0);
 874     ret=close(ciptr->fd);
 875     return ret;
 876 }
 877
 878
 879 Xtransport      TRANS(OS2LocalFuncs) = {
 880         /* Local Interface */
 881         "local",
 882         TRANS_LOCAL,
 883 #ifdef TRANS_CLIENT
 884         TRANS(Os2OpenCOTSClient),
 885 #endif /* TRANS_CLIENT */
 886 #ifdef TRANS_SERVER
 887         TRANS(Os2OpenCOTSServer),
 888 #endif /* TRANS_SERVER */
 889 #ifdef TRANS_CLIENT
 890         TRANS(Os2OpenCLTSClient),
 891 #endif /* TRANS_CLIENT */
 892 #ifdef TRANS_SERVER
 893         TRANS(Os2OpenCLTSServer),
 894 #endif /* TRANS_SERVER */
 895 #ifdef TRANS_REOPEN
 896         TRANS(Os2ReopenCOTSServer),
 897         TRANS(Os2ReopenCLTSServer),
 898 #endif
 899         TRANS(Os2SetOption),
 900 #ifdef TRANS_SERVER
 901         TRANS(Os2CreateListener),
 902         NULL,                  /* ResetListener */
 903         TRANS(Os2Accept),
 904 #endif /* TRANS_SERVER */
 905 #ifdef TRANS_CLIENT
 906         TRANS(Os2Connect),
 907 #endif /* TRANS_CLIENT */
 908         TRANS(Os2BytesReadable),
 909         TRANS(Os2Read),
 910         TRANS(Os2Write),
 911         TRANS(Os2Readv),
 912         TRANS(Os2Writev),
 913         TRANS(Os2Disconnect),
 914         TRANS(Os2Close),
 915         TRANS(Os2CloseForCloning),
 916 };
 917
 918 #ifdef XSERV_t
 919 /* This function is used in the server to initialize the semaphore used with pipes */
 920
 921 BOOL init_server_pipes()
 922 {
 923    static BOOL first_time=TRUE;
 924    ULONG rc;
 925
 926    if(first_time){
 927         rc = DosCreateEventSem(NULL, &hPipeSem,DC_SEM_SHARED,FALSE);
 928         if (rc){
 929            PRMSG(1,"Os2OpenListener (init_server_pipes): Could not create pipe semaphore, rc=%d\n",
 930                 rc,0,0);
 931            return(FALSE);
 932            }
 933      first_time=FALSE;
 934      }
 935 return(TRUE);
 936 }
 937 #endif  /* XSERV_t */