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