WINGs/connection.c

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