WINGs/connection.c

   1 /*
   2  *  WINGs WMConnection function library
   3  *
   4  *  Copyright (c) 1999-2000 Dan Pascu
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21
  22 /*
  23  * TODO:
  24  * - decide if we want to support connections with external sockets, else
  25  *   clean up the structure of the unneeded members.
  26  * - decide what to do with all wwarning() calls that are still there.
  27  *
  28  */
  29
  30
  31 #include "../src/config.h"
  32 #include "wconfig.h"
  33
  34 #include <unistd.h>
  35 #include <fcntl.h>
  36 #include <stdio.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <stdarg.h>
  40 #include <errno.h>
  41 #include <sys/socket.h>
  42 #include <netinet/in.h>
  43 #include <arpa/inet.h>
  44 #include <netdb.h>
  45 #include <signal.h>
  46 #ifdef __FreeBSD__
  47 #include <sys/signal.h>
  48 #endif
  49
  50 #include "WINGs.h"
  51
  52
  53 /* Some older systems does not define this (linux libc5, maybe others too) */
  54 #ifndef SHUT_RDWR
  55 # define SHUT_RDWR              2
  56 #endif
  57
  58 /* For SunOS */
  59 #ifndef SA_RESTART
  60 # define SA_RESTART             0
  61 #endif
  62
  63 /* For Solaris */
  64 #ifndef INADDR_NONE
  65 # define INADDR_NONE           -1
  66 #endif
  67
  68 /* Stuff for setting the sockets into non-blocking mode. */
  69 /*#ifdef        __POSIX_SOURCE
  70 # define NONBLOCK_OPT           O_NONBLOCK
  71 #else
  72 # define NONBLOCK_OPT           FNDELAY
  73 #endif*/
  74
  75 #define NONBLOCK_OPT            O_NONBLOCK
  76
  77 #define NETBUF_SIZE             4096
  78
  79 #define DEF_TIMEOUT             600   /* 600 seconds == 10 minutes */
  80
  81
  82
  83 int WCErrorCode = 0;
  84
  85 static Bool SigInitialized = False;
  86
  87 static unsigned int DefaultTimeout = DEF_TIMEOUT;
  88 static unsigned int OpenTimeout = DEF_TIMEOUT;
  89
  90
  91
  92 typedef struct TimeoutData {
  93     unsigned timeout;
  94     WMHandlerID *handler;
  95 } TimeoutData;
  96
  97
  98 typedef struct W_Connection {
  99     int sock;                     /* the socket we speak through */
 100
 101     struct {
 102         WMHandlerID *read;        /* the input read handler */
 103         WMHandlerID *write;       /* the input write handler */
 104         WMHandlerID *exception;   /* the input exception handler */
 105     } handler;
 106
 107     ConnectionDelegate *delegate; /* client delegates */
 108     void *clientData;             /* client data */
 109     unsigned int uflags;          /* flags for the client */
 110
 111     WMArray *outputQueue;
 112     unsigned bufPos;
 113
 114     TimeoutData sendTimeout;
 115     TimeoutData openTimeout;
 116
 117     WMConnectionState state;
 118     WMConnectionTimeoutState timeoutState;
 119
 120     char *address;
 121     char *service;
 122     char *protocol;
 123
 124     Bool closeOnRelease;
 125     Bool wasNonBlocking;
 126     Bool isNonBlocking;
 127
 128 } W_Connection;
 129
 130
 131
 132 static void
 133 clearOutputQueue(WMConnection *cPtr) /*FOLD00*/
 134 {
 135     cPtr->bufPos = 0;
 136     WMEmptyArray(cPtr->outputQueue);
 137 }
 138
 139
 140 static void
 141 openTimeout(void *cdata) /*FOLD00*/
 142 {
 143     WMConnection *cPtr = (WMConnection*) cdata;
 144
 145     cPtr->openTimeout.handler = NULL;
 146     if (cPtr->handler.write) {
 147         WMDeleteInputHandler(cPtr->handler.write);
 148         cPtr->handler.write = NULL;
 149     }
 150     if (cPtr->state != WCConnected) {
 151         cPtr->state = WCTimedOut;
 152         cPtr->timeoutState = WCTWhileOpening;
 153         if (cPtr->delegate && cPtr->delegate->didTimeout) {
 154             (*cPtr->delegate->didTimeout)(cPtr->delegate, cPtr);
 155         } else {
 156             WMCloseConnection(cPtr);
 157             cPtr->state = WCTimedOut; /* the above set state to WCClosed */
 158         }
 159     }
 160 }
 161
 162
 163 static void
 164 sendTimeout(void *cdata) /*FOLD00*/
 165 {
 166     WMConnection *cPtr = (WMConnection*) cdata;
 167
 168     cPtr->sendTimeout.handler = NULL;
 169     if (cPtr->handler.write) {
 170         WMDeleteInputHandler(cPtr->handler.write);
 171         cPtr->handler.write = NULL;
 172     }
 173     if (WMGetArrayItemCount(cPtr->outputQueue)>0) {
 174         clearOutputQueue(cPtr);
 175         cPtr->state = WCTimedOut;
 176         cPtr->timeoutState = WCTWhileSending;
 177         if (cPtr->delegate && cPtr->delegate->didTimeout) {
 178             (*cPtr->delegate->didTimeout)(cPtr->delegate, cPtr);
 179         } else {
 180             WMCloseConnection(cPtr);
 181             cPtr->state = WCTimedOut; /* the above set state to WCClosed */
 182         }
 183     }
 184 }
 185
 186
 187 static void
 188 inputHandler(int fd, int mask, void *clientData) /*FOLD00*/
 189 {
 190     WMConnection *cPtr = (WMConnection*)clientData;
 191
 192     if (cPtr->state==WCClosed || cPtr->state==WCDied)
 193         return;
 194
 195     if ((mask & WIWriteMask)) {
 196         if (cPtr->state == WCInProgress) {
 197             Bool failed;
 198             int result;
 199             int len = sizeof(result);
 200
 201             WCErrorCode = 0;
 202             if (getsockopt(cPtr->sock, SOL_SOCKET, SO_ERROR,
 203                            (void*)&result, &len) == 0 && result != 0) {
 204                 cPtr->state = WCFailed;
 205                 WCErrorCode = result;
 206                 failed = True;
 207                 /* should call wsyserrorwithcode(result, ...) here? */
 208             } else {
 209                 cPtr->state = WCConnected;
 210                 failed = False;
 211             }
 212
 213             if (cPtr->handler.write) {
 214                 WMDeleteInputHandler(cPtr->handler.write);
 215                 cPtr->handler.write = NULL;
 216             }
 217
 218             if (cPtr->openTimeout.handler) {
 219                 WMDeleteTimerHandler(cPtr->openTimeout.handler);
 220                 cPtr->openTimeout.handler = NULL;
 221             }
 222
 223             if (cPtr->delegate && cPtr->delegate->didInitialize)
 224                 (*cPtr->delegate->didInitialize)(cPtr->delegate, cPtr);
 225
 226             /* we use failed and not cPtr->state here, because cPtr may be
 227              * destroyed by the delegate called above if the connection failed
 228              */
 229             if (failed)
 230                 return;
 231         } else if (cPtr->state == WCConnected) {
 232             WMFlushConnection(cPtr);
 233         }
 234     }
 235
 236     if (!cPtr->delegate)
 237         return;
 238
 239     /* if the connection died, may get destroyed in the delegate, so retain */
 240     wretain(cPtr);
 241
 242     if ((mask & WIReadMask) && cPtr->delegate->didReceiveInput)
 243         (*cPtr->delegate->didReceiveInput)(cPtr->delegate, cPtr);
 244
 245     if ((mask & WIExceptMask) && cPtr->delegate->didCatchException)
 246         (*cPtr->delegate->didCatchException)(cPtr->delegate, cPtr);
 247
 248     wrelease(cPtr);
 249 }
 250
 251
 252 static Bool
 253 setSocketNonBlocking(int sock, Bool flag) /*FOLD00*/
 254 {
 255     int state;
 256     Bool isNonBlock;
 257
 258     state = fcntl(sock, F_GETFL, 0);
 259
 260     if (state < 0) {
 261         /* set WCErrorCode here? -Dan*/
 262         return False;
 263     }
 264
 265     isNonBlock = (state & NONBLOCK_OPT) != 0;
 266
 267     if (flag) {
 268         if (isNonBlock)
 269             return True;
 270         state |= NONBLOCK_OPT;
 271     } else {
 272         if (!isNonBlock)
 273             return True;
 274         state &= ~NONBLOCK_OPT;
 275     }
 276
 277     if (fcntl(sock, F_SETFL, state) < 0) {
 278         /* set WCErrorCode here? -Dan*/
 279         return False;
 280     }
 281
 282     return True;
 283 }
 284
 285
 286 static void
 287 setConnectionAddress(WMConnection *cPtr, struct sockaddr_in *socketaddr) /*FOLD00*/
 288 {
 289     wassertr(cPtr->address==NULL);
 290
 291     cPtr->address = wstrdup(inet_ntoa(socketaddr->sin_addr));
 292     cPtr->service = wmalloc(16);
 293     sprintf(cPtr->service, "%hu", ntohs(socketaddr->sin_port));
 294     cPtr->protocol = wstrdup("tcp");
 295 }
 296
 297
 298 static struct sockaddr_in*
 299 getSocketAddress(char* name, char* service, char* protocol) /*FOLD00*/
 300 {
 301     static struct sockaddr_in socketaddr;
 302     struct servent *sp;
 303
 304     if (!protocol || protocol[0]==0)
 305         protocol = "tcp";
 306
 307     memset(&socketaddr, 0, sizeof(struct sockaddr_in));
 308     socketaddr.sin_family = AF_INET;
 309
 310     /*
 311      * If we were given a hostname, we use any address for that host.
 312      * Otherwise we expect the given name to be an address unless it is
 313      * NULL (any address).
 314      */
 315     if (name && name[0]!=0) {
 316         WMHost *host = WMGetHostWithName(name);
 317
 318         if (!host)
 319             return NULL; /* name is not a hostname nor a number and dot adr */
 320
 321         name = WMGetHostAddress(host);
 322 #ifndef HAVE_INET_ATON
 323         if ((socketaddr.sin_addr.s_addr = inet_addr(name)) == INADDR_NONE) {
 324 #else
 325         if (inet_aton(name, &socketaddr.sin_addr) == 0) {
 326 #endif
 327             WMReleaseHost(host);
 328             return NULL;
 329         }
 330         WMReleaseHost(host);
 331     } else {
 332         socketaddr.sin_addr.s_addr = htonl(INADDR_ANY);
 333     }
 334
 335     if (!service || service[0]==0) {
 336         socketaddr.sin_port = 0;
 337     } else if ((sp = getservbyname(service, protocol))==0) {
 338         char *endptr;
 339         unsigned portNumber;
 340
 341         portNumber = strtoul(service, &endptr, 10);
 342
 343         if (service[0]!=0 && *endptr==0 && portNumber<65536) {
 344             socketaddr.sin_port = htons(portNumber);
 345         } else {
 346             return NULL;
 347         }
 348     } else {
 349         socketaddr.sin_port = sp->s_port;
 350     }
 351
 352     return &socketaddr;
 353 }
 354
 355 static void
 356 handle_sigpipe(int signum)
 357 {
 358     if (0) signum=0; /* To avoid a gcc warning */
 359     return;
 360 }
 361
 362 static WMConnection*
 363 createConnectionWithSocket(int sock, Bool closeOnRelease) /*FOLD00*/
 364 {
 365     WMConnection *cPtr;
 366     struct sigaction sig_action;
 367
 368     cPtr = wmalloc(sizeof(WMConnection));
 369     wretain(cPtr);
 370     memset(cPtr, 0, sizeof(WMConnection));
 371
 372     fcntl(sock, F_SETFD, FD_CLOEXEC); /* by default close on exec */
 373
 374     cPtr->sock = sock;
 375     cPtr->openTimeout.timeout = OpenTimeout;
 376     cPtr->openTimeout.handler = NULL;
 377     cPtr->sendTimeout.timeout = DefaultTimeout;
 378     cPtr->sendTimeout.handler = NULL;
 379     cPtr->closeOnRelease = closeOnRelease;
 380     cPtr->outputQueue =
 381         WMCreateArrayWithDestructor(16, (WMFreeDataProc*)WMReleaseData);
 382     cPtr->state = WCNotConnected;
 383     cPtr->timeoutState = WCTNone;
 384
 385     /* ignore dead pipe */
 386     if (!SigInitialized) {
 387         sig_action.sa_handler = &handle_sigpipe;
 388         /* Because POSIX mandates that only signal with handlers are reset
 389            accross an exec*(), we do not want to propagate ignoring SIGPIPEs
 390            to children. Hence the dummy handler.
 391            Philippe Troin <phil@fifi.org>
 392         */
 393         sig_action.sa_flags = SA_RESTART;
 394         sigaction(SIGPIPE, &sig_action, NULL);
 395         SigInitialized = True;
 396     }
 397
 398     return cPtr;
 399 }
 400
 401
 402 #if 0
 403 WMConnection*
 404 WMCreateConnectionWithSocket(int sock, Bool closeOnRelease) /*FOLD00*/
 405 {
 406     WMConnection *cPtr;
 407     struct sockaddr_in clientname;
 408     int size;
 409     int n;
 410
 411     cPtr = createConnectionWithSocket(sock, closeOnRelease);
 412     cPtr->wasNonBlocking = WMIsConnectionNonBlocking(cPtr);
 413     cPtr->isNonBlocking = cPtr->wasNonBlocking;
 414
 415     /* some way to find out if it is connected, and binded. can't find
 416        if it listens though!!!
 417     */
 418
 419     size = sizeof(clientname);
 420     n = getpeername(sock, (struct sockaddr*) &clientname, &size);
 421     if (n==0) {
 422         /* Since we have a peer, it means we are connected */
 423         cPtr->state = WCConnected;
 424     } else {
 425         size = sizeof(clientname);
 426         n = getsockname(sock, (struct sockaddr*) &clientname, &size);
 427         if (n==0) {
 428             /* We don't have a peer, but we are binded to an address.
 429              * Assume we are listening on it (we don't know that for sure!)
 430              */
 431             cPtr->state = WCListening;
 432         } else {
 433             cPtr->state = WCNotConnected;
 434         }
 435     }
 436
 437     return cPtr;
 438 }
 439 #endif
 440
 441
 442 /*
 443  * host     is the name on which we want to listen for incoming connections,
 444  *          and it must be a name of this host, or NULL if we want to listen
 445  *          on any incoming address.
 446  * service  is either a service name as present in /etc/services, or the port
 447  *          number we want to listen on. If NULL, a random port between
 448  *          1024 and 65535 will be assigned to us.
 449  * protocol is one of "tcp" or "udp". If NULL, "tcp" will be used by default.
 450  *          currently only "tcp" is supported.
 451  */
 452 WMConnection*
 453 WMCreateConnectionAsServerAtAddress(char *host, char *service, char *protocol) /*FOLD00*/
 454 {
 455     WMConnection *cPtr;
 456     struct sockaddr_in *socketaddr;
 457     int sock, on;
 458     int size;
 459
 460     WCErrorCode = 0;
 461
 462     if ((socketaddr = getSocketAddress(host, service, protocol)) == NULL) {
 463         wwarning(_("Bad address-service-protocol combination"));
 464         return NULL;
 465     }
 466
 467     /* Create the actual socket */
 468     sock = socket(PF_INET, SOCK_STREAM, 0);
 469     if (sock<0) {
 470         WCErrorCode = errno;
 471         return NULL;
 472     }
 473
 474     /*
 475      * Set socket options. We try to make the port reusable and have it
 476      * close as fast as possible without waiting in unnecessary wait states
 477      * on close.
 478      */
 479     on = 1;
 480     setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on));
 481
 482     if (bind(sock, (struct sockaddr *)socketaddr, sizeof(*socketaddr)) < 0) {
 483         WCErrorCode = errno;
 484         close(sock);
 485         return NULL;
 486     }
 487
 488     if (listen(sock, 10) < 0) {
 489         WCErrorCode = errno;
 490         close(sock);
 491         return NULL;
 492     }
 493
 494     /* Find out what is the address/service/protocol we get */
 495     /* In case some of address/service/protocol were NULL */
 496     size = sizeof(*socketaddr);
 497     if (getsockname(sock, (struct sockaddr*)socketaddr, &size) < 0) {
 498         WCErrorCode = errno;
 499         close(sock);
 500         return NULL;
 501     }
 502
 503     cPtr = createConnectionWithSocket(sock, True);
 504     cPtr->state = WCListening;
 505     WMSetConnectionNonBlocking(cPtr, True);
 506
 507     setConnectionAddress(cPtr, socketaddr);
 508
 509     return cPtr;
 510 }
 511
 512
 513 WMConnection*
 514 WMCreateConnectionToAddress(char *host, char *service, char *protocol) /*FOLD00*/
 515 {
 516     WMConnection *cPtr;
 517     struct sockaddr_in *socketaddr;
 518     int sock;
 519
 520     WCErrorCode = 0;
 521
 522     wassertrv(service!=NULL && service[0]!=0, NULL);
 523
 524     if (host==NULL || host[0]==0)
 525         host = "localhost";
 526
 527     if ((socketaddr = getSocketAddress(host, service, protocol)) == NULL) {
 528         wwarning(_("Bad address-service-protocol combination"));
 529         return NULL;
 530     }
 531
 532     /* Create the actual socket */
 533     sock = socket(PF_INET, SOCK_STREAM, 0);
 534     if (sock<0) {
 535         WCErrorCode = errno;
 536         return NULL;
 537     }
 538     /* make socket blocking while we connect. */
 539     setSocketNonBlocking(sock, False);
 540     if (connect(sock, (struct sockaddr*)socketaddr, sizeof(*socketaddr)) < 0) {
 541         WCErrorCode = errno;
 542         close(sock);
 543         return NULL;
 544     }
 545
 546     cPtr = createConnectionWithSocket(sock, True);
 547     cPtr->state = WCConnected;
 548     WMSetConnectionNonBlocking(cPtr, True);
 549     setConnectionAddress(cPtr, socketaddr);
 550
 551     return cPtr;
 552 }
 553
 554
 555 WMConnection*
 556 WMCreateConnectionToAddressAndNotify(char *host, char *service, char *protocol) /*FOLD00*/
 557 {
 558     WMConnection *cPtr;
 559     struct sockaddr_in *socketaddr;
 560     int sock;
 561     Bool isNonBlocking;
 562
 563     WCErrorCode = 0;
 564
 565     wassertrv(service!=NULL && service[0]!=0, NULL);
 566
 567     if (host==NULL || host[0]==0)
 568         host = "localhost";
 569
 570     if ((socketaddr = getSocketAddress(host, service, protocol)) == NULL) {
 571         wwarning(_("Bad address-service-protocol combination"));
 572         return NULL;
 573     }
 574
 575     /* Create the actual socket */
 576     sock = socket(PF_INET, SOCK_STREAM, 0);
 577     if (sock<0) {
 578         WCErrorCode = errno;
 579         return NULL;
 580     }
 581     isNonBlocking = setSocketNonBlocking(sock, True);
 582     if (connect(sock, (struct sockaddr*)socketaddr, sizeof(*socketaddr)) < 0) {
 583         if (errno!=EINPROGRESS) {
 584             WCErrorCode = errno;
 585             close(sock);
 586             return NULL;
 587         }
 588     }
 589
 590     cPtr = createConnectionWithSocket(sock, True);
 591     cPtr->state = WCInProgress;
 592     cPtr->isNonBlocking = isNonBlocking;
 593
 594     cPtr->handler.write = WMAddInputHandler(cPtr->sock, WIWriteMask,
 595                                             inputHandler, cPtr);
 596
 597     cPtr->openTimeout.handler =
 598         WMAddTimerHandler(cPtr->openTimeout.timeout*1000, openTimeout, cPtr);
 599
 600     setConnectionAddress(cPtr, socketaddr);
 601
 602     return cPtr;
 603 }
 604
 605
 606 static void
 607 removeAllHandlers(WMConnection *cPtr) /*FOLD00*/
 608 {
 609     if (cPtr->handler.read)
 610         WMDeleteInputHandler(cPtr->handler.read);
 611     if (cPtr->handler.write)
 612         WMDeleteInputHandler(cPtr->handler.write);
 613     if (cPtr->handler.exception)
 614         WMDeleteInputHandler(cPtr->handler.exception);
 615     if (cPtr->openTimeout.handler)
 616         WMDeleteTimerHandler(cPtr->openTimeout.handler);
 617     if (cPtr->sendTimeout.handler)
 618         WMDeleteTimerHandler(cPtr->sendTimeout.handler);
 619
 620     cPtr->handler.read = NULL;
 621     cPtr->handler.write = NULL;
 622     cPtr->handler.exception = NULL;
 623     cPtr->openTimeout.handler = NULL;
 624     cPtr->sendTimeout.handler = NULL;
 625 }
 626
 627
 628 void
 629 WMDestroyConnection(WMConnection *cPtr) /*FOLD00*/
 630 {
 631     if (cPtr->closeOnRelease && cPtr->sock>=0) {
 632         shutdown(cPtr->sock, SHUT_RDWR);
 633         close(cPtr->sock);
 634     }
 635
 636     removeAllHandlers(cPtr);
 637     WMFreeArray(cPtr->outputQueue); /* will also free the items with the destructor */
 638
 639     if (cPtr->address) {
 640         wfree(cPtr->address);
 641         wfree(cPtr->service);
 642         wfree(cPtr->protocol);
 643     }
 644
 645     wrelease(cPtr);
 646 }
 647
 648
 649 void
 650 WMCloseConnection(WMConnection *cPtr) /*FOLD00*/
 651 {
 652     if (cPtr->sock>=0) {
 653         shutdown(cPtr->sock, SHUT_RDWR);
 654         close(cPtr->sock);
 655         cPtr->sock = -1;
 656     }
 657
 658     removeAllHandlers(cPtr);
 659     clearOutputQueue(cPtr);
 660
 661     cPtr->state = WCClosed;
 662 }
 663
 664
 665 WMConnection*
 666 WMAcceptConnection(WMConnection *listener) /*FOLD00*/
 667 {
 668     struct sockaddr_in clientname;
 669     int size;
 670     int newSock;
 671     WMConnection *newConnection;
 672
 673     WCErrorCode = 0;
 674     wassertrv(listener && listener->state==WCListening, NULL);
 675
 676     size = sizeof(clientname);
 677     newSock = accept(listener->sock, (struct sockaddr*) &clientname, &size);
 678     if (newSock<0) {
 679         WCErrorCode = ((errno!=EAGAIN && errno!=EWOULDBLOCK) ? errno : 0);
 680         return NULL;
 681     }
 682
 683     newConnection = createConnectionWithSocket(newSock, True);
 684     WMSetConnectionNonBlocking(newConnection, True);
 685     newConnection->state = WCConnected;
 686     setConnectionAddress(newConnection, &clientname);
 687
 688     return newConnection;
 689 }
 690
 691
 692 char*
 693 WMGetConnectionAddress(WMConnection *cPtr) /*FOLD00*/
 694 {
 695     return cPtr->address;
 696 }
 697
 698
 699 char*
 700 WMGetConnectionService(WMConnection *cPtr) /*FOLD00*/
 701 {
 702     return cPtr->service;
 703 }
 704
 705
 706 char*
 707 WMGetConnectionProtocol(WMConnection *cPtr) /*FOLD00*/
 708 {
 709     return cPtr->protocol;
 710 }
 711
 712
 713 int
 714 WMGetConnectionSocket(WMConnection *cPtr) /*FOLD00*/
 715 {
 716     return cPtr->sock;
 717 }
 718
 719
 720 WMConnectionState
 721 WMGetConnectionState(WMConnection *cPtr) /*FOLD00*/
 722 {
 723     return cPtr->state;
 724 }
 725
 726
 727 WMConnectionTimeoutState
 728 WMGetConnectionTimeoutState(WMConnection *cPtr) /*FOLD00*/
 729 {
 730     return cPtr->timeoutState;
 731 }
 732
 733
 734 Bool
 735 WMEnqueueConnectionData(WMConnection *cPtr, WMData *data) /*FOLD00*/
 736 {
 737     wassertrv(cPtr->state!=WCNotConnected && cPtr->state!=WCListening, False);
 738     wassertrv(cPtr->state!=WCInProgress && cPtr->state!=WCFailed, False);
 739
 740     if (cPtr->state!=WCConnected)
 741         return False;
 742
 743     WMAddToArray(cPtr->outputQueue, WMRetainData(data));
 744     return True;
 745 }
 746
 747
 748 int
 749 WMSendConnectionData(WMConnection *cPtr, WMData *data) /*FOLD00*/
 750 {
 751     int bytes, pos, len, totalTransfer;
 752     TimeoutData *tPtr = &cPtr->sendTimeout;
 753     const unsigned char *dataBytes;
 754
 755     wassertrv(cPtr->state!=WCNotConnected && cPtr->state!=WCListening, -1);
 756     wassertrv(cPtr->state!=WCInProgress && cPtr->state!=WCFailed, -1);
 757
 758     if (cPtr->state!=WCConnected)
 759         return -1;
 760
 761     /* If we have no data just flush the queue, else try to send data */
 762     if (data && WMGetDataLength(data)>0) {
 763         WMAddToArray(cPtr->outputQueue, WMRetainData(data));
 764         /* If there already was something in queue, and also a write input
 765          * handler is established, it means we were unable to send, so
 766          * return and let the write handler notify us when we can send.
 767          */
 768         if (WMGetArrayItemCount(cPtr->outputQueue)>1 && cPtr->handler.write)
 769             return 0;
 770     }
 771
 772     totalTransfer = 0;
 773
 774     while (WMGetArrayItemCount(cPtr->outputQueue) > 0) {
 775         data = WMGetFromArray(cPtr->outputQueue, 0);
 776         dataBytes = (const unsigned char *)WMDataBytes(data);
 777         len = WMGetDataLength(data);
 778         pos = cPtr->bufPos; /* where we're left last time */
 779         while(pos < len) {
 780         again:
 781             bytes = write(cPtr->sock, dataBytes+pos, len - pos);
 782             if(bytes<0) {
 783                 switch (errno) {
 784                 case EINTR:
 785                     goto again;
 786                 case EWOULDBLOCK:
 787                     /* save the position where we're left and add a timeout */
 788                     cPtr->bufPos = pos;
 789                     if (!tPtr->handler) {
 790                         tPtr->handler = WMAddTimerHandler(tPtr->timeout*1000,
 791                                                           sendTimeout, cPtr);
 792                     }
 793                     if (!cPtr->handler.write) {
 794                         cPtr->handler.write =
 795                             WMAddInputHandler(cPtr->sock, WIWriteMask,
 796                                               inputHandler, cPtr);
 797                     }
 798                     return totalTransfer;
 799                 default:
 800                     WCErrorCode = errno;
 801                     cPtr->state = WCDied;
 802                     removeAllHandlers(cPtr);
 803                     if (cPtr->delegate && cPtr->delegate->didDie)
 804                         (*cPtr->delegate->didDie)(cPtr->delegate, cPtr);
 805                     return -1;
 806                 }
 807             }
 808             pos += bytes;
 809             totalTransfer += bytes;
 810         }
 811         WMDeleteFromArray(cPtr->outputQueue, 0);
 812         cPtr->bufPos = 0;
 813         if (tPtr->handler) {
 814             WMDeleteTimerHandler(tPtr->handler);
 815             tPtr->handler = NULL;
 816         }
 817         if (cPtr->handler.write) {
 818             WMDeleteInputHandler(cPtr->handler.write);
 819             cPtr->handler.write = NULL;
 820         }
 821     }
 822
 823     return totalTransfer;
 824 }
 825
 826
 827 /*
 828  * WMGetConnectionAvailableData(connection):
 829  *
 830  * will return a WMData structure containing the available data on the
 831  * specified connection. If connection is non-blocking (default) and no data
 832  * is available when this function is called, an empty WMData is returned.
 833  *
 834  * If an error occurs while reading or the other side closed connection,
 835  * it will return NULL.
 836  * Also trying to read from an already died or closed connection is
 837  * considered to be an error condition, and will return NULL.
 838  */
 839 WMData*
 840 WMGetConnectionAvailableData(WMConnection *cPtr) /*FOLD00*/
 841 {
 842     char buffer[NETBUF_SIZE];
 843     int nbytes;
 844     WMData *aData;
 845
 846     wassertrv(cPtr->state!=WCNotConnected && cPtr->state!=WCListening, NULL);
 847     wassertrv(cPtr->state!=WCInProgress && cPtr->state!=WCFailed, NULL);
 848
 849     if (cPtr->state!=WCConnected)
 850         return NULL;
 851
 852     aData = NULL;
 853
 854 again:
 855     nbytes = read(cPtr->sock, buffer, NETBUF_SIZE);
 856     if (nbytes<0) {
 857         switch (errno) {
 858         case EINTR:
 859             goto again;
 860         case EWOULDBLOCK:
 861             aData = WMCreateDataWithCapacity(0);
 862             break;
 863         default:
 864             WCErrorCode = errno;
 865             cPtr->state = WCDied;
 866             removeAllHandlers(cPtr);
 867             if (cPtr->delegate && cPtr->delegate->didDie)
 868                 (*cPtr->delegate->didDie)(cPtr->delegate, cPtr);
 869             break;
 870         }
 871     } else if (nbytes==0) {      /* the other side has closed connection */
 872         cPtr->state = WCClosed;
 873         removeAllHandlers(cPtr);
 874         if (cPtr->delegate && cPtr->delegate->didDie)
 875             (*cPtr->delegate->didDie)(cPtr->delegate, cPtr);
 876     } else {
 877         aData = WMCreateDataWithBytes(buffer, nbytes);
 878     }
 879
 880     return aData;
 881 }
 882
 883
 884 void
 885 WMSetConnectionDelegate(WMConnection *cPtr, ConnectionDelegate *delegate) /*FOLD00*/
 886 {
 887     wassertr(cPtr->sock >= 0);
 888     /* Don't try to set the delegate multiple times */
 889     wassertr(cPtr->delegate == NULL);
 890
 891     cPtr->delegate = delegate;
 892     if (delegate && delegate->didReceiveInput && !cPtr->handler.read)
 893         cPtr->handler.read = WMAddInputHandler(cPtr->sock, WIReadMask,
 894                                                inputHandler, cPtr);
 895     if (delegate && delegate->didCatchException && !cPtr->handler.exception)
 896         cPtr->handler.exception = WMAddInputHandler(cPtr->sock, WIExceptMask,
 897                                                     inputHandler, cPtr);
 898 }
 899
 900
 901 #if 0
 902 Bool
 903 WMIsConnectionNonBlocking(WMConnection *cPtr) /*FOLD00*/
 904 {
 905 #if 1
 906     int state;
 907
 908     state = fcntl(cPtr->sock, F_GETFL, 0);
 909
 910     if (state < 0) {
 911         /* If we can't use fcntl on socket, this probably also means we could
 912          * not use fcntl to set non-blocking mode, and since a socket defaults
 913          * to blocking when created, return False as the best assumption */
 914         return False;
 915     }
 916
 917     return ((state & NONBLOCK_OPT)!=0);
 918 #else
 919     return cPtr->isNonBlocking;
 920 #endif
 921 }
 922 #endif
 923
 924
 925 Bool
 926 WMSetConnectionNonBlocking(WMConnection *cPtr, Bool flag) /*FOLD00*/
 927 {
 928     wassertrv(cPtr!=NULL && cPtr->sock>=0, False);
 929
 930     if (cPtr->isNonBlocking == flag)
 931         return True;
 932
 933     if (setSocketNonBlocking(cPtr->sock, flag)==True) {
 934         cPtr->isNonBlocking = flag;
 935         return True;
 936     }
 937
 938     return False;
 939 }
 940
 941
 942 Bool
 943 WMSetConnectionCloseOnExec(WMConnection *cPtr, Bool flag)
 944 {
 945     wassertrv(cPtr!=NULL && cPtr->sock>=0, False);
 946
 947     if (fcntl(cPtr->sock, F_SETFD, (flag ? FD_CLOEXEC : 0)) < 0) {
 948         return False;
 949     }
 950
 951     return True;
 952 }
 953
 954
 955 void*
 956 WMGetConnectionClientData(WMConnection *cPtr) /*FOLD00*/
 957 {
 958     return cPtr->clientData;
 959 }
 960
 961
 962 void
 963 WMSetConnectionClientData(WMConnection *cPtr, void *data) /*FOLD00*/
 964 {
 965     cPtr->clientData = data;
 966 }
 967
 968
 969 unsigned int
 970 WMGetConnectionFlags(WMConnection *cPtr) /*FOLD00*/
 971 {
 972     return cPtr->uflags;
 973 }
 974
 975
 976 void
 977 WMSetConnectionFlags(WMConnection *cPtr, unsigned int flags) /*FOLD00*/
 978 {
 979     cPtr->uflags = flags;
 980 }
 981
 982
 983 WMArray*
 984 WMGetConnectionUnsentData(WMConnection *cPtr)
 985 {
 986     return cPtr->outputQueue;
 987 }
 988
 989
 990 void
 991 WMSetConnectionDefaultTimeout(unsigned int timeout) /*FOLD00*/
 992 {
 993     if (timeout == 0) {
 994         DefaultTimeout = DEF_TIMEOUT;
 995     } else {
 996         DefaultTimeout = timeout;
 997     }
 998 }
 999
1000
1001 void
1002 WMSetConnectionOpenTimeout(unsigned int timeout) /*FOLD00*/
1003 {
1004     if (timeout == 0) {
1005         OpenTimeout = DefaultTimeout;
1006     } else {
1007         OpenTimeout = timeout;
1008     }
1009 }
1010
1011
1012 void
1013 WMSetConnectionSendTimeout(WMConnection *cPtr, unsigned int timeout) /*FOLD00*/
1014 {
1015     if (timeout == 0) {
1016         cPtr->sendTimeout.timeout = DefaultTimeout;
1017     } else {
1018         cPtr->sendTimeout.timeout = timeout;
1019     }
1020 }
1021
1022