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