src/unix/gsocket.cpp

   1 /* -------------------------------------------------------------------------
   2  * Project:     GSocket (Generic Socket) for WX
   3  * Name:        gsocket.c
   4  * Copyright:   (c) Guilhem Lavaux
   5  * Licence:     wxWindows Licence
   6  * Authors:     David Elliott (C++ conversion, maintainer)
   7  *              Guilhem Lavaux,
   8  *              Guillermo Rodriguez Garcia <guille@iies.es>
   9  * Purpose:     GSocket main Unix and OS/2 file
  10  * Licence:     The wxWindows licence
  11  * CVSID:       $Id$
  12  * -------------------------------------------------------------------------
  13  */
  14
  15 /*
  16  * PLEASE don't put C++ comments here - this is a C source file.
  17  */
  18
  19 #if defined(__WATCOMC__)
  20 #include "wx/wxprec.h"
  21 #include <errno.h>
  22 #include <nerrno.h>
  23 #endif
  24
  25 #ifndef __GSOCKET_STANDALONE__
  26 #include "wx/defs.h"
  27 #endif
  28
  29 #if defined(__VISAGECPP__)
  30 #define BSD_SELECT /* use Berkley Sockets select */
  31 #endif
  32
  33 #if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
  34
  35 #include <assert.h>
  36 #include <sys/types.h>
  37 #ifdef __VISAGECPP__
  38 #include <string.h>
  39 #include <sys/time.h>
  40 #include <types.h>
  41 #include <netinet/in.h>
  42 #endif
  43 #include <netdb.h>
  44 #include <sys/ioctl.h>
  45
  46 #ifdef __VMS__
  47 #include <socket.h>
  48 struct sockaddr_un
  49 {
  50     u_char  sun_len;        /* sockaddr len including null */
  51     u_char  sun_family;     /* AF_UNIX */
  52     char    sun_path[108];  /* path name (gag) */
  53 };
  54 #else
  55 #include <sys/socket.h>
  56 #include <sys/un.h>
  57 #endif
  58
  59 #ifndef __VISAGECPP__
  60 #include <sys/time.h>
  61 #include <netinet/in.h>
  62 #include <arpa/inet.h>
  63 #include <errno.h>
  64 #include <string.h>
  65 #include <unistd.h>
  66 #else
  67 #include <nerrno.h>
  68 #  if __IBMCPP__ < 400
  69 #include <machine/endian.h>
  70 #include <socket.h>
  71 #include <ioctl.h>
  72 #include <select.h>
  73 #include <unistd.h>
  74
  75 #define EBADF   SOCEBADF
  76
  77 #    ifdef min
  78 #    undef min
  79 #    endif
  80 #  else
  81 #include <sys/socket.h>
  82 #include <sys/ioctl.h>
  83 #include <sys/select.h>
  84
  85 #define close(a) soclose(a)
  86 #define select(a,b,c,d,e) bsdselect(a,b,c,d,e)
  87 int _System bsdselect(int,
  88                       struct fd_set *,
  89                       struct fd_set *,
  90                       struct fd_set *,
  91                       struct timeval *);
  92 int _System soclose(int);
  93 #  endif
  94 #endif
  95 #ifdef __EMX__
  96 #include <sys/select.h>
  97 #endif
  98
  99 #include <stdio.h>
 100 #include <stdlib.h>
 101 #include <stddef.h>
 102 #include <ctype.h>
 103 #ifdef sun
 104 #  include <sys/filio.h>
 105 #endif
 106 #ifdef sgi
 107 #  include <bstring.h>
 108 #endif
 109 #ifdef _AIX
 110 #  include <strings.h>
 111 #endif
 112 #include <signal.h>
 113
 114 #ifndef WX_SOCKLEN_T
 115
 116 #ifdef VMS
 117 #  define WX_SOCKLEN_T unsigned int
 118 #else
 119 #  ifdef __GLIBC__
 120 #    if __GLIBC__ == 2
 121 #      define WX_SOCKLEN_T socklen_t
 122 #    endif
 123 #  elif defined(__WXMAC__)
 124 #    define WX_SOCKLEN_T socklen_t
 125 #  else
 126 #    define WX_SOCKLEN_T int
 127 #  endif
 128 #endif
 129
 130 #endif /* SOCKLEN_T */
 131
 132 #ifndef SOCKOPTLEN_T
 133 #define SOCKOPTLEN_T WX_SOCKLEN_T
 134 #endif
 135
 136 /*
 137  * MSW defines this, Unices don't.
 138  */
 139 #ifndef INVALID_SOCKET
 140 #define INVALID_SOCKET -1
 141 #endif
 142
 143 /* UnixWare reportedly needs this for FIONBIO definition */
 144 #ifdef __UNIXWARE__
 145 #include <sys/filio.h>
 146 #endif
 147
 148 /*
 149  * INADDR_BROADCAST is identical to INADDR_NONE which is not defined
 150  * on all systems. INADDR_BROADCAST should be fine to indicate an error.
 151  */
 152 #ifndef INADDR_NONE
 153 #define INADDR_NONE INADDR_BROADCAST
 154 #endif
 155
 156 #if defined(__VISAGECPP__) || defined(__WATCOMC__)
 157
 158     #define MASK_SIGNAL() {
 159     #define UNMASK_SIGNAL() }
 160
 161 #else
 162
 163     #define MASK_SIGNAL()                       \
 164     {                                           \
 165         void (*old_handler)(int);               \
 166                                                 \
 167         old_handler = signal(SIGPIPE, SIG_IGN);
 168
 169     #define UNMASK_SIGNAL()                     \
 170         signal(SIGPIPE, old_handler);           \
 171     }
 172
 173 #endif
 174
 175 /* If a SIGPIPE is issued by a socket call on a remotely closed socket,
 176    the program will "crash" unless it explicitly handles the SIGPIPE.
 177    By using MSG_NOSIGNAL, the SIGPIPE is suppressed. Later, we will
 178    use SO_NOSIGPIPE (if available), the BSD equivalent. */
 179 #ifdef MSG_NOSIGNAL
 180 #  define GSOCKET_MSG_NOSIGNAL MSG_NOSIGNAL
 181 #else /* MSG_NOSIGNAL not available (FreeBSD including OS X) */
 182 #  define GSOCKET_MSG_NOSIGNAL 0
 183 #endif /* MSG_NOSIGNAL */
 184
 185 #ifndef __GSOCKET_STANDALONE__
 186 #  include "wx/unix/gsockunx.h"
 187 #  include "wx/gsocket.h"
 188 #else
 189 #  include "gsockunx.h"
 190 #  include "gsocket.h"
 191 #  ifndef WXUNUSED
 192 #    define WXUNUSED(x)
 193 #  endif
 194 #endif /* __GSOCKET_STANDALONE__ */
 195
 196 /* debugging helpers */
 197 #ifdef __GSOCKET_DEBUG__
 198 #  define GSocket_Debug(args) printf args
 199 #else
 200 #  define GSocket_Debug(args)
 201 #endif /* __GSOCKET_DEBUG__ */
 202
 203 /* Table of GUI-related functions. We must call them indirectly because
 204  * of wxBase and GUI separation: */
 205
 206 static GSocketGUIFunctionsTable *gs_gui_functions;
 207
 208 class GSocketGUIFunctionsTableNull: public GSocketGUIFunctionsTable
 209 {
 210 public:
 211     virtual bool OnInit();
 212     virtual void OnExit();
 213     virtual bool CanUseEventLoop();
 214     virtual bool Init_Socket(GSocket *socket);
 215     virtual void Destroy_Socket(GSocket *socket);
 216     virtual void Install_Callback(GSocket *socket, GSocketEvent event);
 217     virtual void Uninstall_Callback(GSocket *socket, GSocketEvent event);
 218     virtual void Enable_Events(GSocket *socket);
 219     virtual void Disable_Events(GSocket *socket);
 220 };
 221
 222 bool GSocketGUIFunctionsTableNull::OnInit()
 223 {   return true; }
 224 void GSocketGUIFunctionsTableNull::OnExit()
 225 {}
 226 bool GSocketGUIFunctionsTableNull::CanUseEventLoop()
 227 {   return false; }
 228 bool GSocketGUIFunctionsTableNull::Init_Socket(GSocket *WXUNUSED(socket))
 229 {   return true; }
 230 void GSocketGUIFunctionsTableNull::Destroy_Socket(GSocket *WXUNUSED(socket))
 231 {}
 232 void GSocketGUIFunctionsTableNull::Install_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event))
 233 {}
 234 void GSocketGUIFunctionsTableNull::Uninstall_Callback(GSocket *WXUNUSED(socket), GSocketEvent WXUNUSED(event))
 235 {}
 236 void GSocketGUIFunctionsTableNull::Enable_Events(GSocket *WXUNUSED(socket))
 237 {}
 238 void GSocketGUIFunctionsTableNull::Disable_Events(GSocket *WXUNUSED(socket))
 239 {}
 240 /* Global initialisers */
 241
 242 void GSocket_SetGUIFunctions(GSocketGUIFunctionsTable *guifunc)
 243 {
 244   gs_gui_functions = guifunc;
 245 }
 246
 247 int GSocket_Init(void)
 248 {
 249   if (!gs_gui_functions)
 250   {
 251     static GSocketGUIFunctionsTableNull table;
 252     gs_gui_functions = &table;
 253   }
 254   if ( !gs_gui_functions->OnInit() )
 255     return 0;
 256   return 1;
 257 }
 258
 259 void GSocket_Cleanup(void)
 260 {
 261   if (gs_gui_functions)
 262   {
 263       gs_gui_functions->OnExit();
 264   }
 265 }
 266
 267 /* Constructors / Destructors for GSocket */
 268
 269 GSocket::GSocket()
 270 {
 271   int i;
 272
 273   m_fd                  = INVALID_SOCKET;
 274   for (i=0;i<GSOCK_MAX_EVENT;i++)
 275   {
 276     m_cbacks[i]         = NULL;
 277   }
 278   m_detected            = 0;
 279   m_local               = NULL;
 280   m_peer                = NULL;
 281   m_error               = GSOCK_NOERROR;
 282   m_server              = false;
 283   m_stream              = true;
 284   m_gui_dependent       = NULL;
 285   m_non_blocking        = false;
 286   m_reusable            = false;
 287   m_timeout             = 10*60*1000;
 288                                 /* 10 minutes * 60 sec * 1000 millisec */
 289   m_establishing        = false;
 290
 291   assert(gs_gui_functions);
 292   /* Per-socket GUI-specific initialization */
 293   m_ok = gs_gui_functions->Init_Socket(this);
 294 }
 295
 296 void GSocket::Close()
 297 {
 298     gs_gui_functions->Disable_Events(this);
 299     /* gsockosx.c calls CFSocketInvalidate which closes the socket for us */
 300 #if !(defined(__DARWIN__) && (defined(__WXMAC__) || defined(__WXCOCOA__)))
 301     close(m_fd);
 302 #endif
 303     m_fd = INVALID_SOCKET;
 304 }
 305
 306 GSocket::~GSocket()
 307 {
 308   assert(this);
 309
 310   /* Check that the socket is really shutdowned */
 311   if (m_fd != INVALID_SOCKET)
 312     Shutdown();
 313
 314   /* Per-socket GUI-specific cleanup */
 315   gs_gui_functions->Destroy_Socket(this);
 316
 317   /* Destroy private addresses */
 318   if (m_local)
 319     GAddress_destroy(m_local);
 320
 321   if (m_peer)
 322     GAddress_destroy(m_peer);
 323 }
 324
 325 /* GSocket_Shutdown:
 326  *  Disallow further read/write operations on this socket, close
 327  *  the fd and disable all callbacks.
 328  */
 329 void GSocket::Shutdown()
 330 {
 331   int evt;
 332
 333   assert(this);
 334
 335   /* If socket has been created, shutdown it */
 336   if (m_fd != INVALID_SOCKET)
 337   {
 338     shutdown(m_fd, 2);
 339     Close();
 340   }
 341
 342   /* Disable GUI callbacks */
 343   for (evt = 0; evt < GSOCK_MAX_EVENT; evt++)
 344     m_cbacks[evt] = NULL;
 345
 346   m_detected = GSOCK_LOST_FLAG;
 347 }
 348
 349 /* Address handling */
 350
 351 /* GSocket_SetLocal:
 352  * GSocket_GetLocal:
 353  * GSocket_SetPeer:
 354  * GSocket_GetPeer:
 355  *  Set or get the local or peer address for this socket. The 'set'
 356  *  functions return GSOCK_NOERROR on success, an error code otherwise.
 357  *  The 'get' functions return a pointer to a GAddress object on success,
 358  *  or NULL otherwise, in which case they set the error code of the
 359  *  corresponding GSocket.
 360  *
 361  *  Error codes:
 362  *    GSOCK_INVSOCK - the socket is not valid.
 363  *    GSOCK_INVADDR - the address is not valid.
 364  */
 365 GSocketError GSocket::SetLocal(GAddress *address)
 366 {
 367   assert(this);
 368
 369   /* the socket must be initialized, or it must be a server */
 370   if ((m_fd != INVALID_SOCKET && !m_server))
 371   {
 372     m_error = GSOCK_INVSOCK;
 373     return GSOCK_INVSOCK;
 374   }
 375
 376   /* check address */
 377   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 378   {
 379     m_error = GSOCK_INVADDR;
 380     return GSOCK_INVADDR;
 381   }
 382
 383   if (m_local)
 384     GAddress_destroy(m_local);
 385
 386   m_local = GAddress_copy(address);
 387
 388   return GSOCK_NOERROR;
 389 }
 390
 391 GSocketError GSocket::SetPeer(GAddress *address)
 392 {
 393   assert(this);
 394
 395   /* check address */
 396   if (address == NULL || address->m_family == GSOCK_NOFAMILY)
 397   {
 398     m_error = GSOCK_INVADDR;
 399     return GSOCK_INVADDR;
 400   }
 401
 402   if (m_peer)
 403     GAddress_destroy(m_peer);
 404
 405   m_peer = GAddress_copy(address);
 406
 407   return GSOCK_NOERROR;
 408 }
 409
 410 GAddress *GSocket::GetLocal()
 411 {
 412   GAddress *address;
 413   struct sockaddr addr;
 414   WX_SOCKLEN_T size = sizeof(addr);
 415   GSocketError err;
 416
 417   assert(this);
 418
 419   /* try to get it from the m_local var first */
 420   if (m_local)
 421     return GAddress_copy(m_local);
 422
 423   /* else, if the socket is initialized, try getsockname */
 424   if (m_fd == INVALID_SOCKET)
 425   {
 426     m_error = GSOCK_INVSOCK;
 427     return NULL;
 428   }
 429
 430   if (getsockname(m_fd, &addr, (WX_SOCKLEN_T *) &size) < 0)
 431   {
 432     m_error = GSOCK_IOERR;
 433     return NULL;
 434   }
 435
 436   /* got a valid address from getsockname, create a GAddress object */
 437   address = GAddress_new();
 438   if (address == NULL)
 439   {
 440     m_error = GSOCK_MEMERR;
 441     return NULL;
 442   }
 443
 444   err = _GAddress_translate_from(address, &addr, size);
 445   if (err != GSOCK_NOERROR)
 446   {
 447     GAddress_destroy(address);
 448     m_error = err;
 449     return NULL;
 450   }
 451
 452   return address;
 453 }
 454
 455 GAddress *GSocket::GetPeer()
 456 {
 457   assert(this);
 458
 459   /* try to get it from the m_peer var */
 460   if (m_peer)
 461     return GAddress_copy(m_peer);
 462
 463   return NULL;
 464 }
 465
 466 /* Server specific parts */
 467
 468 /* GSocket_SetServer:
 469  *  Sets up this socket as a server. The local address must have been
 470  *  set with GSocket_SetLocal() before GSocket_SetServer() is called.
 471  *  Returns GSOCK_NOERROR on success, one of the following otherwise:
 472  *
 473  *  Error codes:
 474  *    GSOCK_INVSOCK - the socket is in use.
 475  *    GSOCK_INVADDR - the local address has not been set.
 476  *    GSOCK_IOERR   - low-level error.
 477  */
 478 GSocketError GSocket::SetServer()
 479 {
 480   int arg = 1;
 481
 482   assert(this);
 483
 484   /* must not be in use */
 485   if (m_fd != INVALID_SOCKET)
 486   {
 487     m_error = GSOCK_INVSOCK;
 488     return GSOCK_INVSOCK;
 489   }
 490
 491   /* the local addr must have been set */
 492   if (!m_local)
 493   {
 494     m_error = GSOCK_INVADDR;
 495     return GSOCK_INVADDR;
 496   }
 497
 498   /* Initialize all fields */
 499   m_stream   = true;
 500   m_server   = true;
 501
 502   /* Create the socket */
 503   m_fd = socket(m_local->m_realfamily, SOCK_STREAM, 0);
 504
 505   if (m_fd == INVALID_SOCKET)
 506   {
 507     m_error = GSOCK_IOERR;
 508     return GSOCK_IOERR;
 509   }
 510
 511   /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
 512 #ifdef SO_NOSIGPIPE
 513   setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(u_long));
 514 #endif
 515
 516   ioctl(m_fd, FIONBIO, &arg);
 517   gs_gui_functions->Enable_Events(this);
 518
 519   /* allow a socket to re-bind if the socket is in the TIME_WAIT
 520      state after being previously closed.
 521    */
 522   if (m_reusable)
 523     setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR, (const char*)&arg, sizeof(u_long));
 524
 525   /* Bind to the local address,
 526    * retrieve the actual address bound,
 527    * and listen up to 5 connections.
 528    */
 529   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 530       (getsockname(m_fd,
 531                    m_local->m_addr,
 532                    (WX_SOCKLEN_T *) &m_local->m_len) != 0) ||
 533       (listen(m_fd, 5) != 0))
 534   {
 535     Close();
 536     m_error = GSOCK_IOERR;
 537     return GSOCK_IOERR;
 538   }
 539
 540   return GSOCK_NOERROR;
 541 }
 542
 543 /* GSocket_WaitConnection:
 544  *  Waits for an incoming client connection. Returns a pointer to
 545  *  a GSocket object, or NULL if there was an error, in which case
 546  *  the last error field will be updated for the calling GSocket.
 547  *
 548  *  Error codes (set in the calling GSocket)
 549  *    GSOCK_INVSOCK    - the socket is not valid or not a server.
 550  *    GSOCK_TIMEDOUT   - timeout, no incoming connections.
 551  *    GSOCK_WOULDBLOCK - the call would block and the socket is nonblocking.
 552  *    GSOCK_MEMERR     - couldn't allocate memory.
 553  *    GSOCK_IOERR      - low-level error.
 554  */
 555 GSocket *GSocket::WaitConnection()
 556 {
 557   struct sockaddr from;
 558   WX_SOCKLEN_T fromlen = sizeof(from);
 559   GSocket *connection;
 560   GSocketError err;
 561   int arg = 1;
 562
 563   assert(this);
 564
 565   /* If the socket has already been created, we exit immediately */
 566   if (m_fd == INVALID_SOCKET || !m_server)
 567   {
 568     m_error = GSOCK_INVSOCK;
 569     return NULL;
 570   }
 571
 572   /* Create a GSocket object for the new connection */
 573   connection = GSocket_new();
 574
 575   if (!connection)
 576   {
 577     m_error = GSOCK_MEMERR;
 578     return NULL;
 579   }
 580
 581   /* Wait for a connection (with timeout) */
 582   if (Input_Timeout() == GSOCK_TIMEDOUT)
 583   {
 584     delete connection;
 585     /* m_error set by _GSocket_Input_Timeout */
 586     return NULL;
 587   }
 588
 589   connection->m_fd = accept(m_fd, &from, (WX_SOCKLEN_T *) &fromlen);
 590
 591   /* Reenable CONNECTION events */
 592   Enable(GSOCK_CONNECTION);
 593
 594   if (connection->m_fd == INVALID_SOCKET)
 595   {
 596     if (errno == EWOULDBLOCK)
 597       m_error = GSOCK_WOULDBLOCK;
 598     else
 599       m_error = GSOCK_IOERR;
 600
 601     delete connection;
 602     return NULL;
 603   }
 604
 605   /* Initialize all fields */
 606   connection->m_server   = false;
 607   connection->m_stream   = true;
 608
 609   /* Setup the peer address field */
 610   connection->m_peer = GAddress_new();
 611   if (!connection->m_peer)
 612   {
 613     delete connection;
 614     m_error = GSOCK_MEMERR;
 615     return NULL;
 616   }
 617   err = _GAddress_translate_from(connection->m_peer, &from, fromlen);
 618   if (err != GSOCK_NOERROR)
 619   {
 620     delete connection;
 621     m_error = err;
 622     return NULL;
 623   }
 624 #if defined(__EMX__) || defined(__VISAGECPP__)
 625   ioctl(connection->m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 626 #else
 627   ioctl(connection->m_fd, FIONBIO, &arg);
 628 #endif
 629   gs_gui_functions->Enable_Events(connection);
 630
 631   return connection;
 632 }
 633
 634 bool GSocket::SetReusable()
 635 {
 636     /* socket must not be null, and must not be in use/already bound */
 637     if (this && m_fd == INVALID_SOCKET) {
 638         m_reusable = true;
 639         return true;
 640     }
 641     return false;
 642 }
 643
 644 /* Client specific parts */
 645
 646 /* GSocket_Connect:
 647  *  For stream (connection oriented) sockets, GSocket_Connect() tries
 648  *  to establish a client connection to a server using the peer address
 649  *  as established with GSocket_SetPeer(). Returns GSOCK_NOERROR if the
 650  *  connection has been successfully established, or one of the error
 651  *  codes listed below. Note that for nonblocking sockets, a return
 652  *  value of GSOCK_WOULDBLOCK doesn't mean a failure. The connection
 653  *  request can be completed later; you should use GSocket_Select()
 654  *  to poll for GSOCK_CONNECTION | GSOCK_LOST, or wait for the
 655  *  corresponding asynchronous events.
 656  *
 657  *  For datagram (non connection oriented) sockets, GSocket_Connect()
 658  *  just sets the peer address established with GSocket_SetPeer() as
 659  *  default destination.
 660  *
 661  *  Error codes:
 662  *    GSOCK_INVSOCK    - the socket is in use or not valid.
 663  *    GSOCK_INVADDR    - the peer address has not been established.
 664  *    GSOCK_TIMEDOUT   - timeout, the connection failed.
 665  *    GSOCK_WOULDBLOCK - connection in progress (nonblocking sockets only)
 666  *    GSOCK_MEMERR     - couldn't allocate memory.
 667  *    GSOCK_IOERR      - low-level error.
 668  */
 669 GSocketError GSocket::Connect(GSocketStream stream)
 670 {
 671   int err, ret;
 672   int arg = 1;
 673
 674   assert(this);
 675
 676   /* Enable CONNECTION events (needed for nonblocking connections) */
 677   Enable(GSOCK_CONNECTION);
 678
 679   if (m_fd != INVALID_SOCKET)
 680   {
 681     m_error = GSOCK_INVSOCK;
 682     return GSOCK_INVSOCK;
 683   }
 684
 685   if (!m_peer)
 686   {
 687     m_error = GSOCK_INVADDR;
 688     return GSOCK_INVADDR;
 689   }
 690
 691   /* Streamed or dgram socket? */
 692   m_stream   = (stream == GSOCK_STREAMED);
 693   m_server   = false;
 694   m_establishing = false;
 695
 696   /* Create the socket */
 697   m_fd = socket(m_peer->m_realfamily,
 698                      m_stream? SOCK_STREAM : SOCK_DGRAM, 0);
 699
 700   if (m_fd == INVALID_SOCKET)
 701   {
 702     m_error = GSOCK_IOERR;
 703     return GSOCK_IOERR;
 704   }
 705
 706   /* FreeBSD variants can't use MSG_NOSIGNAL, and instead use a socket option */
 707 #ifdef SO_NOSIGPIPE
 708   setsockopt(m_fd, SOL_SOCKET, SO_NOSIGPIPE, (const char*)&arg, sizeof(u_long));
 709 #endif
 710
 711 #if defined(__EMX__) || defined(__VISAGECPP__)
 712   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 713 #else
 714   ioctl(m_fd, FIONBIO, &arg);
 715 #endif
 716
 717   /* Connect it to the peer address, with a timeout (see below) */
 718   ret = connect(m_fd, m_peer->m_addr, m_peer->m_len);
 719
 720   /* We only call Enable_Events if we know e aren't shutting down the socket */
 721
 722   if (m_non_blocking)
 723   {
 724     gs_gui_functions->Enable_Events(this);
 725   }
 726
 727   if (ret == -1)
 728   {
 729     err = errno;
 730
 731     /* If connect failed with EINPROGRESS and the GSocket object
 732      * is in blocking mode, we select() for the specified timeout
 733      * checking for writability to see if the connection request
 734      * completes.
 735      */
 736     if ((err == EINPROGRESS) && (!m_non_blocking))
 737     {
 738       if (Output_Timeout() == GSOCK_TIMEDOUT)
 739       {
 740         Close();
 741         /* m_error is set in _GSocket_Output_Timeout */
 742         return GSOCK_TIMEDOUT;
 743       }
 744       else
 745       {
 746         int error;
 747         SOCKOPTLEN_T len = sizeof(error);
 748
 749         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*) &error, &len);
 750
 751         gs_gui_functions->Enable_Events(this);
 752
 753         if (!error)
 754           return GSOCK_NOERROR;
 755       }
 756     }
 757
 758     /* If connect failed with EINPROGRESS and the GSocket object
 759      * is set to nonblocking, we set m_error to GSOCK_WOULDBLOCK
 760      * (and return GSOCK_WOULDBLOCK) but we don't close the socket;
 761      * this way if the connection completes, a GSOCK_CONNECTION
 762      * event will be generated, if enabled.
 763      */
 764     if ((err == EINPROGRESS) && (m_non_blocking))
 765     {
 766       m_establishing = true;
 767       m_error = GSOCK_WOULDBLOCK;
 768       return GSOCK_WOULDBLOCK;
 769     }
 770
 771     /* If connect failed with an error other than EINPROGRESS,
 772      * then the call to GSocket_Connect has failed.
 773      */
 774     Close();
 775     m_error = GSOCK_IOERR;
 776     return GSOCK_IOERR;
 777   }
 778
 779   return GSOCK_NOERROR;
 780 }
 781
 782 /* Datagram sockets */
 783
 784 /* GSocket_SetNonOriented:
 785  *  Sets up this socket as a non-connection oriented (datagram) socket.
 786  *  Before using this function, the local address must have been set
 787  *  with GSocket_SetLocal(), or the call will fail. Returns GSOCK_NOERROR
 788  *  on success, or one of the following otherwise.
 789  *
 790  *  Error codes:
 791  *    GSOCK_INVSOCK - the socket is in use.
 792  *    GSOCK_INVADDR - the local address has not been set.
 793  *    GSOCK_IOERR   - low-level error.
 794  */
 795 GSocketError GSocket::SetNonOriented()
 796 {
 797   int arg = 1;
 798
 799   assert(this);
 800
 801   if (m_fd != INVALID_SOCKET)
 802   {
 803     m_error = GSOCK_INVSOCK;
 804     return GSOCK_INVSOCK;
 805   }
 806
 807   if (!m_local)
 808   {
 809     m_error = GSOCK_INVADDR;
 810     return GSOCK_INVADDR;
 811   }
 812
 813   /* Initialize all fields */
 814   m_stream   = false;
 815   m_server   = false;
 816
 817   /* Create the socket */
 818   m_fd = socket(m_local->m_realfamily, SOCK_DGRAM, 0);
 819
 820   if (m_fd == INVALID_SOCKET)
 821   {
 822     m_error = GSOCK_IOERR;
 823     return GSOCK_IOERR;
 824   }
 825 #if defined(__EMX__) || defined(__VISAGECPP__)
 826   ioctl(m_fd, FIONBIO, (char*)&arg, sizeof(arg));
 827 #else
 828   ioctl(m_fd, FIONBIO, &arg);
 829 #endif
 830   gs_gui_functions->Enable_Events(this);
 831
 832   /* Bind to the local address,
 833    * and retrieve the actual address bound.
 834    */
 835   if ((bind(m_fd, m_local->m_addr, m_local->m_len) != 0) ||
 836       (getsockname(m_fd,
 837                    m_local->m_addr,
 838                    (WX_SOCKLEN_T *) &m_local->m_len) != 0))
 839   {
 840     Close();
 841     m_error = GSOCK_IOERR;
 842     return GSOCK_IOERR;
 843   }
 844
 845   return GSOCK_NOERROR;
 846 }
 847
 848 /* Generic IO */
 849
 850 /* Like recv(), send(), ... */
 851 int GSocket::Read(char *buffer, int size)
 852 {
 853   int ret;
 854
 855   assert(this);
 856
 857   if (m_fd == INVALID_SOCKET || m_server)
 858   {
 859     m_error = GSOCK_INVSOCK;
 860     return -1;
 861   }
 862
 863   /* Disable events during query of socket status */
 864   Disable(GSOCK_INPUT);
 865
 866   /* If the socket is blocking, wait for data (with a timeout) */
 867   if (Input_Timeout() == GSOCK_TIMEDOUT)
 868     /* We no longer return here immediately, otherwise socket events would not be re-enabled! */
 869     ret = -1;
 870   else {
 871     /* Read the data */
 872     if (m_stream)
 873       ret = Recv_Stream(buffer, size);
 874     else
 875       ret = Recv_Dgram(buffer, size);
 876   }
 877
 878   if (ret == -1)
 879   {
 880     if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
 881       m_error = GSOCK_WOULDBLOCK;
 882     else
 883       m_error = GSOCK_IOERR;
 884   }
 885
 886   /* Enable events again now that we are done processing */
 887   Enable(GSOCK_INPUT);
 888
 889   return ret;
 890 }
 891
 892 int GSocket::Write(const char *buffer, int size)
 893 {
 894   int ret;
 895
 896   assert(this);
 897
 898   GSocket_Debug(( "GSocket_Write #1, size %d\n", size ));
 899
 900   if (m_fd == INVALID_SOCKET || m_server)
 901   {
 902     m_error = GSOCK_INVSOCK;
 903     return -1;
 904   }
 905
 906   GSocket_Debug(( "GSocket_Write #2, size %d\n", size ));
 907
 908   /* If the socket is blocking, wait for writability (with a timeout) */
 909   if (Output_Timeout() == GSOCK_TIMEDOUT)
 910     return -1;
 911
 912   GSocket_Debug(( "GSocket_Write #3, size %d\n", size ));
 913
 914   /* Write the data */
 915   if (m_stream)
 916     ret = Send_Stream(buffer, size);
 917   else
 918     ret = Send_Dgram(buffer, size);
 919
 920   GSocket_Debug(( "GSocket_Write #4, size %d\n", size ));
 921
 922   if (ret == -1)
 923   {
 924     if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
 925     {
 926       m_error = GSOCK_WOULDBLOCK;
 927       GSocket_Debug(( "GSocket_Write error WOULDBLOCK\n" ));
 928     }
 929     else
 930     {
 931       m_error = GSOCK_IOERR;
 932       GSocket_Debug(( "GSocket_Write error IOERR\n" ));
 933     }
 934
 935     /* Only reenable OUTPUT events after an error (just like WSAAsyncSelect
 936      * in MSW). Once the first OUTPUT event is received, users can assume
 937      * that the socket is writable until a read operation fails. Only then
 938      * will further OUTPUT events be posted.
 939      */
 940     Enable(GSOCK_OUTPUT);
 941     return -1;
 942   }
 943
 944   GSocket_Debug(( "GSocket_Write #5, size %d ret %d\n", size, ret ));
 945
 946   return ret;
 947 }
 948
 949 /* GSocket_Select:
 950  *  Polls the socket to determine its status. This function will
 951  *  check for the events specified in the 'flags' parameter, and
 952  *  it will return a mask indicating which operations can be
 953  *  performed. This function won't block, regardless of the
 954  *  mode (blocking | nonblocking) of the socket.
 955  */
 956 GSocketEventFlags GSocket::Select(GSocketEventFlags flags)
 957 {
 958   if (!gs_gui_functions->CanUseEventLoop())
 959   {
 960
 961     GSocketEventFlags result = 0;
 962     fd_set readfds;
 963     fd_set writefds;
 964     fd_set exceptfds;
 965     struct timeval tv;
 966
 967     assert(this);
 968
 969     /* Do not use a static struct, Linux can garble it */
 970     tv.tv_sec = m_timeout / 1000;
 971     tv.tv_usec = (m_timeout % 1000) * 1000;
 972
 973     FD_ZERO(&readfds);
 974     FD_ZERO(&writefds);
 975     FD_ZERO(&exceptfds);
 976     FD_SET(m_fd, &readfds);
 977     if (flags & GSOCK_OUTPUT_FLAG || flags & GSOCK_CONNECTION_FLAG)
 978       FD_SET(m_fd, &writefds);
 979     FD_SET(m_fd, &exceptfds);
 980
 981     /* Check 'sticky' CONNECTION flag first */
 982     result |= (GSOCK_CONNECTION_FLAG & m_detected);
 983
 984     /* If we have already detected a LOST event, then don't try
 985      * to do any further processing.
 986      */
 987     if ((m_detected & GSOCK_LOST_FLAG) != 0)
 988     {
 989       m_establishing = false;
 990
 991       return (GSOCK_LOST_FLAG & flags);
 992     }
 993
 994     /* Try select now */
 995     if (select(m_fd + 1, &readfds, &writefds, &exceptfds, &tv) <= 0)
 996     {
 997       /* What to do here? */
 998       return (result & flags);
 999     }
1000
1001     /* Check for readability */
1002     if (FD_ISSET(m_fd, &readfds))
1003     {
1004       char c;
1005
1006       int num = recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
1007
1008       if (num > 0)
1009       {
1010         result |= GSOCK_INPUT_FLAG;
1011       }
1012       else
1013       {
1014         if (m_server && m_stream)
1015         {
1016           result |= GSOCK_CONNECTION_FLAG;
1017           m_detected |= GSOCK_CONNECTION_FLAG;
1018         }
1019         else if ((errno != EWOULDBLOCK) && (errno != EAGAIN) && (errno != EINTR))
1020         {
1021           m_detected = GSOCK_LOST_FLAG;
1022           m_establishing = false;
1023
1024           /* LOST event: Abort any further processing */
1025           return (GSOCK_LOST_FLAG & flags);
1026         }
1027       }
1028     }
1029
1030     /* Check for writability */
1031     if (FD_ISSET(m_fd, &writefds))
1032     {
1033       if (m_establishing && !m_server)
1034       {
1035         int error;
1036         SOCKOPTLEN_T len = sizeof(error);
1037
1038         m_establishing = false;
1039
1040         getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1041
1042         if (error)
1043         {
1044           m_detected = GSOCK_LOST_FLAG;
1045
1046           /* LOST event: Abort any further processing */
1047           return (GSOCK_LOST_FLAG & flags);
1048         }
1049         else
1050         {
1051           result |= GSOCK_CONNECTION_FLAG;
1052           m_detected |= GSOCK_CONNECTION_FLAG;
1053         }
1054       }
1055       else
1056       {
1057         result |= GSOCK_OUTPUT_FLAG;
1058       }
1059     }
1060
1061     /* Check for exceptions and errors (is this useful in Unices?) */
1062     if (FD_ISSET(m_fd, &exceptfds))
1063     {
1064       m_establishing = false;
1065       m_detected = GSOCK_LOST_FLAG;
1066
1067       /* LOST event: Abort any further processing */
1068       return (GSOCK_LOST_FLAG & flags);
1069     }
1070
1071     return (result & flags);
1072
1073   }
1074   else
1075   {
1076
1077     assert(this);
1078     return flags & m_detected;
1079
1080   }
1081 }
1082
1083 /* Flags */
1084
1085 /* GSocket_SetNonBlocking:
1086  *  Sets the socket to non-blocking mode. All IO calls will return
1087  *  immediately.
1088  */
1089 void GSocket::SetNonBlocking(bool non_block)
1090 {
1091   assert(this);
1092
1093   GSocket_Debug( ("GSocket_SetNonBlocking: %d\n", (int)non_block) );
1094
1095   m_non_blocking = non_block;
1096 }
1097
1098 /* GSocket_SetTimeout:
1099  *  Sets the timeout for blocking calls. Time is expressed in
1100  *  milliseconds.
1101  */
1102 void GSocket::SetTimeout(unsigned long millisec)
1103 {
1104   assert(this);
1105
1106   m_timeout = millisec;
1107 }
1108
1109 /* GSocket_GetError:
1110  *  Returns the last error occurred for this socket. Note that successful
1111  *  operations do not clear this back to GSOCK_NOERROR, so use it only
1112  *  after an error.
1113  */
1114 GSocketError WXDLLIMPEXP_NET GSocket::GetError()
1115 {
1116   assert(this);
1117
1118   return m_error;
1119 }
1120
1121 /* Callbacks */
1122
1123 /* GSOCK_INPUT:
1124  *   There is data to be read in the input buffer. If, after a read
1125  *   operation, there is still data available, the callback function will
1126  *   be called again.
1127  * GSOCK_OUTPUT:
1128  *   The socket is available for writing. That is, the next write call
1129  *   won't block. This event is generated only once, when the connection is
1130  *   first established, and then only if a call failed with GSOCK_WOULDBLOCK,
1131  *   when the output buffer empties again. This means that the app should
1132  *   assume that it can write since the first OUTPUT event, and no more
1133  *   OUTPUT events will be generated unless an error occurs.
1134  * GSOCK_CONNECTION:
1135  *   Connection successfully established, for client sockets, or incoming
1136  *   client connection, for server sockets. Wait for this event (also watch
1137  *   out for GSOCK_LOST) after you issue a nonblocking GSocket_Connect() call.
1138  * GSOCK_LOST:
1139  *   The connection is lost (or a connection request failed); this could
1140  *   be due to a failure, or due to the peer closing it gracefully.
1141  */
1142
1143 /* GSocket_SetCallback:
1144  *  Enables the callbacks specified by 'flags'. Note that 'flags'
1145  *  may be a combination of flags OR'ed toghether, so the same
1146  *  callback function can be made to accept different events.
1147  *  The callback function must have the following prototype:
1148  *
1149  *  void function(GSocket *socket, GSocketEvent event, char *cdata)
1150  */
1151 void GSocket::SetCallback(GSocketEventFlags flags,
1152                          GSocketCallback callback, char *cdata)
1153 {
1154   int count;
1155
1156   assert(this);
1157
1158   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1159   {
1160     if ((flags & (1 << count)) != 0)
1161     {
1162       m_cbacks[count] = callback;
1163       m_data[count] = cdata;
1164     }
1165   }
1166 }
1167
1168 /* GSocket_UnsetCallback:
1169  *  Disables all callbacks specified by 'flags', which may be a
1170  *  combination of flags OR'ed toghether.
1171  */
1172 void GSocket::UnsetCallback(GSocketEventFlags flags)
1173 {
1174   int count;
1175
1176   assert(this);
1177
1178   for (count = 0; count < GSOCK_MAX_EVENT; count++)
1179   {
1180     if ((flags & (1 << count)) != 0)
1181     {
1182       m_cbacks[count] = NULL;
1183       m_data[count] = NULL;
1184     }
1185   }
1186 }
1187
1188 GSocketError GSocket::GetSockOpt(int level, int optname,
1189                                 void *optval, int *optlen)
1190 {
1191     if (getsockopt(m_fd, level, optname, (char*)optval, (SOCKOPTLEN_T*)optlen) == 0)
1192     {
1193         return GSOCK_NOERROR;
1194     }
1195     return GSOCK_OPTERR;
1196 }
1197
1198 GSocketError GSocket::SetSockOpt(int level, int optname,
1199                                 const void *optval, int optlen)
1200 {
1201     if (setsockopt(m_fd, level, optname, (const char*)optval, optlen) == 0)
1202     {
1203         return GSOCK_NOERROR;
1204     }
1205     return GSOCK_OPTERR;
1206 }
1207
1208 #define CALL_CALLBACK(socket, event) {                                  \
1209   socket->Disable(event);                                               \
1210   if (socket->m_cbacks[event])                                          \
1211     socket->m_cbacks[event](socket, event, socket->m_data[event]);      \
1212 }
1213
1214
1215 void GSocket::Enable(GSocketEvent event)
1216 {
1217   m_detected &= ~(1 << event);
1218   gs_gui_functions->Install_Callback(this, event);
1219 }
1220
1221 void GSocket::Disable(GSocketEvent event)
1222 {
1223   m_detected |= (1 << event);
1224   gs_gui_functions->Uninstall_Callback(this, event);
1225 }
1226
1227 /* _GSocket_Input_Timeout:
1228  *  For blocking sockets, wait until data is available or
1229  *  until timeout ellapses.
1230  */
1231 GSocketError GSocket::Input_Timeout()
1232 {
1233   struct timeval tv;
1234   fd_set readfds;
1235   int ret;
1236
1237   /* Linux select() will overwrite the struct on return */
1238   tv.tv_sec  = (m_timeout / 1000);
1239   tv.tv_usec = (m_timeout % 1000) * 1000;
1240
1241   if (!m_non_blocking)
1242   {
1243     FD_ZERO(&readfds);
1244     FD_SET(m_fd, &readfds);
1245     ret = select(m_fd + 1, &readfds, NULL, NULL, &tv);
1246     if (ret == 0)
1247     {
1248       GSocket_Debug(( "GSocket_Input_Timeout, select returned 0\n" ));
1249       m_error = GSOCK_TIMEDOUT;
1250       return GSOCK_TIMEDOUT;
1251     }
1252     if (ret == -1)
1253     {
1254       GSocket_Debug(( "GSocket_Input_Timeout, select returned -1\n" ));
1255       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1256       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1257       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1258       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1259       m_error = GSOCK_TIMEDOUT;
1260       return GSOCK_TIMEDOUT;
1261     }
1262   }
1263   return GSOCK_NOERROR;
1264 }
1265
1266 /* _GSocket_Output_Timeout:
1267  *  For blocking sockets, wait until data can be sent without
1268  *  blocking or until timeout ellapses.
1269  */
1270 GSocketError GSocket::Output_Timeout()
1271 {
1272   struct timeval tv;
1273   fd_set writefds;
1274   int ret;
1275
1276   /* Linux select() will overwrite the struct on return */
1277   tv.tv_sec  = (m_timeout / 1000);
1278   tv.tv_usec = (m_timeout % 1000) * 1000;
1279
1280   GSocket_Debug( ("m_non_blocking has: %d\n", (int)m_non_blocking) );
1281
1282   if (!m_non_blocking)
1283   {
1284     FD_ZERO(&writefds);
1285     FD_SET(m_fd, &writefds);
1286     ret = select(m_fd + 1, NULL, &writefds, NULL, &tv);
1287     if (ret == 0)
1288     {
1289       GSocket_Debug(( "GSocket_Output_Timeout, select returned 0\n" ));
1290       m_error = GSOCK_TIMEDOUT;
1291       return GSOCK_TIMEDOUT;
1292     }
1293     if (ret == -1)
1294     {
1295       GSocket_Debug(( "GSocket_Output_Timeout, select returned -1\n" ));
1296       if (errno == EBADF) { GSocket_Debug(( "Invalid file descriptor\n" )); }
1297       if (errno == EINTR) { GSocket_Debug(( "A non blocked signal was caught\n" )); }
1298       if (errno == EINVAL) { GSocket_Debug(( "The highest number descriptor is negative\n" )); }
1299       if (errno == ENOMEM) { GSocket_Debug(( "Not enough memory\n" )); }
1300       m_error = GSOCK_TIMEDOUT;
1301       return GSOCK_TIMEDOUT;
1302     }
1303     if ( ! FD_ISSET(m_fd, &writefds) ) {
1304         GSocket_Debug(( "GSocket_Output_Timeout is buggy!\n" ));
1305     }
1306     else {
1307         GSocket_Debug(( "GSocket_Output_Timeout seems correct\n" ));
1308     }
1309   }
1310   else
1311   {
1312     GSocket_Debug(( "GSocket_Output_Timeout, didn't try select!\n" ));
1313   }
1314
1315   return GSOCK_NOERROR;
1316 }
1317
1318 int GSocket::Recv_Stream(char *buffer, int size)
1319 {
1320   int ret;
1321   do
1322   {
1323     ret = recv(m_fd, buffer, size, GSOCKET_MSG_NOSIGNAL);
1324   } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1325   return ret;
1326 }
1327
1328 int GSocket::Recv_Dgram(char *buffer, int size)
1329 {
1330   struct sockaddr from;
1331   WX_SOCKLEN_T fromlen = sizeof(from);
1332   int ret;
1333   GSocketError err;
1334
1335   fromlen = sizeof(from);
1336
1337   do
1338   {
1339     ret = recvfrom(m_fd, buffer, size, 0, &from, (WX_SOCKLEN_T *) &fromlen);
1340   } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1341
1342   if (ret == -1)
1343     return -1;
1344
1345   /* Translate a system address into a GSocket address */
1346   if (!m_peer)
1347   {
1348     m_peer = GAddress_new();
1349     if (!m_peer)
1350     {
1351       m_error = GSOCK_MEMERR;
1352       return -1;
1353     }
1354   }
1355   err = _GAddress_translate_from(m_peer, &from, fromlen);
1356   if (err != GSOCK_NOERROR)
1357   {
1358     GAddress_destroy(m_peer);
1359     m_peer  = NULL;
1360     m_error = err;
1361     return -1;
1362   }
1363
1364   return ret;
1365 }
1366
1367 int GSocket::Send_Stream(const char *buffer, int size)
1368 {
1369   int ret;
1370
1371   MASK_SIGNAL();
1372
1373   do
1374   {
1375     ret = send(m_fd, (char *)buffer, size, GSOCKET_MSG_NOSIGNAL);
1376   } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1377
1378   UNMASK_SIGNAL();
1379
1380   return ret;
1381 }
1382
1383 int GSocket::Send_Dgram(const char *buffer, int size)
1384 {
1385   struct sockaddr *addr;
1386   int len, ret;
1387   GSocketError err;
1388
1389   if (!m_peer)
1390   {
1391     m_error = GSOCK_INVADDR;
1392     return -1;
1393   }
1394
1395   err = _GAddress_translate_to(m_peer, &addr, &len);
1396   if (err != GSOCK_NOERROR)
1397   {
1398     m_error = err;
1399     return -1;
1400   }
1401
1402   MASK_SIGNAL();
1403
1404   do
1405   {
1406     ret = sendto(m_fd, (char *)buffer, size, 0, addr, len);
1407   } while (ret == -1 && errno == EINTR); /* Loop until not interrupted */
1408
1409   UNMASK_SIGNAL();
1410
1411   /* Frees memory allocated from _GAddress_translate_to */
1412   free(addr);
1413
1414   return ret;
1415 }
1416
1417 void GSocket::Detected_Read()
1418 {
1419   char c;
1420
1421   /* Safeguard against straggling call to Detected_Read */
1422   if (m_fd == INVALID_SOCKET)
1423   {
1424     return;
1425   }
1426
1427   /* If we have already detected a LOST event, then don't try
1428    * to do any further processing.
1429    */
1430   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1431   {
1432     m_establishing = false;
1433
1434     CALL_CALLBACK(this, GSOCK_LOST);
1435     Shutdown();
1436     return;
1437   }
1438
1439   int num =  recv(m_fd, &c, 1, MSG_PEEK | GSOCKET_MSG_NOSIGNAL);
1440
1441   if (num > 0)
1442   {
1443     CALL_CALLBACK(this, GSOCK_INPUT);
1444   }
1445   else
1446   {
1447     if (m_server && m_stream)
1448     {
1449       CALL_CALLBACK(this, GSOCK_CONNECTION);
1450     }
1451     else
1452     {
1453       /* Do not throw a lost event in cases where the socket isn't really lost */
1454       if ((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == EINTR))
1455       {
1456         CALL_CALLBACK(this, GSOCK_INPUT);
1457       }
1458       else
1459       {
1460         CALL_CALLBACK(this, GSOCK_LOST);
1461         Shutdown();
1462       }
1463     }
1464   }
1465 }
1466
1467 void GSocket::Detected_Write()
1468 {
1469   /* If we have already detected a LOST event, then don't try
1470    * to do any further processing.
1471    */
1472   if ((m_detected & GSOCK_LOST_FLAG) != 0)
1473   {
1474     m_establishing = false;
1475
1476     CALL_CALLBACK(this, GSOCK_LOST);
1477     Shutdown();
1478     return;
1479   }
1480
1481   if (m_establishing && !m_server)
1482   {
1483     int error;
1484     SOCKOPTLEN_T len = sizeof(error);
1485
1486     m_establishing = false;
1487
1488     getsockopt(m_fd, SOL_SOCKET, SO_ERROR, (char*)&error, &len);
1489
1490     if (error)
1491     {
1492       CALL_CALLBACK(this, GSOCK_LOST);
1493       Shutdown();
1494     }
1495     else
1496     {
1497       CALL_CALLBACK(this, GSOCK_CONNECTION);
1498       /* We have to fire this event by hand because CONNECTION (for clients)
1499        * and OUTPUT are internally the same and we just disabled CONNECTION
1500        * events with the above macro.
1501        */
1502       CALL_CALLBACK(this, GSOCK_OUTPUT);
1503     }
1504   }
1505   else
1506   {
1507     CALL_CALLBACK(this, GSOCK_OUTPUT);
1508   }
1509 }
1510
1511 /* Compatibility functions for GSocket */
1512 GSocket *GSocket_new(void)
1513 {
1514     GSocket *newsocket = new GSocket();
1515     if(newsocket->IsOk())
1516         return newsocket;
1517     delete newsocket;
1518     return NULL;
1519 }
1520
1521 /*
1522  * -------------------------------------------------------------------------
1523  * GAddress
1524  * -------------------------------------------------------------------------
1525  */
1526
1527 /* CHECK_ADDRESS verifies that the current address family is either
1528  * GSOCK_NOFAMILY or GSOCK_*family*, and if it is GSOCK_NOFAMILY, it
1529  * initalizes it to be a GSOCK_*family*. In other cases, it returns
1530  * an appropiate error code.
1531  *
1532  * CHECK_ADDRESS_RETVAL does the same but returning 'retval' on error.
1533  */
1534 #define CHECK_ADDRESS(address, family)                              \
1535 {                                                                   \
1536   if (address->m_family == GSOCK_NOFAMILY)                          \
1537     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1538       return address->m_error;                                      \
1539   if (address->m_family != GSOCK_##family)                          \
1540   {                                                                 \
1541     address->m_error = GSOCK_INVADDR;                               \
1542     return GSOCK_INVADDR;                                           \
1543   }                                                                 \
1544 }
1545
1546 #define CHECK_ADDRESS_RETVAL(address, family, retval)               \
1547 {                                                                   \
1548   if (address->m_family == GSOCK_NOFAMILY)                          \
1549     if (_GAddress_Init_##family(address) != GSOCK_NOERROR)          \
1550       return retval;                                                \
1551   if (address->m_family != GSOCK_##family)                          \
1552   {                                                                 \
1553     address->m_error = GSOCK_INVADDR;                               \
1554     return retval;                                                  \
1555   }                                                                 \
1556 }
1557
1558
1559 GAddress *GAddress_new(void)
1560 {
1561   GAddress *address;
1562
1563   if ((address = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1564     return NULL;
1565
1566   address->m_family  = GSOCK_NOFAMILY;
1567   address->m_addr    = NULL;
1568   address->m_len     = 0;
1569
1570   return address;
1571 }
1572
1573 GAddress *GAddress_copy(GAddress *address)
1574 {
1575   GAddress *addr2;
1576
1577   assert(address != NULL);
1578
1579   if ((addr2 = (GAddress *) malloc(sizeof(GAddress))) == NULL)
1580     return NULL;
1581
1582   memcpy(addr2, address, sizeof(GAddress));
1583
1584   if (address->m_addr && address->m_len > 0)
1585   {
1586     addr2->m_addr = (struct sockaddr *)malloc(addr2->m_len);
1587     if (addr2->m_addr == NULL)
1588     {
1589       free(addr2);
1590       return NULL;
1591     }
1592     memcpy(addr2->m_addr, address->m_addr, addr2->m_len);
1593   }
1594
1595   return addr2;
1596 }
1597
1598 void GAddress_destroy(GAddress *address)
1599 {
1600   assert(address != NULL);
1601
1602   if (address->m_addr)
1603     free(address->m_addr);
1604
1605   free(address);
1606 }
1607
1608 void GAddress_SetFamily(GAddress *address, GAddressType type)
1609 {
1610   assert(address != NULL);
1611
1612   address->m_family = type;
1613 }
1614
1615 GAddressType GAddress_GetFamily(GAddress *address)
1616 {
1617   assert(address != NULL);
1618
1619   return address->m_family;
1620 }
1621
1622 GSocketError _GAddress_translate_from(GAddress *address,
1623                                       struct sockaddr *addr, int len)
1624 {
1625   address->m_realfamily = addr->sa_family;
1626   switch (addr->sa_family)
1627   {
1628     case AF_INET:
1629       address->m_family = GSOCK_INET;
1630       break;
1631     case AF_UNIX:
1632       address->m_family = GSOCK_UNIX;
1633       break;
1634 #ifdef AF_INET6
1635     case AF_INET6:
1636       address->m_family = GSOCK_INET6;
1637       break;
1638 #endif
1639     default:
1640     {
1641       address->m_error = GSOCK_INVOP;
1642       return GSOCK_INVOP;
1643     }
1644   }
1645
1646   if (address->m_addr)
1647     free(address->m_addr);
1648
1649   address->m_len  = len;
1650   address->m_addr = (struct sockaddr *)malloc(len);
1651
1652   if (address->m_addr == NULL)
1653   {
1654     address->m_error = GSOCK_MEMERR;
1655     return GSOCK_MEMERR;
1656   }
1657   memcpy(address->m_addr, addr, len);
1658
1659   return GSOCK_NOERROR;
1660 }
1661
1662 GSocketError _GAddress_translate_to(GAddress *address,
1663                                     struct sockaddr **addr, int *len)
1664 {
1665   if (!address->m_addr)
1666   {
1667     address->m_error = GSOCK_INVADDR;
1668     return GSOCK_INVADDR;
1669   }
1670
1671   *len = address->m_len;
1672   *addr = (struct sockaddr *)malloc(address->m_len);
1673   if (*addr == NULL)
1674   {
1675     address->m_error = GSOCK_MEMERR;
1676     return GSOCK_MEMERR;
1677   }
1678
1679   memcpy(*addr, address->m_addr, address->m_len);
1680   return GSOCK_NOERROR;
1681 }
1682
1683 /*
1684  * -------------------------------------------------------------------------
1685  * Internet address family
1686  * -------------------------------------------------------------------------
1687  */
1688
1689 GSocketError _GAddress_Init_INET(GAddress *address)
1690 {
1691   address->m_len  = sizeof(struct sockaddr_in);
1692   address->m_addr = (struct sockaddr *) malloc(address->m_len);
1693   if (address->m_addr == NULL)
1694   {
1695     address->m_error = GSOCK_MEMERR;
1696     return GSOCK_MEMERR;
1697   }
1698
1699   address->m_family = GSOCK_INET;
1700   address->m_realfamily = PF_INET;
1701   ((struct sockaddr_in *)address->m_addr)->sin_family = AF_INET;
1702   ((struct sockaddr_in *)address->m_addr)->sin_addr.s_addr = INADDR_ANY;
1703
1704   return GSOCK_NOERROR;
1705 }
1706
1707 GSocketError GAddress_INET_SetHostName(GAddress *address, const char *hostname)
1708 {
1709   struct hostent *he;
1710   struct in_addr *addr;
1711
1712   assert(address != NULL);
1713
1714   CHECK_ADDRESS(address, INET);
1715
1716   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1717
1718   /* If it is a numeric host name, convert it now */
1719 #if defined(HAVE_INET_ATON)
1720   if (inet_aton(hostname, addr) == 0)
1721   {
1722 #elif defined(HAVE_INET_ADDR)
1723   if ( (addr->s_addr = inet_addr(hostname)) == (unsigned)-1 )
1724   {
1725 #else
1726   /* Use gethostbyname by default */
1727 #ifndef __WXMAC__
1728   int val = 1;  /* VA doesn't like constants in conditional expressions */
1729   if (val)
1730 #endif
1731   {
1732 #endif
1733     struct in_addr *array_addr;
1734
1735     /* It is a real name, we solve it */
1736     if ((he = gethostbyname(hostname)) == NULL)
1737     {
1738       /* Reset to invalid address */
1739       addr->s_addr = INADDR_NONE;
1740       address->m_error = GSOCK_NOHOST;
1741       return GSOCK_NOHOST;
1742     }
1743     array_addr = (struct in_addr *) *(he->h_addr_list);
1744     addr->s_addr = array_addr[0].s_addr;
1745   }
1746   return GSOCK_NOERROR;
1747 }
1748
1749 GSocketError GAddress_INET_SetAnyAddress(GAddress *address)
1750 {
1751   return GAddress_INET_SetHostAddress(address, INADDR_ANY);
1752 }
1753
1754 GSocketError GAddress_INET_SetHostAddress(GAddress *address,
1755                                           unsigned long hostaddr)
1756 {
1757   struct in_addr *addr;
1758
1759   assert(address != NULL);
1760
1761   CHECK_ADDRESS(address, INET);
1762
1763   addr = &(((struct sockaddr_in *)address->m_addr)->sin_addr);
1764   addr->s_addr = htonl(hostaddr);
1765
1766   return GSOCK_NOERROR;
1767 }
1768
1769 GSocketError GAddress_INET_SetPortName(GAddress *address, const char *port,
1770                                        const char *protocol)
1771 {
1772   struct servent *se;
1773   struct sockaddr_in *addr;
1774
1775   assert(address != NULL);
1776   CHECK_ADDRESS(address, INET);
1777
1778   if (!port)
1779   {
1780     address->m_error = GSOCK_INVPORT;
1781     return GSOCK_INVPORT;
1782   }
1783
1784 #if defined(__WXPM__) && defined(__EMX__)
1785   se = getservbyname(port, (char*)protocol);
1786 #else
1787   se = getservbyname(port, protocol);
1788 #endif
1789   if (!se)
1790   {
1791     /* the cast to int suppresses compiler warnings about subscript having the
1792        type char */
1793     if (isdigit((int)port[0]))
1794     {
1795       int port_int;
1796
1797       port_int = atoi(port);
1798       addr = (struct sockaddr_in *)address->m_addr;
1799       addr->sin_port = htons(port_int);
1800       return GSOCK_NOERROR;
1801     }
1802
1803     address->m_error = GSOCK_INVPORT;
1804     return GSOCK_INVPORT;
1805   }
1806
1807   addr = (struct sockaddr_in *)address->m_addr;
1808   addr->sin_port = se->s_port;
1809
1810   return GSOCK_NOERROR;
1811 }
1812
1813 GSocketError GAddress_INET_SetPort(GAddress *address, unsigned short port)
1814 {
1815   struct sockaddr_in *addr;
1816
1817   assert(address != NULL);
1818   CHECK_ADDRESS(address, INET);
1819
1820   addr = (struct sockaddr_in *)address->m_addr;
1821   addr->sin_port = htons(port);
1822
1823   return GSOCK_NOERROR;
1824 }
1825
1826 GSocketError GAddress_INET_GetHostName(GAddress *address, char *hostname, size_t sbuf)
1827 {
1828   struct hostent *he;
1829   char *addr_buf;
1830   struct sockaddr_in *addr;
1831
1832   assert(address != NULL);
1833   CHECK_ADDRESS(address, INET);
1834
1835   addr = (struct sockaddr_in *)address->m_addr;
1836   addr_buf = (char *)&(addr->sin_addr);
1837
1838   he = gethostbyaddr(addr_buf, sizeof(addr->sin_addr), AF_INET);
1839   if (he == NULL)
1840   {
1841     address->m_error = GSOCK_NOHOST;
1842     return GSOCK_NOHOST;
1843   }
1844
1845   strncpy(hostname, he->h_name, sbuf);
1846
1847   return GSOCK_NOERROR;
1848 }
1849
1850 unsigned long GAddress_INET_GetHostAddress(GAddress *address)
1851 {
1852   struct sockaddr_in *addr;
1853
1854   assert(address != NULL);
1855   CHECK_ADDRESS_RETVAL(address, INET, 0);
1856
1857   addr = (struct sockaddr_in *)address->m_addr;
1858
1859   return ntohl(addr->sin_addr.s_addr);
1860 }
1861
1862 unsigned short GAddress_INET_GetPort(GAddress *address)
1863 {
1864   struct sockaddr_in *addr;
1865
1866   assert(address != NULL);
1867   CHECK_ADDRESS_RETVAL(address, INET, 0);
1868
1869   addr = (struct sockaddr_in *)address->m_addr;
1870   return ntohs(addr->sin_port);
1871 }
1872
1873 /*
1874  * -------------------------------------------------------------------------
1875  * Unix address family
1876  * -------------------------------------------------------------------------
1877  */
1878
1879 #ifndef __VISAGECPP__
1880 GSocketError _GAddress_Init_UNIX(GAddress *address)
1881 {
1882   address->m_len  = sizeof(struct sockaddr_un);
1883   address->m_addr = (struct sockaddr *)malloc(address->m_len);
1884   if (address->m_addr == NULL)
1885   {
1886     address->m_error = GSOCK_MEMERR;
1887     return GSOCK_MEMERR;
1888   }
1889
1890   address->m_family = GSOCK_UNIX;
1891   address->m_realfamily = PF_UNIX;
1892   ((struct sockaddr_un *)address->m_addr)->sun_family = AF_UNIX;
1893   ((struct sockaddr_un *)address->m_addr)->sun_path[0] = 0;
1894
1895   return GSOCK_NOERROR;
1896 }
1897
1898 #define UNIX_SOCK_PATHLEN (sizeof(addr->sun_path)/sizeof(addr->sun_path[0]))
1899
1900 GSocketError GAddress_UNIX_SetPath(GAddress *address, const char *path)
1901 {
1902   struct sockaddr_un *addr;
1903
1904   assert(address != NULL);
1905
1906   CHECK_ADDRESS(address, UNIX);
1907
1908   addr = ((struct sockaddr_un *)address->m_addr);
1909   strncpy(addr->sun_path, path, UNIX_SOCK_PATHLEN);
1910   addr->sun_path[UNIX_SOCK_PATHLEN - 1] = '\0';
1911
1912   return GSOCK_NOERROR;
1913 }
1914
1915 GSocketError GAddress_UNIX_GetPath(GAddress *address, char *path, size_t sbuf)
1916 {
1917   struct sockaddr_un *addr;
1918
1919   assert(address != NULL);
1920   CHECK_ADDRESS(address, UNIX);
1921
1922   addr = (struct sockaddr_un *)address->m_addr;
1923
1924   strncpy(path, addr->sun_path, sbuf);
1925
1926   return GSOCK_NOERROR;
1927 }
1928 #endif  /* !defined(__VISAGECPP__) */
1929 #endif  /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */